@intentic/sandbox-contract 1.232.0 → 1.234.0

package/src/contracts/extensions.contract.ts

@@ -1,23 +1,23 @@
 import { oc } from "@orpc/contract";
+import { CapabilityIdParamSchema } from "../schemas/capabilities.js";
 import {
-    CapabilityIdParamSchema,
     ExtensionEnabledInputSchema,
     ExtensionProcessParamSchema,
     ExtensionProcessStatusSchema,
     ExtensionSettingsInputSchema,
     ExtensionSettingsSchema,
-    ExtensionReadinessSchema,
+    ExtensionsListSchema,
     ExtensionUpdateActionSchema,
     ExtensionUpdateAppliedSchema,
     ExtensionUpdatePolicyInputSchema,
     ExtensionUpdatePreviewSchema,
     ExtensionUpdatesCheckedSchema,
     ExtensionUsageInputSchema,
-    ExtensionsListSchema,
-    OkSchema,
     WorkspaceExtensionCreatedSchema,
     WorkspaceExtensionCreateSchema,
-} from "../schemas.js";
+} from "../schemas/extension-updates.js";
+import { ExtensionReadinessSchema } from "../schemas/maintenance.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Installed extensions resolved to their approved manifests, what the web extension host boots from. The
 // bundle itself is a plain Hono route (GET /extensions/{id}/bundle): raw ESM bytes are not an oRPC payload.
@@ -162,8 +162,9 @@ export const extensionsContract = {
         })
         .input(ExtensionUpdatePolicyInputSchema)
         .output(OkSchema),
-    // Declared background processes (contributes.processes): tmux-managed through the panel machinery
-    // (session `panel-ext-<id>-<name>`, PORT-assigned, optional tunneled preview route).
+    // Declared background processes (contributes.processes): supervised children of the daemon (respawned
+    // with backoff, PORT-assigned, one log file each — the terminals list carries their `svc-ext-<id>-<name>`
+    // log-view rows), with an optional tunneled preview route.
     processStatus: oc
         .route({
             method: "GET",

package/src/contracts/git.contract.ts

@@ -3,48 +3,49 @@ import {
     CommitResultSchema,
     CommitSchema,
     DiscardSchema,
-    FileDiffSchema,
-    GitActionResultSchema,
     GitBranchCreateAtSchema,
-    GitBranchCreateSchema,
     GitBranchDeleteSchema,
     GitBranchesSchema,
     GitChangesSchema,
-    GitCheckoutSchema,
-    GitCommitActionSchema,
-    GitCommitDiffQuerySchema,
-    GitCommitDiffSchema,
-    GitCommitFileDiffQuerySchema,
     GitFileDiffQuerySchema,
     GitFileQuerySchema,
     GitFileSchema,
     GitFilesSchema,
     GitFileWriteSchema,
+    GitOperationStateSchema,
+    GitRemoteStateSchema,
+    GitStageSchema,
+    GitStatusSchema,
+    PushSchema,
+} from "../schemas/git.js";
+import {
+    GitActionResultSchema,
+    GitBranchCreateSchema,
+    GitCheckoutSchema,
+    GitCommitActionSchema,
+    GitCommitDiffQuerySchema,
+    GitCommitDiffSchema,
+    GitCommitFileDiffQuerySchema,
     GitLogQuerySchema,
     GitLogSchema,
-    GitOperationStateSchema,
     GitPublishFileResultSchema,
     GitPublishFileSchema,
-    GitUndoSchema,
-    GitUndoStateSchema,
     GitRemoteReposSchema,
-    GitRemoteStateSchema,
     GitReposSchema,
     GitResetSchema,
-    GitStageSchema,
-    GitStatusSchema,
     GitTagCreateSchema,
     GitTagDeleteSchema,
     GitTagPushSchema,
-    OkSchema,
-    PushSchema,
-    RepoParamSchema,
+    GitUndoSchema,
+    GitUndoStateSchema,
     StashApplySchema,
     StashDiffQuerySchema,
     StashListSchema,
     StashPushSchema,
     StashRefParamSchema,
-} from "../schemas.js";
+} from "../schemas/git-history.js";
+import { FileDiffSchema } from "../schemas/history.js";
+import { OkSchema, RepoParamSchema } from "../schemas/shared.js";
 
 // Per-repo git ops over the workspace repos: "root" (the /work repo) plus every discovered repo under /work
 // ({repo} is the repo's root-relative dir, URL-encoded). An unknown {repo} is a handler-thrown

package/src/contracts/grok.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { AccountIdSchema, DeviceStartSchema, OauthAccountListSchema, OkSchema } from "../schemas.js";
+import { AccountIdSchema, DeviceStartSchema, OauthAccountListSchema } from "../schemas/provider-oauth.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // xAI Grok (via OpenCode) uses subscription OAuth, the sandbox owns the credential (OpenCode persists the
 // tokens and refreshes them). `start` authorizes xAI's headless device-code method and returns the verification

package/src/contracts/history.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { FileDiffSchema, OkSchema, SnapshotDiffSchema, SnapshotFileDiffQuerySchema, SnapshotIdSchema, SnapshotsListSchema } from "../schemas.js";
+import { FileDiffSchema, SnapshotDiffSchema, SnapshotFileDiffQuerySchema, SnapshotIdSchema, SnapshotsListSchema } from "../schemas/history.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Workspace history: daemon-owned snapshots of /work with diff + restore. `diff` compares a checkpoint against
 // the previous visible checkpoint (everything that happened since it, hidden interval captures included); an

package/src/contracts/host.contract.ts

@@ -1,6 +1,9 @@
 import { eventIterator, oc } from "@orpc/contract";
 import { z } from "zod";
-import { HostFactsSchema, HostScopesSchema, MachineFlowLineSchema, MachineSandboxFlowSchema, OkSchema } from "../schemas.js";
+import { MachineFlowLineSchema, MachineSandboxFlowSchema } from "../schemas/computers.js";
+import { HostScopesSchema } from "../schemas/capabilities.js";
+import { HostFactsSchema } from "../schemas/hosts.js";
+import { OkSchema } from "../schemas/shared.js";
 
 /* What a connected computer can be ASKED, over the socket it opened to this sandbox.
  *

package/src/contracts/intentic.contract.ts

@@ -1,6 +1,7 @@
 import { eventIterator, oc } from "@orpc/contract";
 import { IntenticLineSchema } from "../events.js";
-import { IntenticRunSchema, OkSchema } from "../schemas.js";
+import { IntenticRunSchema } from "../schemas/intentic.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Run the in-sandbox intentic CLI (resolve/plan/apply/deployments/…) and stream its ndjson lines as they
 // arrive, so the UI sees live progress. A non-zero exit surfaces as a thrown error once the stream ends.

package/src/contracts/inventory.contract.ts

@@ -1,5 +1,5 @@
 import { oc } from "@orpc/contract";
-import { AddInventoryInputSchema, InventoryListSchema, InventoryNameParamSchema } from "../schemas.js";
+import { AddInventoryInputSchema, InventoryListSchema, InventoryNameParamSchema } from "../schemas/inventory.js";
 
 // The i.have.* / i.want.service entries in deploy.config.ts's managed region. add/remove rewrite the region and
 // commit it (mirroring an agent edit) and return the full updated list so the UI re-renders from one response.

package/src/contracts/issues.contract.ts

@@ -0,0 +1,60 @@
+import { oc } from "@orpc/contract";
+import { IssueIdParamSchema, IssueInstallsSchema, IssueIntakeIdParamSchema, IssuesListSchema, IssueStatusInputSchema } from "../schemas/issues.js";
+import { OkSchema } from "../schemas/shared.js";
+
+/* The issues inbox: bug reports that arrived from the owner's own sites and apps, grouped by fingerprint.
+ *
+ * THE OWNER'S SIDE ONLY. Reports come in through the public `/intake/…` routes, which are deliberately a
+ * different prefix rather than a verb on this one: those are reachable by any browser on the internet, these
+ * are not, and two id spaces (an automation's public id out there, an issue's fingerprint in here) sharing one
+ * path prefix is how a widened rule stops being visible.
+ *
+ * Nothing here creates an issue. The daemon writes them; this is triage. */
+export const issuesContract = {
+    list: oc
+        .route({
+            method: "GET",
+            path: "/issues",
+            summary: "Bugs your users have reported",
+            description: "Everything that has crashed or been written in, grouped so a crash that hit a thousand people is one row with a count.",
+        })
+        .output(IssuesListSchema),
+    status: oc
+        .route({
+            method: "POST",
+            path: "/issues/{id}/status",
+            summary: "File one away, or reopen it",
+            description: "Moves one issue between open, resolved and ignored. Resolving does not close anything upstream: it is your own inbox.",
+        })
+        .input(IssueStatusInputSchema)
+        .output(OkSchema),
+    investigate: oc
+        .route({
+            method: "POST",
+            path: "/issues/{id}/investigate",
+            summary: "Put an agent on it now",
+            description:
+                "Starts a turn on this issue with the crash, its stack and what led up to it as the brief. Answers straight away and runs detached; the issue goes to 'being looked at'.",
+        })
+        .input(IssueIdParamSchema)
+        .output(OkSchema),
+    remove: oc
+        .route({
+            method: "DELETE",
+            path: "/issues/{id}",
+            summary: "Throw one away",
+            description: "Forgets an issue entirely. It will come back as new if it happens again, which is usually what you want.",
+        })
+        .input(IssueIdParamSchema)
+        .output(OkSchema),
+    installs: oc
+        .route({
+            method: "GET",
+            path: "/issues/installs/{automationId}",
+            summary: "Which sites have loaded the reporter",
+            description:
+                "The sites whose pages actually loaded this intake's script, and the ones that were turned away. The answer to 'did the snippet land?', which an empty inbox cannot give you.",
+        })
+        .input(IssueIntakeIdParamSchema)
+        .output(IssueInstallsSchema),
+};

package/src/contracts/logs.contract.ts

@@ -1,5 +1,11 @@
 import { oc } from "@orpc/contract";
-import { ClientDiagnosticsAcceptedSchema, ClientDiagnosticsReportSchema, LogReadQuerySchema, LogReadSchema, LogsListSchema } from "../schemas.js";
+import {
+    ClientDiagnosticsAcceptedSchema,
+    ClientDiagnosticsReportSchema,
+    LogReadQuerySchema,
+    LogReadSchema,
+    LogsListSchema,
+} from "../schemas/logs.js";
 
 // Daemon-owned debug logs (historyRoot/logs): terminal pipe-pane captures, intentic CLI run logs, daemon.log.
 // Reads are read-only by design, the files are written by the daemon/tmux only, so the record stays

package/src/contracts/loops.contract.ts

@@ -8,8 +8,8 @@ import {
     LoopRecordSchema,
     LoopSchema,
     LoopsListSchema,
-    OkSchema,
-} from "../schemas.js";
+} from "../schemas/loops.js";
+import { OkSchema } from "../schemas/shared.js";
 
 /* The loop routes, "run this conversation again until the goal is met".
  *

package/src/contracts/panels.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, PanelRepoParamSchema, PanelsListSchema } from "../schemas.js";
+import { PanelRepoParamSchema, PanelsListSchema } from "../schemas/panels.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Per-repository dev servers + the content facts the web app's extensions detect on. `list` enumerates every
 // repo with its runtime status + facts; `start`/`stop` drive the repo's dev server. Their tmux sessions list

package/src/contracts/personas.contract.ts

@@ -1,15 +1,15 @@
 import { oc } from "@orpc/contract";
 import {
-    OkSchema,
     PersonaIdParamSchema,
     PersonaKitSchema,
     PersonaPromptSchema,
     PersonaSchema,
-    PersonasListSchema,
     PersonaSkillBodySchema,
     PersonaSkillNameSchema,
     PersonaSkillSchema,
-} from "../schemas.js";
+    PersonasListSchema,
+} from "../schemas/personas.js";
+import { OkSchema } from "../schemas/shared.js";
 
 /* The sandbox's named personas (PersonaSchema): which connected accounts each one speaks for, what a session
  * wearing it may do, where it works, and what it is told. The card half is a plain three-verb CRUD with no apply

package/src/contracts/ports.contract.ts

@@ -1,8 +1,9 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, PortForwardResultSchema, PortParamSchema, PortsListSchema } from "../schemas.js";
+import { PortForwardResultSchema, PortParamSchema, PortsListSchema } from "../schemas/ports.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Listening TCP ports in the sandbox + explicit forwarding through the preview proxy (see the ports section in
-// schemas.ts). `forward` is idempotent, re-forwarding a port returns its existing slot's URL; `unforward`
+// schemas/ports.ts). `forward` is idempotent, re-forwarding a port returns its existing slot's URL; `unforward`
 // frees the slot immediately (the hostname keeps resolving, the proxy just stops mapping it).
 export const portsContract = {
     list: oc

package/src/contracts/prepush.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, PrepushRunSchema } from "../schemas.js";
+import { PrepushRunSchema } from "../schemas/ci.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // The pre-push check, the command the workspace runs when the user pushes, before anything leaves the machine
 // (see PrepushRunSchema for where this sits and why). Three verbs about ONE run: the check answers about the

package/src/contracts/providers.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { ModelsSchema, NativeProviderParamSchema } from "../schemas.js";
+import { NativeProviderParamSchema } from "../schemas/agent.js";
+import { ModelsSchema } from "../schemas/provider-oauth.js";
 
 // EVERY NATIVE PROVIDER'S PICKER CATALOG, ON ONE ROUTE.
 //

package/src/contracts/public.contract.ts

@@ -1,7 +1,8 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, PublicListSchema, PublishResultSchema, PublishSchema, UnpublishSchema } from "../schemas.js";
+import { PublicListSchema, PublishResultSchema, PublishSchema, UnpublishSchema } from "../schemas/public.js";
+import { OkSchema } from "../schemas/shared.js";
 
-// The workspace outbox, what `public/` currently holds and its address (see the public section in schemas.ts).
+// The workspace outbox, what `public/` currently holds and its address (see schemas/public.ts).
 // `publish` copies a workspace file or directory in, creating the outbox if this is the first one; `unpublish`
 // withdraws one and removes the outbox behind the last, so the directory's presence always means exactly "there
 // is something published". There is no route to READ a published file: that is the whole point of the

package/src/contracts/push.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, PushChannelIdSchema, PushChannelSchema, PushConfigQuerySchema, PushConfigSchema, PushTestSchema } from "../schemas.js";
+import { PushChannelIdSchema, PushChannelSchema, PushConfigQuerySchema, PushConfigSchema, PushTestSchema } from "../schemas/push.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Push notifications for this sandbox. The daemon owns the VAPID keypair and the channel list (see
 // push/push-store.ts for why the key lives on the history volume), and sends on the three moments where the

package/src/contracts/runner.contract.ts

@@ -2,7 +2,9 @@ import { eventIterator, oc } from "@orpc/contract";
 import { z } from "zod";
 import { AgentEventSchema } from "../events.js";
 import { RunnerFactsSchema, RunnerSyncLineSchema, RunnerSyncSchema, RunnerTurnSchema } from "../runner-protocol.js";
-import { AgentReplySchema, EditorContextSchema, OkSchema } from "../schemas.js";
+import { EditorContextSchema } from "../schemas/agent.js";
+import { AgentReplySchema } from "../schemas/plan-limits.js";
+import { OkSchema } from "../schemas/shared.js";
 
 /* What a RUNNER can be asked, over the socket it opened to its parent sandbox. Phase-1 skeleton: the shape is
  * decided (docs/remote-runners-plan.md §5, workspace root), the implementations land with runner mode.
@@ -40,8 +42,22 @@ export const runnerContract = {
      * editor context UNCOMPOSED: the note over those paths has to be built against the runner's own
      * workspace root, since that is the machine whose files the agent will open. */
     steer: oc
-        .input(z.object({ conversationId: z.string().min(1), text: z.string(), attachments: z.array(z.string()).optional(), editorContext: EditorContextSchema.optional() }))
+        .input(
+            z.object({
+                conversationId: z.string().min(1),
+                text: z.string(),
+                attachments: z.array(z.string()).optional(),
+                editorContext: EditorContextSchema.optional(),
+            }),
+        )
         .output(z.object({ applied: z.boolean(), invalid: z.string().optional() })),
+    /* The parent pushing its declared shape onto this runner: a settings-only definition (sandbox.toml text,
+     * runner-protocol.ts's hello says why settings are all a runner declares). REPLACE semantics, not the
+     * owner-facing apply's merge-beside: a key the definition omits returns to its default, because the parent
+     * is a runner's whole authority and "make this runner match" must also unset what the parent unset. The
+     * answer names the keys now holding non-default values, which is what the parent adopts as the runner's
+     * new declared shape without waiting for a reconnect. */
+    applyDefinition: oc.input(z.object({ toml: z.string() })).output(z.object({ settings: z.array(z.string()) })),
     // Stop the running turn; the parent's stop button reaching through.
     interrupt: oc.input(RunnerTurnSchema.pick({ conversationId: true })).output(OkSchema),
     // Liveness, driven by the parent: keepalive and gone-detection in one, the host hub's heartbeat verbatim.

package/src/contracts/secrets.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, SecretInventorySchema, SecretKeyParamSchema, SecretKeysSchema, SecretRevealSchema, SecretSetSchema } from "../schemas.js";
+import { SecretInventorySchema, SecretKeyParamSchema, SecretKeysSchema, SecretRevealSchema, SecretSetSchema } from "../schemas/secrets.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // User-supplied env-var secrets, written to the sandbox's gitignored desired-state/.env (which
 // `apply` reloads each run, no restart). `set` upserts one KEY=value, `remove` deletes it; `list` returns the

package/src/contracts/sessions.contract.ts

@@ -1,7 +1,7 @@
 import { oc } from "@orpc/contract";
 import { z } from "zod";
 import { SessionTranscriptSchema } from "../events.js";
-import { SessionIdParamSchema, SessionsListSchema } from "../schemas.js";
+import { SessionIdParamSchema, SessionsListSchema } from "../schemas/sessions.js";
 
 // Past conversations in this workspace (the SDK-native session store, keyed on the working dir, which for a
 // repo covers its linked worktrees too, so an isolated conversation's transcript is reachable from the

package/src/contracts/settings.contract.ts

@@ -1,13 +1,7 @@
 import { oc } from "@orpc/contract";
-import {
-    BuiltinPromptSchema,
-    BuiltinPromptTextSchema,
-    DayWindowQuerySchema,
-    OkSchema,
-    RuleFiringsSchema,
-    SandboxSettingsSchema,
-    SavingsReportSchema,
-} from "../schemas.js";
+import { BuiltinPromptSchema, BuiltinPromptTextSchema, RuleFiringsSchema, SandboxSettingsSchema, SavingsReportSchema } from "../schemas/settings.js";
+import { OkSchema } from "../schemas/shared.js";
+import { DayWindowQuerySchema } from "../schemas/usage.js";
 
 // Per-sandbox agent settings (.intentic/config/settings.json). `get` returns the current flags with defaults applied
 // when the file is absent; `set` overwrites them. `savings` reports what each token-reduction mechanism was

package/src/contracts/share.contract.ts

@@ -1,7 +1,8 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, ShareCreateSchema, ShareListSchema, ShareRemoveSchema, ShareUpdateSchema, SharedConversationSchema } from "../schemas.js";
+import { ShareCreateSchema, SharedConversationSchema, ShareListSchema, ShareRemoveSchema, ShareUpdateSchema } from "../schemas/share.js";
+import { OkSchema } from "../schemas/shared.js";
 
-/* Conversations published as read-only pages (see the share section in schemas.ts).
+/* Conversations published as read-only pages (see schemas/share.ts).
  *
  * Its own group rather than two more routes on `public`, because the two speak different path spaces and mean
  * different things by "publish". The outbox's routes take a path in the workspace and copy the bytes at it; a

package/src/contracts/skills.contract.ts

@@ -1,5 +1,6 @@
 import { oc } from "@orpc/contract";
-import { OkSchema, SkillBodySchema, SkillDraftSchema, SkillIdSchema, SkillRemoveSchema, SkillsListSchema } from "../schemas.js";
+import { SkillBodySchema, SkillDraftSchema, SkillIdSchema, SkillRemoveSchema, SkillsListSchema } from "../schemas/settings.js";
+import { OkSchema } from "../schemas/shared.js";
 
 /* WHAT THE AGENT KNOWS RIGHT NOW, and which half of it the owner controls.
  *

package/src/contracts/system.contract.ts

@@ -1,24 +1,21 @@
 import { eventIterator, oc } from "@orpc/contract";
 import { z } from "zod";
 import { SessionTranscriptSchema, SystemEventSchema } from "../events.js";
+import { MachineFlowLineSchema, MachineSandboxFlowInputSchema } from "../schemas/computers.js";
+import { PresenceReportSchema } from "../schemas/logs.js";
+import { OkSchema } from "../schemas/shared.js";
+import { DaemonSessionSchema, InfoSchema, ManifestProblemsSchema } from "../schemas/system.js";
 import {
     BrowserNameParamSchema,
     BrowsersListSchema,
-    DaemonSessionSchema,
-    InfoSchema,
-    ManifestProblemsSchema,
-    MachineFlowLineSchema,
-    MachineSandboxFlowInputSchema,
-    OkSchema,
-    PresenceReportSchema,
     SubagentIdParamSchema,
     SubagentsListSchema,
     TerminalNameParamSchema,
     TerminalScrollbackQuerySchema,
     TerminalScrollbackSchema,
     TerminalsListSchema,
-    UsageSummarySchema,
-} from "../schemas.js";
+} from "../schemas/terminal.js";
+import { UsageSummarySchema } from "../schemas/usage.js";
 
 // Sandbox status + identity, the long-lived liveness stream, and the connect-token-relayed host tunnel.
 // `events` interleaves heartbeat frames (browser holds it open to detect the sandbox dying instantly) with

package/src/contracts/translator.contract.ts

@@ -1,6 +1,9 @@
 import { oc } from "@orpc/contract";
 import { z } from "zod";
-import { KeyedProviderSchema, OkSchema, TranslatorAccountsSchema, TranslatorCompleteSchema, TranslatorStartSchema } from "../schemas.js";
+import { TranslatorAccountsSchema } from "../schemas/plan-limits.js";
+import { TranslatorCompleteSchema, TranslatorStartSchema } from "../schemas/provider-oauth.js";
+import { KeyedProviderSchema } from "../schemas/provider-subscriptions.js";
+import { OkSchema } from "../schemas/shared.js";
 
 // Routed-provider subscriptions (Sandbox ▸ Agent). The bundled translator (CLIProxyAPI) runs a non-Claude model
 // UNDER the Claude Code harness on the user's SUBSCRIPTION, so each provider connects via an OAuth login rather

package/src/contracts/usage.contract.ts

@@ -1,5 +1,5 @@
 import { oc } from "@orpc/contract";
-import { DayWindowQuerySchema, UsageRollupSchema } from "../schemas.js";
+import { DayWindowQuerySchema, UsageRollupSchema } from "../schemas/usage.js";
 
 // The durable spend ledger (see UsageTurnSchema). Read-only over the wire, rows are appended daemon-side at
 // turn end, so the ledger stays a trustworthy record of what was actually spent, the same principle as the

package/src/contracts/vpn.contract.ts

@@ -1,13 +1,7 @@
 import { eventIterator, oc } from "@orpc/contract";
 import { IntenticLineSchema } from "../events.js";
-import {
-    ForticlientImportInputSchema,
-    ForticlientImportSchema,
-    OkSchema,
-    VpnConnectInputSchema,
-    VpnIdParamSchema,
-    VpnListSchema,
-} from "../schemas.js";
+import { OkSchema } from "../schemas/shared.js";
+import { ForticlientImportInputSchema, ForticlientImportSchema, VpnConnectInputSchema, VpnIdParamSchema, VpnListSchema } from "../schemas/vpn.js";
 
 // The live VPN surface. A VPN is ADDED as a `vpn` capability (credentials, autoConnect, capabilities.contract);
 // it is DIALLED here. The split is deliberate: connecting is a runtime operation that both the operator (the

package/src/contracts/webext.contract.ts

@@ -0,0 +1,37 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+import { WebExtScopesSchema } from "../schemas/capabilities.js";
+import { OkSchema } from "../schemas/shared.js";
+import { WebExtFactsSchema } from "../schemas/webext.js";
+
+/* What a connected BROWSER can be asked, over the socket its extension opened to this sandbox.
+ *
+ * The inversion is the host contract's (contracts/host.contract.ts): the extension dialled out, and the
+ * extension is the oRPC SERVER. A browser cannot be dialled — it is behind the same NAT as the laptop it runs
+ * on, and it is not even a process that is always there — so it can only be the side that connects, while
+ * everything is asked OF it.
+ *
+ * `mcp` IS THE SAME DELIBERATE HOLE IN THE TYPING, for the same reason: if this contract described each tool,
+ * a browser could not learn one without a matching daemon release, and the daemon would have to hold every
+ * tool's schema to translate. Keeping one opaque procedure buys the extension the Chrome Web Store's release
+ * cycle, which is measured in review days and is not this daemon's to wait on. The payload is still validated
+ * where it is understood: in the extension, against the tool's own schema.
+ *
+ * There is no `runSandboxFlow` twin here. A browser runs nothing that takes minutes and narrates itself; every
+ * one of its operations is a click or a read that either happened or did not. */
+export const webextContract = {
+    // What this browser is, and what it is currently allowed to touch: pulled right after the socket
+    // authenticates and again whenever the card is read, because the grant list changes IN THE BROWSER (the
+    // person clicks Allow on a site) rather than here, so a cached copy would be a card that lies.
+    describe: oc.output(WebExtFactsSchema),
+    /* The switches the owner ticked on the capability card. The extension ENFORCES them; nothing on this side
+     * checks one. Note what is NOT in here: which sites the agent may touch. Those are Chrome's own optional
+     * host permissions, granted by the person in the browser and revocable there, so the strongest boundary in
+     * this feature is one the sandbox cannot even describe, let alone widen. */
+    setScopes: oc.input(WebExtScopesSchema).output(OkSchema),
+    // Liveness, driven by the daemon: doubles as the keepalive for the tunnel and as the probe whose failure
+    // means the browser is closed rather than quiet.
+    ping: oc.output(OkSchema),
+    // One MCP JSON-RPC message in, its answer out, forwarded verbatim in both directions. See above.
+    mcp: oc.input(z.unknown()).output(z.unknown()),
+};

package/src/contracts/workflows.contract.ts

@@ -1,6 +1,6 @@
 import { oc } from "@orpc/contract";
+import { OkSchema } from "../schemas/shared.js";
 import {
-    OkSchema,
     WorkflowIdParamSchema,
     WorkflowRunIdParamSchema,
     WorkflowRunSchema,
@@ -9,7 +9,7 @@ import {
     WorkflowSaveSchema,
     WorkflowSchema,
     WorkflowsListSchema,
-} from "../schemas.js";
+} from "../schemas/workflows.js";
 
 /* The workflow routes, "run these sessions, in this order, each handing its result to the next".
  *

package/src/contracts/workspace.contract.ts

@@ -1,17 +1,23 @@
 import { oc } from "@orpc/contract";
+import { WorkspaceHealthQuerySchema, WorkspaceHealthSchema } from "../schemas/codebase-health.js";
+import { WorkspaceModulesSchema } from "../schemas/git.js";
+import { OkSchema } from "../schemas/shared.js";
 import {
     AddAppsSchema,
     AppParamSchema,
     AppsListSchema,
     CloneRepoSchema,
     CloneResultSchema,
-    WorkspaceSearchResultSchema,
-    WorkspaceSearchQuerySchema,
-    OkSchema,
     RepoAppsParamSchema,
     ReposListSchema,
     RunTestsSchema,
     TemplatesListSchema,
+    WorkspaceGraphSchema,
+    WorkspaceSyncSchema,
+} from "../schemas/workspace-repos.js";
+import { WorkspaceSearchQuerySchema, WorkspaceSearchResultSchema } from "../schemas/workspace-search.js";
+import { WorkspaceInstallResultSchema, WorkspaceInstallSchema, WorkspaceSetupSchema } from "../schemas/workspace-setup.js";
+import {
     WorkspaceChildrenQuerySchema,
     WorkspaceChildrenSchema,
     WorkspaceClassificationSchema,
@@ -19,22 +25,14 @@ import {
     WorkspaceFileQuerySchema,
     WorkspaceFileReadQuerySchema,
     WorkspaceFileSchema,
-    WorkspaceGraphSchema,
-    WorkspaceHealthQuerySchema,
-    WorkspaceHealthSchema,
-    WorkspaceInstallResultSchema,
-    WorkspaceInstallSchema,
     WorkspaceMediaTicketQuerySchema,
     WorkspaceMediaTicketSchema,
-    WorkspaceModulesSchema,
     WorkspaceMoveSchema,
     WorkspaceResolveQuerySchema,
     WorkspaceResolveSchema,
     WorkspaceScopeSchema,
-    WorkspaceSetupSchema,
-    WorkspaceSyncSchema,
     WorkspaceTreeSchema,
-} from "../schemas.js";
+} from "../schemas/workspace-tree.js";
 
 // The full /work view + extra-repo cloning. The binary preview (/workspace/raw) is intentionally NOT here, it
 // stays a plain Hono route serving raw bytes with a Content-Type header (oRPC's request/response shape doesn't

package/src/conversation-ids.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, expect, test, vi } from "vitest";
 import { newConversationId } from "./conversation-ids.js";
-import { ConversationIdSchema } from "./schemas.js";
+import { ConversationIdSchema } from "./schemas/agent.js";
 
 const mockRandomValues = (values: readonly number[]) => {
     const remaining = [...values];