@coreplane/switchboard 1.260.2 → 1.260.4

package/dist/assets/deploy/cloudflare-memory/backgroundTasks.ts

@@ -1,18 +1,42 @@
 type WaitUntilContext = Pick<DurableObjectState, "waitUntil">;
 
 const TASKS = Symbol.for("switchboard.memory-worker.pending-background-tasks");
+const REGISTRATIONS = Symbol.for("switchboard.memory-worker.background-task-registrations");
 type PendingTasks = Map<Promise<unknown>, string>;
+type Registrations = string[];
 
-const pendingTasks = (): PendingTasks => {
-  const root = globalThis as typeof globalThis & { [TASKS]?: PendingTasks };
-  return (root[TASKS] ??= new Map());
+type DiagnosticRoot = typeof globalThis & {
+  [TASKS]?: PendingTasks;
+  [REGISTRATIONS]?: Registrations;
 };
 
+const root = (): DiagnosticRoot => globalThis as DiagnosticRoot;
+const pendingTasks = (): PendingTasks => (root()[TASKS] ??= new Map());
+
+export function beginBackgroundTaskDiagnostics(): void {
+  root()[REGISTRATIONS] = [];
+}
+
+export function endBackgroundTaskDiagnostics(): void {
+  delete root()[REGISTRATIONS];
+}
+
+export function backgroundTaskDiagnostics(): {
+  registeredBackgroundTasks: string[];
+  pendingPromises: string[];
+} {
+  return {
+    registeredBackgroundTasks: [...(root()[REGISTRATIONS] ?? [])],
+    pendingPromises: [...pendingTasks().values()],
+  };
+}
+
 /** Keep deliberately detached Worker work in the runtime's request lifetime.
  * The process-wide label set is also the test seam: a case cannot finish while
  * work it started is still able to contend with the next case. */
 export function holdBackgroundTask(context: WaitUntilContext, label: string, task: Promise<unknown>): void {
   const pending = pendingTasks();
+  root()[REGISTRATIONS]?.push(label);
   const held = task.finally(() => pending.delete(held));
   pending.set(held, label);
   context.waitUntil(held);

package/dist/assets/deploy/cloudflare-memory/testDiagnostics.ts

@@ -0,0 +1,227 @@
+import { afterEach, beforeEach, type TestContext } from "vitest";
+import {
+  assertNoPendingBackgroundTasks,
+  backgroundTaskDiagnostics,
+  beginBackgroundTaskDiagnostics,
+  endBackgroundTaskDiagnostics,
+} from "./backgroundTasks.ts";
+import { MEMORY_DIAGNOSTICS_ANNOTATION, type MemoryTestAnnotation } from "./testDiagnosticsProtocol.ts";
+
+type TimerKind = "timeout" | "interval";
+type TimerHandler = (...args: unknown[]) => unknown;
+type TimerSetter = (
+  handler: TimerHandler,
+  delay?: number,
+  ...args: unknown[]
+) => ReturnType<typeof globalThis.setTimeout>;
+interface PendingTimer {
+  id: ReturnType<typeof setTimeout>;
+  kind: TimerKind;
+  label: string;
+  owner: string;
+}
+interface RunningTest {
+  name: string;
+  trackTimers: boolean;
+  timers: Map<ReturnType<typeof setTimeout>, PendingTimer>;
+}
+interface TimerOriginals {
+  setTimeout: typeof globalThis.setTimeout;
+  clearTimeout: typeof globalThis.clearTimeout;
+  setInterval: typeof globalThis.setInterval;
+  clearInterval: typeof globalThis.clearInterval;
+}
+
+const RUNNING = Symbol.for("switchboard.memory-worker.running-test");
+const TIMER_ORIGINALS = Symbol.for("switchboard.memory-worker.timer-originals");
+const REJECTION_TRAP = Symbol.for("switchboard.memory-worker.rejection-trap");
+
+type DiagnosticGlobal = typeof globalThis & {
+  [RUNNING]?: RunningTest;
+  [TIMER_ORIGINALS]?: TimerOriginals;
+  [REJECTION_TRAP]?: boolean;
+  __vitest_worker__?: { ctx?: { poolId?: number; workerId?: number } };
+  process?: {
+    env?: Record<string, string | undefined>;
+    prependListener?: (event: "unhandledRejection", listener: (reason: unknown) => void) => void;
+  };
+};
+
+const diagnosticGlobal = (): DiagnosticGlobal => globalThis as DiagnosticGlobal;
+
+function reasonText(reason: unknown): string {
+  return reason instanceof Error ? reason.message : String(reason);
+}
+
+function runningTestName(): string {
+  return diagnosticGlobal()[RUNNING]?.name ?? "<no test>";
+}
+
+function unhandledRejection(reason: unknown): never {
+  throw new Error(`unhandled rejection while "${runningTestName()}" was running: ${reasonText(reason)}`);
+}
+
+function installUnhandledRejectionTrap(): void {
+  const root = diagnosticGlobal();
+  if (root[REJECTION_TRAP]) return;
+  root[REJECTION_TRAP] = true;
+
+  if (typeof root.addEventListener === "function") {
+    root.addEventListener("unhandledrejection", (event) => {
+      const rejection = event as PromiseRejectionEvent;
+      rejection.preventDefault();
+      unhandledRejection(rejection.reason);
+    });
+    return;
+  }
+
+  root.process?.prependListener?.("unhandledRejection", unhandledRejection);
+}
+
+function timerLabel(kind: TimerKind, handler: TimerHandler, delay?: number): string {
+  const callback = typeof handler === "function" && handler.name ? handler.name : "anonymous";
+  return `${kind} ${callback} (${delay ?? 0}ms)`;
+}
+
+function strayTimerError(timer: PendingTimer): Error {
+  return new Error(`stray ${timer.label} from "${timer.owner}" fired while "${runningTestName()}" was running`);
+}
+
+function installTimerTrap(): void {
+  const root = diagnosticGlobal();
+  if (root[TIMER_ORIGINALS]) return;
+
+  const originals: TimerOriginals = {
+    setTimeout: root.setTimeout.bind(root),
+    clearTimeout: root.clearTimeout.bind(root),
+    setInterval: root.setInterval.bind(root),
+    clearInterval: root.clearInterval.bind(root),
+  };
+  root[TIMER_ORIGINALS] = originals;
+
+  root.setTimeout = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+    const running = root[RUNNING];
+    if (!running?.trackTimers || typeof handler !== "function") {
+      return (originals.setTimeout as unknown as TimerSetter)(handler, delay, ...args);
+    }
+
+    const pending: PendingTimer = {
+      id: undefined as unknown as ReturnType<typeof setTimeout>,
+      kind: "timeout",
+      label: timerLabel("timeout", handler, delay),
+      owner: running.name,
+    };
+    const id = (originals.setTimeout as unknown as TimerSetter)(
+      (...callbackArgs: unknown[]) => {
+        running.timers.delete(id);
+        if (root[RUNNING]?.name !== pending.owner) throw strayTimerError(pending);
+        handler(...callbackArgs);
+      },
+      delay,
+      ...args,
+    );
+    pending.id = id;
+    running.timers.set(id, pending);
+    return id;
+  }) as typeof globalThis.setTimeout;
+
+  root.setInterval = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+    const running = root[RUNNING];
+    if (!running?.trackTimers || typeof handler !== "function") {
+      return (originals.setInterval as unknown as TimerSetter)(handler, delay, ...args);
+    }
+
+    const pending: PendingTimer = {
+      id: undefined as unknown as ReturnType<typeof setTimeout>,
+      kind: "interval",
+      label: timerLabel("interval", handler, delay),
+      owner: running.name,
+    };
+    const id = (originals.setInterval as unknown as TimerSetter)(
+      (...callbackArgs: unknown[]) => {
+        if (root[RUNNING]?.name !== pending.owner) throw strayTimerError(pending);
+        handler(...callbackArgs);
+      },
+      delay,
+      ...args,
+    );
+    pending.id = id;
+    running.timers.set(id, pending);
+    return id;
+  }) as typeof globalThis.setInterval;
+
+  root.clearTimeout = ((id?: ReturnType<typeof setTimeout>) => {
+    root[RUNNING]?.timers.delete(id as ReturnType<typeof setTimeout>);
+    return originals.clearTimeout(id);
+  }) as typeof globalThis.clearTimeout;
+  root.clearInterval = ((id?: ReturnType<typeof setInterval>) => {
+    root[RUNNING]?.timers.delete(id as ReturnType<typeof setTimeout>);
+    return originals.clearInterval(id);
+  }) as typeof globalThis.clearInterval;
+}
+
+function poolWorker(): string {
+  const root = diagnosticGlobal();
+  const poolId = root.__vitest_worker__?.ctx?.poolId ?? root.process?.env?.VITEST_POOL_ID;
+  const workerId = root.__vitest_worker__?.ctx?.workerId ?? root.process?.env?.VITEST_WORKER_ID;
+  return `pool ${poolId ?? "unknown"} / worker ${workerId ?? "unknown"}`;
+}
+
+function pendingTimerLabels(running: RunningTest): string[] {
+  running.trackTimers = false;
+  return [...running.timers.values()].map((timer) => timer.label);
+}
+
+function clearPendingTimers(running: RunningTest): void {
+  const originals = diagnosticGlobal()[TIMER_ORIGINALS];
+  if (!originals) return;
+  for (const timer of running.timers.values()) {
+    if (timer.kind === "interval") originals.clearInterval(timer.id);
+    else originals.clearTimeout(timer.id);
+  }
+  running.timers.clear();
+}
+
+function testName(context: TestContext): string {
+  return context.task.fullTestName || context.task.name;
+}
+
+export function installMemoryTestDiagnostics(): void {
+  installUnhandledRejectionTrap();
+  installTimerTrap();
+
+  beforeEach((context) => {
+    diagnosticGlobal()[RUNNING] = { name: testName(context), trackTimers: true, timers: new Map() };
+    beginBackgroundTaskDiagnostics();
+  });
+
+  afterEach((context) => {
+    const root = diagnosticGlobal();
+    const running = root[RUNNING] ?? { name: testName(context), trackTimers: false, timers: new Map() };
+    const background = backgroundTaskDiagnostics();
+    const timers = pendingTimerLabels(running);
+    const annotation: MemoryTestAnnotation = {
+      poolWorker: poolWorker(),
+      ...background,
+      pendingTimers: timers,
+    };
+
+    const problems: Error[] = [];
+    try {
+      assertNoPendingBackgroundTasks();
+    } catch (error) {
+      problems.push(error instanceof Error ? error : new Error(String(error)));
+    }
+    if (timers.length > 0) {
+      problems.push(new Error(`test ended with ${timers.length} pending timer(s): ${timers.join(", ")}`));
+    }
+
+    (context.task.meta as Record<string, unknown>)[MEMORY_DIAGNOSTICS_ANNOTATION] = annotation;
+    clearPendingTimers(running);
+    endBackgroundTaskDiagnostics();
+    delete root[RUNNING];
+
+    if (problems.length === 1) throw problems[0];
+    if (problems.length > 1) throw new AggregateError(problems, "test ended with pending asynchronous work");
+  });
+}

package/dist/assets/deploy/cloudflare-memory/testDiagnosticsProtocol.ts

@@ -0,0 +1,22 @@
+export const MEMORY_DIAGNOSTICS_ANNOTATION = "memory-worker-diagnostics";
+
+export interface MemoryTestAnnotation {
+  poolWorker: string;
+  registeredBackgroundTasks: string[];
+  pendingPromises: string[];
+  pendingTimers: string[];
+}
+
+export interface MemoryTestDiagnostic extends MemoryTestAnnotation {
+  test: string;
+  file: string;
+  state: "passed" | "failed" | "skipped" | "pending";
+  durationMs: number;
+  startedAt: number;
+}
+
+export interface MemoryTestDiagnosticsArtifact {
+  reason: "passed" | "failed" | "interrupted";
+  unhandledErrors: string[];
+  tests: MemoryTestDiagnostic[];
+}

package/dist/assets/deploy/cloudflare-memory/testDiagnosticsReporter.ts

@@ -0,0 +1,88 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { Reporter, TestRunEndReason } from "vitest/reporters";
+import {
+  MEMORY_DIAGNOSTICS_ANNOTATION,
+  type MemoryTestAnnotation,
+  type MemoryTestDiagnostic,
+  type MemoryTestDiagnosticsArtifact,
+} from "./testDiagnosticsProtocol.ts";
+
+type TestCase = Parameters<NonNullable<Reporter["onTestCaseResult"]>>[0];
+
+export interface MemoryDiagnosticsReporterOptions {
+  outputFile?: string;
+  writeLog?: (line: string) => void;
+}
+
+function annotationFor(testCase: TestCase): MemoryTestAnnotation {
+  const annotation = (testCase.meta() as Record<string, unknown>)[MEMORY_DIAGNOSTICS_ANNOTATION];
+  if (
+    typeof annotation === "object" &&
+    annotation !== null &&
+    "poolWorker" in annotation &&
+    typeof annotation.poolWorker === "string"
+  ) {
+    return annotation as MemoryTestAnnotation;
+  }
+  return {
+    poolWorker: "unknown",
+    registeredBackgroundTasks: [],
+    pendingPromises: [],
+    pendingTimers: [],
+  };
+}
+
+function errorMessage(error: { message?: string } | unknown): string {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
+    ? error.message
+    : String(error);
+}
+
+export class MemoryDiagnosticsReporter implements Reporter {
+  readonly #outputFile: string;
+  readonly #writeLog: (line: string) => void;
+  readonly #tests: MemoryTestDiagnostic[] = [];
+
+  constructor(options: MemoryDiagnosticsReporterOptions = {}) {
+    this.#outputFile =
+      options.outputFile ??
+      process.env.MEMORY_TEST_DIAGNOSTICS_PATH ??
+      path.join(process.cwd(), "artifacts", "memory-test-diagnostics.json");
+    this.#writeLog = options.writeLog ?? ((line) => process.stdout.write(`${line}\n`));
+  }
+
+  onTestCaseResult(testCase: TestCase): void {
+    const diagnostic = testCase.diagnostic();
+    const result = testCase.result();
+    this.#tests.push({
+      test: testCase.fullName,
+      file: testCase.module.moduleId,
+      state: result.state,
+      durationMs: diagnostic?.duration ?? 0,
+      startedAt: diagnostic?.startTime ?? 0,
+      ...annotationFor(testCase),
+    });
+  }
+
+  async onTestRunEnd(
+    _testModules: Parameters<NonNullable<Reporter["onTestRunEnd"]>>[0],
+    unhandledErrors: Parameters<NonNullable<Reporter["onTestRunEnd"]>>[1],
+    reason: TestRunEndReason,
+  ): Promise<void> {
+    const artifact: MemoryTestDiagnosticsArtifact = {
+      reason,
+      unhandledErrors: unhandledErrors.map(errorMessage),
+      tests: this.#tests,
+    };
+    await mkdir(path.dirname(this.#outputFile), { recursive: true });
+    await writeFile(this.#outputFile, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+
+    const slowest = [...this.#tests].sort((a, b) => b.durationMs - a.durationMs).slice(0, 5);
+    const summary =
+      slowest.length === 0
+        ? "no completed tests"
+        : slowest.map((test) => `${Math.round(test.durationMs)}ms ${test.test}`).join("; ");
+    this.#writeLog(`[memory diagnostics] slowest ${slowest.length}: ${summary}`);
+  }
+}

package/dist/assets/deploy/cloudflare-memory/tsconfig.json

@@ -7,11 +7,23 @@
     "module": "esnext",
     "moduleResolution": "bundler",
     "lib": ["esnext"],
-    "types": ["@cloudflare/workers-types/experimental", "@cloudflare/vitest-pool-workers/types"],
+    "types": ["@cloudflare/workers-types/experimental", "@cloudflare/vitest-pool-workers/types", "node"],
     "strict": true,
     "noEmit": true,
     "skipLibCheck": true,
     "allowImportingTsExtensions": true
   },
-  "include": ["worker.ts", "worker.test.ts", "friction.test.ts", "schedules.test.ts", "test-env.d.ts"]
+  "include": [
+    "worker.ts",
+    "worker.test.ts",
+    "schedules.test.ts",
+    "backgroundTasks.ts",
+    "backgroundTasks.test.ts",
+    "testDiagnostics.ts",
+    "testDiagnosticsProtocol.ts",
+    "testDiagnosticsReporter.ts",
+    "testSetup.ts",
+    "vitest.config.ts",
+    "test-env.d.ts"
+  ]
 }

package/dist/assets/deploy/cloudflare-resident/Dockerfile

@@ -152,10 +152,19 @@ RUN rm -f /usr/local/bin/bun \
 # The build asserts the binary with the probe the extract script uses at run
 # time (`command -v`): `unsquashfs -version` exits 1 on squashfs-tools 4.5 (this
 # base) when no filesystem is named, and failed the 1.2.0 image build that way.
+#
+# ripgrep (`rg`) + fd: the grep/find tools call these binaries directly. Ubuntu
+# packages fd as `fd-find` with the binary named `fdfind`, so the image exposes
+# the conventional `fd` name from /usr/local/bin (ahead of /usr/bin on PATH).
+# Both are image tools, never downloaded by a run; their PATH probes make a
+# missing package or link fail the image build instead of every resident run.
 RUN apt-get update \
-  && apt-get install -y --no-install-recommends squashfs-tools \
+  && apt-get install -y --no-install-recommends squashfs-tools ripgrep fd-find \
+  && ln -s /usr/bin/fdfind /usr/local/bin/fd \
   && rm -rf /var/lib/apt/lists/* \
-  && command -v unsquashfs >/dev/null
+  && command -v unsquashfs >/dev/null \
+  && command -v rg >/dev/null \
+  && command -v fd >/dev/null
 
 # The toolchain for what a run BUILDS and LOOKS AT — the same layer as the
 # sandbox image's (deploy/cloudflare-sandbox/Dockerfile);

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.260.2",
+  "version": "1.260.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.260.2",
+      "version": "1.260.4",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.260.2",
+      "version": "1.260.4",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.260.2",
+  "version": "1.260.4",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",
@@ -39,9 +39,9 @@
     "cli": "tsx src/cli.ts",
     "verify": "npm run verify:root && npm run verify --workspaces --if-present && npm run check:site",
     "verify:root": "npm run check:consistency && npm run typecheck && npm run lint && npm run format:check && npm test && npm run check:dist",
-    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run check:deps-drift && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run vocabulary:check && npm run check:project-facts && npm run check:registry-drift && npm run agents:check && npm run clock:check && npm run screenshots:check",
+    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run check:deps-drift && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run vocabulary:check && npm run user-message:check && npm run check:project-facts && npm run check:registry-drift && npm run agents:check && npm run clock:check && npm run screenshots:check",
     "ci:gate": "node scripts/ci-gate.mjs",
-    "fix": "npm run docs:gen && npm run pr-title:gen && npm run agents:gen && npm run clock:gen && npm run hygiene:gen && npm run vocabulary:gen && npm run deploy:gen && npm run skills:sync && npm run lint:fix && npm run format",
+    "fix": "npm run docs:gen && npm run pr-title:gen && npm run agents:gen && npm run clock:gen && npm run hygiene:gen && npm run vocabulary:gen && npm run user-message:check -- --write && npm run deploy:gen && npm run skills:sync && npm run lint:fix && npm run format",
     "deploy:gen": "npm run --silent cli -- deploy init",
     "deploy:check": "npm run --silent cli -- deploy init --check",
     "check:lockfile": "node scripts/check-lockfile.mjs",
@@ -75,6 +75,7 @@
     "hygiene:gen": "node scripts/public-hygiene.mjs --write",
     "vocabulary:check": "node scripts/vocabulary-check.mjs",
     "vocabulary:gen": "node scripts/vocabulary-check.mjs --write",
+    "user-message:check": "node scripts/user-message-check.mjs",
     "docs:changed": "node scripts/docs-changed.mjs",
     "deploy:targets": "node scripts/deploy-targets.mjs",
     "docs:dev": "npm run dev -w docs --",

package/dist/assets/project.json

@@ -183,6 +183,10 @@
       "does": "Records the remaining internal words; refuses growth unless `-- --force`.",
       "when": "Part of `fix`."
     },
+    "user-message:check": {
+      "does": "No user-facing statement delegates recovery.",
+      "when": "Part of `check:consistency`; the baseline only shrinks."
+    },
     "agents:gen": {
       "does": "Writes the Commands table in AGENTS.md from `package.json` and this file.",
       "when": "After adding or changing a script; part of `fix`."

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.260.2",
-  "commit": "95c0153dc141f2e586238634e66970fea994bf7b",
-  "builtAt": "2026-09-21T20:25:49.397Z"
+  "version": "1.260.4",
+  "commit": "714dbd34ad03841fe421bfdc78648854b4c8dbc1",
+  "builtAt": "2026-09-22T07:09:50.930Z"
 }

package/dist/assets/src/agents/registry.ts

@@ -191,7 +191,7 @@ const CONTRACT_HEADINGS_LIST = Object.values(CONTRACT_SECTION_HEADINGS)
 // assembled by the child, which would choose what to leave out. Both coding
 // prompts carry this verbatim so the resident and sandbox children read the
 // same rule; the review prompts name the same block and the same severity.
-const UNIT_CONTRACT = `UNIT CONTRACT: when your first user turn carries a \`${CONTRACT_HEADING}\` block — its sub-headings, in this order: ${CONTRACT_HEADINGS_LIST} — it is the contract for one plan unit, rendered by Switchboard from the plan itself, and it outranks any free-text task beside it. Do its first instruction first: the rebase of the unit's branch onto the merged parent (a conflict ends the unit — report it and stop; never resolve it by force). Then implement the unit's section as written: every test scenario it lists is added as a test, every spec row it names is updated so its proof binding resolves, the agent rules are followed, and no guard it names is weakened. The review is handed the same block and checks the diff against it: a test scenario the unit listed and the diff did not add is a finding at minor severity — the same severity as a spec contradiction. Never edit the plan record itself; where the unit is wrong or a criterion could not be proven, say so in the handoff and in your final message.`;
+const UNIT_CONTRACT = `UNIT CONTRACT: when your first user turn carries a \`${CONTRACT_HEADING}\` block — its sub-headings, in this order: ${CONTRACT_HEADINGS_LIST} — it is the contract for one plan unit, rendered by Switchboard from the plan itself, and it outranks any free-text task beside it. Do its first instruction first: the rebase of the unit's branch onto the merged parent. Then implement the unit's section as written: every test scenario it lists is added as a test, every spec row it names is updated so its proof binding resolves, the agent rules are followed, and no guard it names is weakened. The review is handed the same block and checks the diff against it: a test scenario the unit listed and the diff did not add is a finding at minor severity — the same severity as a spec contradiction. Never edit the plan record itself; where the unit is wrong or a criterion could not be proven, say so in the handoff and in your final message.`;
 
 // The unit handoff (docs/reference/specs/agent-coding.md item 9; agent-ship.md
 // item 14): the contract's return edge, as data. A child that ran for a plan
@@ -289,10 +289,11 @@ export const FAST_GATES_BEFORE_PUSH =
 // (src/core/ship/contract.ts).
 export const REBASE_BEFORE_PUSH =
   "REBASE BEFORE EVERY PUSH — always, not configurable. Immediately before each push: fetch your base branch, " +
-  "rebase your branch onto it, resolve any conflict with the context you already have (the repository's " +
-  "AGENTS.md says how a generated file is regenerated — regenerate it, never hand-merge it), re-run THE FAST " +
-  "GATES on the rebased tree, and only then push. Every head that reaches review is then current with its " +
-  "base when it lands, and no unit ends merge-ready behind a sibling that merged first.";
+  "rebase your branch onto it, and resolve any conflict with the context you already have in one bounded model " +
+  "round — the thread's context and the repository's AGENTS.md (which says how a generated file is regenerated: " +
+  "regenerate it, never hand-merge it). If you cannot resolve it inside that bound, end the round; otherwise " +
+  "re-run THE FAST GATES on the rebased tree, and only then push. Every head that reaches review is then current " +
+  "with its base when it lands, and no unit ends merge-ready behind a sibling that merged first.";
 
 const CODING_SYSTEM = `You are Switchboard's coding agent, operating from a Slack request.
 

package/dist/assets/src/core/coordinator/contract.ts

@@ -10,7 +10,13 @@
 //
 import { IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
 import { isVerbosity, type Verbosity } from "../verbosity.js";
-import { isAddressSeverity, type AddressSeverity, type AddressSeveritySource } from "../ship/coordinator.js";
+import { isFindingShape } from "../reviewVerdict.js";
+import {
+  isAddressSeverity,
+  type AddressSeverity,
+  type AddressSeveritySource,
+  type HumanGatePending,
+} from "../ship/coordinator.js";
 import { isHandoffShape, type Handoff } from "../ship/handoff.js";
 
 // A coordinator is a Workflow instance in the shim Worker whose children are
@@ -421,6 +427,8 @@ export interface UnitIdle {
   runId?: string;
   spendUsd: number | null;
   handoff?: Handoff;
+  /** The human-gated question this idle is waiting on. */
+  humanGate?: HumanGatePending;
   wakes: number;
 }
 
@@ -439,6 +447,7 @@ export type UnitWakeAnswer =
       texts: string[];
       senders: string[];
       leaseMs?: number;
+      humanGate?: HumanGatePending;
     }
   | { kind: "answered"; reply: string }
   | { kind: "stopped" }
@@ -579,6 +588,23 @@ const isRoundGate = (v: unknown): boolean =>
   Array.isArray(v.findings) &&
   v.findings.every((f) => typeof f === "string");
 
+export const isHumanGatePending = (v: unknown): v is HumanGatePending =>
+  isObject(v) &&
+  isObject(v.pr) &&
+  typeof v.pr.number === "number" &&
+  Number.isInteger(v.pr.number) &&
+  v.pr.number > 0 &&
+  isText(v.pr.url) &&
+  typeof v.round === "number" &&
+  Number.isInteger(v.round) &&
+  v.round >= 1 &&
+  Array.isArray(v.findings) &&
+  v.findings.every((finding: unknown) => isFindingShape(finding)) &&
+  (v.verdict === "approve" || v.verdict === "request_changes") &&
+  (v.reviewRunId === undefined || isText(v.reviewRunId)) &&
+  (v.headSha === undefined || isText(v.headSha)) &&
+  (v.askedAt === undefined || isFinite(v.askedAt));
+
 const isUnitIdle = (v: unknown): boolean =>
   isObject(v) &&
   isText(v.why, IDLE_WHY_MAX) &&
@@ -588,6 +614,7 @@ const isUnitIdle = (v: unknown): boolean =>
   (v.runId === undefined || isText(v.runId)) &&
   (v.spendUsd === null || isFinite(v.spendUsd)) &&
   (v.handoff === undefined || isHandoffShape(v.handoff)) &&
+  (v.humanGate === undefined || isHumanGatePending(v.humanGate)) &&
   isCount(v.wakes);
 
 const isSegment = (v: unknown): boolean =>
@@ -616,7 +643,8 @@ export const isUnitWakeAnswer = (v: unknown): v is UnitWakeAnswer => {
     v.texts.every((text) => typeof text === "string") &&
     Array.isArray(v.senders) &&
     v.senders.every((sender) => isText(sender)) &&
-    (v.leaseMs === undefined || (isFinite(v.leaseMs) && v.leaseMs > 0))
+    (v.leaseMs === undefined || (isFinite(v.leaseMs) && v.leaseMs > 0)) &&
+    (v.humanGate === undefined || isHumanGatePending(v.humanGate))
   );
 };
 
@@ -693,6 +721,24 @@ export type RunFinishedSend =
   | { kind: "no-binding"; instance: string }
   | { kind: "failed"; instance: string; type: string; reason: string };
 
+/** Wake one unit after durable outside input was appended. The payload is
+ * deliberately empty: the unit re-reads its own event list before acting. */
+export async function sendUnitNudge(
+  workflow: WorkflowSender | undefined,
+  key: { instanceId: string; unit: string },
+): Promise<RunFinishedSend> {
+  const instance = key.instanceId;
+  if (!workflow) return { kind: "no-binding", instance };
+  const type = unitNudgeEventType(key);
+  try {
+    const handle = await workflow.get(instance);
+    await handle.sendEvent({ type, payload: {} });
+    return { kind: "sent", instance, type };
+  } catch (err) {
+    return { kind: "failed", instance, type, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 /** The one send per settled head (http-ingress.md item 12): best effort like
  *  `sendRunFinished` — a refusal is answered, never thrown, and the parent's
  *  bounded merge wait times out on its own. */