@intentic/sandbox-contract 1.329.0 → 1.331.0

package/dist/text/transcript-page.d.ts

@@ -0,0 +1,5 @@
+import type { TranscriptRow, TranscriptTool } from "../events/transcript.js";
+export declare const PAGE_TEXT_CAP = 8000;
+export declare const fitPageRow: <Row extends TranscriptRow>(row: Row) => Row;
+export declare const fitNestedTool: (tool: TranscriptTool) => TranscriptTool;
+//# sourceMappingURL=transcript-page.d.ts.map

package/dist/text/transcript-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-page.d.ts","sourceRoot":"","sources":["../../src/text/transcript-page.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAS7E,eAAO,MAAM,aAAa,OAAQ,CAAC;AAkBnC,eAAO,MAAM,UAAU,GAAI,GAAG,SAAS,aAAa,OAAO,GAAG,KAAG,GACgB,CAAC;AAGlF,eAAO,MAAM,aAAa,SAAU,cAAc,KAAG,cAInD,CAAC"}

package/dist/text/transcript-page.js

@@ -0,0 +1,17 @@
+export const PAGE_TEXT_CAP = 8_000;
+const fitContent = (entry) => entry.type === "text" && entry.text.length > PAGE_TEXT_CAP ? { ...entry, text: entry.text.slice(0, PAGE_TEXT_CAP) } : entry;
+const fitPageTool = (tool) => {
+    const { children, content, ...carried } = tool;
+    return {
+        ...carried,
+        ...(content !== undefined ? { content: content.map(fitContent) } : {}),
+        ...(children !== undefined && children.length > 0 ? { nested: children.length } : {}),
+    };
+};
+export const fitPageRow = (row) => row.tools === undefined ? row : { ...row, tools: row.tools.map(fitPageTool) };
+export const fitNestedTool = (tool) => ({
+    ...tool,
+    ...(tool.content !== undefined ? { content: tool.content.map(fitContent) } : {}),
+    ...(tool.children !== undefined ? { children: tool.children.map(fitNestedTool) } : {}),
+});
+//# sourceMappingURL=transcript-page.js.map

package/dist/text/transcript-page.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-page.js","sourceRoot":"","sources":["../../src/text/transcript-page.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC;AAEnC,MAAM,UAAU,GAAG,CAAC,KAAsB,EAAmB,EAAE,CAC3D,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AAKhI,MAAM,WAAW,GAAG,CAAC,IAAoB,EAAkB,EAAE;IACzD,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/C,OAAO;QACH,GAAG,OAAO;QACV,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACtE,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxF,CAAC;AACN,CAAC,CAAC;AAGF,MAAM,CAAC,MAAM,UAAU,GAAG,CAA4B,GAAQ,EAAO,EAAE,CACnE,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;AAGlF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAoB,EAAkB,EAAE,CAAC,CAAC;IACpE,GAAG,IAAI;IACP,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAChF,GAAG,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;CACzF,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/sandbox-contract",
-  "version": "1.329.0",
+  "version": "1.331.0",
   "description": "oRPC wire contract for the intentic sandbox daemon, shared by the daemon and its browser client",
   "license": "MIT",
   "type": "module",
@@ -306,10 +306,10 @@
     }
   },
   "dependencies": {
-    "@intentic/base": "1.329.0",
-    "@intentic/constants": "1.329.0",
-    "@intentic/extension-manifest": "1.329.0",
-    "@intentic/registry": "1.329.0",
+    "@intentic/base": "1.331.0",
+    "@intentic/constants": "1.331.0",
+    "@intentic/extension-manifest": "1.331.0",
+    "@intentic/registry": "1.331.0",
     "@orpc/contract": "1.15.4",
     "tslib": "2.8.1",
     "zod": "4.6.5"

package/src/chores/probes.ts

@@ -86,7 +86,6 @@ const STANDALONE_DIRS =
     `sed -n -e 's|/\\*\\*[[:space:]]*$||' -e 's|^[[:space:]]*-[[:space:]]*!\\([^[:space:]#]*\\).*$|\\1|p'`;
 
 // The line that opens one standalone package's report, as JSON so a guard can still read the stream with `jq -s`.
-const STANDALONE_KEY = `standalone`;
 const STANDALONE_LINE = /^\{"standalone":"([^"]*)"\}$/;
 
 // Runs `measure` against each standalone package in a scratch copy, never in place: `--lockfile-only` would write
@@ -97,7 +96,7 @@ const STANDALONE_LINE = /^\{"standalone":"([^"]*)"\}$/;
 const standaloneCommand = (measure: string): string =>
     `${STANDALONE_DIRS} | while IFS= read -r dir; do ` +
     `[ -f "$dir/package.json" ] || continue; ` +
-    `printf '{"${STANDALONE_KEY}":"%s"}\\n' "$dir"; ` +
+    `printf '{"standalone":"%s"}\\n' "$dir"; ` +
     `scratch=$(mktemp -d) || continue; ` +
     `for file in package.json pnpm-lock.yaml package-lock.json .npmrc; do [ -f "$dir/$file" ] && cp "$dir/$file" "$scratch/"; done; ` +
     `( cd "$scratch" && { [ -f pnpm-lock.yaml ] || { [ -f package-lock.json ] && pnpm import >/dev/null 2>&1; } || ` +

package/src/contracts/device.contract.ts

@@ -7,7 +7,7 @@ import { DeviceFactsSchema } from "../schemas/hosts.js";
 import { LoopbackCatchEventSchema, LoopbackCatchSchema } from "../schemas/loopback-catch.js";
 import { OkSchema } from "../schemas/shared.js";
 import { ProjectDeliveryResultSchema, ProjectDeliverySchema } from "../schemas/project-delivery.js";
-import { StageArtifactResultSchema, StageArtifactSchema } from "../schemas/device-artifacts.js";
+import { DialLoopbackSchema, StageArtifactResultSchema, StageArtifactSchema } from "../schemas/device-artifacts.js";
 
 // What a connected device can be asked, over the socket it opened; the machine is the oRPC server, the daemon the
 // client. No `.route()`: the procedure path is the address, not HTTP. Every input is strict (devices.ts says why). `mcp` stays opaque (`z.unknown()`) so a machine
@@ -41,4 +41,9 @@ export const deviceContract = {
     // Only the daemon calls it, for the agent's `devices push`, and only on an agent advertising `programs`; the machine
     // refuses every op unless "Run programs this sandbox sends" is on.
     stageArtifact: oc.input(StageArtifactSchema).output(StageArtifactResultSchema),
+    // A connection to the sandbox side of a `devices reach` tunnel: the machine dials its own 127.0.0.1:<port> and, once
+    // that answered, opens a WebSocket back to /system/hosts/tunnel with the ticket. Answers once the local port took
+    // the connection, or throws (nothing listening there, the switch is off). Advertised with `programs`; the machine
+    // allows it when "Run commands" or "Run programs this sandbox sends" is on, either of which already reaches it.
+    dialLoopback: oc.input(DialLoopbackSchema).output(z.object({ ok: z.literal(true) })),
 };

package/src/contracts/runs.contract.ts

@@ -0,0 +1,26 @@
+import { procedure } from "../protocol/route-meta.js";
+import { RUN_TARGETS_FILE, RunStartedSchema, RunStartSchema, RunTargetsListSchema } from "../schemas/run-targets.js";
+
+// A repository's programs run on the owner's own computers (schemas/run-targets.ts): what each repository declares, and
+// the button that runs one. The run itself is `devices run` in a terminal, the same command an agent runs, so what the
+// owner watches is what an agent gets.
+export const runsContract = {
+    targets: procedure
+        .route({
+            method: "GET",
+            path: "/runs/targets",
+            summary: "What each repository can run on your computers",
+            description: `Every repository that declares run targets at \`${RUN_TARGETS_FILE}\`, and which of your computers could run one now.`,
+        })
+        .output(RunTargetsListSchema),
+    start: procedure
+        .route({
+            method: "POST",
+            path: "/runs/start",
+            summary: "Run a target on one of your computers",
+            description:
+                "Builds it in the sandbox, carries the build to the computer and starts it there, in a terminal you can watch. The computer still decides: its \"Run programs this sandbox sends\" switch has to be on.",
+        })
+        .input(RunStartSchema)
+        .output(RunStartedSchema),
+};

package/src/contracts/system.contract.ts

@@ -17,6 +17,7 @@ import { DaemonSessionSchema, InfoSchema, ManifestProblemsSchema, ManifestRepair
 import { AutoUpdateInputSchema, AutoUpdateSchema, SkipUpdateInputSchema } from "../schemas/updates.js";
 import {
     BrowserNameParamSchema,
+    BrowserPageParamSchema,
     BrowsersListSchema,
     OpenBrowserInputSchema,
     OpenBrowserResultSchema,
@@ -253,6 +254,18 @@ export const systemContract = {
         })
         .input(BrowserNameParamSchema)
         .output(OkSchema),
+    // One tab, closed without watching its window: the Browsers strip shows every window's tabs, and only the window in
+    // front has a picture socket to say a close on.
+    closeBrowserPage: systemRoute
+        .route({
+            method: "DELETE",
+            path: "/system/browsers/{name}/pages/{pageId}",
+            summary: "Close one tab of a browser",
+            description:
+                "Closes one tab of a browser window, as its own close button does. A tab that is already gone answers the same, since gone is what was asked for.",
+        })
+        .input(BrowserPageParamSchema)
+        .output(OkSchema),
     // The picture and the hands come over /system/desktop-view; this is whether there is anything on it, and which windows
     // a tab could show alone. Pushed through the `desktop` runtime domain as windows open, close and take the keyboard,
     // and as their titles change while a view is open; never polled by the client.

package/src/contracts/workspace.contract.ts

@@ -13,9 +13,9 @@ import {
     ReposListSchema,
     RunTestsSchema,
     TemplatesListSchema,
-    WorkspaceGraphSchema,
     WorkspaceSyncSchema,
 } from "../schemas/workspace/workspace-repos.js";
+import { PackageModulesParamSchema, PackageModulesSchema, WorkspaceGraphSchema } from "../schemas/workspace/workspace-graph.js";
 import { WorkspaceSearchQuerySchema, WorkspaceSearchResultSchema } from "../schemas/workspace/workspace-search.js";
 import { WorkspaceInstallResultSchema, WorkspaceInstallSchema, WorkspaceSetupSchema } from "../schemas/workspace/workspace-setup.js";
 import {
@@ -341,6 +341,17 @@ export const workspaceContract = {
         })
         .input(RepoAppsParamSchema)
         .output(WorkspaceGraphSchema),
+    // One package's modules grouped into units, and the value imports between them, placed in its declared layers.
+    packageModules: procedure
+        .route({
+            method: "GET",
+            path: "/workspace/repos/{repo}/layers",
+            summary: "How one package's modules import each other",
+            description:
+                "One workspace package's source directories as units, the value imports between them, and the layers its layers.json declares, which is what a view of its insides draws.",
+        })
+        .input(PackageModulesParamSchema)
+        .output(PackageModulesSchema),
     // Every repo's package dirs in one call, since a review spans repos and per-repo would fan out per open.
     modules: procedure
         .route({

package/src/index.ts

@@ -28,6 +28,7 @@ import { loopsContract } from "./contracts/loops.contract.js";
 import { pagesContract } from "./contracts/pages.contract.js";
 import { panelsContract } from "./contracts/panels.contract.js";
 import { portsContract } from "./contracts/ports.contract.js";
+import { runsContract } from "./contracts/runs.contract.js";
 import { publicContract } from "./contracts/public.contract.js";
 import { netdiskContract } from "./contracts/netdisk.contract.js";
 import { providersContract } from "./contracts/providers.contract.js";
@@ -96,6 +97,7 @@ export * from "./protocol/vitals.js";
 export { loopsContract } from "./contracts/loops.contract.js";
 export { panelsContract } from "./contracts/panels.contract.js";
 export { portsContract } from "./contracts/ports.contract.js";
+export { runsContract } from "./contracts/runs.contract.js";
 export { pagesContract, PageAppCallResultSchema, PageAppCallSchema, PageErrorsResultSchema, PageErrorsSchema } from "./contracts/pages.contract.js";
 export { publicContract } from "./contracts/public.contract.js";
 export { providersContract, type RunnableProviders, RunnableProvidersSchema } from "./contracts/providers.contract.js";
@@ -135,6 +137,7 @@ export * from "./events/child-run.js";
 export * from "./policy/turned-away.js";
 export * from "./text/mentions.js";
 export * from "./text/pages.js";
+export * from "./text/transcript-page.js";
 export * from "./protocol/sse.js";
 export * from "./protocol/routes.js";
 export { type ControlReach, defaultFloor, type RouteAccess, type RouteMeta, routeAccess } from "./protocol/route-meta.js";
@@ -200,6 +203,7 @@ export * from "./policy/fence-paths.js";
 export * from "./policy/persona-home.js";
 export * from "./schemas/agents.js";
 export * from "./schemas/speaker.js";
+export * from "./schemas/speech.js";
 export * from "./schemas/approvals.js";
 export * from "./schemas/automations.js";
 export * from "./schemas/agents-list.js";
@@ -212,6 +216,7 @@ export * from "./schemas/context-trim.js";
 export * from "./schemas/devices.js";
 export * from "./schemas/project-delivery.js";
 export * from "./schemas/device-artifacts.js";
+export * from "./schemas/run-targets.js";
 export * from "./schemas/engines.js";
 export * from "./schemas/environment.js";
 export * from "./schemas/exit.js";
@@ -265,6 +270,7 @@ export * from "./schemas/offload.js";
 export * from "./schemas/webext.js";
 export * from "./schemas/phone.js";
 export * from "./schemas/workflows.js";
+export * from "./schemas/workspace/workspace-graph.js";
 export * from "./schemas/workspace/workspace-repos.js";
 export * from "./schemas/workspace/workspace-search.js";
 export * from "./schemas/workspace/workspace-setup.js";
@@ -277,7 +283,6 @@ export * from "./text/title.js";
 export * from "./state/versions.js";
 export * from "./text/model-answer.js";
 export * from "./text/shell-regions.js";
-export * from "./text/whisper.js";
 export * from "./text/workflow-faults.js";
 export * from "./text/emoji.js";
 export * from "./time/zone.js";
@@ -316,6 +321,7 @@ export const sandboxContract = {
     pages: pagesContract,
     panels: panelsContract,
     ports: portsContract,
+    runs: runsContract,
     public: publicContract,
     providers: providersContract,
     push: pushContract,

package/src/models/agent-runtimes.ts

@@ -121,7 +121,7 @@ export const OPENCODE: AgentCapabilities = {
     steering: false,
     permissions: "plan",
     questions: false,
-    // Added at runtime under the conversation's own names, each prompt showing its session only its own (opencode-mcp.ts).
+    // Added at runtime under the conversation's own names, each session's own rules showing it only its own (opencode-mcp.ts).
     mcp: "http",
     execution: ["shell"],
     effort: false,
@@ -131,7 +131,7 @@ export const OPENCODE: AgentCapabilities = {
     terminals: false,
     recovery: false,
     warm: false,
-    // `system` on the prompt body, per message; adds to OpenCode's own prompt, with no seam to replace it.
+    // The session's own instruction entry, set per message; adds to OpenCode's own prompt, with no seam to replace it.
     instructions: "append",
     skillDiscovery: "prompt",
     // OpenCode raises its permission asks for the commands its config names; the daemon answers from the rulebook, a

package/src/models/model-roles.ts

@@ -92,6 +92,14 @@ export const MODEL_ROLES = [
         trigger: "pressed",
         icon: "wrench",
     },
+    {
+        id: "refactor-run",
+        label: "Refactors",
+        blurb: "The agent started from a hotspot or key module on a repository's Health tab.",
+        kind: "run",
+        trigger: "pressed",
+        icon: "hammer",
+    },
     {
         id: "documentation-run",
         label: "Documentation runs",

package/src/models/plan-pools.test.ts

@@ -132,6 +132,22 @@ test("spent is the contract's one line: 99.5% still has room, 100% is spent unti
     expect(headroomState(CLAUDE, { id: "claude-opus-4-6" })).toEqual({ kind: "spent" });
 });
 
+// Anthropic reports whole percents: an account read at 100 kept serving turns for hours, so that reading is the line,
+// not proof. Only the provider's refusal makes such a pool spent.
+test("a pool read at 100 in whole percents is at the line with no room, until a refusal proves it empty", () => {
+    const week = window({ kind: "seven_day", utilization: 100, resetsAt: 900, rounded: true });
+    const atLine = usage(window({ kind: "five_hour", utilization: 75, rounded: true }), week);
+    expect(headroomState(atLine)).toEqual({ kind: "ready", room: 0 });
+    expect(headroomState(atLine, { id: "claude-opus-5-5" })).toEqual({ kind: "ready", room: 0 });
+    // A precise 100 is still spent.
+    expect(headroomState(usage(window({ kind: "seven_day", utilization: 100, resetsAt: 900 })))).toEqual({ kind: "spent", reopensAt: 900 });
+    // The provider refused it: spent until the pool reopens, and a reading still at the line does not answer that.
+    const facts = { account: "a", usage: { ...atLine, measuredAt: 2_000 } };
+    const refused = refusal({ kind: "limit", account: "a" });
+    expect(refusalVerdict(refused, [facts])).toBe("standing");
+    expect(serviceStates([facts], refused).get("a")).toEqual({ kind: "spent", reopensAt: 900 });
+});
+
 test("with no model named, an account is spent only when no model can run on it", () => {
     // A full Opus slice leaves every other model the room of the fullest pool still open.
     expect(headroomState(CLAUDE)).toEqual({ kind: "ready", room: 70 });
@@ -243,3 +259,14 @@ test("an unnamed turn takes the most room, then an unmeasured account, then a sp
     expect(roomiestAccount([entry("seatless", blocked), entry("unread", { kind: "unknown" })])).toBeUndefined();
     expect(roomiestAccount([entry("low", { kind: "ready", room: 5 }), entry("high", { kind: "ready", room: 60 })])?.id).toBe("high");
 });
+
+test("an account at the line is tried after an unmeasured one and before a spent one, and never a move's destination", () => {
+    const entry = (id: string, state: AccountState) => ({ id, state });
+    const atLine: AccountState = { kind: "ready", room: 0 };
+    expect(preferredAccount([entry("line", atLine), entry("low", { kind: "ready", room: 2 })])?.id).toBe("low");
+    expect(preferredAccount([entry("line", atLine), entry("unread", { kind: "unknown" })])?.id).toBe("unread");
+    expect(preferredAccount([entry("spent", { kind: "spent" }), entry("line", atLine)])?.id).toBe("line");
+    // A move lands only on proven room: two accounts at the line would otherwise hand a refused turn back and forth.
+    expect(roomiestAccount([entry("line", atLine), entry("spent", { kind: "spent" })])).toBeUndefined();
+    expect(roomiestAccount([entry("line", atLine), entry("low", { kind: "ready", room: 2 })])?.id).toBe("low");
+});

package/src/models/plan-pools.ts

@@ -8,6 +8,18 @@ import type { AccountState, AccountUsage, ProviderRefusal, UsageWindow, WindowGa
 // anything short of it still has room.
 export const SPENT_UTILIZATION = 100;
 
+// Whether a reading proves its pool empty. A pool read at the line by a provider that rounds to whole percents
+// (`rounded`) does not: Anthropic reports 99.5% as 100 and keeps serving turns on it, so treating that as spent strands
+// the last of an allowance (and turns a plain send into one scheduled for the reset). Such a pool is at the line, with
+// no room to rank by; only the provider's refusal (pinnedFull) proves it empty.
+export const provenFull = (window: UsageWindow): boolean => window.utilization >= SPENT_UTILIZATION && window.rounded !== true;
+
+// A pool a standing limit refusal shows full: at the line, and proven so whatever the provider's rounding.
+export const pinnedFull = (window: UsageWindow): UsageWindow => {
+    const { rounded: _rounded, ...pool } = window;
+    return { ...pool, utilization: Math.max(window.utilization, SPENT_UTILIZATION) };
+};
+
 export interface ModelRef {
     // Wire model id.
     readonly id: string;
@@ -210,15 +222,15 @@ export const headroomState = (usage: AccountUsage | undefined, model?: ModelRef)
     if (windows.length === 0) {
         return { kind: "unknown" };
     }
-    const full = windows.filter((window) => window.utilization >= SPENT_UTILIZATION);
-    const open = windows.filter((window) => window.utilization < SPENT_UTILIZATION);
+    const full = windows.filter(provenFull);
+    const open = windows.filter((window) => !provenFull(window));
     if (model !== undefined || full.some((window) => window.gates === "all") || open.length === 0) {
         const holding = model !== undefined ? full : full.some((window) => window.gates === "all") ? full.filter((window) => window.gates === "all") : full;
         if (holding.length > 0) {
             return spent(reopening(holding, model === undefined && !holding.some((window) => window.gates === "all")));
         }
     }
-    return { kind: "ready", room: SPENT_UTILIZATION - Math.max(...open.map((window) => window.utilization)) };
+    return { kind: "ready", room: Math.max(0, SPENT_UTILIZATION - Math.max(...open.map((window) => window.utilization))) };
 };
 
 // A standing limit refusal reads its pool as full, since a polled reading freezes the moment a pool actually empties: the
@@ -231,7 +243,7 @@ const refusedPool = (usage: AccountUsage | undefined, refusal: ProviderRefusal,
         const sameModel = refusal.model === undefined || model === undefined || refusal.model === model.id;
         return sameModel ? spent(refusal.resetsAt) : headroomState(usage, model);
     }
-    const pinned = usage.windows.map((window) => (window === binding ? { ...window, utilization: Math.max(window.utilization, SPENT_UTILIZATION) } : window));
+    const pinned = usage.windows.map((window) => (window === binding ? pinnedFull(window) : window));
     const state = headroomState({ ...usage, windows: pinned }, model);
     // The provider's own "try again at" is when it reopens, over whatever the polled pool last said.
     return state.kind === "spent" && refusal.resetsAt !== undefined ? spent(refusal.resetsAt) : state;
@@ -287,19 +299,35 @@ export const serviceStates = (
     );
 };
 
-// Worst last: proven room, no reading either way, known spent, and nothing a turn can run on.
-const PREFERENCE: Record<AccountState["kind"], number> = { ready: 0, unknown: 1, spent: 2, blocked: 3 };
+// Worst last: proven room, no reading either way, a pool at the line (it may hold a sliver, or nothing), known spent,
+// and nothing a turn can run on.
+const preference = (state: AccountState): number => {
+    switch (state.kind) {
+        case "ready":
+            return state.room > 0 ? 0 : 2;
+        case "unknown":
+            return 1;
+        case "spent":
+            return 3;
+        case "blocked":
+            return 4;
+    }
+};
 
-/** The account an unnamed turn runs on: ready by most room, then unmeasured, then spent, blocked only when that is all there is. Ties keep the caller's order. */
+/** The account an unnamed turn runs on: ready by most room, then unmeasured, then at the line, then spent, blocked only when that is all there is. Ties keep the caller's order. */
 export const preferredAccount = <T extends { readonly state: AccountState }>(entries: readonly T[]): T | undefined =>
     entries.reduce<T | undefined>((best, next) => {
         if (best === undefined) {
             return next;
         }
-        const tier = PREFERENCE[next.state.kind] - PREFERENCE[best.state.kind];
+        const tier = preference(next.state) - preference(best.state);
         return tier < 0 || (tier === 0 && next.state.kind === "ready" && best.state.kind === "ready" && next.state.room > best.state.room) ? next : best;
     }, undefined);
 
-/** The roomiest account with proven room, or none: what a move off a refused account may land on. Ties keep the caller's order. */
+/**
+ * The roomiest account with proven room, or none: what a move off a refused account may land on. Ties keep the caller's
+ * order. An account at the line is left out: a move there could be refused in turn, and with one refusal remembered per
+ * provider, two such accounts would hand the turn back and forth.
+ */
 export const roomiestAccount = <T extends { readonly state: AccountState }>(entries: readonly T[]): T | undefined =>
-    preferredAccount(entries.filter((entry) => entry.state.kind === "ready"));
+    preferredAccount(entries.filter((entry) => entry.state.kind === "ready" && entry.state.room > 0));

package/src/protocol/doors/listener-protocol.ts

@@ -9,7 +9,9 @@ import { rawRouteUrl } from "../raw/raw-routes.js";
 // The path of one of the four listener routes for a provider, built from RAW_ROUTES so the gateway and the daemon
 // cannot spell it two ways.
 export const listenerRouteUrl = (route: "state" | "dispatch" | "failure" | "status", provider: string): string =>
-    route === "state" ? rawRouteUrl("GET /listeners/{provider}/state", { provider }) : rawRouteUrl(`POST /listeners/{provider}/${route}`, { provider });
+    route === "state"
+        ? rawRouteUrl("GET /listeners/{provider}/state", { provider })
+        : rawRouteUrl(`POST /listeners/{provider}/${route}`, { provider });
 
 // The reconcile feed GET /listeners/<provider>/state answers: the enabled automations listening to this provider and
 // the connectors the asking extension contributes, each with its whole config, secrets included, since the gateway
@@ -86,10 +88,9 @@ export const ListenerPairingSchema = z.object({
 export type ListenerPairing = z.infer<typeof ListenerPairingSchema>;
 
 // Push-based status: a gateway POSTs its connection/voice snapshot to /listeners/<provider>/status, since the daemon
-// holds no provider connection to probe itself. Extends ActivityStatus with whisper's voice-pending flag and each
-// unpaired capability's pairing ceremony by id.
+// holds no provider connection to probe itself. Extends ActivityStatus with each unpaired capability's pairing ceremony
+// by id.
 export const ListenerStatusSchema = ActivityStatusSchema.extend({
-    whisperReady: z.boolean().optional(),
     pairing: z.record(z.string(), ListenerPairingSchema).optional(),
 });
 export type ListenerStatus = z.infer<typeof ListenerStatusSchema>;

package/src/protocol/raw/raw-routes.ts

@@ -16,7 +16,11 @@ export const RAW_ROUTES = {
     "GET /diff/raw": { lane: "bulk" },
     // Arming the dictation model is a read any tier makes; dictating is writing a message, the collaborator's grant.
     "GET /speech/status": { guest: true },
+    "POST /speech/prepare": { guest: true },
     "POST /speech/transcribe": { floor: "collaborator", guest: true },
+    // The live phrase stream (schemas/speech.ts): a WebSocket, so the query ticket, floored at the collaborator in the
+    // handler like the transcribe it streams.
+    "GET /speech/stream": { auth: "door" },
     // The bytes behind the workspace reads; each applies the caller's fence itself.
     "GET /workspace/raw": { guest: true, lane: "bulk" },
     // No door, unlike media: the page fetches a thumbnail itself, so the request carries the header.
@@ -127,6 +131,14 @@ export const RAW_ROUTES = {
     // The `devices push` CLI: a program the agent built, carried to one of the owner's computers in chunks; held to the
     // devices the calling conversation's turn mounts, and refused by the machine itself unless "Run programs" is on.
     "POST /devices/{name}/artifacts": { agent: true, control: "never" },
+    // The rest of the `devices` command, held to the same rule (hosts/device-door.routes.ts): the device's app_start for a
+    // shell, and its loopback ports reached from the sandbox (hosts/device-tunnels.ts).
+    "POST /devices/{name}/apps": { agent: true, control: "never" },
+    "POST /devices/{name}/tunnels": { agent: true, control: "never" },
+    "DELETE /devices/{name}/tunnels/{port}": { agent: true, control: "never" },
+    "GET /devices/tunnels": { agent: true },
+    // Where a device dials back with a tunnel's one-time ticket; the ticket is the whole credential, checked by the route.
+    "GET /system/hosts/tunnel": { auth: "door", control: "never" },
     // An extension gateway's realtime-listener control: /state hands back its connectors' stored credentials, so only the
     // extension token of the extension declaring that `listener.provider` reaches them, checked in the handler too.
     "GET /listeners/{provider}/state": { floor: "maintainer", panel: false, control: "never" },

package/src/schemas/agents.ts

@@ -3,7 +3,7 @@ import { LandingDeliverySchema } from "./project-delivery.js";
 import { z } from "zod";
 import { AgentHarnessSchema, AgentOriginSchema, AgentProviderSchema, ConversationQueueSchema, ForkedFromSchema } from "./agent.js";
 import { LoopStateSchema } from "./loops.js";
-import { LimitPolicySchema, RetryPolicySchema, TurnBreakPolicySchema, TurnBreakSchema } from "./turn-break.js";
+import { LimitPolicySchema, RetryPolicySchema, RoomPolicySchema, TurnBreakPolicySchema, TurnBreakSchema } from "./turn-break.js";
 import { KeepWarmSchema } from "./keep-warm.js";
 import { AgentNeedSchema } from "./needs.js";
 import { EMOJI_MAX_LENGTH, isSingleEmoji } from "../text/emoji.js";
@@ -362,6 +362,7 @@ export const AgentSummarySchema = z.object({
     limitPolicy: LimitPolicySchema.optional(),
     outagePolicy: RetryPolicySchema.optional(),
     stopPolicy: RetryPolicySchema.optional(),
+    memoryPolicy: RoomPolicySchema.optional(),
     // A collaborator's ask to land (collaborators can't merge themselves); cleared by whichever merge or discard
     // answers it.
     landRequested: z
@@ -907,9 +908,11 @@ export const AgentUnsentSchema = z.object({
 // verbs is how the surfaces drifted apart in the first place.
 export const AgentBreakPolicySchema = z.object({
     id: z.string().min(1).describe("Which conversation."),
-    ending: TurnBreakSchema.describe("Which wall this answers for: a spent usage limit, a provider outage, or a turn that stopped short."),
+    ending: TurnBreakSchema.describe(
+        "Which wall this answers for: a spent usage limit, a provider outage, a turn that stopped short, or a message the sandbox held because it was short of memory.",
+    ),
     policy: TurnBreakPolicySchema.nullable().describe(
-        "What happens next for that ending. `wait` holds the turn for a press; `retry` re-runs it on a bounded ladder (outage, stop); `resend` sends it again at the published reset and `move` also tries another account with room (limit only). An answer the ending does not allow is refused. Null clears the override and goes back to following the sandbox-wide policy, so a conversation does not sit holding a frozen copy of a default it has quietly stopped following.",
+        "What happens next for that ending. `wait` holds the turn for a press; `retry` re-runs it on a bounded ladder (outage, stop); `resend` sends it again at the published reset (limit) or once memory frees up (memory), and `move` also tries another account with room (limit only). An answer the ending does not allow is refused. Null clears the override and goes back to following the sandbox-wide policy, so a conversation does not sit holding a frozen copy of a default it has quietly stopped following.",
     ),
 });
 export const AgentFileDiffQuerySchema = z.object({

package/src/schemas/device-artifacts.ts

@@ -76,3 +76,24 @@ export const PushedArtifactSchema = z.object({
     reused: z.boolean(),
 });
 export type PushedArtifact = z.infer<typeof PushedArtifactSchema>;
+
+// A DEVICE'S LOOPBACK PORT, REACHED FROM THE SANDBOX (`devices reach`, hosts/device-tunnels.ts). The sandbox listens on
+// its own 127.0.0.1:<localPort>; each connection asks the device to dial its own 127.0.0.1:<devicePort> and open a
+// WebSocket back to /system/hosts/tunnel carrying the ticket below, and the two are pumped together.
+export const DialLoopbackSchema = z
+    .object({
+        ticket: z.string().regex(/^[0-9a-f]{48}$/),
+        port: z.int().min(1).max(65535),
+    })
+    .strict();
+export type DialLoopback = z.infer<typeof DialLoopbackSchema>;
+
+export const DeviceTunnelSchema = z.object({
+    device: z.string(),
+    devicePort: z.int().min(1).max(65535),
+    localPort: z.int().min(1).max(65535),
+    // What a program in the sandbox opens to reach the device's port.
+    url: z.string(),
+    openedAt: z.string(),
+});
+export type DeviceTunnel = z.infer<typeof DeviceTunnelSchema>;

package/src/schemas/environment.ts

@@ -45,12 +45,37 @@ export type RuntimeInstall = z.infer<typeof RuntimeInstallSchema>;
 // (`environment propose`) clears its tool's entries.
 export const SettledDraftSchema = z.object({ tool: z.string(), hash: z.string(), at: z.number() });
 export type SettledDraft = z.infer<typeof SettledDraftSchema>;
+// One overlay the daemon composed, by the hash a rebuild is stamped with, and the custom-section blocks it carried (each
+// by name and the hash of its trimmed steps). Kept so "is this tool in the image" is answered against the overlay the
+// running container was actually built from, which is rarely the newest one composed: every approval, capability change
+// and daemon update composes again, and a rebuild builds whatever was newest when it started.
+export const EnvironmentCompositionSchema = z.object({
+    hash: z.string(),
+    at: z.number(),
+    blocks: z.array(z.object({ name: z.string(), hash: z.string() })),
+});
+export type EnvironmentComposition = z.infer<typeof EnvironmentCompositionSchema>;
+// A draft the daemon wrote on its own (a recurring runtime install, a cache-rule revision of an approved block), by the
+// name its file carries and the hash of its steps. A draft that later vanishes with no answer on record was thrown away
+// by hand (the Changes panel's discard, a git clean): that is read as a no, rather than writing it back on the next
+// sweep. `install` is the ledger entry an auto-draft came from, which a no declines.
+export const EnvironmentOfferSchema = z.object({
+    tool: z.string(),
+    hash: z.string(),
+    at: z.number(),
+    install: z.string().optional(),
+});
+export type EnvironmentOffer = z.infer<typeof EnvironmentOfferSchema>;
 export const RuntimeInstallsFileSchema = z.object({
     installs: z.array(RuntimeInstallSchema),
     // The last drift snapshot, persisted so a daemon restart does not blank the card until the next sweep.
     drift: EnvironmentDriftSchema.optional(),
     // Drafts already answered, newest last and capped; absent on a ledger written before removal existed.
     settled: z.array(SettledDraftSchema).optional(),
+    // Overlays composed, oldest first and capped; absent on a ledger written before they were kept.
+    compositions: z.array(EnvironmentCompositionSchema).optional(),
+    // Drafts the daemon wrote that nobody has answered yet; absent on a ledger written before they were kept.
+    offered: z.array(EnvironmentOfferSchema).optional(),
 });
 export type RuntimeInstallsFile = z.infer<typeof RuntimeInstallsFileSchema>;
 // Ledger entry as the Environment card shows it: recurrence joined with whether it's present in the live container

package/src/schemas/providers/plan-limits.ts

@@ -23,6 +23,12 @@ export const UsageWindowSchema = z.object({
     utilization: z.number(), // 0-100
     resetsAt: z.number().optional(),
     gates: WindowGatesSchema,
+    rounded: z
+        .boolean()
+        .optional()
+        .describe(
+            "The provider rounds this figure to a whole percent (Anthropic does), so a reading of 100 may be 99.5 and the pool can still serve. Such a pool reads as at the line, not spent: only the provider's refusal proves it empty.",
+        ),
 });
 export type UsageWindow = z.infer<typeof UsageWindowSchema>;
 // A failed re-read, whatever the cause: a 429 park, a 403 asking for verification, a 5xx, a timeout. Recorded as the fact
@@ -59,7 +65,9 @@ export const AccountStateSchema = z.discriminatedUnion("kind", [
         kind: z.literal("ready"),
         room: z
             .number()
-            .describe("How much of the fullest pool that gates the turn is left, in percent (above 0, up to 100). Pickers take the most room."),
+            .describe(
+                "How much of the fullest pool that gates the turn is left, in percent (0 up to 100). Pickers take the most room. 0 is a rounded pool read at 100: at the line, tried after an unmeasured account, never a limit move's destination.",
+            ),
     }),
     z.object({
         kind: z.literal("spent"),