@intentic/sandbox-contract 1.311.0 → 1.313.0

package/src/schemas/system.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { StatePlanSchema } from "./state-plan.js";
 // version is this build's baked-in version; latest/updateAvailable come from comparing it to the published stable
 // release.
 // Whether a runtime can serve a turn, probed off the turn path. "unknown" reads as available-but-unverified, never as
@@ -27,6 +28,14 @@ export const StagedUpdateSchema = z.object({
         ),
     // Epoch ms the download finished; used to check this is still the update being offered.
     at: z.number().describe("When the download finished, in milliseconds, which answers whether this is still the update being offered."),
+    // The staged build's state pre-flight (the daemon's state-plan.ts, run by `ic sandbox prepare` over read-only mounts
+    // of this sandbox's volumes): what its first boot converts, before anyone accepts the update.
+    // Embedded verbatim by the ic that staged it (StatePlanSchema); a marker an older ic wrote held only `ok` with
+    // `downgrade` and `steps`, or `failures`, so everything but `ok` stays optional here.
+    plan: StatePlanSchema.partial()
+        .extend({ ok: StatePlanSchema.shape.ok })
+        .optional()
+        .describe("What the downloaded build's first boot would convert in this sandbox's stored files. Absent when no plan could be had, which says nothing either way."),
 });
 export type StagedUpdate = z.infer<typeof StagedUpdateSchema>;
 export const InfoSchema = z.object({
@@ -75,8 +84,9 @@ export const InfoSchema = z.object({
     ),
 });
 export type Info = z.infer<typeof InfoSchema>;
-// What the daemon could not read in its own `.intentic/` state files. Reported per file, only for files listed in
-// REPORTED_MANIFEST_PATHS (workspace-state.ts). `kind`:
+// What the daemon could not read in its own `.intentic/` state files, and in the files on its volume that
+// REPORTED_VOLUME_FILES names. Reported per file, only for files listed in REPORTED_MANIFEST_PATHS or
+// REPORTED_VOLUME_FILES (workspace-state.ts). `kind`:
 // unreadable: whole file ignored, everything in it at default.
 // unknownKey: only that key ignored; `suggestion` may name what it should be.
 // invalidEntry: one list entry skipped, rest of the file stands.
@@ -86,6 +96,13 @@ export const ManifestProblemSchema = z.object({
         .describe(
             "What to do about it. Unreadable means the whole file is being ignored and everything in it is at its default. An unknown key means only that key is ignored. An invalid entry means one item of a list was skipped and the rest is fine.",
         ),
+    // Why, as a word a reader matches on; `detail` is prose for a person and never parsed. Absent from an older daemon.
+    reason: z
+        .enum(["io", "not-json", "conversion-failed", "rejected"])
+        .optional()
+        .describe(
+            "Why it could not be read: the file could not be opened (io), it is not JSON, a conversion to this version's shape failed, or its contents are not what this version expects (rejected). A rejected file after a newer version ran is usually that version's, not a broken one.",
+        ),
     detail: z.string().describe("What exactly was wrong, as one sentence and nothing else. Never the remedy: that is `fix`."),
     suggestion: z.string().optional().describe("The name it was probably meant to be, when one is close enough to guess honestly."),
     // Set only when the fix isn't "open the file and correct it", e.g. a version skew where editing would be wrong.
@@ -98,7 +115,11 @@ export type ManifestProblem = z.infer<typeof ManifestProblemSchema>;
 // Workspace-relative path and everything currently wrong with that file; a clean file is absent from the list, not
 // present and empty.
 export const ManifestProblemReportSchema = z.object({
-    path: z.string().describe("The file, as a workspace path. The file is the unit somebody fixes, which is why problems are grouped by it."),
+    path: z
+        .string()
+        .describe(
+            "The file, as a workspace path, or as its absolute path on the daemon's own history volume for one kept there (the conversation registry). The file is the unit somebody fixes, which is why problems are grouped by it.",
+        ),
     problems: z
         .array(ManifestProblemSchema)
         .describe("Everything currently wrong with it. A file with nothing wrong is absent rather than present and empty."),

package/src/schemas/workspace/mainline.test.ts

@@ -0,0 +1,28 @@
+import { pushFixConversationId } from "../../ids/conversation-ids.js";
+import { pushFixBase, pushRedOf, type Red, RedSchema } from "./mainline.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.
+
+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` });
+        const other = red({ scope: `web` });
+        const mine = red({});
+        expect(pushRedOf([land, other, mine], `app`)).toBe(mine);
+        expect(pushRedOf([land, other], `app`)).toBeUndefined();
+        expect(pushRedOf(undefined, `app`)).toBeUndefined();
+    });
+
+    test(`names its hand-over by when it began, with the workspace root spelled as the workspace`, () => {
+        expect(pushFixBase(red({}))).toBe(pushFixConversationId(`app`, `red:100`));
+        expect(pushFixBase(red({ scope: `` }))).toBe(pushFixConversationId(`workspace`, `red:100`));
+        expect(pushFixBase(undefined)).toBeUndefined();
+    });
+
+    test(`that began later is a fresh attempt`, () => {
+        expect(pushFixBase(red({ since: 200 }))).toBe(pushFixConversationId(`app`, `red:200`));
+    });
+});

package/src/schemas/workspace/mainline.ts

@@ -0,0 +1,268 @@
+// main-line checks: the whole-tree check the daemon runs after work lands, and what became of what it found
+import { z } from "zod";
+import { pushFixConversationId } from "../../ids/conversation-ids.js";
+import { AgentRunPickSchema } from "../agent.js";
+
+// Nothing is verified inside a conversation any more: a turn ends when the model says it is done, its work lands, and
+// the main tree's own check runs afterwards, off everyone's clock, one project at a time. This is that check as the
+// editor reads it: what is being measured, what is waiting, what the last run said, and who is working on a red one.
+
+export const MainlineLandSchema = z.object({
+    conversationId: z.string().describe("The conversation whose work landed."),
+    title: z.string().optional().describe("Its title when it landed."),
+    at: z.number().describe("When the land asked for the check, in milliseconds."),
+});
+export type MainlineLand = z.infer<typeof MainlineLandSchema>;
+
+// A land a red is laid at, as a reader names it.
+export const MainlineLandRefSchema = z.object({
+    conversationId: z.string().describe("The conversation whose work landed."),
+    title: z.string().optional().describe("Its title when it landed."),
+});
+export type MainlineLandRef = z.infer<typeof MainlineLandRefSchema>;
+
+// One failure a run named, split the way a reader scans it.
+export const MainlineFailureSchema = z.object({
+    name: z.string().describe("What failed: a test by its own name, anything else (a type error, a whole task) as the check printed it."),
+    path: z.string().optional().describe("The repository path it failed in, when it names one."),
+});
+export type MainlineFailure = z.infer<typeof MainlineFailureSchema>;
+
+// What happened to a red verdict's failures, decided once the lands behind it had their own check.
+export const MainlineRoutingKindSchema = z.enum([
+    // More work landed while this ran; the check that measures it decides, so nobody is sent after a failure it may fix.
+    "waiting",
+    // A conversation still working touches what failed; nobody else is started until it stops.
+    "held",
+    // Sent back to the conversation that landed it, which still had the work in mind.
+    "original",
+    // A fresh conversation was started on it with the failures, the suspects' changes and where to read their sessions.
+    "fix-up",
+    // Nobody was sent: repairs are switched off, or no conversation could take it. An automation may.
+    "reported",
+    // Gone at the next check, before anybody was sent.
+    "resolved",
+    // The sends and fresh attempts a red streak allows are used up; it waits for a person.
+    "spent",
+    // A person set findings aside as not to be fixed (`findings` names which); what a push left is the owner's to dismiss.
+    "dismissed",
+]);
+export type MainlineRoutingKind = z.infer<typeof MainlineRoutingKindSchema>;
+
+export const MainlineRoutingSchema = z.object({
+    kind: MainlineRoutingKindSchema.describe("What became of the failures."),
+    conversationId: z
+        .string()
+        .optional()
+        .describe("The conversation working on them (the original or a fresh one), or the one still working that the repair waits for."),
+    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 MainlineRouting = z.infer<typeof MainlineRoutingSchema>;
+
+// The first failures a run names; the whole list stays in its terminal.
+export const MAINLINE_FAILURES_KEPT = 30;
+
+export const MainlineRunSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace. Empty is the workspace root."),
+    command: z.string().describe("What ran."),
+    status: z.enum(["green", "red"]).describe("How it ended."),
+    startedAt: z.number().describe("When it started, in milliseconds."),
+    at: z.number().describe("When it ended, in milliseconds."),
+    lands: z.array(MainlineLandSchema).describe("The lands it answered for, oldest first. Empty for a run no land asked for."),
+    failures: z.array(z.string()).describe(`The first failures it named, at most ${MAINLINE_FAILURES_KEPT}.`),
+    failureCount: z.number().describe("How many failures it named in all. Zero on a red run that wrote no list."),
+    attempt: z.number().describe("How many red runs in a row this is for the project; zero when green."),
+    suspects: z
+        .array(z.string())
+        .optional()
+        .describe("The conversations whose lands these failures were laid at, when any could be named."),
+    named: z
+        .boolean()
+        .optional()
+        .describe(
+            "Whether the failures were laid at the suspects by the paths they changed. False when nobody could be told apart (every land the run covered is a suspect) or nothing new failed in it (none is). Absent on green, and from a daemon that did not say.",
+        ),
+    units: z
+        .array(MainlineFailureSchema)
+        .optional()
+        .describe("The same first failures, split into a name and the path they failed in. Absent from a daemon that does not split them."),
+    routing: MainlineRoutingSchema.optional().describe("What became of a red run's failures. Absent on green, and until it is decided."),
+});
+export type MainlineRun = z.infer<typeof MainlineRunSchema>;
+
+export const MainlineProjectSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace. Empty is the workspace root."),
+    running: z
+        .object({
+            command: z.string().describe("What is running."),
+            startedAt: z.number().describe("When it started, in milliseconds."),
+            lands: z.array(MainlineLandSchema).describe("The lands it answers for."),
+            on: z.string().optional().describe("The runner it was sent to, on one of your machines. Absent when it runs in this sandbox."),
+        })
+        .optional()
+        .describe("The check running on it now, if any."),
+    session: z
+        .string()
+        .optional()
+        .describe("The terminal session its check runs in, running or last, to attach to for the whole log. Absent from a daemon that does not say."),
+    queued: z.array(MainlineLandSchema).describe("Lands waiting for the next check, which will measure them together."),
+    last: MainlineRunSchema.optional().describe("Its most recent settled check."),
+    redSince: z.number().optional().describe("When its checks went red and stayed so, in milliseconds. Absent while green."),
+    red: z
+        .object({
+            since: z.number().describe("When its checks went red and stayed so, in milliseconds."),
+            cause: z
+                .array(MainlineLandRefSchema)
+                .describe("The work this red is laid at, oldest first: the lands its failures were laid at on the latest run of the streak that could name any. Empty when none could be."),
+            named: z.boolean().describe("Whether `cause` was narrowed by the paths the lands changed; false when it is every land the run covered."),
+            fixer: MainlineRoutingSchema.optional().describe("The latest decision about who has it. Absent until one is made."),
+        })
+        .optional()
+        .describe("The red streak it is in, as the sandbox laid it. Absent while green, and from a daemon that does not lay it."),
+});
+export type MainlineProject = z.infer<typeof MainlineProjectSchema>;
+
+
+// WHAT A PUSH LEFT BEHIND. The pre-push hook never refuses (verify-push.mjs, `--advisory`): it measures, reports, and the
+// push goes. What it 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 (RED_POLICY).
+
+// 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 land check's failures and 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>;
+
+// ONE RED, whatever went red: a land check's project, what a push left in a project, main's CI on a branch. What it owes
+// (its findings), who it was laid at and whether that was narrowed, and every decision about it, oldest first. Each
+// source answers its own red by its own policy (RED_POLICY); the record is the same.
+export const RedSourceSchema = z.enum(["land", "push", "ci"]);
+export type RedSource = z.infer<typeof RedSourceSchema>;
+
+// Who answers a red: `route` sends it itself (the land check's router, conversations/land/land-breakage.ts), `owner`
+// waits for a person's press (what a push left, conversations/fix/push-fix.ts), `fix-agent` starts the source's own fix
+// agent once the red is main's standing word (CI, ci/repair-gate.ts).
+export const RED_POLICY = { land: "route", push: "owner", ci: "fix-agent" } as const satisfies Record<RedSource, "route" | "owner" | "fix-agent">;
+
+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."),
+    suspects: z.array(z.string()).default([]).describe("The conversations it was laid at."),
+    named: z.boolean().default(false).describe("Whether the paths they changed narrowed it to them."),
+    decisions: z.array(MainlineRoutingSchema).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 MainlinePushSchema = 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 MainlinePush = z.infer<typeof MainlinePushSchema>;
+
+export const MainlineStatusSchema = z.object({
+    projects: z.array(MainlineProjectSchema).describe("Every project a land has been checked in, or is waiting to be."),
+    recent: z.array(MainlineRunSchema).describe("The latest settled checks across every project, newest first."),
+    pushed: z
+        .array(MainlinePushSchema)
+        .optional()
+        .describe("The latest pushes the hook measured across every project, newest first, with what each brought in. Absent from a daemon that records none."),
+    reds: z
+        .array(RedSchema)
+        .optional()
+        .describe(
+            "Every red the main line holds, one record whatever went red: each red project's land check and what pushes left in each project, with what each owes and every decision about it. Absent from a daemon that keeps none.",
+        ),
+});
+export type MainlineStatus = z.infer<typeof MainlineStatusSchema>;
+
+export const MainlinePushDismissSchema = 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 MainlinePushDismiss = z.infer<typeof MainlinePushDismissSchema>;
+
+export const MainlinePushDismissResultSchema = z.object({
+    changed: z.number().describe("How many findings changed state."),
+});
+
+export const MainlinePushRecheckSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace."),
+});
+
+export const MainlinePushRecheckResultSchema = 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 MainlinePushRecheckResult = z.infer<typeof MainlinePushRecheckResultSchema>;
+
+export const MainlinePushFixSchema = 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 MainlinePushFix = z.infer<typeof MainlinePushFixSchema>;
+
+export const MainlinePushFixResultSchema = 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

@@ -72,8 +72,33 @@ export const WorkspaceTreeSchema = z.object({
         .describe(
             "Folders whose whole contents are empty folders, and nothing else. Complete for the workspace, however much of the tree above was listed, and ordered like the tree, so a parent comes before the branch below it.",
         ),
+    generation: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe(
+            "Which state of the shared tree this is; the changes that follow count from it. Absent for a conversation's own checkout, which is listed when asked and followed by no changes.",
+        ),
 });
 export type WorkspaceTree = z.infer<typeof WorkspaceTreeSchema>;
+// What moved in the shared tree between two generations: every folder whose own entries changed, parents first.
+export const WorkspaceTreeDeltaSchema = z.object({
+    from: z.number().int().nonnegative().describe("The generation this applies on top of. A reader holding any other fetches the tree afresh instead."),
+    generation: z.number().int().nonnegative().describe("The generation it leaves the tree at."),
+    dirs: z
+        .array(
+            z.object({
+                path: z.string().describe("The folder, as a workspace path; empty for the workspace root."),
+                entries: z
+                    .array(WorkspaceTreeEntrySchema)
+                    .describe("Its entries now, without their contents: a folder whose own entries also changed comes as an item of its own."),
+            }),
+        )
+        .describe("Each folder that changed, parents before the folders inside them."),
+    barren: z.array(z.string()).optional().describe("The barren folders now, present only when that list moved."),
+});
+export type WorkspaceTreeDelta = z.infer<typeof WorkspaceTreeDeltaSchema>;
 // Lazy-loads one directory's children past the tree walk's budget; depth reads several levels into one flat `entries`
 // list instead of one request per directory.
 export const WorkspaceChildrenQuerySchema = WorkspaceScopeSchema.extend({
@@ -253,6 +278,28 @@ export const WorkspaceExtractSchema = z.object({
         ),
 });
 export type WorkspaceExtract = z.infer<typeof WorkspaceExtractSchema>;
+// A delete moves the entry into the daemon's trash rather than erasing it, so the gesture can be taken back.
+export const WorkspaceDeletedSchema = z.object({
+    ok: z.literal(true).describe("Always true: the entry is gone from where it was, or was never there."),
+    trashed: z
+        .string()
+        .optional()
+        .describe(
+            "The trash id that brings it back through the restore call, for a day. Absent when there was nothing at that path to delete.",
+        ),
+});
+export type WorkspaceDeleted = z.infer<typeof WorkspaceDeletedSchema>;
+export const WorkspaceRestoreSchema = z.object({
+    trashed: z.string().min(1).describe("The trash id a delete answered with."),
+});
+export const WorkspaceRestoredSchema = z.object({
+    path: z
+        .string()
+        .describe(
+            "Where it came back, as a workspace path: where it was deleted from, or beside that under a `(restored)` name when something new has taken the name since.",
+        ),
+});
+export type WorkspaceRestored = z.infer<typeof WorkspaceRestoredSchema>;
 // Deterministic, no-LLM classification into coarse buckets, read-only, applied via /workspace/move. reason is the
 // winning signal: magic:<mime>, ext:<ext>, repository:<marker>, text-content, or unknown.
 export const WorkspaceBucketSchema = z.enum(["repositories", "documents", "media", "archives", "other"]);

package/src/state/contract-lock.test.ts

@@ -1,20 +1,81 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { shrunkSurfaces } from "@intentic/constants/contract-shrink";
 import { packageRoot } from "@intentic/constants/node";
-import { currentLock } from "./contract-lock.js";
+import { RAW_ROUTE_LIST } from "../protocol/raw-routes.js";
+import type { RouteMeta } from "../protocol/route-meta.js";
+import { accessChanges, currentLock, serializeLock } from "./contract-lock.js";
+
+const committedText = (): string => readFileSync(join(packageRoot(import.meta.url), "contract.lock.json"), "utf8");
+
+const ACCESS_MOVED =
+    "a route's access moved — run `pnpm --filter @intentic/sandbox-contract lock` and commit contract.lock.json with this change. " +
+    "Any change to an existing route's reach (a lower floor, a guest, agent, panel or sync grant, a wider control rung, or a " +
+    "tighter one that locks callers out) lands as a `type!:` commit with a `Breaking-Note:` trailer saying who can now reach " +
+    "what, or who no longer can.";
 
 // contract.lock.json must match the exported schemas; the git-aware half of this check lives in contract-shrink.mjs.
 // Needs 30s: serializing ~500 schemas can run past the unit hang detector under load.
 test(
     "contract.lock.json matches the schemas this package exports",
     () => {
-        const committed = JSON.parse(readFileSync(join(packageRoot(import.meta.url), "contract.lock.json"), "utf8")) as Record<string, unknown>;
+        const committed = committedText();
+        const current = currentLock();
+        // Named first, so a reach change says which route before the whole-lock diff does.
+        expect(accessChanges(committed, serializeLock(current)), ACCESS_MOVED).toEqual([]);
         expect(
-            currentLock(),
+            current,
             "the wire contract moved — run `pnpm --filter @intentic/sandbox-contract lock` and commit contract.lock.json with this change. " +
                 "If a schema or field was removed or changed (not added), land it as a `type!:` commit with a `Breaking-Note:` trailer " +
                 "saying, in the user's words, what stops working and what to do instead.",
-        ).toEqual(committed);
+        ).toEqual(JSON.parse(committed));
     },
     { timeout: 30_000 },
 );
+
+// The wire outside oRPC is pinned the same way: a changed tunnel path, a gone control message or a renamed verdict is a
+// shrink the push gate and the landing draft both flag, where before nothing could see it.
+test("the lock flags a change to the wire no oRPC route carries", () => {
+    const base = currentLock() as Record<string, Record<string, unknown>>;
+    const moved = structuredClone(base);
+    (moved["wire:tunnel"] as { path: string }).path = "/tunnel/v3";
+    delete (moved["wire:browser-wire"] as { webTransport?: unknown }).webTransport;
+    expect(shrunkSurfaces(base, moved)).toEqual(["wire:browser-wire.webTransport", "wire:tunnel.path"]);
+    expect(shrunkSurfaces(moved, base)).toEqual(["wire:tunnel.path"]);
+});
+
+// The lock as it would be with one raw route declared otherwise: the declaration is swapped in place, and back.
+const lockWith = (name: string, change: (declared: RouteMeta) => RouteMeta): Record<string, unknown> => {
+    const route = RAW_ROUTE_LIST.find((candidate) => candidate.name === name);
+    if (route === undefined) {
+        throw new Error(`${name} is gone; pick another raw route with a maintainer floor and no grants`);
+    }
+    const declared = route.meta;
+    Reflect.set(route, "meta", change(declared));
+    try {
+        return currentLock();
+    } finally {
+        Reflect.set(route, "meta", declared);
+    }
+};
+
+const ROUTE = "POST /system/sync/report";
+
+// A lowered floor on any route, not only the ones route-reach.test.ts pins: the lock check names it, and the push gate and
+// the landing draft read it as a shrink that needs a declared break.
+test("lowering one route's floor fails the lock check, naming the route", () => {
+    const committed = currentLock();
+    const lowered = lockWith(ROUTE, (declared) => ({ ...declared, floor: "viewer" }));
+    expect(accessChanges(serializeLock(committed), serializeLock(lowered))).toEqual([`${ROUTE}: floor "maintainer" → "viewer"`]);
+    expect(shrunkSurfaces(committed, lowered)).toEqual([`access:${ROUTE}.floor`]);
+});
+
+// A grant a route never declared still has a value in the lock, so granting it is a changed value, not growth that
+// passes; taking one away reads the same way, since it locks out a caller that relied on it.
+test("granting guest or agent reach reads as a shrink, and so does taking it back", () => {
+    const committed = currentLock();
+    const granted = lockWith(ROUTE, (declared) => ({ ...declared, guest: true, agent: true }));
+    expect(accessChanges(serializeLock(committed), serializeLock(granted))).toEqual([`${ROUTE}: agent false → true, guest false → true`]);
+    expect(shrunkSurfaces(committed, granted)).toEqual([`access:${ROUTE}.agent`, `access:${ROUTE}.guest`]);
+    expect(shrunkSurfaces(granted, committed)).toEqual([`access:${ROUTE}.agent`, `access:${ROUTE}.guest`]);
+});

package/src/state/contract-lock.ts

@@ -1,7 +1,19 @@
 // contract.lock.json is every exported schema serialized to canonical JSON Schema, so git can flag a wire-contract
 // change. contract-shrink demands a `!` commit with a Breaking-Note when a schema, field or type shrinks; additions
-// pass freely. Derived from the package's exports, not a hand-kept list.
+// pass freely. Derived from the package's exports, not a hand-kept list, plus the wire no oRPC route carries: the
+// manifests the Rust crates that define it write beside their TypeScript (the tunnel, what a browser sees of the front
+// and the edge, and the front's control socket with Node), under `wire:` names no export can take.
+//
+// And who reaches each route: every raw route's and every procedure's RouteMeta, each reach field with its default
+// resolved (route-meta.ts `routeAccess`), under `access:METHOD /path`. Resolved, so every field is a value on every
+// route: a lowered floor, a `guest`, `agent` or `panel` granted, a control rung widened are each a changed value, which
+// contract-shrink reads as a shrink, the same `!` and Breaking-Note a removed field needs. A field left absent could
+// instead be added unseen, since growth passes freely. route-reach.test.ts in the daemon proves the gates honour
+// exactly these declarations; this pins the declarations themselves.
 
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { packageRoot } from "@intentic/constants/node";
 import { z } from "zod";
 import * as contract from "../index.js";
 
@@ -21,6 +33,57 @@ const sorted = (value: unknown): unknown => {
     return value;
 };
 
+const ACCESS_PREFIX = "access:";
+
+// The access half of the lock, one entry per route with its fields in key order; a procedure also names itself, so a
+// route moving between procedures is seen.
+const accessEntries = (): Record<string, Readonly<Record<string, string | boolean>>> => {
+    const entries = new Map<string, Readonly<Record<string, string | boolean>>>();
+    for (const route of [...contract.RAW_ROUTE_LIST, ...contract.SANDBOX_ROUTES]) {
+        const key = `${ACCESS_PREFIX}${route.method} ${route.path}`;
+        if (entries.has(key)) {
+            throw new Error(`two routes declare ${route.method} ${route.path}; the lock can record only one reach for it`);
+        }
+        const access = contract.routeAccess(route.method, route.meta);
+        const fields = route.name === `${route.method} ${route.path}` ? access : { ...access, procedure: route.name };
+        entries.set(key, Object.fromEntries(Object.entries(fields).toSorted(([a], [b]) => a.localeCompare(b))));
+    }
+    return Object.fromEntries([...entries].toSorted(([a], [b]) => a.localeCompare(b)));
+};
+
+// A lock text's access half: route key to its fields. Entries under other names are not its business.
+const accessHalf = (text: string): Record<string, Readonly<Record<string, string | boolean>>> => {
+    const lock = z.record(z.string(), z.unknown()).parse(JSON.parse(text));
+    return z
+        .record(z.string(), z.record(z.string(), z.union([z.string(), z.boolean()])))
+        .parse(Object.fromEntries(Object.entries(lock).filter(([key]) => key.startsWith(ACCESS_PREFIX))));
+};
+
+// Each route whose recorded reach differs between two locks, one line naming the route and every field that moved, so a
+// failing lock check says which route's access changed rather than leaving it to a diff of hundreds of entries. Takes
+// the two lock texts, as serializeLock writes them.
+export const accessChanges = (baseText: string, headText: string): string[] => {
+    const base = accessHalf(baseText);
+    const head = accessHalf(headText);
+    const keys = new Set([...Object.keys(base), ...Object.keys(head)]);
+    return [...keys].toSorted().flatMap((key) => {
+        const route = key.slice(ACCESS_PREFIX.length);
+        const was = base[key];
+        const now = head[key];
+        if (was === undefined || now === undefined) {
+            return [`${route}: ${was === undefined ? "new route" : "no longer declared"}`];
+        }
+        const moved = [...new Set([...Object.keys(was), ...Object.keys(now)])]
+            .toSorted()
+            .filter((field) => was[field] !== now[field])
+            .map((field) => `${field} ${JSON.stringify(was[field]) ?? "absent"} → ${JSON.stringify(now[field]) ?? "absent"}`);
+        return moved.length === 0 ? [] : [`${route}: ${moved.join(", ")}`];
+    });
+};
+
+// Each written by its crate's own test: `tunnel`, `browser-wire` and `front-wire` under _sandbox/front/crates.
+const WIRE_MANIFESTS = ["browser-wire", "front-wire", "tunnel"] as const;
+
 export const currentLock = (): Record<string, unknown> => {
     const lock: Record<string, unknown> = {};
     for (const name of Object.keys(contract).sort()) {
@@ -38,7 +101,12 @@ export const currentLock = (): Record<string, unknown> => {
             lock[name] = "<unserializable>";
         }
     }
-    return lock;
+    for (const manifest of WIRE_MANIFESTS) {
+        // Read from src/ whether this runs from src/ or dist/: the manifests are data `cargo test` writes, never compiled.
+        const text = readFileSync(join(packageRoot(import.meta.url), "src", "front", "generated", `${manifest}.json`), "utf8");
+        lock[`wire:${manifest}`] = sorted(JSON.parse(text));
+    }
+    return { ...lock, ...accessEntries() };
 };
 
 // One line per schema, not pretty-printed: keeps the lock short enough that a diff shows which surfaces moved.

package/src/state/definition.ts

@@ -48,9 +48,10 @@ const bareField = (field: z.ZodType): z.ZodType => {
     return inner;
 };
 
-const definitionSettings = (): z.ZodType<Partial<z.infer<typeof SandboxSettingsSchema>>> => {
+// Typed as the prefault it is, so the static input type says what the runtime does: an absent table is accepted.
+const definitionSettings = (): z.ZodPrefault<z.ZodType<Partial<z.infer<typeof SandboxSettingsSchema>>>> => {
     const shape = Object.fromEntries(Object.entries(SandboxSettingsSchema.shape).map(([key, field]) => [key, bareField(field).optional()]));
-    return z.strictObject(shape).prefault({}) as unknown as z.ZodType<Partial<z.infer<typeof SandboxSettingsSchema>>>;
+    return z.strictObject(shape).prefault({}) as unknown as z.ZodPrefault<z.ZodType<Partial<z.infer<typeof SandboxSettingsSchema>>>>;
 };
 
 export const SandboxDefinitionSchema = z.strictObject({

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

@@ -59,6 +59,14 @@ test.each([
     });
 });
 
+// The daemon's own reading decides, whatever the watch list says: a wake waiting in its queue keeps it working with no
+// watch at all, and a daemon that says nothing wakes it is not second-guessed from a list it still shows.
+test("an agent the daemon says awaits a wake is still working, and one it says does not is judged on what it holds", () => {
+    expect(fixStance(agent({ status: `idle`, awaitingWake: true })).kind).toBe(`working`);
+    const watches = [{ id: `watch-a1b2`, note: `CI on the pushed branch`, intervalSeconds: 60, deadlineAt: 9_000 }];
+    expect(fixStance(agent({ status: `idle`, awaitingWake: false, watches, diff: { files: 1, insertions: 1, deletions: 0 } })).kind).toBe(`ready`);
+});
+
 // Diff present doesn't change a failed status to ready; it only earns a mention in the hint.
 test("an agent that failed after writing files still reads as failed", () => {
     const stance = fixStance(agent({ status: `error`, diff: { files: 2, insertions: 34, deletions: 6 } }));