@intentic/sandbox-contract 1.314.0 → 1.316.0

package/src/events/errands.test.ts

@@ -1,5 +1,5 @@
 import { errandOfPrompt, errandOfRow } from "./errands.js";
-import { landBreakagePrompt, landFixPrompt } from "./land-breakage.js";
+import { LAND_BREAKAGE_OPENING, LAND_FIX_OPENING } from "./land-breakage.js";
 import { LAND_CONFLICT_OPENING } from "./land-conflict.js";
 import { verifyNudgePrompt } from "./verify-nudge.js";
 
@@ -11,12 +11,12 @@ describe(`which errand a message is`, () => {
     });
 
     test(`is read by its opening on a row written before rows said, and on nothing but a message`, () => {
-        expect(errandOfPrompt(landBreakagePrompt([`- a failure`]))).toBe(`land-breakage`);
-        expect(errandOfPrompt(landFixPrompt([`- a failure`]))).toBe(`land-fix`);
+        expect(errandOfPrompt(`${LAND_BREAKAGE_OPENING}\n\n- a failure`)).toBe(`land-breakage`);
+        expect(errandOfPrompt(`${LAND_FIX_OPENING}\n\n- a failure`)).toBe(`land-fix`);
         expect(errandOfPrompt(verifyNudgePrompt([`x`]))).toBe(`verify-nudge`);
         expect(errandOfPrompt(`${LAND_CONFLICT_OPENING}\n\nthe files`)).toBe(`land-conflict`);
         expect(errandOfPrompt(`Please fix the parser`)).toBeUndefined();
-        expect(errandOfRow({ role: `assistant`, text: landFixPrompt([]) })).toBeUndefined();
+        expect(errandOfRow({ role: `assistant`, text: LAND_FIX_OPENING })).toBeUndefined();
         expect(errandOfRow({ role: `user`, text: `hello` })).toBeUndefined();
     });
 });

package/src/events/land-breakage.ts

@@ -1,23 +1,19 @@
-// The follow-up the daemon sends a conversation whose land turned the main tree's own check red, recognised by its opening.
+// The follow-ups the daemon USED to send when the check it ran after every land went red: back to the conversation
+// that landed the work, or to a fresh conversation started on it. Nothing sends either any more: nothing checks work
+// after it lands, CI checks what the owner pushes (schemas/workspace/push-checks.ts). They stay on the wire because
+// records already hold them, and the chat has to go on recognising them: a prompt nobody typed must not reach a reader
+// as their own words.
 
 // Anchored on by the chat, so it must stay unique and stable across releases.
 export const LAND_BREAKAGE_OPENING =
     "What this conversation landed turned the main tree's own check red after it arrived. Each failure below appeared with that land and was not failing before it. Fix them on this branch and check the fix as you would any change; it lands like any other turn.";
 
-// The prompt a breakage actually sends: its opening, then the failures, each already worded for the model.
-export const landBreakagePrompt = (parts: readonly string[]): string => [LAND_BREAKAGE_OPENING, ...parts].join("\n\n");
-
 // Whether a stored prompt is one.
 export const isLandBreakage = (prompt: string): boolean => prompt.startsWith(LAND_BREAKAGE_OPENING);
 
-// The opening of a FRESH conversation the daemon starts on a red main-line check that the conversation that landed the
-// work could not take: nobody could be named, several could, or the one named had gone cold or run out of room.
 // Anchored on by the chat like the follow-up above, so it must stay unique and stable across releases.
 export const LAND_FIX_OPENING =
     "The main tree's own check went red after work landed, and no conversation still holding that work could take it, so this one was started to fix it. The failures, the lands they arrived with and where to read those conversations are below. Fix them in this isolated worktree and check the fix as you would any change; your work lands like any other turn.";
 
-// The prompt a fresh fix-up is started with: its opening, then the evidence, each part already worded for the model.
-export const landFixPrompt = (parts: readonly string[]): string => [LAND_FIX_OPENING, ...parts].join("\n\n");
-
 // Whether a stored prompt is one.
 export const isLandFix = (prompt: string): boolean => prompt.startsWith(LAND_FIX_OPENING);

package/src/events/requests.ts

@@ -99,7 +99,7 @@ export const PermissionAskSchema = z.object({
         "The program this request is holding, when the request is about one. Present on a command gate's request and absent on every other permission ask.",
     ),
     child: ChildAgentAskSchema.optional().describe(
-        "The child agent this request would start or reach, and what it runs on. Present on the child-agent gate's request and absent on every other permission ask.",
+        "The subagent this request would start or reach, and what it runs on. Present on the request to start or reach a subagent and absent on every other permission ask.",
     ),
     // The judge's own sentence, present only when the title can't say it; never written by the agent being gated.
     explain: z

package/src/events/transcript.ts

@@ -97,9 +97,15 @@ export const TranscriptToolSchema: z.ZodType<TranscriptTool> = z.lazy(() =>
         ),
     }),
 );
-// The child a call started, keyed by that call's own id, so `subagent`/`subagent_update` frames need no separate
-// correlation. Identifying fields arrive once; status/spend/activity replace on each update.
+// The subagent a call started, on that call's card whichever mechanism started it (transcript-fold.ts places it).
+// Identifying fields arrive once; status/spend/activity replace on each update.
 export const TranscriptSubagentSchema = z.object({
+    id: z
+        .string()
+        .optional()
+        .describe(
+            "Its own id, where that is not the card's: a spawned subagent is named by its own conversation, which is what the roster, `wait` and its page call it. Absent, the card's id is its id, as it is for one the runtime started in-process.",
+        ),
     kind: SubagentKindSchema,
     agentType: z.string().optional(),
     description: z.string().optional(),
@@ -151,7 +157,7 @@ export type TranscriptWatchWake = z.infer<typeof TranscriptWatchWakeSchema>;
 
 // Another agent's words that reached this conversation as a prompt; the row keeps the prompt and names the sender.
 export const TranscriptAgentWordsSchema = z.object({
-    kind: z.enum(["peer", "child"]).describe("Who sent it: another conversation in the workspace, or a child agent this one started."),
+    kind: z.enum(["peer", "child"]).describe("Who sent it: another conversation in the workspace, or a subagent this one started."),
     from: z.string().describe("The sending conversation's id."),
     title: z.string().optional().describe("The sender's title, when it had one."),
     failed: z.boolean().optional().describe("A child's report on a turn that failed rather than finished."),

package/src/events/verify-nudge.ts

@@ -1,7 +1,7 @@
 // The follow-up the daemon USED to send when a turn ended with work it could not confirm. Nothing sends it any more:
-// checks run after work lands, never inside a conversation (schemas/workspace/mainline.ts). It stays on the wire because
-// records already hold it, and the chat has to go on recognising it: a prompt nobody typed must not reach a reader as
-// their own words.
+// nothing checks inside a conversation, CI checks what the owner pushes (schemas/workspace/push-checks.ts). It stays on
+// the wire because records already hold it, and the chat has to go on recognising it: a prompt nobody typed must not
+// reach a reader as their own words.
 
 // Anchored on by the reader, so it must stay unique and stable across releases — a reworded opening un-recognises every
 // nudge already in a record, and they read as the user's own typing again.

package/src/index.ts

@@ -83,7 +83,7 @@ export { intenticContract } from "./contracts/intentic.contract.js";
 export { inventoryContract } from "./contracts/inventory.contract.js";
 export { issuesContract } from "./contracts/issues.contract.js";
 export { logsContract } from "./contracts/logs.contract.js";
-export { REQUEST_ID_EVIDENCE_ROUTE, REQUEST_ID_HEADER } from "./protocol/request-id.js";
+export { REQUEST_ID_HEADER } from "./protocol/request-id.js";
 export * from "./protocol/edge-verdict.js";
 export { loopsContract } from "./contracts/loops.contract.js";
 export { panelsContract } from "./contracts/panels.contract.js";
@@ -234,7 +234,7 @@ export * from "./schemas/webext.js";
 export * from "./schemas/workflows.js";
 export * from "./schemas/workspace/workspace-repos.js";
 export * from "./schemas/workspace/workspace-search.js";
-export * from "./schemas/workspace/mainline.js";
+export * from "./schemas/workspace/push-checks.js";
 export * from "./schemas/workspace/workspace-setup.js";
 export * from "./schemas/workspace/workspace-tree.js";
 export * from "./state/arrival.js";

package/src/models/agent-runtimes.ts

@@ -181,7 +181,7 @@ export const PI: AgentCapabilities = {
     secrets: "none",
 };
 
-// Cursor's own runtime, driven through `@cursor/sdk` in this daemon's process; an embedding surface, so most seams
+// Cursor's own runtime, driven through `@cursor/sdk` from this daemon's process; an embedding surface, so most seams
 // other runtimes lack are function arguments here. The harness axis doesn't apply: the SDK is the only door.
 export const CURSOR: AgentCapabilities = {
     runtime: "cursor",
@@ -199,11 +199,12 @@ export const CURSOR: AgentCapabilities = {
     // Cursor publishes effort as model parameters, not one scale; true here just means it's forwardable at all.
     effort: true,
     fastMode: false,
-    // cwd: Cursor's loop runs inside the daemon's own process, whose /work must stay the shared checkout.
-    isolation: "cwd",
+    // The SDK agent of an anchored turn runs in a runtime process born in the turn's mount namespace (the daemon keeps
+    // the loop, the tools and the hook gate), so its shell and its edits see the worktree at /work.
+    isolation: "namespace",
     // Cursor's commands are files on disk the SDK loads but doesn't publish back, so there's no list to offer.
     commands: false,
-    // The SDK runs its shell in-process; there is no tmux session for the terminal panel to attach to.
+    // The SDK runs its shell itself, as a plain child; there is no tmux session for the terminal panel to attach to.
     terminals: false,
     // The SDK throws typed errors instead of dissolving a refusal into prose, so the adapter files coded frames.
     recovery: true,

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

@@ -167,6 +167,13 @@ test("a revoked sign-in outranks a lost seat, which outranks a bench, whatever t
         reason: "cooling down",
         until: 2_000,
     });
+    // One Google wants its owner to verify: neither waiting nor reconnecting lifts it, and the row carries the page.
+    expect(serviceState({ ...facts, cooling: { reason: "Verify your account to continue.", verify: "https://accounts.google.com/v" } })).toEqual({
+        kind: "blocked",
+        fix: "verify",
+        reason: "Verify your account to continue.",
+        url: "https://accounts.google.com/v",
+    });
     // A bench whose instant has passed is over.
     expect(serviceState({ ...facts, cooling: { until: 999 } }, undefined, undefined, 1_000_000)).toEqual({ kind: "ready", room: 100 });
 });
@@ -202,6 +209,21 @@ test("a refusal stands until a later reading contradicts it, and never past its
     expect(refusalVerdict(refusal({ kind: "limit", account: "a" }), [])).toBe("standing");
 });
 
+// Codex's usage endpoint kept reading room while every turn was refused "try again at 3:38 PM": the provider's own
+// instant is what ends the refusal, where it is known which account it refused.
+test("a spent allowance with the provider's own reset stands until that instant, whatever a later reading says", () => {
+    const room = at(2_000, window({ kind: "five_hour", utilization: 0 }));
+    const until = { kind: "limit", resetsAt: 10 } as const;
+    expect(refusalVerdict(refusal({ ...until, account: "a" }), [{ account: "a", usage: room }], 9_999)).toBe("standing");
+    expect(refusalVerdict(refusal({ ...until, account: "a" }), [{ account: "a", usage: room }], 10_000)).toBe("answered");
+    // A routed refusal names no account, but with one account there is no doubt whose it was.
+    expect(refusalVerdict(refusal(until), [{ account: "a", usage: room }], 9_999)).toBe("standing");
+    // Over several, the translator benches the one it refused and routes on, so another's room still answers it.
+    expect(refusalVerdict(refusal(until), [{ account: "a", usage: room }, { account: "b", usage: room }], 9_999)).toBe("answered");
+    // Spent until the instant the provider named, not the pool's own reset.
+    expect(serviceStates([{ account: "a", usage: room }], refusal({ ...until, account: "a" }), undefined, 9_999).get("a")).toEqual({ kind: "spent", reopensAt: 10 });
+});
+
 test("a provider's accounts are judged together: a standing refusal lands only on the account it names", () => {
     const room = at(500, window({ kind: "five_hour", utilization: 40 }));
     const states = serviceStates([{ account: "a", usage: room }, { account: "b", usage: room }], refusal({ kind: "entitlement", account: "a" }));

package/src/models/plan-pools.ts

@@ -145,8 +145,11 @@ export interface ServiceFacts {
     // Why the sign-in needs renewing, where the provider said.
     readonly detail?: string | undefined;
     readonly seatRefusal?: string | undefined;
-    readonly cooling?: { readonly until?: number | undefined; readonly reason?: string | undefined } | undefined;
+    readonly cooling?: { readonly until?: number | undefined; readonly reason?: string | undefined; readonly verify?: string | undefined } | undefined;
     readonly usage?: AccountUsage | undefined;
+    // How the account is named to a person (its label, a routed credential's address); a surface that quotes a figure
+    // says whose it is.
+    readonly label?: string | undefined;
 }
 
 // A spent allowance is over once a reading with room lands after it; a refused credential once any reading does (the
@@ -168,11 +171,22 @@ const answers = (refusal: ProviderRefusal, facts: ServiceFacts): boolean => {
  * the account it named is disconnected, `answered` once that account (or, for a refusal naming none, any account) has a
  * later reading that contradicts it, else `standing`. An empty list is one not loaded yet, so the refusal stands.
  */
-export const refusalVerdict = (refusal: ProviderRefusal, accounts: readonly ServiceFacts[]): "standing" | "answered" | "gone" => {
+export const refusalVerdict = (
+    refusal: ProviderRefusal,
+    accounts: readonly ServiceFacts[],
+    now: number = Date.now(),
+): "standing" | "answered" | "gone" => {
     const named = accounts.filter((facts) => facts.account === refusal.account);
     if (refusal.account !== undefined && named.length === 0) {
         return accounts.length === 0 ? "standing" : "gone";
     }
+    // Where the provider named when to try again, and it is known which account it refused (it named one, or there is
+    // only one), its own words outrank a usage endpoint that kept showing room while it refused: over at that instant,
+    // and not before. A nameless refusal over several accounts is still answered by any of them reading room, since the
+    // translator benches the one it refused and routes on.
+    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && (refusal.account !== undefined || accounts.length <= 1)) {
+        return refusal.resetsAt * 1000 <= now ? "answered" : "standing";
+    }
     return (refusal.account === undefined ? accounts : named).some((facts) => answers(refusal, facts)) ? "answered" : "standing";
 };
 
@@ -215,10 +229,12 @@ const refusedPool = (usage: AccountUsage | undefined, refusal: ProviderRefusal,
     if (usage === undefined || binding === undefined) {
         // No pool to pin: the refusal itself is the evidence, unless it was about a different model than this question.
         const sameModel = refusal.model === undefined || model === undefined || refusal.model === model.id;
-        return sameModel ? { kind: "spent" } : headroomState(usage, model);
+        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));
-    return headroomState({ ...usage, windows: pinned }, model);
+    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;
 };
 
 /**
@@ -240,6 +256,11 @@ export const serviceState = (facts: ServiceFacts, refusal?: ProviderRefusal, mod
         return { kind: "blocked", fix: "admin", reason: refusal.message };
     }
     const cooling = facts.cooling;
+    // A bench the provider wants a person for: the account's owner confirms it on the provider's page, and no wait or
+    // reconnect here lifts it. Outranks the retry instant, which is only when the proxy will ask again.
+    if (cooling?.verify !== undefined) {
+        return { kind: "blocked", fix: "verify", reason: cooling.reason ?? "the provider wants this account verified", url: cooling.verify };
+    }
     // A bench with no instant is one no wait lifts (a Google account with no project): somebody has to connect again.
     if (cooling !== undefined && cooling.until === undefined) {
         return { kind: "blocked", fix: "reconnect", reason: cooling.reason ?? "benched by the translator" };
@@ -257,7 +278,7 @@ export const serviceStates = (
     model?: ModelRef,
     now: number = Date.now(),
 ): ReadonlyMap<string, AccountState> => {
-    const standing = refusal !== undefined && refusalVerdict(refusal, accounts) === "standing" ? refusal : undefined;
+    const standing = refusal !== undefined && refusalVerdict(refusal, accounts, now) === "standing" ? refusal : undefined;
     return new Map(
         accounts.map((facts) => [
             facts.account,

package/src/protocol/ingress-contract.fixture.json

@@ -48,6 +48,7 @@
         "GET /diff/raw",
         "GET /workspace/raw",
         "GET /workspace/media",
+        "GET /workspace/download",
         "POST /workspace/upload",
         "POST /workspace/upload-archive",
         "GET /system/sync/ssh",
@@ -59,6 +60,7 @@
     ],
     "lanes": [
         { "host": "sandbox-abcdef012345.sbx.example.test", "method": "GET", "path": "/workspace/media?path=a.mp4", "lane": "bulk" },
+        { "host": "sandbox-abcdef012345.sbx.example.test", "method": "GET", "path": "/workspace/download?ticket=t", "lane": "bulk" },
         { "host": "sandbox-abcdef012345.sbx.example.test", "method": "POST", "path": "/workspace/upload?path=a", "lane": "bulk" },
         { "host": "sandbox-abcdef012345.sbx.example.test:443", "method": "GET", "path": "/system/runners/git/app/info/refs?service=git-upload-pack", "lane": "bulk" },
         { "host": "sandbox-abcdef012345.sbx.example.test", "method": "POST", "path": "/system/runners/git/app/git-receive-pack", "lane": "bulk" },

package/src/protocol/raw-routes.ts

@@ -18,6 +18,8 @@ export const RAW_ROUTES = {
     "GET /workspace/thumb": { guest: true },
     // Fetched by a <video>/<audio> tag, which sends no header: its scoped ticket is checked in the handler.
     "GET /workspace/media": { auth: "door", guest: true, lane: "bulk" },
+    // Navigated to for a ZIP of a selection, so no header either: the ticket it carries names the selection.
+    "GET /workspace/download": { auth: "door", guest: true, lane: "bulk" },
     // An attachment is part of the message it rides with; any other target edits the shared tree.
     "POST /workspace/upload": { floor: "writer", attachmentFloor: "collaborator", lane: "bulk" },
     "POST /workspace/upload-diff": {},
@@ -91,12 +93,13 @@ export const RAW_ROUTES = {
     "GET /wallet/status": { agent: true, control: "never" },
     "POST /wallet/fetch": { agent: true, control: "never" },
     "GET /wallet/history": { agent: true, control: "never" },
-    // The `agents` CLI's children: start, follow up, answer (never a consent card), list.
+    // The `agents` CLI's children: start, follow up, answer (never a consent card), cancel, list.
     "POST /children/spawn": { agent: true, control: "never" },
     "GET /children/providers": { agent: true, control: "never" },
     "POST /children/wait": { agent: true, control: "never" },
     "POST /children/send": { agent: true, control: "never" },
     "POST /children/answer": { agent: true, control: "never" },
+    "POST /children/cancel": { agent: true, control: "never" },
     "GET /children": { agent: true, control: "never" },
     // The fleet reads, and the one write: words in front of another conversation, which a person can do by typing.
     "GET /fleet": { agent: true },

package/src/protocol/request-id.ts

@@ -1,5 +1,2 @@
 // Correlates a browser call to the daemon request that served it; a token only, never a security boundary.
 export const REQUEST_ID_HEADER = "x-intentic-request-id";
-
-// Confirms daemon CORS accepts this header before sending; no evidence here means don't send, unlike supportsRoute.
-export const REQUEST_ID_EVIDENCE_ROUTE = "logs.report";

package/src/schemas/agent.ts

@@ -131,7 +131,7 @@ export type ForkedFrom = z.infer<typeof ForkedFromSchema>;
 const AgentTurnFieldsSchema = z.object({
     prompt: z.string().describe("What to say to the agent. May be empty if you are only attaching files."),
     errand: TurnErrandSchema.optional().describe(
-        "What the words are for, when the app or the sandbox composed them rather than a person typing them: a land conflict to resolve, a red main line to fix. Shown as the sandbox's words, not yours. Leave it out for your own words.",
+        "What the words are for, when the app or the sandbox composed them rather than a person typing them: a land conflict to resolve, a red CI run to fix. Shown as the sandbox's words, not yours. Leave it out for your own words.",
     ),
     // Minted by the sender so a send whose answer was lost can be sent again without being delivered twice.
     messageId: z

package/src/schemas/agents.ts

@@ -88,11 +88,11 @@ export const UnfinishedWorkSchema = z.object({
     check: z
         .string()
         .optional()
-        .describe("The end-of-turn check that was still failing when the turn ended, by name. No longer written: checks run after work lands."),
+        .describe("The end-of-turn check that was still failing when the turn ended, by name. No longer written: nothing checks inside a turn."),
 });
 export type UnfinishedWork = z.infer<typeof UnfinishedWorkSchema>;
 // What the last turn showed of its own work, read off its tool calls and never asked of the model: the record a card
-// badges instead of sending the turn back to prove anything. Checks run after the work lands (mainline.ts).
+// badges instead of sending the turn back to prove anything. CI checks what the owner pushes (push-checks.ts).
 export const TurnProofSchema = z.object({
     at: z.number().describe("When the turn that left this ended, in milliseconds."),
     verification: z
@@ -137,7 +137,7 @@ export const LandedMessageSchema = z.object({
         .optional()
         .describe("Why a test this change weakened is meant to be weaker, in the conversation's own words. Nearly always absent."),
     // Present only when the conversation declared an exception a check should grant this change (`Allow: <check> — <reason>`);
-    // the check after the land and the push read it off the commit.
+    // the push reads it off the commit.
     allows: z
         .array(z.string())
         .optional()
@@ -418,6 +418,13 @@ export const AgentSummarySchema = z.object({
         .describe(
             "When somebody last opened it, in milliseconds. Newer activity than this is what makes it unread. Kept by the sandbox rather than by a browser, so clearing site data or picking up a phone does not resurrect every badge.",
         ),
+    // Browser-side words the daemon cannot read, reported so the unattended archive sweep never files them away.
+    unsentAt: z
+        .number()
+        .optional()
+        .describe(
+            "Since when somebody's composer has held a message for it that they have not sent yet, in milliseconds. While set, the sandbox never archives it on its own for being idle.",
+        ),
     attention: AgentAttentionSchema.describe("Which kinds of waiting-for-you it is doing."),
     // Only the causes that still hold, re-read live (conversations/land/standing.ts), never the stored report's own list: a
     // blocker the user has since cleared is not something to offer them an action about.
@@ -448,7 +455,7 @@ export const AgentSummarySchema = z.object({
         })
         .optional()
         .describe(
-            "Subagents and child agents this one delegated to. Absent means it never has, which is most conversations. Their spend is their own and is not folded into this conversation's cost.",
+            "Subagents this one started, in-process and spawned alike. Absent means it never has, which is most conversations. Their spend is their own and is not folded into this conversation's cost.",
         ),
     // Cumulative output across every repo (base → branch tip), refreshed on each land; independent of what has actually
     // landed.
@@ -567,10 +574,8 @@ export const AgentSummarySchema = z.object({
         ),
 });
 export type AgentSummary = z.infer<typeof AgentSummarySchema>;
-// Whether a conversation runs again by itself: the daemon's own reading, or, from a daemon older than it, whether a watch
-// is armed, which was all that one could say.
-export const awaitsWake = (agent: { readonly awaitingWake?: boolean | undefined; readonly watches?: readonly unknown[] | undefined }): boolean =>
-    agent.awaitingWake ?? (agent.watches?.length ?? 0) > 0;
+// Whether a conversation runs again by itself: the daemon's own reading, never guessed from its armed watches.
+export const awaitsWake = (agent: { readonly awaitingWake?: boolean | undefined }): boolean => agent.awaitingWake === true;
 // One armed watch as a card carries it; derived from AgentSummarySchema.watches so the two shapes can't drift apart.
 export type AgentWatch = NonNullable<AgentSummary["watches"]>[number];
 // One background job as a card carries it.
@@ -740,6 +745,14 @@ export const AgentAutoLandSchema = z.object({
             "Whether its work merges automatically when a turn finishes. Null clears the override and goes back to following the sandbox-wide setting, so a conversation does not sit holding a frozen copy of a default it has quietly stopped following.",
         ),
 });
+// A composer's unsent words, reported by the editor that holds them: the words themselves stay in the browser.
+export const AgentUnsentSchema = z.object({
+    id: z.string().min(1).describe("Which conversation."),
+    at: z
+        .number()
+        .nullable()
+        .describe("When the composer started holding the unsent message, in milliseconds. Null says it no longer holds one: it was sent or cleared."),
+});
 // Same `null`-clears-the-override shape as autoLand, for this conversation's own answer to one ending's question.
 // One route rather than one per ending: they are the same decision asked about different walls, and three near-identical
 // verbs is how the surfaces drifted apart in the first place.

package/src/schemas/automations.ts

@@ -28,8 +28,8 @@ import { ZoneSchema } from "../time/zone.js";
 // reads these.
 // turn.settled: fires once per isolated turn regardless of outcome, while the diff is still on screen
 // agent.landed: fires only once work reaches the main tree, including a later manual Land
-// deps.broken/deps.fixed: edges from the dependency verifier around a landed change, not standing states, so a chore
-// wakes on the transition, never on a tree that stays red
+// deps.broken/deps.fixed: retired with the check that ran after every land (2026-09-27). Nothing emits them any more;
+// they stay so an automation written for them still reads, and it never fires. Main's red CI is the `ci` listener's.
 export const WorkspaceEventKindSchema = z.enum(["turn.settled", "agent.landed", "deps.broken", "deps.fixed"]);
 export type WorkspaceEventKind = z.infer<typeof WorkspaceEventKindSchema>;
 // Payload of a workspace-triggered wake, delivered as JSON in $AUTOMATION_PAYLOAD and appended to the prompt.

package/src/schemas/ci.ts

@@ -1,6 +1,7 @@
 // ci: pipeline runs on the workspace repos' github/gitlab remotes
 import { z } from "zod";
 import { AgentRunPickSchema } from "./agent.js";
+import { RedDecisionSchema } from "./workspace/push-checks.js";
 // The daemon maps each workspace repo to its CI project via a connected github/gitlab capability, registers a webhook
 // to fire `ci` listener automations instantly, and serves the Pipelines rail from a webhook-freshened, poll-backfilled
 // cache. `host` names which provider API serves a repo; the listener provider is always `ci`, since a trigger narrows
@@ -39,6 +40,9 @@ export const PipelineRunSchema = z.object({
         .describe(
             "What set it off, in the forge's own word rather than flattened into a shared vocabulary, because the forge's word is the precise one.",
         ),
+    // github's workflow name: several workflows run on one push there, and one passing says nothing of another. Absent on
+    // gitlab, where a commit's pipeline is the project's one.
+    workflow: z.string().optional().describe("Which workflow it is a run of, where a push starts several. Absent where a commit has one pipeline."),
     branch: z.string().describe("Which branch."),
     sha: z.string().describe("Which commit."),
     status: PipelineStatusSchema.describe(
@@ -108,10 +112,31 @@ export type CiRepo = z.infer<typeof CiRepoSchema>;
 // Fallback poll interval when a repo's webhook couldn't register; lives here since both the poller and the automation
 // editor need it to tell the owner what a `hookWarning` actually costs (minutes' delay, not the feature).
 export const CI_POLL_INTERVAL_MS = 2 * 60_000;
+// Main's CI while it is red, as the daemon's one fix agent on it sees it (ci/main-fixer.ts): from the first job that
+// failed until a later run of every workflow that failed on it passes, whatever else failed along the way.
+export const CiMainRedSchema = z.object({
+    repo: z.string().describe("Which workspace repository."),
+    branch: z.string().describe("Which main-line branch."),
+    since: z.number().describe("When its first job failed, in milliseconds."),
+    runId: z.number().describe("The newest run that failed on it."),
+    jobs: z.array(z.string()).describe("The jobs failing on it now, by name: the newest red run's failures, and any that failed since."),
+    fixer: z
+        .string()
+        .optional()
+        .describe("The one conversation working on it, which every failure goes to until the branch is green. Absent while nobody is on it."),
+    decision: RedDecisionSchema.optional().describe(
+        "The latest thing decided about it: `fix-up` while the fix agent has it, `spent` once it waits for you (its turns are used up, or it stopped without a fix), `reported` when repairs are off.",
+    ),
+});
+export type CiMainRed = z.infer<typeof CiMainRedSchema>;
 export const CiRunsResponseSchema = z.object({
     repos: z.array(CiRepoSchema).describe("Which workspace repositories are wired to a forge, and how each one's notifications are set up."),
     // Newest first, across all mapped repos.
     runs: z.array(PipelineRunSchema).describe("Runs across all of them, newest first."),
+    reds: z
+        .array(CiMainRedSchema)
+        .optional()
+        .describe("Every main-line branch red right now, with the fix agent on it. Absent from a daemon that keeps none."),
 });
 export type CiRunsResponse = z.infer<typeof CiRunsResponseSchema>;
 // Re-resolves repo → project + token on every call, so a stale card can't act on a mapping the workspace no longer has.

package/src/schemas/devices.ts

@@ -505,7 +505,7 @@ export const DeviceSchema = z.object({
     // The host connection's key, when this machine is also a connected device. Absent otherwise.
     hostId: z.string().optional(),
     // The card that connection is of, beside the key rather than parsed out of it: the machine's name, a label. Absent
-    // with `hostId`, and from a daemon older than the field (`deviceCard` reads the key then).
+    // with `hostId`.
     card: z.string().optional(),
     // The computer this row is an environment of, from whichever door has said (MachineIdSchema): what `machinesOf`
     // groups by. Absent when no door has, which leaves the row a computer of its own.
@@ -563,20 +563,15 @@ export const deviceDistro = (device: Device): string | undefined => {
 const byEnvironment = (a: Device, b: Device): number =>
     Number(isWslDevice(a)) - Number(isWslDevice(b)) || (deviceDistro(a) ?? a.label).localeCompare(deviceDistro(b) ?? b.label);
 
-// The card a device's door hangs off: one card is one computer, so two doors naming the same card are one machine
-// whatever either has said about itself — which is the whole of what an environment that has never connected says.
-// The row's own label, else its key read by the one parser there is (a row from a daemon older than `card`).
-export const deviceCard = (device: Pick<Device, "card" | "hostId">): string | undefined =>
-    device.card ?? (device.hostId === undefined ? undefined : parseHostConnection(device.hostId).card);
-
 // The computer a device is on, by whichever door said: its row, its connect-time facts, its report, its sync enrollment.
 export const deviceMachineId = (device: Device): string | undefined =>
     device.machineId ?? device.facts?.machineId ?? device.report?.machineId ?? device.sync?.machineId;
 
-// What makes two devices one computer: a shared card, or a shared machine id. Nothing else: a hostname is shared by a
-// PC and its WSL distros and by two unrelated machines with the same name, so it joined things by accident.
+// What makes two devices one computer: a shared card (the row's own `card`, never parsed back out of its key: one card
+// is one computer, whatever either door has said about itself), or a shared machine id. Nothing else: a hostname is
+// shared by a PC and its WSL distros and by two unrelated machines with the same name, so it joined things by accident.
 const tokensOf = (device: Device): string[] => {
-    const card = deviceCard(device);
+    const { card } = device;
     const machine = deviceMachineId(device);
     return [...(card === undefined ? [] : [`card:${card.toLowerCase()}`]), ...(machine === undefined ? [] : [`machine:${machine}`])];
 };
@@ -621,8 +616,9 @@ const machineOf = (environments: readonly Device[]): Machine => {
     if (first === undefined) {
         return { key: "", label: "", environments };
     }
-    const named = environments.map(deviceCard).find((key) => key !== undefined) ?? (rest.length === 0 ? undefined : deviceMachineId(first));
-    const label = first.label === first.hostId ? (deviceCard(first) ?? first.label) : first.label;
+    const named =
+        environments.map((device) => device.card).find((key) => key !== undefined) ?? (rest.length === 0 ? undefined : deviceMachineId(first));
+    const label = first.label === first.hostId ? (first.card ?? first.label) : first.label;
     return { key: named ?? first.key, label, environments };
 };
 

package/src/schemas/personas.ts

@@ -134,15 +134,15 @@ export const TURN_BRIEFING_NOTES: readonly TurnBriefingNote[] = [
     },
     {
         id: "delegation",
-        label: "Spawning child agents",
+        label: "Spawning subagents",
         when: "First message, on a shell-only runtime, for a card that may delegate.",
         cost: "The agent does the work itself rather than handing parts of it to other conversations.",
     },
     {
         id: "checks",
         label: "Checks after landing",
-        when: "First message and after a compaction, and again whenever the main tree's own check turns red or back to green: what runs after its work lands, and which failures the main tree already has.",
-        cost: "The agent does not know which failures are the main tree's own and not its doing, so it may spend a turn chasing one somebody else is already fixing.",
+        when: "First message and after a compaction: that nothing checks its work when it finishes or after it lands, which checks are its to run, and that CI checks what the owner pushes.",
+        cost: "The agent does not know what checks its work, so it may run the whole repository's suite on a shared machine, or chase a failure main already has.",
     },
     {
         id: "dependencies",

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

@@ -47,7 +47,7 @@ export const AccountUsageSchema = z.object({
 export type AccountUsage = z.infer<typeof AccountUsageSchema>;
 // Who has to act for a blocked account, which is the only thing a surface chooses its instruction by: the reason is the
 // words for a person, never a key.
-export const AccountFixSchema = z.enum(["reconnect", "admin", "wait"]);
+export const AccountFixSchema = z.enum(["reconnect", "admin", "verify", "wait"]);
 export type AccountFix = z.infer<typeof AccountFixSchema>;
 // Whether an account can serve a turn, decided once by the daemon (models/plan-pools.ts `serviceState`) from every fact
 // it holds about it: a revoked sign-in, a lost seat, a translator bench, a refusal still standing, and its plan limits.
@@ -69,10 +69,11 @@ export const AccountStateSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("blocked"),
         fix: AccountFixSchema.describe(
-            "Who can make it serve again: `reconnect` (sign in again on this sandbox), `admin` (an organisation admin hands the seat back), or `wait` (it lifts by itself, at `until` where known).",
+            "Who can make it serve again: `reconnect` (sign in again on this sandbox), `admin` (an organisation admin hands the seat back), `verify` (the account's owner confirms it on the provider's page, at `url`), or `wait` (it lifts by itself, at `until` where known).",
         ),
         reason: z.string().describe("Why, in words a person can act on: the provider's own sentence where it gave one."),
         until: z.number().optional().describe("When waiting lifts it, in epoch seconds, for `wait` only."),
+        url: z.string().optional().describe("The provider's page where the account's owner lifts it, for `verify` only."),
     }),
     z.object({ kind: z.literal("unknown").describe("Nothing blocks it and nothing has been measured: usable, never read as room.") }),
 ]);
@@ -122,6 +123,14 @@ export const ProviderRefusalSchema = z.object({
     // Lets a `limit` refusal be read against the pool that model spends (`UsageWindow.gates`), not the account's
     // fullest pool.
     model: z.string().optional().describe("Which model the refused turn was on, where that is known."),
+    // The provider's own "try again at …", which a polled reading cannot contradict: a usage endpoint can keep showing
+    // room while the plan refuses every turn.
+    resetsAt: z
+        .number()
+        .optional()
+        .describe(
+            "When the provider said to try again, in epoch seconds, for a spent allowance where it named one. Until then the refusal stands whatever a reading says; after it, it is over.",
+        ),
 });
 export type ProviderRefusal = z.infer<typeof ProviderRefusalSchema>;
 export const ProviderRefusalsSchema = z.object({
@@ -151,6 +160,9 @@ export const TranslatorAccountSchema = z.object({
             // Why, in the words of what is missing: the proxy's own sentence where it gave one short enough to print,
             // else this sandbox's. Never a pasted upstream body.
             reason: z.string().optional(),
+            // The provider's page where the account's owner confirms it (Google's VALIDATION_REQUIRED). Present means
+            // a person has to act there: the proxy's retry fails until they do.
+            verify: z.string().optional(),
         })
         .optional(),
     state: AccountStateSchema.optional().describe(
@@ -205,7 +217,7 @@ export const AgentReplySchema = z.discriminatedUnion("kind", [
         feedback: z.string().optional().describe("Why not, which goes back to the model as the reason."),
         // Whole, not a patch: effort or an account named for one model means nothing on another.
         child: ChildRunSchema.optional().describe(
-            "For a request to start a child agent: what to start it on instead of what the agent asked for. It replaces the whole run (model, account, effort and the rest), not only the fields it names. Ignored with a no, and on any other request.",
+            "For a request to start a subagent: what to start it on instead of what the agent asked for. It replaces the whole run (model, account, effort and the rest), not only the fields it names. Ignored with a no, and on any other request.",
         ),
     }),
     z.object({
@@ -400,6 +412,12 @@ export const SwitchAccountSchema = z.object({
         .describe(
             "Keep the provider session across the move (the model keeps everything, and re-reads all of it once on the other account) rather than opening a fresh one seeded from the record.",
         ),
+    run: z
+        .boolean()
+        .optional()
+        .describe(
+            "Also run a turn that a spent allowance, a stop or a refusal is holding, at once on the new account. Leave it out to only move the conversation: a held turn stays held until something asks for it.",
+        ),
 });
 export type SwitchAccount = z.infer<typeof SwitchAccountSchema>;
 export const AccountSwitchedSchema = z.object({

package/src/schemas/settings-history.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { dropAll, fold, isJsonObject, mapValue, retype } from "../documents/conversions.js";
+import { at, drop, dropAll, fold, isJsonObject, mapValue, retype } from "../documents/conversions.js";
 import type { KeepWarmSettings, RuleSchema } from "./settings.js";
 
 // The conversions the settings shape has had, oldest first: what brings any earlier release's settings to
@@ -105,4 +105,6 @@ export const SETTINGS_HISTORY = [
         "drops rules at the retired turn.ending moment (and the verify-ui-edits built-in), which run nothing",
     ),
     keepWarmObject,
+    // Where the check after landing ran (2026-09-27): nothing checks work after it lands any more, CI does.
+    at("offload", drop("landCheck")),
 ] as const;