@intentic/sandbox-contract 1.315.0 → 1.316.0

package/src/schemas/personas.ts

@@ -141,8 +141,8 @@ export const TURN_BRIEFING_NOTES: readonly TurnBriefingNote[] = [
     {
         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

@@ -123,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({

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;

package/src/schemas/settings.test.ts

@@ -48,15 +48,16 @@ describe(`where a command lives`, () => {
         expect(file([{ when: `push`, run: `pnpm verify:push` }])).toBe(false);
     });
 
-    test(`a land check is one per repository and narrows by no path`, () => {
+    // `land` is retired like `turn`: it runs nothing, so a file written while it ran reads however it spelled one.
+    test(`a retired land check still reads, however many a file names and whatever paths it gives`, () => {
         const file = (checks: unknown[]) => RepoChecksFileSchema.safeParse({ checks }).success;
         expect(
             file([
                 { when: `land`, run: `pnpm verify` },
                 { when: `land`, run: `pnpm test` },
             ]),
-        ).toBe(false);
-        expect(file([{ when: `land`, run: `pnpm verify`, paths: [`src/**`] }])).toBe(false);
+        ).toBe(true);
+        expect(file([{ when: `land`, run: `pnpm verify`, paths: [`src/**`] }])).toBe(true);
     });
 });
 

package/src/schemas/settings.ts

@@ -15,8 +15,8 @@ export type SystemPromptMode = z.infer<typeof SystemPromptModeSchema>;
 export const BuiltinPromptSchema = z.object({ base: z.enum(["intentic", "claude"]) });
 // Rules: "at this moment, if this is true, do this". The owner's rules decide (land, hold, version); every command a
 // moment runs is a repository's own check (`<repo>/.intentic/checks.json`), compiled into this same table by the daemon,
-// so no command lives in settings. Nothing verifies inside a turn: the whole-tree check runs after work lands and never
-// holds anything (schemas/workspace/mainline.ts).
+// so no command lives in settings. Nothing verifies inside a turn or after a land: CI checks what the owner pushes, and
+// nothing here holds anything (schemas/workspace/push-checks.ts).
 export const RuleMomentSchema = z.enum([
     // A command here runs on the just-written file (`{file}` is its path); the cheapest moment to catch a defect.
     "file.edited",
@@ -436,30 +436,26 @@ export const SandboxSettingsSchema = z.object({
     ),
     // Worth it since the container is recreated on every update or environment approval — otherwise approving a
     // Dockerfile change costs the run that asked for it.
-    // What happens to breakage found after the work that caused it has left the turn. A land that turns the main tree's own
-    // check red waits for the lands queued behind it to be checked too, then goes back to the conversation that landed it
-    // while that one still has it in mind, or to a fresh conversation when nobody can be named or the one named has gone
-    // cold; main's CI staying red on one failure gets a fix agent once pushes go quiet, with a fleet failure re-run instead.
-    // Off, all of it is only reported.
+    // What happens when main's CI goes red (ci/main-fixer.ts): its first failed job starts one fix agent, which is sent
+    // every later failure on main until main is green, within a few turns, and a failure on the CI fleet itself is re-run
+    // once instead. Off, it is only reported.
     autoRepair: z
         .boolean()
         .default(true)
         .describe(
-            "Whether breakage found after the work left its turn is repaired without asking. A land that turns the main tree's check red is repaired once the work queued behind it has been checked too: by the conversation that landed it while it still has the work in mind, otherwise by a fresh conversation handed the failures and the suspects' changes. Main's CI staying red on the same failure gets a fix agent once pushes go quiet, and a failure on the CI fleet itself is re-run once instead. Off, all of it is only reported.",
+            "Whether main's CI going red is repaired without asking. The first job that fails on main starts one fix agent, without waiting for the rest of the run, and every later failure on main goes to that same agent until a run passes. It gets a few turns; when they are spent, or it finishes without changing anything (a failure that is not in the code), the red waits for you. A failure on the CI fleet itself is re-run once instead. Off, all of it is only reported.",
         ),
     // Where heavy work runs: a runner (the same image, on one of the owner's machines) instead of this sandbox. Keyed by
-    // the heavy-command rule an agent's command matched (system/resources/heavy-commands.ts), and one entry for the
-    // check after landing, each naming a runner id. A runner that is offline, outdated or full hands the work back here,
-    // which the command's output says. Never pushed to a runner itself (portability/definition.ts), which must not pass
-    // work on again.
+    // the heavy-command rule an agent's command matched (system/resources/heavy-commands.ts), each naming a runner id. A
+    // runner that is offline, outdated or full hands the work back here, which the command's output says. Never pushed
+    // to a runner itself (portability/definition.ts), which must not pass work on again.
     offload: z
         .object({
             commands: z.record(z.string().min(1), z.string().min(1)).default({}),
-            landCheck: z.string().min(1).optional(),
         })
         .default({ commands: {} })
         .describe(
-            "Which heavy work runs on a runner on one of your machines instead of this sandbox: agents' commands by the kind the heavy-command rules sort them into (tests, typechecks, verify…), and the check after landing. The code travels as it stands, uncommitted work included; the output streams back, and any file the command changed comes back with it. A machine that is offline, outdated or busy hands the work back to this sandbox, and the output says so.",
+            "Which heavy work runs on a runner on one of your machines instead of this sandbox: agents' commands by the kind the heavy-command rules sort them into (tests, typechecks, verify…). The code travels as it stands, uncommitted work included; the output streams back, and any file the command changed comes back with it. A machine that is offline, outdated or busy hands the work back to this sandbox, and the output says so.",
         ),
     autoResumeOnRestart: z
         .boolean()
@@ -665,9 +661,9 @@ export type SavingsReport = z.infer<typeof SavingsReportSchema>;
 // spelling for the daemon that reads it, the screen that names it and the demo that mimics it.
 export const REPO_CHECKS_FILE = `${STATE_DIR}/checks.json`;
 
-// Named for the occasion as a repository would say it: `edit` is `file.edited`, and `land` is the daemon's run over the
-// main tree after every land (rules/repo-checks.ts maps them). `turn` is retired: nothing runs when a turn ends any more,
-// and a declaration naming it still reads but runs nothing. No check refuses a land, a commit or a push.
+// Named for the occasion as a repository would say it: `edit` is `file.edited` (rules/repo-checks.ts maps it). `turn`
+// and `land` are retired: nothing runs when a turn ends or after work lands any more (CI checks what the owner pushes),
+// and a declaration naming either still reads but runs nothing. No check refuses a land, a commit or a push.
 // `edit` runs on one file (`{file}`) and its output rides back in the edit's own response, so a command declared there is
 // paid per edit and has to take the file.
 export const RepoCheckMomentSchema = z.enum(["edit", "turn", "land"]);
@@ -675,7 +671,7 @@ export type RepoCheckMoment = z.infer<typeof RepoCheckMomentSchema>;
 
 export const RepoCheckSchema = z.object({
     when: RepoCheckMomentSchema.describe(
-        "When to run it: `edit` on each file as it is written (`{file}` is its path), `land` on the main tree after finished work lands (absent, the package's own verify or test script runs there). `turn` is retired and runs nothing: checks no longer run while a conversation works.",
+        "When to run it: `edit` on each file as it is written (`{file}` is its path). `turn` and `land` are retired and run nothing: checks no longer run while a conversation works or after its work lands, since CI checks what is pushed.",
     ),
     run: z.string().min(1).max(500).describe("The command, run in this repository's own directory, so it reads as it would in a terminal there."),
     label: z.string().min(1).max(80).optional().describe("What to call it on screen. Absent names it after the command."),
@@ -695,11 +691,7 @@ export const RepoChecksFileSchema = z.object({
     checks: z
         .array(RepoCheckSchema)
         .max(10)
-        .default([])
-        // One land check per repository: it is THE verdict on the main tree the push hook replays, not one of several.
-        .refine((checks) => checks.filter((check) => check.when === "land").length <= 1, { message: "a repository declares at most one land check" })
-        // A land checks the whole tree an install settled, not a change, so there is nothing for a glob to narrow.
-        .refine((checks) => checks.every((check) => check.when !== "land" || check.paths === undefined), { message: "a land check takes no paths" }),
+        .default([]),
 });
 export type RepoChecksFile = z.infer<typeof RepoChecksFileSchema>;
 
@@ -711,7 +703,7 @@ export const RepoChecksSummarySchema = z.object({
     fired: z
         .array(z.number().nullable())
         .describe(
-            "When each declared check last reported something, in the file's order, as epoch milliseconds; null for one that never has, or for the land check, whose verdict the activity feed records instead.",
+            "When each declared check last reported something, in the file's order, as epoch milliseconds; null for one that never has, or for a retired one, which runs nothing.",
         ),
     adopted: z
         .boolean()
@@ -722,16 +714,10 @@ export const RepoChecksSummarySchema = z.object({
             "Whether the declaration changed since it was adopted, which holds it until the owner looks again. True only for a repository that was adopted before.",
         ),
     error: z.string().optional().describe("Why the file could not be read, when it exists but does not parse. The checks list is empty in that case."),
-    landDefault: z
-        .string()
-        .optional()
-        .describe(
-            "What runs on the main tree after a land when the file declares no `land` check: the package's own verify or test script. Absent when the repository has neither.",
-        ),
 });
 export type RepoChecksSummary = z.infer<typeof RepoChecksSummarySchema>;
 export const RepoChecksListSchema = z.object({
-    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks or has a package check that runs after a land, in id order."),
+    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks, in id order."),
 });
 export type RepoChecksList = z.infer<typeof RepoChecksListSchema>;
 export const RepoChecksAdoptSchema = z.object({

package/src/schemas/speaker.ts

@@ -68,12 +68,12 @@ export const speakerOwner = (speaker: TurnSpeaker): Pick<SessionOwner, "email" |
 /** A person, verified, at the keyboard: never a program holding a token a person minted. */
 export const spokenByPerson = (speaker: TurnSpeaker | undefined): boolean => speaker?.kind === "person";
 
-// WHAT A COMPOSED PROMPT IS FOR, when the sandbox or the app wrote it rather than whoever is named as speaking: a land's
-// breakage sent back to it, a fresh fix-up on a red main line and its later nudges, a note to a conversation still
-// working on what failed, the brief a person's press hands an agent (what a push left, main's red CI), a land conflict to
+// WHAT A COMPOSED PROMPT IS FOR, when the sandbox or the app wrote it rather than whoever is named as speaking: the brief
+// a fix agent is handed (what a push left, main's red CI, each later failure on main) and its nudges, a land conflict to
 // resolve. Carried on the turn and the row it opens, so a reader shows it as the sandbox's words, not the owner's, and
 // never has to recognise the prompt by its opening; the four openings older rows are recognised by stay what they are
-// (events/errands.ts, errandOfPrompt).
+// (events/errands.ts, errandOfPrompt). `verify-nudge` and the `land-*` errands are retired with the checks that sent them
+// and stay only because records hold them.
 export const TurnErrandSchema = z.enum([
     "land-conflict",
     "verify-nudge",

package/src/schemas/workspace/{mainline.test.ts → push-checks.test.ts}

@@ -1,5 +1,5 @@
 import { pushFixConversationId } from "../../ids/conversation-ids.js";
-import { pushFixBase, pushRedOf, type Red, RedSchema } from "./mainline.js";
+import { pushFixBase, pushRedOf, type Red, RedSchema } from "./push-checks.js";
 
 // What a push left is a Red like any other (source `push`, scope the project), and the hand-over's id is named by when
 // that red began, so the editor and the daemon find the same attempt whichever of them asks.
@@ -7,12 +7,12 @@ import { pushFixBase, pushRedOf, type Red, RedSchema } from "./mainline.js";
 const red = (over: Partial<Red>): Red => RedSchema.parse({ source: `push`, scope: `app`, since: 100, ...over });
 
 describe(`a project's push red`, () => {
-    test(`is the push red of that project, never a land check's red of the same folder or another project's`, () => {
-        const land = red({ source: `land` });
+    test(`is the push red of that project, never a CI red of the same name or another project's`, () => {
+        const ci = red({ source: `ci` });
         const other = red({ scope: `web` });
         const mine = red({});
-        expect(pushRedOf([land, other, mine], `app`)).toBe(mine);
-        expect(pushRedOf([land, other], `app`)).toBeUndefined();
+        expect(pushRedOf([ci, other, mine], `app`)).toBe(mine);
+        expect(pushRedOf([ci, other], `app`)).toBeUndefined();
         expect(pushRedOf(undefined, `app`)).toBeUndefined();
     });
 

package/src/schemas/workspace/push-checks.ts

@@ -0,0 +1,155 @@
+// what the pre-push hook let through, and the one record every red keeps, whatever went red
+import { z } from "zod";
+import { pushFixConversationId } from "../../ids/conversation-ids.js";
+import { AgentRunPickSchema } from "../agent.js";
+
+// Nothing checks work inside a conversation or after it lands: CI checks what the owner pushes (ci/main-fixer.ts puts
+// one fix agent on main's red), and the pre-push hook measures the push on the way out without ever refusing it
+// (verify-push.mjs, `--advisory`). What the hook found used to vanish with the terminal it printed to. It now leaves a
+// report in the repository's git dir, the daemon files it once the push has actually reached the remote, and what it
+// found is owed, as the project's push Red, until a later measurement no longer prints it or somebody dismisses it.
+// Nobody is sent after it: acting on it is the owner's call.
+
+// ONE FINDING, whatever measured it: a check run's line as the repository's own tooling printed it, named by what
+// printed it (`source`, the repository's word: a check's id, `lint`, a hook), with the command that shows it again and
+// whether a later measurement can say it is gone. A push's findings are these; a CI run's failed jobs become them too.
+export const FindingSchema = z.object({
+    id: z.string().describe("Stable across measurements: the same problem found again is the same id."),
+    source: z.string().describe("What measured it, in the repository's own words: a check's id, `lint`, a hook."),
+    text: z.string().describe("The finding as it was printed."),
+    path: z.string().optional().describe("The repository path it is about, when it names one."),
+    command: z.string().optional().describe("The command that shows it again."),
+    recheckable: z
+        .boolean()
+        .describe("Whether a later measurement can find it gone. False for one about commits already made, which ends only when dismissed."),
+    gate: z
+        .enum(["code", "tidy"])
+        .optional()
+        .describe(
+            "For a check's finding: `code` means the tree fails the check whoever caused it; `tidy` means the change measured added this line.",
+        ),
+    commit: z
+        .object({ sha: z.string(), subject: z.string() })
+        .optional()
+        .describe("The newest commit of the change measured that touched the path it names, when it names one."),
+});
+export type Finding = z.infer<typeof FindingSchema>;
+
+// What was decided about a red, in the order it was decided.
+export const RedDecisionKindSchema = z.enum([
+    // A fix agent was put on it: pressed for by a person, or started by the sandbox on main's red CI.
+    "fix-up",
+    // Nobody was sent: repairs are switched off, or nothing could take it.
+    "reported",
+    // A later measurement no longer found it (`findings` names which).
+    "resolved",
+    // The fix agent had its turns, or stopped without a fix: it waits for a person.
+    "spent",
+    // A person set findings aside as not to be fixed (`findings` names which).
+    "dismissed",
+]);
+export type RedDecisionKind = z.infer<typeof RedDecisionKindSchema>;
+
+export const RedDecisionSchema = z.object({
+    kind: RedDecisionKindSchema.describe("What was decided."),
+    conversationId: z.string().optional().describe("The conversation working on it, when one is."),
+    at: z.number().describe("When that was decided, in milliseconds."),
+    detail: z.string().optional().describe("One sentence on why, in the sandbox's words."),
+    findings: z
+        .array(z.string())
+        .optional()
+        .describe("The findings it was about, by id, when it was about some of a red's findings rather than the whole red."),
+});
+export type RedDecision = z.infer<typeof RedDecisionSchema>;
+
+// ONE RED, whatever went red: what a push left in a project, main's CI on a branch. What it owes (its findings) and every
+// decision about it, oldest first. A push's red waits for the owner's press (conversations/fix/push-fix.ts); main's CI
+// red gets one fix agent by itself (ci/main-fixer.ts). The record is the same.
+export const RedSourceSchema = z.enum(["push", "ci"]);
+export type RedSource = z.infer<typeof RedSourceSchema>;
+
+export const RedSchema = z.object({
+    source: RedSourceSchema.describe("What went red."),
+    scope: z.string().describe("Where: a project's folder, or a repository and branch."),
+    since: z.number().describe("When the red streak began (state/red-streak.ts)."),
+    findings: z.array(FindingSchema).default([]).describe("What it owes, as the red's own measurement named it."),
+    decisions: z.array(RedDecisionSchema).default([]).describe("What was decided about it, oldest first."),
+});
+export type Red = z.infer<typeof RedSchema>;
+
+// ONE PUSH THE HOOK MEASURED, as the record lists it: where it went and what it found that it brought in. What of that is
+// still owed is the project's push Red's to say (`findings`), never the push's.
+export const PushCheckSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace. Empty is the workspace root."),
+    id: z.string().describe("The report's own id."),
+    at: z.number().describe("When the push check ran, in milliseconds."),
+    remote: z.string().optional().describe("The remote it was pushed to."),
+    branch: z.string().optional().describe("The branch it was pushed to."),
+    base: z.string().optional().describe("The commit the pushed range starts from; absent when the remote had nothing to compare with."),
+    head: z.string().describe("The commit that was pushed."),
+    commits: z.number().describe("How many commits the push carried."),
+    findings: z
+        .array(FindingSchema)
+        .describe("What it found that this push brought in, less what an earlier push had already left open. Empty for a clean push."),
+    refused: z
+        .boolean()
+        .optional()
+        .describe(
+            "True when the repository's own pre-push hook refused it, so nothing reached the remote and its one finding is what the hook said.",
+        ),
+});
+export type PushCheck = z.infer<typeof PushCheckSchema>;
+
+export const PushChecksSchema = z.object({
+    pushed: z.array(PushCheckSchema).describe("The latest pushes the hook measured across every project, newest first, with what each brought in."),
+    reds: z.array(RedSchema).describe("What pushes left in each project and is still owed, one push Red per project, with every decision about it."),
+});
+export type PushChecks = z.infer<typeof PushChecksSchema>;
+
+export const PushDismissSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace."),
+    ids: z.array(z.string()).optional().describe("Which findings. Leave it out for every open one in the project."),
+    restore: z.boolean().optional().describe("Undo: open the named dismissed findings again."),
+});
+export type PushDismiss = z.infer<typeof PushDismissSchema>;
+
+export const PushDismissResultSchema = z.object({
+    changed: z.number().describe("How many findings changed state."),
+});
+
+export const PushRecheckSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace."),
+});
+
+export const PushRecheckResultSchema = z.object({
+    measured: z.boolean().describe("Whether the project could be measured at all; false leaves every finding as it was."),
+    resolved: z.number().describe("How many findings the measurement no longer saw."),
+    open: z.number().describe("How many are still open."),
+});
+export type PushRecheckResult = z.infer<typeof PushRecheckResultSchema>;
+
+export const PushFixSchema = z.object({
+    project: z.string().describe("Which project's open push findings to hand over, by folder relative to the workspace."),
+    pick: AgentRunPickSchema.describe("Which model to open the conversation on, when somebody chose one. Leave it out for the sandbox's own choice."),
+    mode: z
+        .enum(["continue", "start-over"])
+        .optional()
+        .describe(
+            "What to do about an attempt already made at these findings: `continue` carries on in it, `start-over` files it away and opens the next attempt. Leave it out for the plain press.",
+        ),
+});
+export type PushFix = z.infer<typeof PushFixSchema>;
+
+export const PushFixResultSchema = z.object({
+    conversationId: z.string().describe("The conversation holding the findings. Open it to watch."),
+});
+
+// What pushes left in `project`, as the reds name it; undefined while nothing is owed.
+export const pushRedOf = (reds: readonly Red[] | undefined, project: string): Red | undefined =>
+    reds?.find((red) => red.source === "push" && red.scope === project);
+
+// The conversation id a hand-over of a push red wears (attempt 1), derived from when the red began, so the editor and the
+// daemon agree on whether an agent is already on it: pressing again while anything is owed continues the same attempt,
+// and a red that begins after everything was handled starts a fresh one. Undefined when nothing is owed.
+export const pushFixBase = (red: Pick<Red, "scope" | "since"> | undefined): string | undefined =>
+    red === undefined ? undefined : pushFixConversationId(red.scope === "" ? "workspace" : red.scope, `red:${red.since}`);

package/src/schemas/workspace/workspace-tree.ts

@@ -132,6 +132,21 @@ export const WorkspaceMediaTicketSchema = z.object({
     ticket: z.string().describe("Hand this to the streaming route in the query string. It buys exactly the one file it was minted for."),
     expiresAt: z.number().describe("When it stops working, in milliseconds, so a player can tell a dead ticket from a dead file."),
 });
+// Credential for GET /workspace/download, which the browser navigates to so its own download manager streams the archive
+// to disk. The ticket carries the whole selection, resolved when minted, so however many entries it names the URL stays
+// short.
+export const WorkspaceDownloadTicketQuerySchema = WorkspaceScopeSchema.extend({
+    paths: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(10_000)
+        .describe("The files and folders to download together, as workspace paths. A folder brings everything inside it."),
+});
+export const WorkspaceDownloadTicketSchema = z.object({
+    ticket: z.string().describe("Hand this to the download route in the query string. It buys exactly the selection it was minted for, once resolved."),
+    expiresAt: z.number().describe("When it stops working, in milliseconds. It is meant to be used at once."),
+    filename: z.string().describe("What the archive is saved as, so a caller can say what is on its way."),
+});
 // A read of a window: offset negative reads that many bytes from the end (for following a growing log); limit is
 // clamped to the daemon's own cap. Coerced from query strings.
 export const WorkspaceFileReadQuerySchema = WorkspaceScopeSchema.extend({

package/src/state/fix-stance.test.ts

@@ -50,7 +50,8 @@ test.each([
     ["holding nothing yet", undefined],
 ] as const)("a turn that ended waiting on its own watch, %s, is still working", (_case, diff) => {
     const watches = [{ id: `watch-a1b2`, note: `CI on the pushed branch`, intervalSeconds: 60, deadlineAt: 9_000 }];
-    expect(fixStance(agent({ status: `idle`, watches, ...(diff === undefined ? {} : { diff }) }))).toStrictEqual({
+    // The daemon reads the armed watch as a wake to come (awaitingWake); the stance reads that, never the watch list.
+    expect(fixStance(agent({ status: `idle`, watches, awaitingWake: true, ...(diff === undefined ? {} : { diff }) }))).toStrictEqual({
         kind: `working`,
         ongoing: true,
         retry: false,

package/src/state/landed-commit.ts

@@ -18,5 +18,5 @@ export const landedCommitMessage = (landed: LandedMessage): string => {
 export const declaredTestNote = (said: string): string | undefined => /^Test-Note:[ \t]*(\S.*)$/m.exec(said)?.[1]?.trim();
 
 // The `Allow: <check> — <reason>` lines a conversation ended its last message with, each an exception it declared for
-// its change on purpose; the check after the land and the push read them off the landed commit.
+// its change on purpose; the push reads them off the landed commit.
 export const declaredAllows = (said: string): string[] => [...said.matchAll(/^Allow:[ \t]*(\S.*)$/gm)].map((match) => match[1]!.trim());

package/src/state/red-streak.ts

@@ -1,7 +1,7 @@
-// ONE DEFINITION OF A RED STREAK, for every source that goes red: a land check's project (verify-store.ts), main's CI
-// (repair-gate.ts), a pipeline branch on the board (the pipelines extension's ciStreaks.ts) and the Main line's older
-// daemons (the editor's mainlineView.ts). A streak is the unbroken run of red at the head: a red extends it, anything
-// else ends it, and `since` is where it began, which is what names one failure across every red that continues it.
+// ONE DEFINITION OF A RED STREAK, for every source that goes red: what a project's pushes left (push-checks-store.ts)
+// and a pipeline branch on the board (the pipelines extension's ciStreaks.ts). A streak is the unbroken run of red at
+// the head: a red extends it, anything else ends it, and `since` is where it began, which is what names one failure
+// across every red that continues it.
 
 export interface Streak {
     // When (or at which run) the streak began: the first red of the unbroken run.

package/src/state/runtime-state.ts

@@ -59,9 +59,8 @@ const RUNTIME_DOMAINS = [
     // The audit log grew or a gateway's status moved or aged out; the log lives outside /work, so no file push carries it.
     { domain: "activity", invalidates: [["activity"], ["activity-status"]] },
 
-    // The main tree's own check after a land: queued, started, settled, or its red handed to somebody. Held in the
-    // daemon's memory as much as in a file, so a push is the only way a watcher hears it move.
-    { domain: "mainline", invalidates: [["mainline"]] },
+    // What the pre-push hook left behind: a push filed, a finding measured gone, dismissed or handed to an agent.
+    { domain: "pushes", invalidates: [["push-checks"]] },
 ] as const satisfies readonly RuntimeDomainBinding[];
 
 export const RUNTIME_DOMAIN_BINDINGS: readonly RuntimeDomainBinding[] = RUNTIME_DOMAINS;

package/src/state/workspace-state.ts

@@ -379,24 +379,12 @@ const STATE_FILES = [
         portability: "derived",
         note: "The target stamps its own daemon version on first boot.",
     },
-    {
-        path: ".intentic/records/verify.json",
-        invalidates: [],
-        why: "The main-line check's memory: each project's last verdict and red streak, and the latest runs with what became of each red one. Read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain), so no file watch is needed.",
-        portability: "carry",
-    },
     {
         path: ".intentic/records/push-checks.json",
         invalidates: [],
-        why: "What each push check found and let through, per project, and what became of every finding: still open, measured gone, or dismissed. Filed from the report the pre-push hook leaves in the repository's git dir; read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain).",
+        why: "What each push check found and let through, per project, and what became of every finding: still open, measured gone, or dismissed. Filed from the report the pre-push hook leaves in the repository's git dir; read through GET /workspace/push-checks, which the daemon pushes itself (the `pushes` runtime domain).",
         portability: "carry",
     },
-    {
-        path: ".intentic/local/verify/",
-        invalidates: [],
-        why: "A running check's wrapper artifacts (log + exit status), read once by the daemon when the panel finishes.",
-        portability: "derived",
-    },
     // What an update converted before it booted all the way (the sandbox daemon's state-journal.ts): a copy of every
     // file the new version changed, kept until it commits and for a grace window after. `secret` whatever the source
     // was, since a vault's copy is a vault; locked below for the same reason.