@intentic/sandbox-contract 1.308.2 → 1.310.0

package/src/state/workspace-state.test.ts

@@ -1,6 +1,5 @@
 import { STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
-import { describe, it, expect } from "bun:test";
 import {
     BACKED_UP_STATE_PATHS,
     isLockedWorkspacePath,
@@ -60,8 +59,8 @@ describe(`staleQueryKeys`, () => {
     });
 
     it(`ignores a store's own temp file while it is mid-swap`, () => {
-        // jsonFile's atomic-rename temp name: `.<name>.<pid>.tmp` beside the target.
-        expect(staleQueryKeys([`.intentic/.settings.json.42.tmp`], [])).toEqual([]);
+        // writeTextFile's atomic-rename temp name: `.<name>.<pid>.<n>.tmp` beside the target.
+        expect(staleQueryKeys([`.intentic/.settings.json.42.7.tmp`], [])).toEqual([]);
         expect(staleQueryKeys([`.intentic/config/settings.json`], [])).toEqual([`settings`, `manifests`]);
     });
 
@@ -346,8 +345,6 @@ describe(`VERSIONED_STATE_PATHS`, () => {
             // Which commands count as heavy, and how many may run at once; a shared-box decision worth a `git log`
             // line.
             `${STATE_DIR}/config/heavy-commands.json`,
-            // The exclude list carves entries out by name; an unlisted directory is invisible to git and to land.
-            `${STATE_DIR}/config/hooks/`,
             `${STATE_DIR}/config/loop-designs.json`,
             `${STATE_DIR}/config/personas.json`,
             // A persona's prompt and reachable skills: the text that decides how it behaves, same reason as its card.

package/src/state/workspace-state.ts

@@ -120,20 +120,6 @@ const STATE_FILES = [
     // Bash command. `carry`: a property of the workspace, not the machine. `versioned`: raising the limit is a decision
     // worth a diff.
     { path: ".intentic/config/heavy-commands.json", invalidates: ["settings"], portability: "carry", versioned: true },
-    // Scripts the rule table runs, one per reader (settings.json points at them per event, e.g. `file.edited`).
-    // `versioned`: this is code that runs against every file an agent writes, more consequential than the rule naming
-    // it. `carry`: authored text, no credential. Invalidates nothing: the settings screen renders the rules from
-    // settings.json, not these scripts.
-    {
-        path: ".intentic/config/hooks/",
-        invalidates: [],
-        why: "The settings screen renders the rules that name these scripts, out of settings.json; nothing in the browser reads the scripts themselves.",
-        portability: "carry",
-        versioned: true,
-        // The daemon only runs these scripts by path; it never builds them, so there's no `statePath` call for the
-        // coverage guard to find.
-        outsideWriter: "the owner or an agent, authoring them; the daemon only ever RUNS one, by the path a rule's command names",
-    },
     // Last-fired stamps for the rule table. `derived`: records what happened on this machine, not carried.
     {
         path: ".intentic/local/rule-firings.json",

package/src/text/archives.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { archiveFormat, archivePrefixOf, archiveRootOf, archiveStem, isBrowsableArchive, wrapsItsOwnName } from "./archives.js";
 
 describe(`archive names`, () => {

package/src/text/documents.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { documentOf, documentTitle, isDocumentPath, isPlanDocumentPath } from "./documents.js";
 import { PLAN_DOCUMENTS_DIR } from "../state/workspace-state.js";
 

package/src/text/embed.test.ts

@@ -1,5 +1,4 @@
 import { webcrypto } from "node:crypto";
-import { test, expect, beforeAll, mock } from "bun:test";
 import { stubGlobal, unstubAllGlobals } from "@intentic/testing/bun";
 import { EmbedError, embedFailure, embedUrl, fetchEmbedJson, solveProofOfWork } from "./embed.js";
 
@@ -40,12 +39,12 @@ test("a refusal carries the server's own sentence and status, and a bodyless one
 test("a JSON fetch answers the body or throws the refusal", async () => {
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
+        jest.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
     );
     expect(await fetchEmbedJson<{ ok: boolean }>("https://x/y")).toEqual({ ok: true });
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
+        jest.fn(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
     );
     await expect(fetchEmbedJson("https://x/y")).rejects.toMatchObject({ message: "rate limited", status: 429 });
     unstubAllGlobals();

package/src/text/emoji.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { isSingleEmoji } from "./emoji.js";
 
 describe("isSingleEmoji", () => {

package/src/text/mentions.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { MENTION_LIMIT, mentionedPathTokens, mentionPaths } from "./mentions.js";
 

package/src/text/path-refs.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { isTestPath, rankRefCandidates, referenceTails } from "./path-refs.js";
 
 describe("referenceTails", () => {

package/src/text/title.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { deriveTitle } from "./title.js";
 

package/src/text/transcript-fold.test.ts

@@ -1,5 +1,4 @@
 import { STATE_DIR } from "@intentic/constants";
-import { describe, it, expect } from "bun:test";
 import type { AgentEvent } from "../events/agent-events.js";
 import type { TranscriptPatch, TranscriptRow } from "../events/transcript.js";
 import { watchWakePrompt } from "../events/watch-wake.js";
@@ -186,7 +185,8 @@ describe("foldTurn", () => {
                 code: "provider-outage",
                 message: "Anthropic is down.",
                 autoResume: "scheduled",
-                outage: { retryAt: 1, attempt: 2, maxAttempts: 6 },
+                outage: { retryAt: 1 },
+                retries: { made: 1, max: 6 },
             },
         ];
         // The row states what happened and nothing more: what happens next, and the one control that changes it, are
@@ -200,6 +200,33 @@ describe("foldTurn", () => {
         });
     });
 
+    // The count lives in the record, so a reader scrolling back sees how many times a stuck turn was sent again.
+    it("says on a stopped turn's row which automatic try comes next, or that the ladder stood down", () => {
+        const timedOut = "Google turn timed out waiting for OpenCode.";
+        const booked: AgentEvent[] = [{ kind: "error", message: timedOut, autoResume: "scheduled", nextAt: 1, retries: { made: 1, max: 3 } }];
+        expect(foldOf("hi", booked).at(-1)).toEqual({ role: "notice", text: `${timedOut} Retrying by itself: attempt 2 of 3.` });
+        const spent: AgentEvent[] = [{ kind: "error", message: timedOut, autoResume: "available", retries: { made: 3, max: 3 } }];
+        expect(foldOf("hi", spent).at(-1)).toEqual({
+            role: "notice",
+            text: `${timedOut} Retried 3 of 3 times by itself; nothing more is sent automatically.`,
+        });
+        // An outage nobody armed says so, instead of promising the breaker's retry.
+        const unarmed: AgentEvent[] = [
+            {
+                kind: "error",
+                code: "provider-outage",
+                message: "Anthropic is down.",
+                autoResume: "available",
+                outage: { retryAt: 1 },
+                retries: { made: 0, max: 6 },
+            },
+        ];
+        expect(foldOf("hi", unarmed).at(-1)).toEqual({
+            role: "notice",
+            text: "Anthropic is down. Nothing is retrying it, so the turn is waiting here.",
+        });
+    });
+
     it("writes the turn's own events down as notices", () => {
         const events: AgentEvent[] = [
             { kind: "worktree", branch: "agent/x", base: "abc1234", sync: { commits: 2, blocked: [] } },
@@ -213,7 +240,7 @@ describe("foldTurn", () => {
             { role: "notice", text: "Context compacted to free up space." },
             {
                 role: "notice",
-                text: "Changes landed in your workspace: review them in the Changes panel. Installing 1 new dependency it added; the project's checks run when that finishes, and the outcome lands in Activity.",
+                text: "Changes landed in your workspace: review them in the Changes panel. Installing 1 dependency it added or changed; the project's checks run when that finishes, and the outcome lands in Activity.",
                 noticeAction: "depsInstall",
             },
         ]);
@@ -495,8 +522,8 @@ describe("patches", () => {
     });
 });
 
-// A refusal that ran nothing offers the message back to the composer — true where somebody typed one, false for a run
-// that started itself, where there is no composer and no typed message.
+// A refusal that ran nothing offers the message back for another press — true where somebody typed one, false for a
+// run that started itself, where there is no composer and no typed message.
 describe(`a refusal that ran nothing`, () => {
     const REFUSED = { kind: `error`, code: `context-window-too-small`, message: `This model accepts 16,384 tokens.` } as const satisfies AgentEvent;
 
@@ -551,9 +578,9 @@ describe(`a refusal that ran nothing`, () => {
         expect(foldOf(`land it`, [REFUSED]).at(-1)?.noticeAction).toBeUndefined();
     });
 
-    // The bug this retraction exists for: the composer keeps the words for another press, so a bubble left standing
-    // here is the SAME message a second time, and a third, once per press against a gate that keeps refusing.
-    it(`takes the message back out, leaving the composer's copy as the only one`, () => {
+    // The bug this retraction exists for: the conversation's queue keeps the words for another press, so a bubble left
+    // standing here is the SAME message a second time, and a third, once per press against a gate that keeps refusing.
+    it(`takes the message back out, leaving the queue's copy as the only one`, () => {
         const fold = new TranscriptFold(openingOf(`land it`));
         const patches = fold.apply(REFUSED);
 

package/src/text/transcript-fold.ts

@@ -62,10 +62,11 @@ const dependencyLine = (deps: { missing: number; started: string[]; deferred: bo
     if (deps === undefined || deps.missing === 0) {
         return ``;
     }
-    const what = `${deps.missing} new ${deps.missing === 1 ? `dependency` : `dependencies`}`;
+    // `missing` counts versions the turn bumped as well as names it added, so the sentence names both.
+    const what = `${deps.missing} ${deps.missing === 1 ? `dependency` : `dependencies`} it added or changed`;
     return deps.deferred
-        ? ` ${what} are queued: installation starts after this turn and any other active agents finish, appears in Work terminals, then its checks and outcome land in Activity.`
-        : ` Installing ${what} it added; the project's checks run when that finishes, and the outcome lands in Activity.`;
+        ? ` ${what} ${deps.missing === 1 ? `is` : `are`} queued: installation starts after this turn and any other active agents finish, appears in Work terminals, then its checks and outcome land in Activity.`
+        : ` Installing ${what}; the project's checks run when that finishes, and the outcome lands in Activity.`;
 };
 
 // One line reporting the daemon's rebase of this agent's branch onto the current workspace; `blocked` names repos it
@@ -106,10 +107,10 @@ const landedRow = (event: Extract<AgentEvent, { kind: "landed" }>): TranscriptRo
     };
 };
 
-// The clause after a refusal that ran nothing. A turn somebody typed is held in the composer for another press; a turn
-// that started itself — an automation, a loop, a watch wake — has no typed message and nobody watching, so promising a
-// resend there names a composer the reader is not looking at. Neither version promises a retry: whether one comes is
-// the scheduler's decision, not this row's to state.
+// The clause after a refusal that ran nothing. A turn somebody typed is held in its conversation's queue for another
+// press; a turn that started itself — an automation, a loop, a watch wake — has no typed message and nobody watching,
+// so promising a resend there names a composer the reader is not looking at. Neither version promises a retry: whether
+// one comes is the scheduler's decision, not this row's to state.
 const undelivered = (unattended: boolean): string =>
     unattended
         ? `Nothing ran, and nothing is held: this run started on its own, so there is no message waiting to be sent again.`
@@ -152,9 +153,7 @@ const errorRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow
     const { message, code } = event;
     switch (code) {
         case "provider-outage":
-            return event.outage === undefined
-                ? { role: "notice", text: `${message} Nothing is retrying it, so the turn is waiting here.` }
-                : { role: "notice", text: `${message} Retrying by itself: attempt ${event.outage.attempt} of ${event.outage.maxAttempts}.` };
+            return { role: "notice", text: `${message} ${retryClause(event) ?? `Nothing is retrying it, so the turn is waiting here.`}` };
         case "claude-token-refused":
             return event.autoResume === "scheduled"
                 ? {
@@ -169,18 +168,31 @@ const errorRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow
             break;
     }
     if (!turnedAwayCode(code)) {
-        return { role: "notice", text: message };
+        const clause = retryClause(event);
+        return { role: "notice", text: clause === undefined ? message : `${message} ${clause}` };
     }
     return heldRow(event);
 };
 
-// The turn's opening user row: text, timestamp, attachments, and whatever the daemon later stamps onto it (checkpoint,
-// notes).
-export const userRow = (text: string, sentAt: number, attachments: readonly string[]): TranscriptRow => {
+// What a laddered wall's automatic re-runs are doing, said on the failure's own row so the count stays in the record.
+const retryClause = (event: Extract<AgentEvent, { kind: "error" }>): string | undefined => {
+    const { retries } = event;
+    if (retries === undefined) {
+        return undefined;
+    }
+    if (event.autoResume === "scheduled") {
+        return `Retrying by itself: attempt ${retries.made + 1} of ${retries.max}.`;
+    }
+    return retries.made >= retries.max ? `Retried ${retries.made} of ${retries.max} times by itself; nothing more is sent automatically.` : undefined;
+};
+
+// The turn's opening user row: text, timestamp, attachments, the message's id, and whatever the daemon later stamps onto
+// it (checkpoint, notes).
+export const userRow = (text: string, sentAt: number, attachments: readonly string[], messageId?: string): TranscriptRow => {
     // Drops an attachment already inline as an @-mention, unless it's a generated upload path (its own thumbnail).
     const inline = new Set(mentionedPathTokens(text));
     const chips = attachments.filter((path) => !inline.has(path) || path.includes(`/records/artifacts/attachments/`));
-    return { role: "user", text, sentAt, ...(chips.length > 0 ? { attachments: chips } : {}) };
+    return { role: "user", text, sentAt, ...(chips.length > 0 ? { attachments: chips } : {}), ...(messageId === undefined ? {} : { messageId }) };
 };
 
 export class TranscriptFold {
@@ -196,7 +208,7 @@ export class TranscriptFold {
     private readonly parked = new Map<string, number>();
     // The turn's opening user row, where the checkpoint and daemon notes land; cleared once `retract` takes it back.
     private opener: number | undefined;
-    // Set by `retract`: this turn was refused before it ran, and its message went back to the composer.
+    // Set by `retract`: this turn was refused before it ran, and its message went back to the conversation's queue.
     private unrun = false;
 
     constructor(
@@ -426,6 +438,7 @@ export class TranscriptFold {
             text: event.text,
             sentAt: event.sentAt,
             ...(event.attachments === undefined ? {} : { attachments: [...event.attachments] }),
+            ...(event.messageId === undefined ? {} : { messageId: event.messageId }),
         });
         // Anchors pair by position with the checkpoints only a person's steer reserves.
         if (event.voice === undefined) {
@@ -461,9 +474,9 @@ export class TranscriptFold {
         );
     }
 
-    // Attended refusals only: the composer holds those words for another press, so a bubble left standing repeats them
-    // once per press. Splicing is safe because nothing ran — no open bubble, no parked card, no steer above it. A turn
-    // the sandbox kept (`held`) keeps its message and is recorded: no composer anywhere holds a copy of it.
+    // Attended refusals only: the conversation's queue holds those words for another press, so a bubble left standing
+    // repeats them once per press. Splicing is safe because nothing ran — no open bubble, no parked card, no steer above
+    // it. A turn the sandbox kept (`held`) keeps its message and is recorded: no queue holds a copy of it.
     private retract(event: Extract<AgentEvent, { kind: "error" }>): TranscriptPatch[] {
         if (!this.turnedAway(event) || event.held !== undefined) {
             return [];

package/src/text/whisper.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { cleanTranscription } from "./whisper.js";
 
 test("flattens whisper output onto one line", () => {

package/src/text/workflow-faults.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { type Workflow, WorkflowSchema, type WorkflowStep } from "../schemas/workflows.js";
 import { workflowFaults, workflowRunFaults } from "./workflow-faults.js";
 

package/src/time/zone.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { asCivilDay, asZone, civilDayIn, cronOptions, isZone, sameClock, utcDayOf, UTC, zoneLabel } from "./zone.js";
 import type { Zone } from "./zone.js";
 

package/dist/contracts/prepush.contract.d.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-export declare const PrepushRunSchema: z.ZodPrefault<z.ZodObject<{
-    repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>>;
-export declare const prepushContract: {
-    state: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            error: "error";
-            failed: "failed";
-            idle: "idle";
-            passed: "passed";
-            running: "running";
-        }>;
-        command: z.ZodString;
-        startedAt: z.ZodOptional<z.ZodNumber>;
-        finishedAt: z.ZodOptional<z.ZodNumber>;
-        exitCode: z.ZodOptional<z.ZodNumber>;
-        timedOut: z.ZodOptional<z.ZodBoolean>;
-        session: z.ZodOptional<z.ZodString>;
-        output: z.ZodString;
-    }, z.core.$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
-    run: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodPrefault<z.ZodObject<{
-        repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>, z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-    }, z.core.$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
-    cancel: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
-        ok: z.ZodLiteral<true>;
-    }, z.core.$strip>, Record<never, never>, import("../protocol/route-meta.js").RouteMeta & Record<never, never>>;
-};
-//# sourceMappingURL=prepush.contract.d.ts.map

package/dist/contracts/prepush.contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepush.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,gBAAgB;;kBAQZ,CAAC;AAWlB,eAAO,MAAM,eAAe;IACxB,KAAK;;;;;;;;;;;;;;;;;IASL,GAAG;;;;;IAUH,MAAM;;;CAQT,CAAC"}

package/dist/contracts/prepush.contract.js

@@ -1,41 +0,0 @@
-import { procedure } from "../protocol/route-meta.js";
-import { z } from "zod";
-import { CommandRunSchema } from "../schemas/ci.js";
-import { OkSchema } from "../schemas/shared.js";
-export const PrepushRunSchema = z
-    .object({
-    repos: z
-        .array(z.string().min(1))
-        .max(100)
-        .default([])
-        .describe("The repositories going out, by workspace id. Empty runs only what stands for every push, whichever repository it is."),
-})
-    .prefault({});
-export const prepushContract = {
-    state: procedure
-        .route({
-        method: "GET",
-        path: "/prepush/state",
-        summary: "How the pre-push check is going",
-        description: "The verdict, or the progress so far. Nothing is addressed by id here, because there is one working tree and so exactly one check.",
-    })
-        .output(CommandRunSchema),
-    run: procedure
-        .route({
-        method: "POST",
-        path: "/prepush/run",
-        summary: "Run the checks before pushing",
-        description: "Starts the suite the workspace runs before anything leaves the machine, and answers immediately. A suite takes minutes, and a request held open that long dies at the first proxy. It runs in a real terminal, so watch it there and poll for the verdict. Name the repositories going out, and each one's own checks run in its own directory.",
-    })
-        .input(PrepushRunSchema)
-        .output(OkSchema),
-    cancel: procedure
-        .route({
-        method: "POST",
-        path: "/prepush/cancel",
-        summary: "Stop the pre-push check",
-        description: "Kills the run. It settles as cancelled and the push it was gating does not go.",
-    })
-        .output(OkSchema),
-};
-//# sourceMappingURL=prepush.contract.js.map

package/dist/contracts/prepush.contract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepush.contract.js","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAOhD,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC;KAC5B,MAAM,CAAC;IACJ,KAAK,EAAE,CAAC;SACH,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;SACxB,GAAG,CAAC,GAAG,CAAC;SACR,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CAAC,sHAAsH,CAAC;CACxI,CAAC;KACD,QAAQ,CAAC,EAAE,CAAC,CAAC;AAWlB,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,KAAK,EAAE,SAAS;SACX,KAAK,CAAC;QACH,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,iCAAiC;QAC1C,WAAW,EACP,mIAAmI;KAC1I,CAAC;SACD,MAAM,CAAC,gBAAgB,CAAC;IAC7B,GAAG,EAAE,SAAS;SACT,KAAK,CAAC;QACH,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,cAAc;QACpB,OAAO,EAAE,+BAA+B;QACxC,WAAW,EACP,iVAAiV;KACxV,CAAC;SACD,KAAK,CAAC,gBAAgB,CAAC;SACvB,MAAM,CAAC,QAAQ,CAAC;IACrB,MAAM,EAAE,SAAS;SACZ,KAAK,CAAC;QACH,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,yBAAyB;QAClC,WAAW,EAAE,gFAAgF;KAChG,CAAC;SACD,MAAM,CAAC,QAAQ,CAAC;CACxB,CAAC"}

package/src/contracts/prepush.contract.ts

@@ -1,58 +0,0 @@
-import { procedure } from "../protocol/route-meta.js";
-import { z } from "zod";
-import { CommandRunSchema } from "../schemas/ci.js";
-import { OkSchema } from "../schemas/shared.js";
-
-// Which repositories are about to be pushed. The check is one run over one working tree, but what stands in it is not
-// the same for every push: a repository's own checks (repo-checks.ts) run only when that repository is going out, and a
-// rule the owner aimed at one repository does the same.
-// `prefault`, so a caller that sends no body at all still starts the check: a browser tab open since before this input
-// existed is the ordinary case, and refusing its push over a missing field would be the worst possible way to say so.
-export const PrepushRunSchema = z
-    .object({
-        repos: z
-            .array(z.string().min(1))
-            .max(100)
-            .default([])
-            .describe("The repositories going out, by workspace id. Empty runs only what stands for every push, whichever repository it is."),
-    })
-    .prefault({});
-
-// The pre-push check, the command the workspace runs when the user pushes, before anything leaves the machine
-// (see CommandRunSchema for where this sits and why). Three verbs about ONE run: the check answers about the
-// main working tree, of which there is exactly one, so nothing here is addressed by id.
-//
-// `run` starts the check and returns immediately, a suite takes minutes, and an oRPC call held open for one
-// would die on the first proxy timeout with the work still going. The dialog that started it polls `state` for
-// the verdict, and opens the terminals panel on the `session` the first answer names: the suite runs in a real
-// tmux window, so watching it is the terminal's job. `cancel` kills that window; the run settles as `cancelled`
-// and the push it was gating does not go.
-export const prepushContract = {
-    state: procedure
-        .route({
-            method: "GET",
-            path: "/prepush/state",
-            summary: "How the pre-push check is going",
-            description:
-                "The verdict, or the progress so far. Nothing is addressed by id here, because there is one working tree and so exactly one check.",
-        })
-        .output(CommandRunSchema),
-    run: procedure
-        .route({
-            method: "POST",
-            path: "/prepush/run",
-            summary: "Run the checks before pushing",
-            description:
-                "Starts the suite the workspace runs before anything leaves the machine, and answers immediately. A suite takes minutes, and a request held open that long dies at the first proxy. It runs in a real terminal, so watch it there and poll for the verdict. Name the repositories going out, and each one's own checks run in its own directory.",
-        })
-        .input(PrepushRunSchema)
-        .output(OkSchema),
-    cancel: procedure
-        .route({
-            method: "POST",
-            path: "/prepush/cancel",
-            summary: "Stop the pre-push check",
-            description: "Kills the run. It settles as cancelled and the push it was gating does not go.",
-        })
-        .output(OkSchema),
-};