kernel/ledger/TaskList.js
Classes
class TaskList
Re-exports
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: TaskList.js — flat, ordered task list for an AI request (each task usually maps to a goal tree leaf + a storylet/tool step). Drives the Task Panel's checklist view. Classes Method Signature Summary Re exports <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/ledger/ToolCallTrace.js
Classes
class ToolCallTrace
Re-exports
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ToolCallTrace.js — wraps engine/state/workflow/Outbox.js + Reconciler.js: every AI initiated tool call is recorded as a transactional effect INTENT (idempotent by stable effect id — commit retries never duplicate a call), delivered via drain(), with ambiguous outcomes parked as RECONCILE and resolved by EVIDENCE (a probe of the authoritative status), never guessed. Classes Method Signature Summary Record an intended tool call for a request (does NOT execute it). Deliver pending tool calls through an executor. Resolve parked (ambiguous) calls by probing authoritative status. All outbox entries for one request (UI view). Settle an intent that was delivered by the AI executor's idempotent path. Re exports , <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


sanitizeLivePatchMarkup(markup, { patchId = 'livepreview' } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: LivePatchService.js — kernel owned, declarative live UI editing. Model output never becomes executable code. A caller can inspect registered surfaces and propose a small allow listed operation list. The service applies that list as a reversible preview, verifies the resulting DOM, and only then persists a canonical patch + receipt beneath /user/live patches. Classes Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviAutonomyServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Method Signature Summary Constants — Kernel owned structured operational cognition for one or more Navis. Entries are Navi authored conclusions, evidence, uncertainty, proposals, and budget accounting. They are never provider hidden reasoning or raw model transcripts. The injected continuity cipher owns encryption; this service never receives or exposes a generic key or decryption API. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviBackgroundCoordinatorError extends Error

class NaviBackgroundTransientExecutionError extends NaviBackgroundCoordinatorError

buildNaviBackgroundCognitionPrompt({ operation = '', objective = '' } = {})

naviBackgroundTokenEnvelope({ operation = '', objective = '', outputTokens = 0, routeAttempts = 1, } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Persistent, cross tab coordinator for bounded Navi background cognition. Web Locks is the execution authority: one exclusive lock remains held across the durable reread, executor call, operational journal append, and terminal job update. BroadcastChannel is observability and wake up only; peer messages never grant authority or replace the durable encrypted job record. Classes Method Signature Summary Explicit retry signal accepted from the kernel owned background executor. Arbitrary errors cannot opt into retries by attaching or fields: the coordinator accepts only instances privately branded here, and this constructor admits only the closed outage/throttle transient set. Method Signature Summary Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviBackupRecoveryError extends Error

class NaviBackupIntegrityError extends NaviBackupRecoveryError

createNaviBackupStateReader({ continuityStore, cognitionStore } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Signed, encrypted Navi backups and recovery branch reconciliation. This service never exports a credential, a private CryptoKey, raw provider output, a live capability, or a canonical write authority. Restore decrypts and validates into a durable non canonical branch. Only an exact reviewed diff may reach an injected canonical merge applier. Classes Method Signature Summary Method Signature Summary Method Signature Summary Verify a restore receipt against the encrypted branch record already committed by this service. This exposes no bundle plaintext or Store mutation authority and is intended for NaviRecoveryBranchAuthority. Activate a staged recovery branch on a device where this Navi does not yet exist. The injected Continuity import authority must itself perform 2 of 3 recovery, full lineage verification, and atomic persistence. Functions Build the production state reader over already initialized continuity and cognition Stores. The reader exports only the Phase 7 allow list. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviCognitionServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviCognitionService — kernel authority for model neutral task continuity. Provider conversations are transports, never task storage. This service persists signed task envelopes, per Navi routes, self model state, disclosure receipts, and encrypted checkpoints before exposing immutable projections. Classes Method Signature Summary Method Signature Summary Load the exact encrypted task record head for kernel commit protocols. This is intentionally exposed only by the kernel owned service, not the capability gateway presented to applications or model tools. Load one durable task graph checkpoint by its exact encrypted record key. V2 graph checkpoints use a disjoint record identifier. Existing v1 ciphertext remains unopened and unchanged, and neither identity can enter the legacy history. Compare and swap one exact durable task graph checkpoint head. Retrying an already committed identical value is idempotent and does not reseal or rewrite the encrypted record. Record one kernel verified Faculty outcome for advisory guidance only. This API is intentionally absent from the application/model capability surface. It persists the minimum receipt projection needed to prove independent outcomes; it cannot sign, install, enable, or execute a learned Guidance Faculty. List inert, unsigned Guidance Faculty candidates for operator review. Record an exact operator review without granting execution authority. The approval proof is single use and bound to the candidate instruction hash and decision; the result remains unsigned and disabled. List continuity signed, analysis only strategy scorecards. Load one encrypted, continuity signed model resource selection. Load one encrypted, continuity


List continuity signed, analysis only strategy scorecards. Load one encrypted, continuity signed model resource selection. Load one encrypted, continuity signed investigation case. List encrypted investigation cases without crossing Navi scope. Load the encrypted, hash bound deterministic episode for one case. Persist one deterministic episode head. Evidence transitions intentionally permit a one record evidence first crash window; every other mismatch is retained as a fail closed recovery condition rather than reset. Persist one revision bound investigation case through the Navi record cipher. The continuity service re signs every accepted revision so the deterministic investigation runtime never receives generic key access. Commit one investigation episode/case transition against the exact durable task head. The task assertion and both encrypted writes share a single Store transaction, eliminating the legacy case/episode crash window without allowing the investigation runtime to mutate the task. Load one immutable encrypted evidence entry. List immutable encrypted evidence, optionally narrowed to one case. Append one signed evidence entry. Evidence IDs are immutable: updates must use a new record and the contract's field. Bind a reviewed broker decision to its effect relevant semantic shape. The full decision hash intentionally includes append only reliability evidence. That evidence may change while an operator is reviewing a disclosure, and the short lived in memory execution plan cache may be unavailable after a service rebind. Carrying this content free semantic attestation across the preflight boundary lets dispatch reconstruct the plan without treating telemetry churn as new authority. Configuration, policy, candidates, endpoint capabilities, route order,


lets dispatch reconstruct the plan without treating telemetry churn as new authority. Configuration, policy, candidates, endpoint capabilities, route order, selection, and attempt bounds remain covered and therefore still fail closed. Return a content free local explanation of either one exact signed resource selection receipt or one exact integrity bound broker decision. This projection never re ranks routes and never dispatches a provider. Load only dispatches that can still require crash recovery. Completed dispatch history is intentionally absent from this encrypted index. Its derived checkpoint/evidence pair remains fail closed and is verified when that exact task is reconstructed or reused. Pre index insta


class NaviCognitionStoreError extends Error

class NaviCognitionStoreConflictError extends NaviCognitionStoreError

class NaviCognitionStoreQuarantineError extends NaviCognitionStoreError

async validateNaviCognitionRecord(value, expected = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Durable ciphertext only storage for the Navi Cognition Fabric. The Store deliberately knows nothing about task, context, or self model plaintext. A kernel only continuity cipher creates authenticated record envelopes before they reach this boundary. Invalid data is quarantined instead of becoming an empty task, route configuration, or self model. Classes Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Atomically apply a bounded set of exact encrypted assertions, writes, and deletions. Assertions are read only compare and swap guards: their revision and envelope hash are rechecked in the same transaction as the mutations they authorize. Kernel only cross Navi scan used to resume encrypted maintenance journals. Permanently destroy one exact ciphertext envelope and its wrapped record key. Callers must bind deletion to both the observed revision and envelope hash so a stale erasure journal cannot delete replacement data. Functions Verify one portable encrypted cognition row without opening its Store. Recovery uses this exact validator before an authenticated backup row may enter a reconciliation branch. The function validates the same binding, envelope hash, and record integrity hash as the live Store read path. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture ·


be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviContextCompilerError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviContextCompiler.js — deterministic, policy filtered Navi model context. This module is deliberately provider agnostic. It accepts a previously verified active Covenant, filters every classified context item before any provider call can be made, and emits a content free disclosure receipt. Provider sessions and model output never become canonical state here. Classes Method Signature Summary Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviContinuityServiceError extends Error

class NaviContinuityServiceDisabledError extends NaviContinuityServiceError

class NaviContinuityServiceIntegrityError extends NaviContinuityServiceError

validateNaviContinuityRecord(value, expected = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviContinuityService.js — kernel authority for model independent Navi identity. AI Echo and other Manifestations receive immutable public projections only. Private keys, generic signing/decryption, raw Store records, recovery bundles, and non extractable CryptoKey handles never cross this boundary. Classes Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Public, secret free progressive recovery posture for one resident Navi. Reveal one deferred A/B factor. Status reads alone can never disclose it. Authenticate one operator held factor together with the kernel only device factor, then record its separate custody without exposing C. Kernel only full Covenant for the policy compiler. App projections omit conditional and destination detail and therefore cannot authorize model disclosure. This method is intentionally absent from the stable gateway. Kernel only, purpose bound cognition encryption. This method is absent from the stable app gateway and cannot encrypt credentials or arbitrary record namespaces. Kernel only inverse of sealCognitionRecord with exact scope binding. Operationally sign a model neutral task without exposing a signer. Operationally sign an observation only investigation case. Verify one historical investigation case signature without exposing a key. Operationally sign one authority free investigation evidence record. Verify one historical investigation evidence signature without exposing a key. Sign a content free record of one exact model context admission. Verify a historical context manifest without exposing a signing key. Sign one deterministic resource selection decision and its exclusions. Verify a


admission. Verify a historical context manifest without exposing a signing key. Sign one deterministic resource selection decision and its exclusions. Verify a historical resource selection receipt without exposing keys. Sign an analysis only scorecard derived from observable task receipts. Verify a historical analysis only strategy scorecard. Sign an inert, disabled Navi authored guidance Faculty. Verify an inert Navi authored guidance Faculty without exposing keys. Verify the continuity signed public identity for a locally known Navi. Verify that one signed lineage event is present in the fully verified canonical lineage. This is purpose bound verification for witnessing; it does not expose a key, raw ledger, or generic signature primitive. Sign an exact, one call Faculty capability without exposing a signer. Sign the final staged action receipt without exposing a signer. Sign one verified post commit recovery outcome. Restore staging is not a signable Navi claim, and the receipt must still name the current lineage head so a caller cannot pre sign a future or stale canonical mutation. Verify one Navi signed canonical recovery outcome without exposing its key. Atomically append and persist the operational reconciliation transition. Replaying the exact signed receipt returns its already verified event; a different receipt naming an old head fails closed. Sign one append only causal memory event without exposing a signer. Verify one Navi authored causal memory event against live key lineage. Sign one exact resource lease state transition without exposing a signer. Verify one Navi authored resource lease against the active operational key lineage. Sign one exact worker assignment or terminal transition without exposing a signer. Verify a Navi delegation against the active


active operational key lineage. Sign one exact worker assignment or terminal transition without exposing a signer. Verify a Navi delegation against the active operational key lineage. Sign one exact Manifestation registration or presence transition. Verify a Manifestation against the active operational key lineage. Sign one exact task handoff transition without exposing a signer. Verify a handoff against the active operational key lineage. Sign one encrypted backup manifest without exposing a signer or key handle. Verify a backup manifest against the active operational key lineage. Export the minimum verified continuity material required to recover this exact Navi on another device. The persistent manifest contains


class NaviContinuityDisabledError extends NaviContinuityError

class NaviContinuityUnavailableError extends NaviContinuityError

class NaviContinuityStorageError extends NaviContinuityError

class NaviContinuityValidationError extends NaviContinuityError

class NaviContinuityConflictError extends NaviContinuityError

class NaviContinuityRevisionExhaustedError extends NaviContinuityError

class NaviContinuityQuarantineError extends NaviContinuityError

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviCovenantTemplateBlockedError extends NaviCovenantError

class NaviCovenantSignatureError extends NaviCovenantError

listNaviCovenantTemplates({ separationRecoveryReady = false } = {})

getNaviCovenantTemplate(template = DEFAULTNAVICOVENANTTEMPLATE, { separationRecoveryReady = false, } = {})

async proposeNaviCovenant({ covenantId, naviId, operator = null, operatorSigner, template = DEFAULTNAVICOVENANTTEMPLATE, revision = 1, effectiveAt = new Date()

async verifyNaviCovenant(covenant, { operatorVerifier = null, naviVerifier = null, keyResolver = null, historical = false, logger = null, } = {})

async activateNaviCovenant(proposal, { operatorSigner, naviSigner, signedAt = new Date()

async reviseNaviCovenant(activeCovenant, { covenantId, operatorSigner, naviVerifier, template = null, effectiveAt = new Date()

suspendNaviCovenant(covenant, options = {})

revokeNaviCovenant(covenant, options = {})

async supersedeNaviCovenant(covenant, { operatorSigner, naviSigner, signedAt = new Date()

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviCovenantTemplates.js — selectable operator–Navi Covenants and lifecycle policy. A Covenant is not active merely because it is well formed. Proposals require the primary operator's signature; activation and supersession require both the operator and the Navi to sign the exact same canonical contract bytes. Emergency suspension and revocation remain operator authorized fail safe transitions. This module exposes lifecycle operations, never a generic sign or decrypt primitive. Classes Method Signature Summary Method Signature Summary Method Signature Summary Functions Return immutable template descriptions without exposing mutable policy source objects. Create and operator sign a proposed Covenant from one exact template. Verify signature bytes, signer roles, key windows, and lifecycle quorum. Re sign an accepted proposal as active with operator + Navi acknowledgment. Create a signed next revision proposal without mutating the active Covenant. Emergency fail safe: the primary operator may suspend an active Covenant. Revoke an active or suspended Covenant; the original signed record remains verifiable. Mark an old active Covenant superseded after its dual signed replacement is active. Return a safe, immutable projection with signature values and policy conditions removed. Resolve already authorized scoped delegate votes. Conflicting decisions at the highest equal priority always pause; array order never breaks a tie. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross


inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviDelegationBranchKeyServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel only provisioning and one shot consumption of persistent Branch keys. A generated P 256 private key is exported only long enough to import a non extractable runtime handle and place its bytes inside a Continuity sealed cognition record. No application facing method returns a CryptoKey, private bytes, public key, or generic signing capability. Classes Method Signature Summary Method Signature Summary NaviDelegationService compatible verifier. The first exact call consumes the proof. Later exact calls are read only validation for persisted delegation records; changed tuples always deny. Constants — Kernel only provisioning and one shot consumption of persistent Branch keys. A generated P 256 private key is exported only long enough to import a non extractable runtime handle and place its bytes inside a Continuity sealed cognition record. No application facing method returns a CryptoKey, private bytes, public key, or generic signing capability. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviDelegationServiceError extends Error

class NaviDelegationIntegrityError extends NaviDelegationServiceError

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviDelegationService — bounded worker authority, persistence, and recovery. A delegated worker is never given cognition storage, continuity keys, raw memory, or ambient filesystem access. The service persists only signed navi delegation v1 contracts, hash only context references, exact capability references, an active resource lease binding, and bounded report evidence. File capable workers operate through a VFS overlay adapter scoped from their verified Faculty capabilities. Classes Method Signature Summary Method Signature Summary Method Signature Summary Functions Derive the only VFS root a delegated capability may name. Capability issuance can call this before NaviDelegationService.create(), so signed tool arguments already target the overlay and never need post signature rewriting. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviDerivedProjectionError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviDerivedProjectionService.js — deterministic, non authoritative Navi views. Canonical memory and relationship services remain the only write authority. This service validates their signed contracts, verifies that signatures bind the current payload hash, and derives Wiki compatible human readable views. It never edits a source contract. A UI edit becomes an unsigned proposal that is handed back to memoryService.proposeDerivedEdit() for policy and review. Required adapters: memoryService.listProjectionEvents({ naviId, branchId, afterSequence, allowedDataClasses }) { event, eventHash, payloadStatus, payload }[] memoryService.proposeDerivedEdit(unsignedProposal) receipt/result relationshipService.listRelationships({ naviId }) Relationship[] The adapters must verify cryptographic signatures before returning contracts. This layer independently verifies schema closure and signed hash binding so a modified cached contract cannot silently become a readable projection. Classes Method Signature Summary Method Signature Summary Replace the local projection cache from the canonical services. Append new memory events and replace the small signed relationship view. Stable local search over the last successfully compiled snapshot. Route a requested view edit back to canonical memory as an unsigned proposal. Even read only authority/lineage views use this path; they can never be mutated in place or acquire a signature in this service. Functions Escape payload text before inserting it into generated Markdown/HTML views. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers;


NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviFacultyPackageBindingError extends Error

async validateNaviFacultyPackageBinding(value, { resourceHash = null } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Strict, side effect free validation for a signed Faculty embedded in an authenticated package manifest. The builder and authorization policy share this boundary so accepted package evidence cannot drift between creation and execution. Classes Method Signature Summary Functions Validate and snapshot an already signed Faculty package binding. This function never adds, removes, or rewrites a Faculty signature. The returned frozen snapshot contains the exact schema values supplied by the caller after strict JSON/schema validation. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviFacultyPackagePolicyError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviFacultyPackagePolicy.js The fail closed trust boundary between a verified OS package and an executable Navi Faculty manifest. PackageManager remains the package integrity/provenance/scanning choke point; this policy narrows its broader application install trust model for Faculties: production authorization requires a fresh ring 0 certificate chain; pinned/TOFU trust never becomes production Faculty authority; developer local/self signed packages require an exact one shot approval; the authenticated package manifest, inline Faculty envelope, canonical Navi payload, and package resource root must all bind the same Faculty; the Faculty publisher signature is verified with the package certificate. No package bytes, public keys, signatures, approval tokens, or verifier diagnostics are returned from this module. Classes Method Signature Summary Method Signature Summary Verify every non interactive invariant and return the exact approval grant a UI must place in ElicitationManager, if an approval is required. Authorize one exact package bound Faculty. Approval tokens are consumed by ElicitationManager and are never retained or returned. Constants Re exports <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviFacultyServiceError extends Error

class NaviFacultyServiceIntegrityError extends NaviFacultyServiceError

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned Faculty authority membrane. Faculty code never receives this service, continuity keys, persistence, or driver objects. It receives only NaviFacultyWorkerHost's bridge. The bridge prepares one exact signed capability and hands it to ToolRouter; ToolRouter must consume that capability immediately before its existing driver dispatch. This module deliberately has no ToolDriver import or path. Classes Method Signature Summary Method Signature Summary Method Signature Summary Pure review projection. It does not require readiness or mutate state. Pure human review binding. It never signs, installs, or enables guidance. Validate that an approved candidate is ready for the existing install UI. Pure analysis only scorecard derivation from verified receipt metrics. Reconcile one exact OS signed default on Faculty revision. This is intentionally not exposed through the application syscall gateway. KernelBootstrap invokes it only after validating the bundled package and live descriptor bindings. Operator pauses and revocations are durable authority decisions and are never rewritten here. Kernel private, non consuming proof used while binding or checking a bounded delegation. The eventual ToolRouter dispatch must still call consumeCapability(), so this method cannot authorize a tool invocation by itself. Kernel private proof for investigation evidence. The caller supplies only a content free receipt claim and the exact case scope it expects; this method re opens the authoritative encrypted Faculty receipt and operation before returning a trusted read binding. It is intentionally not exposed through the Navi or application gateways. Kernel private recovery inventory for known


before returning a trusted read binding. It is intentionally not exposed through the Navi or application gateways. Kernel private recovery inventory for known terminal tool outcomes whose exact resource lease still lacks a durable settlement marker. Kernel private resource binding for a persisted operation. The stable app gateway deliberately does not expose this method. Kernel private recovery projection for a delegated Faculty capability. It resolves an immutable signed receipt from the persisted grant without exposing invocation arguments, result payloads, or a dispatch primitive. Read only compatibility adapter for receipts written before source attestations existed. Legacy records retain their original signature and identity; they are never rewritten, re signed, or eligible to establish an investigation evidence source. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviFacultyWorkerError extends Error

normalizeNaviFacultyJson(value, { label = 'value', maxBytes = NAVIFACULTYWORKERLIMITS.messageBytes, } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviFacultyWorkerHost.js Executes one Faculty operation in a dedicated Worker nested inside an opaque origin iframe. The worker has no ambient OS bridge. Its only host capability is the bounded request channel supplied to . Classes Method Signature Summary DOM owner for the hidden opaque iframe and its sole MessageChannel port. Method Signature Summary Replace only owner for one shot Faculty Workers. is trusted host code and is the only route from Faculty source to ToolRouter. Method Signature Summary Functions Descriptor first JSON normalization that never evaluates accessors. Immutable description of the Faculty execution boundary. Constants — NaviFacultyWorkerHost.js Executes one Faculty operation in a dedicated Worker nested inside an opaque origin iframe. The worker has no ambient OS bridge. Its only host capability is the bounded request channel supplied to . <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviFeatureGatePersistenceError extends Error

class NaviFeatureGateGenerationError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Always on compatibility policy for the kernel owned Navi runtime. Navi is part of WebGPU OS rather than an operator controlled feature. This object keeps the versioned read contract used by kernel services and repairs legacy rollout records. Authority still fails closed inside each operator bound service; an app can neither enable nor disable the runtime. Classes Method Signature Summary Method Signature Summary Method Signature Summary Functions Constants — Always on compatibility policy for the kernel owned Navi runtime. Navi is part of WebGPU OS rather than an operator controlled feature. This object keeps the versioned read contract used by kernel services and repairs legacy rollout records. Authority still fails closed inside each operator bound service; an app can neither enable nor disable the runtime. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


async deriveGuidanceFacultyCandidate(raw = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Pure guidance faculty candidate v2 derivation from observable receipts. This module cannot sign, persist, install, enable, or execute anything. It only creates a review required candidate after two independent verified successes share one exact descriptor and verification profile binding. Functions <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviInvestigationProofReviewError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned human review for a bounded Navi investigation proof. This service never calls a model and never accepts provider hidden reasoning. It projects exact, locally verified evidence into one immutable review request, obtains a one shot ElicitationManager approval, then rechecks every mutable task/case binding before returning the semantic verifier attestation expected by NaviInvestigationService. Classes Method Signature Summary Method Signature Summary Review one exact proof candidate. is the decision shown in the approval UI; the operator must explicitly approve that exact attestation. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviInvestigationError extends Error

shouldInvestigate({ objective, taskKind = '', goalType = '' } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviInvestigationService.js — deterministic, observation only Sherlock episodes. The service owns case progression and evidence validation, but it cannot invoke tools, persist records, grant authority, or execute mutations. Callers must route reads through ToolRouter and submit the verified result. Classes Method Signature Summary Restore canonical case/evidence records and a hash bound episode. A caller may then reconcile one evidence first record after a crash. Attach one already durable verified observation exactly once. Method Signature Summary Functions Select Sherlock only for investigation shaped work, never greetings. Recompute the durable semantic proof binding without trusting the model interpretation that proposed it. This is shared by runtime restore and the cognition persistence boundary before a case can be signed. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviKeyVault.js
Classes
class NaviKeyVaultError extends Error
class NaviKeyVault
Functions
naviConstantTimeEqual(left, right)
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel internal cryptographic boundary for Navi continuity. This module deliberately exposes no generic "sign this key" or "decrypt this ciphertext" syscall surface. Its methods are intended to be held by the kernel continuity service, which supplies the policy decision before a bounded operation reaches this vault. Classes Method Signature Summary Method Signature Summary Create genesis keys and a one time 2 of 3 recovery enrollment. Long lived secret keys are imported non extractable before this returns. Verify and project only the authenticator ceremony metadata committed by a continuity signed recovery bundle. PRF output is never part of this view. Recover a vault using any valid, non revoked pair of enrollment factors. Recover only the continuity and encryption roots, then mint a fresh operational key. The stale operational private key carried by the enrollment payload is deliberately never decoded or imported. Restore non extractable CryptoKey handles loaded from an IndexedDB object store. The state is authenticated before any handle becomes authoritative. Produce a structured cloneable kernel snapshot for IndexedDB. It contains opaque, non extractable CryptoKey handles, never raw secret key bytes. Sign an allowlisted Navi wire contract using the exact Phase 0 canonical bytes. The return value is a object ready to be appended to the contract's top level array. Sign exactly one pre hashed permanent separation ancestry attestation. This deliberately accepts no arbitrary domain, schema, signer, or key role, and therefore does not create a generic continuity signing oracle. Public only continuity verifier for kernel lineage and recovery services. Public only historical


therefore does not create a generic continuity signing oracle. Public only continuity verifier for kernel lineage and recovery services. Public only historical operational verifier; private handles never leave. Prepare a new operational key without changing the active signer. Only public candidate material and an opaque, single use token are returned. The continuity service must append and verify the lineage rotation with the still current old key before calling commit. Commit one staged candidate after its old key lineage event was recorded. Drop an uncommitted candidate; its private handle becomes unreachable. Safe convenience wrapper. The callback must append and verify lineage while the old key is current, returning the committed event hash. Return a newly signed policy that disables the named recovery factor. Authenticate a persisted recovery bundle against a trusted Store head. This verifies bundle/AAD commitments and the continuity signed policy, but intentionally does not open factor encrypted payloads during hydration. Prove an exact factor quorum against the active Navi without rotating a key. This is used only to authenticate a persisted idempotent recovery replay after its original atomic commit response was lost. Replace a stale recovery bundle after operational rotation/revocation. Opening the previous bundle proves a valid 2 of 3 factor quorum; the new bundle receives fresh factors and the vault's authenticated current key history. No old operational private key is revived. Functions Constant time comparison for equal length byte strings. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on


Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviLegacyKnowledgeImportError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Idempotent, non destructive migration of bounded AI Echo knowledge into the Navi causal memory weave. The caller supplies a read only snapshot assembled from legacy AI Echo state. This service never receives the legacy Store, so it cannot reset, delete, or rewrite that source. Each normalized source item receives a content derived event ID; retries verify the existing signed event instead of appending a duplicate. Classes Method Signature Summary Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Explicit, rollback safe migration of unreleased AI Echo owned state. Phase 0 creates and verifies a complete /user backup while navi v1 is off. This Phase 1 service consumes that exact archive only after the always on runtime is operator bound and the operator supplies an exact confirmation. It archives the two AI Echo owned surfaces, resets them, and never touches unrelated /user paths. A failed reset is compensated from the local migration archive. Classes Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviLineageVerificationError extends NaviLineageError

async verifyNaviLineage(entries, { expectedNaviId, expectedBranchId = null, expectedHeadHash = null, expectedEventCount = null, continuityKey, operationalKeys = [], keyResolver = null, certificateVerifier = null, logger = null, } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviLineage.js — linked, signed Navi continuity history. The ledger stores strict contracts plus the exact payload whose hash the event commits to. Operational rotation takes effect after its rotation event, so the old key remains valid for historical verification but cannot authorize another event. Recovery and revocation are continuity key operations. No generic signing primitive is exported. Classes Method Signature Summary Method Signature Summary Method Signature Summary Append one operational state transition for a successful, Navi signed canonical recovery outcome. The prior head is supplied by the receipt and must still be current; callers cannot relabel a stale merge/import. Return an immutable public history with signature bytes and private details omitted. Export strict JSON entries for encrypted kernel persistence. Functions Hash a strict JSON lineage payload using the engine's canonical SHA 256 path. Return deterministic bytes suitable for an external continuity certificate verifier. Verify the complete chain, payload commitments, signature policy, key certificates, key activation windows, and rotation/recovery transitions. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviMaintenanceScheduler.js
Classes
class NaviMaintenanceScheduler
Functions
sharedNaviMaintenanceScheduler()
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Cooperative, lifecycle aware scheduler for encrypted Navi maintenance. All Navi migrations and index hydration share one queue. A browser idle grant advances at most one bounded page. An idle callback with no available budget advances nothing; its timeout, or the delayed timer used where idle callbacks do not exist, is the bounded fallback grant. Classes Method Signature Summary Functions <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel only registry for Navi Manifestation adapters. The descriptors are inert declarations. Live engine, audio, vehicle, or network objects are attached by trusted kernel integrations and are never accepted through an app syscall. The registry therefore exposes a narrow body boundary without turning an avatar, entity, or runtime object into Navi identity authority. Classes Method Signature Summary Kernel only: attach an already constructed trusted runtime. Kernel only convenience wiring for the bounded ActiveBody Construct adapter. Re exports , <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviManifestationServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned Navi Manifestation and task handoff runtime. Models, bodies, voices, avatars, and apps remain replaceable presentation or execution surfaces. Every durable registration and handoff is an encrypted, purpose signed contract bound to the continuity root Navi identifier. Classes Method Signature Summary Method Signature Summary Kernel only exact scope decision used before an adapter observes or acts. Kernel only sensor bridge. Kernel only actuator bridge. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviMemoryServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned causal memory over the existing encrypted cognition Store. Signed events are append only. Their payloads live in separately wrapped AES GCM records so forgetting can destroy one wrapped record key without rewriting history. Provider output, application projections, and callers never receive Store access or encryption/signing authority. Classes Method Signature Summary Method Signature Summary Kernel internal signed contract feed for deterministic derived views. Kernel only content feed for derived views. This is deliberately separate from listEvents(): callers must supply an exact classification allow list and pass the same Covenant/access evaluator as other reads. Convert a derived view edit into a non authoritative memory proposal. Stop admission immediately and wait for already admitted operations. Continuity owners call this before clearing or rebinding key authority. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviModelBrokerError extends Error

normalizeModelFailure(source, signal = null)

normalizeNaviModelRequirements(raw = {}, purpose = 'chat')

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviModelBroker.js — deterministic, per Navi model selection and failover. The broker owns no provider conversation and executes no tools. It chooses one declared cognition route, invokes the injected AI Hub exactly once at a time, and only advances to a bounded fallback after a retryable model call failure. Prompt/model output is deliberately excluded from routing evidence. Classes Method Signature Summary An injected AI Hub must expose . Route catalog and policy remain per Navi; the AI Hub is only the replaceable transport. Method Signature Summary Prepare one immutable, content free route plan. The returned object is branded to this broker instance and may be consumed by execute() once. Prompts and model output never enter the plan. Functions Verify that a projected route decision is the exact content addressed decision produced for the supplied normalized broker configuration. This is an integrity/binding check only; it never authorizes model use. Return the broker's exact model neutral requirement evidence. Resource selection receipts must hash the same defaults and canonical ordering that used; callers must not reconstruct those defaults independently. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviParticleNetworkAdapter.js — inert Navi/Particle Network protocol bridge. This module creates and verifies Realm semantic envelopes, but never opens a socket, fetches a peer, publishes a package, or owns a credential. Network dispatch remains the NetworkDriver's job. Contract verification and live authority are mandatory injected kernel decisions and fail closed. Classes Create a transport only Particle Network adapter. must contain one verifier per adapter ID. A verifier may return true, , or the exact verified signed contract. The latter matches NaviContinuityService's purpose bound verification methods. Method Signature Summary Verify one inbound envelope without applying or dispatching it. Idempotent inbound application boundary built on Realm SemanticInbox. Verification and application are serialized so concurrent replay cannot apply one signed envelope twice. Method Signature Summary Functions Constants Re exports , , , , , , , , <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviParticleReplicationError extends Error

async assertNaviParticleReplicationPayload(value, expectedAdapterId = null)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviParticleReplicationPolicy.js — closed, side effect free Navi replication policy. Particle Network transports already authoritative Navi contracts. It never becomes a second Navi store and it never accepts an arbitrary JSON tunnel. Every permitted record has one fixed schema, semantic kind, classification policy, destination, disclosure evidence, and live authority approval. Classes Method Signature Summary Functions Return the immutable descriptor for one closed Navi/Particle adapter. Validate an already built replication payload, including its nested Navi contract hash and adapter specific semantics. No signature is synthesized. Reject forbidden content before any signer, policy, or transport is called. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviPasskeyRecoveryError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Kernel owned WebAuthn PRF ceremony adapter. Apps see boolean support/enrollment status and completed continuity results. Credential IDs, PRF inputs, and PRF outputs remain inside this adapter and the continuity signed recovery bundle. PRF output is zeroed after each call. Method Signature Summary <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviPreflightService.js
Classes
class NaviPreflightService
Functions
validateUserBackupManifest(manifest)
validateNaviPreflightManifest(manifest)
validateNaviRollbackReceipt(receipt)
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Phase 0 Navi migration preflight. This service is deliberately not wired into the kernel. It only creates and verifies a reversible development archive while is disabled. It has no delete, clear, restore, or reset operation. Classes Method Signature Summary Create a complete, checksum verified /user archive plus rollback receipt. AI Echo's encrypted app sandbox readback is synchronized before the StorageManager backup begins and must be present in that backup. Independently re verify an imported or retained Phase 0 archive. A rollback receipt is issued only after independent archive verification. Verify that a receipt is bound to one exact, still valid archive. Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviProjectDossier.js
Classes
class NaviProjectDossier
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Rebuildable, authority free project dossier for one exact Navi task. The dossier owns no state and never copies provider reasoning, scratchpads, planner transcripts, file bodies, or Wiki bodies. It projects bounded links from the canonical task state, durable run reports, receipts, evidence, Wiki metadata, and Workspace Output Index. Deleting it loses no canonical data. Classes Method Signature Summary Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviRecoveryBranchAuthorityError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel only authority for staged recovery branches and permanent separation. A recovery branch is never an identity authority. It may be inspected and reconciled only within the exact ceiling carried by its verified restore receipt. Publication, authority expansion, identity transfer, and continuity root rotation are unconditional denials. Permanent separation is a distinct, explicitly approved operation that asks Continuity to stage a fresh independent Navi and records a dual continuity signed ancestry attestation without exposing either signer or private key. Classes Method Signature Summary Method Signature Summary Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviRecoveryBranchStoreError extends Error

class NaviRecoveryBranchConflictError extends NaviRecoveryBranchStoreError

class NaviRecoveryBranchIntegrityError extends NaviRecoveryBranchStoreError

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Durable, encrypted at rest recovery branch journal. The Store never persists decrypted Navi backup payloads. It retains the authenticated encrypted bundle, a content free reconciliation diff, and exact approval/settlement evidence. Canonical Navi state remains owned by the continuity and cognition services. Classes Method Signature Summary Method Signature Summary Method Signature Summary Method Signature Summary Durably checkpoints merge progress without widening the recovery branch lifecycle. Checkpoints are deliberately limited to an operation that is already in ; settling or retrying the operation still requires the explicit transition API and its existing transition graph. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviRecoveryEscrowError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel only, progressive recovery factor escrow. Recovery material is isolated from the ordinary VFS and continuity stores in a purpose specific IndexedDB database. Public projections contain only bounded disclosure metadata. The device factor (C) can be retrieved only by kernel code holding the module capability symbol. Classes Method Signature Summary Method Signature Summary Constants — Opaque kernel capability. It must never be copied into a syscall, app projection, log, or persisted record. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviRecoveryRuntimeError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Operator bound Phase 7 recovery aggregate. This runtime keeps approval construction, portable state verification, canonical cognition writes, and ancestry authority inside the kernel. Apps submit recovery factors and human decisions, never hashes or signatures. Classes Method Signature Summary Method Signature Summary Synchronously revoke the operator binding before an async drain begins. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviRelationshipServiceError extends Error

class NaviRelationshipIntegrityError extends NaviRelationshipServiceError

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviRelationshipService — signed, append only relationship authority. Relationships are evidence, not ambient trust. Chat contacts and package publishers never enter this service, and an active relationship grants no authority unless one of its exact signed policy rules matches the request. Raw contracts and encrypted records remain kernel private; public methods return immutable projections with signature values and condition values removed. Classes Method Signature Summary Method Signature Summary Method Signature Summary Kernel internal projection service adapter. Callers must not publish this result: complete signature envelopes are required for downstream cryptographic verification. Apps use list(), which is strictly redacted. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


async projectBrokerDecisionToResourceSelection(rawInput = {}, rawOptions = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviResourceCatalog.js — one deterministic, searchable projection of Navi tools, Faculties, guidance recipes, task episodes, and related resources. Catalog entries are descriptions only. Search never executes a resource or grants permission, and callers must resolve live authority independently. Classes Method Signature Summary Collision resistant identity of the exact searchable catalog snapshot. Deterministically assess one model/tool/Faculty selection round. This is a local policy operation. It neither executes a resource nor grants any authority. When no resource is eligible it returns a bounded, actionable readiness projection suitable for UI display before provider dispatch. Revalidate a selection against the live catalog. Only this selected binding can disclose its full input schema; catalog search remains metadata only. Any catalog, policy, descriptor, verifier, readiness, or score change invalidates the binding before execution. Bind an already completed NaviModelBroker decision to this exact catalog snapshot. The broker remains the only selector; this method never scores, ranks, substitutes, or omits a route from the broker's decision. Functions Convert one existing NaviModelBroker decision into the Phase 8 resource selection contract without running a second selector. The broker's selected route and candidate order are authoritative. This projection only validates, binds, and signs that already made decision. Build the exact descriptor and verifier bindings for every model route in a broker candidate set. The descriptor hash intentionally shares the execution plan route domain so the persisted selection and executable plan attest the same normalized route. No provider


hash intentionally shares the execution plan route domain so the persisted selection and executable plan attest the same normalized route. No provider content or credential enters either binding. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviResourceServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned resource reservation, metering, and settlement. One encrypted CAS account owns every lease for one Navi task. An authenticated encrypted branch index owns the exact aggregate charge and account membership. Account and index revisions commit through one Store batch while all accounts for the same Navi branch share one Web Lock. Every task binds its exact kernel supplied resource ceiling on first reservation. Every externally meaningful lease state is an operationally signed navi resource lease v1 contract. Classes Method Signature Summary Method Signature Summary Advance at most one authenticated legacy account migration page. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


async deriveNaviStrategyScorecard(raw = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Deterministic, per Navi, analysis only scorecards from verified receipts. Functions <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


strictProjectionSnapshot(value, label = 'projection input')

exactProjectionKeys(value, allowed, label, required = [])

projectionInputError(message, code = 'NAVIPROJECTIONINPUTINVALID')

uniqueSortedProjectionStrings(values, label, { minimum = 0, maximum = 1024 } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Strict JSON input helpers shared by authority free Navi projections. These helpers reject accessors, extensions, cycles, sparse arrays, and non finite values before a projection derives hashes or evidence counts. Functions Strict JSON input helpers shared by authority free Navi projections. These helpers reject accessors, extensions, cycles, sparse arrays, and non finite values before a projection derives hashes or evidence counts. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviSurfaceIntelligence.js
Classes
class NaviSurfaceIntelligence
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: NaviSurfaceIntelligence — bounded, read only semantic evidence for visible OS surfaces. Surface observations are untrusted evidence. They never grant authority and never execute an action. Mutations named by an action catalog still enter ToolRouter, Live Patch, Dodad Forge, or an app owned command boundary. Classes Method Signature Summary Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviVfsOverlayServiceError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Kernel owned VFS isolation for delegated Navi workers. A delegated file capability is issued for one deterministic hidden overlay root. The adapter never rewrites a signed path: it verifies that the exact execution path is inside the bound overlay and returns that same path. The immutable snapshot hash describes the overlay at admission time; subsequent writes remain constrained by the signed path scopes rather than changing the authorization identity after every edit. Storage accounting is deliberately application byte based. Kernel owned overlay metadata, hashes, and signed receipts are excluded. Creating an empty overlay and observing a snapshot therefore cost zero storage bytes. Moving an overlay into recoverable trash is a durable application data rewrite and is charged at the exact sum of the files present in its prepared snapshot. Classes Method Signature Summary Method Signature Summary Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/NaviWorkspaceOutputIndex.js
Classes
class NaviWorkspaceOutputIndex
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Rebuildable, non authoritative references to canonical workspace outputs. The index owns no file content. Every entry is derived from an exact VFS observation and points back to the app owned canonical path. Deleting the index loses no user data because the same projection can be rebuilt. Classes Method Signature Summary Content free app declarations used by a rebuild. Rebuild an index from current canonical VFS observations. and are runtime controls, not part of the strict serialized projection input. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/SurfaceTemporalVerifier.js
Classes
class SurfaceTemporalVerifier
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: SurfaceTemporalVerifier compares two retained semantic captures. It is deliberately read only. Visual comparison accepts contract evidence that was captured earlier and compares content hashes only; it never reads a payload. Classes Method Signature Summary <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


class NaviConstructManifestationAdapterError extends Error

createConstructManifestationAdapter({ bodyId, bodyRuntime, manifestationId = NAVICONSTRUCTPRIMARYMANIFESTATIONID, spawnPosition = [0, 0, 0], bodyOptions = {}, readActiveScene, readSelectedEntity, readVerifiedRealmPresence, readSpatialLocality, playAnimation, requestRealmAuthority, maxObservationBytes = DEFAULTMAXOBSERVATIONBYTES, clock = ()

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Narrow Construct manifestation boundary. The adapter deliberately captures only bound ActiveBody style functions and explicit observation readers supplied by trusted kernel wiring. It never exposes the engine object, treats a body as identity, or derives authority from scene, presence, spatial, model, avatar, or body data. Classes Method Signature Summary Functions Create the trusted Construct runtime attached by NaviManifestationAdapterRegistry. bodyRuntime is expected to be an ActiveBodySystem compatible object. Readers are narrow kernel wrappers; each receives a frozen exact scope request. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


createArtifactStudioNaviFaculty({ descriptorHashes = {}, provenance = null, tests = [], signatures = null, version = ARTIFACTSTUDIOFACULTYVERSION, publisherId = ARTIFACTSTUDIOPUBLISHERID, } = {})

async createArtifactStudioFacultyPackageBinding(manifest, { resourceHash = null } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ArtifactStudioFaculty.js Canonical contract factory and worker source for AI Echo's built in Artifact Studio adapter. The worker is deliberately tiny: it can request exactly one declared Artifact tool and receives no storage, credential, network, DOM, or raw JavaScript authority of its own. Functions Return the complete package evidence shape consumed by NaviFacultyPackagePolicy. The release preamble wins when present; raw browser development uses the checked in public fallback package. No private signing material is present in either record. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


createBrowserSemanticNaviFaculty({ descriptorHashes = {}, provenance = null, tests = [], signatures = null, version = BROWSERSEMANTICFACULTYVERSION, publisherId = BROWSERSEMANTICPUBLISHERID, maxCalls = 1, } = {})

async createBrowserSemanticFacultyPackageBinding(manifest, { resourceHash = null } = {})

assertBrowserSemanticManifest(value, definition = BROWSERSEMANTICFACULTYDEFINITION)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Canonical signed boundary for extension backed semantic browser automation. The package is installed inert: only an explicit operator action may enable its device and network authority for a Navi. Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


builtInFacultyPackageEvidence({ label, packageId, version, publisherId, sourcePath, source, generatedPackage, assertManifest, })

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Shared fail closed reader for OS owned signed Faculty package evidence. Functions <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Bind one catalog definition to the immutable version carried by its signed package. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ContractCanonical.js — domain separated signing bytes and secure identifiers. Functions Return the JSON value covered by every top level Navi contract signature. Signature envelopes are excluded to avoid circular signing input. Return the deterministic, domain separated signing text. Return the exact UTF 8 bytes that P 256 signs or verifies. Return a tagged SHA 256 identifier for the signature covered payload. Return a tagged SHA 256 identifier for the complete signed envelope. Compare contract payloads without relying on insertion order. Useful before signing, during recovery diffs, and when checking fixture determinism. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


validateNaviContract(data, expectedSchemaId = null, options = {})

assertNaviContract(data, expectedSchemaId = null, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ContractRegistry.js — isolated Navi v1 schema registry and semantic checks. This registry deliberately does not mutate the OS wide singleton. Kernel bootstrap can integrate it after the Phase 0 gate passes without making an import of this module a side effect. Functions Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ContractSchemas.js — strict, versioned Navi v1 wire schemas. The OS schema validator intentionally supports a compact JSON Schema subset. Every declared object is closed with additionalProperties:false. Fields that intentionally contain application JSON are named or and are still checked by ContractRegistry's JSON safety pass before acceptance. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/contracts/Vocabulary.js
Constants
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Vocabulary.js — canonical Navi v1 terminology and closed policy vocabularies. These values are wire contracts. Additions require a new contract revision; renaming an entry would change signed meaning and is therefore forbidden. Constants <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/navi/contracts/index.js
Re-exports
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Re exports , , , , , , , , , , , , , , , , , , , , , , , , , , , , <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/net-safety.js

kernel/net-safety.js
Functions
isPrivateHost(host)
assertSafeFetchUrl(url, opts = {})
isLocalDevHost(host)
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: net safety.js — shared SSRF / private host guards for OS mediated fetches. Reused by the sandboxed app network bridge, the package UpdateManager, and the package source URL policy so the same allow/deny rules apply everywhere: http(s) only (no file:, data:, blob:, chrome extension:, etc.) no embedded credentials in the URL no loopback / link local / RFC 1918 / CGNAT / multicast / .local hosts Public hostnames pass (still subject to the browser's CORS rules). Functions True if a hostname points at the local machine or a private network range. Parameters: (string) — No description in source JSDoc. Validate and normalise a URL for an OS mediated fetch. Throws on policy violation; returns the normalised href on success. Parameters: (string) — No description in source JSDoc. Returns: normalised href True when a host is localhost like (used to relax https for local dev sources). <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/protocol/CapabilityNegotiator.js
Classes
class CapabilityNegotiator
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: CapabilityNegotiator.js — Particle Realms Protocol capability minting. Thin wrapper over engine/state's CapabilityRegistry + Capability.js (makeCapability/attenuate/authorizes) — no parallel capability logic. Used by the AI Hub's two pass execution loop (Phase 9) to mint short lived, narrowly scoped capabilities for a single OS.ai() request's tool/resource access, on top of (not instead of) the RuleGraph/Permissions manifest gate. Classes Method Signature Summary Mint and register a capability for to perform on (a tool name, resource URI, or prompt name). Narrow a capability with an additional caveat — never widens (Capability.attenuate enforces this). Direct authorization check without touching the registry (e.g. for a capability minted elsewhere). <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/protocol/ElicitationManager.js
Classes
class ElicitationManager
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes ElicitationManager.js — Particle Realms Protocol elicitation (MCP inspired): lets a mid task AI Hub request pause and ask the user a clarifying question instead of guessing. Phase 4 provides the data layer queue; Phase 8's overlay (ElicitationCard.js) is the UI that calls respond()/decline(). Method Signature Summary Ask the user a question mid task. Resolves with the user's structured answer, or rejects on decline/timeout. Approval prompts wait for an explicit operator decision by default. Callers that genuinely need an expiring approval must declare schema.timeoutPolicy = 'expire'. Called by the overlay UI (Phase 8) when the user answers. Kernel only approval token issuer for an exact policy reviewed grant. This does not perform a policy decision. Callers must already have an explicit kernel mode such as Bypass and must still consume the token against the identical grant before the protected operation dispatches. Kernel only one shot verification for an exact user approved action. App scoped cancellation for a deduplicated non capability review. Kernel owned cancellation for every prompt attached to one task. Kernel only settlement for policy reviewed approval prompts belonging to one exact active task. Bypass mode may suppress operator elicitation, but it must not answer clarification, adaptation, recovery, or any prompt owned by another app/request. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities.


uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleRealmsProtocol.js — the MCP inspired protocol facade tying together this app's capability/tool/resource/prompt/root/elicitation/sampling registries. Exposed as kernel.protocol; wrapped by syscalls.protocol. An app calls declare(manifest) once (validated against os.AppAICapabilityManifest in OsSchemas.js) to register its tool/resource/ prompt/root metadata for AI discovery. Declaring metadata here is always advisory/self descriptive — it never grants authority; actual tool execution still goes through ToolRouter's firewall (Phase 3) and actual resource reads still go through ResourceRegistry UntrustedBoundary. Classes Method Signature Summary An app declares its full AI capability manifest in one call. Tools must already be registered with kernel.toolDriver (undeclared/unknown tools are skipped with a warning, never throw — a manifest typo shouldn't crash app boot). <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/protocol/PromptRegistry.js
Classes
class PromptRegistry
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: PromptRegistry.js — Particle Realms Protocol named prompt template catalog (MCP inspired "prompts"). Apps register a render(args) function; the OS owns the final prompt text by always routing rendered output through PromptRegistry.sanitize() before it reaches the AI Hub — an app cannot smuggle raw control tokens or fake role delimiters into the final prompt. Classes PromptRegistry.js — Particle Realms Protocol named prompt template catalog (MCP inspired "prompts"). Apps register a render(args) function; the OS owns the final prompt text by always routing rendered output through PromptRegistry.sanitize() before it reaches the AI Hub — an app cannot smuggle raw control tokens or fake role delimiters into the final prompt. Method Signature Summary Metadata only (no render function) — safe to hand to the AI Hub for discovery. Render a registered prompt template, then run it through the OS sanitization pipeline. Strip control characters and role/untrusted delimiters the OS itself uses internally. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/protocol/ResourceRegistry.js
Classes
class ResourceRegistry
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ResourceRegistry.js — Particle Realms Protocol resource catalog. Apps expose readable data to the AI Hub under a URI scheme (MCP inspired "resources"). Every read is routed through engine/state/worldmodel/UntrustedBoundary.js (Phase 3 reuse) before it's handed back — resource content is always an untrusted observation, never authority, regardless of how much the reading app trusts its own data. Classes Method Signature Summary Register the live reader function for URIs. Record declarative resource metadata (from an AppAICapabilityManifest). Remove both live and declarative state for a closed app. Read a resource. Returns { uri, value, observation } — value is untrusted content. <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model


kernel/protocol/RootBoundaryManager.js
Classes
class RootBoundaryManager
Notes & Examples
Command Bus Pattern

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: RootBoundaryManager.js — Particle Realms Protocol "roots" (MCP inspired): the set of resource URI prefixes an app has declared as in scope for a given AI request. Roots only ever NARROW what an OS.ai() request may touch — they are advisory scoping on top of (never a substitute for) the ResourceRegistry/RuleGraph capability checks. Classes RootBoundaryManager.js — Particle Realms Protocol "roots" (MCP inspired): the set of resource URI prefixes an app has declared as in scope for a given AI request. Roots only ever NARROW what an OS.ai() request may touch — they are advisory scoping on top of (never a substitute for) the ResourceRegistry/RuleGraph capability checks. Method Signature Summary True if falls within one of appId's declared roots (default root: the app's own scheme). <! HUMAN NOTES Notes & Examples Command Bus Pattern The OS uses a capability gated command bus for inter app and system communication. Apps register command handlers; the kernel routes commands based on capabilities. Commands can be local (same app), cross app (with permission), or system level (elevated). Example: Command registration and invocation See also: WebGPU OS Architecture · Security Model