@coreplane/switchboard 1.260.2 → 1.260.3

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/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.260.2",
+  "version": "1.260.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.260.2",
+      "version": "1.260.3",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.260.2",
+      "version": "1.260.3",
       "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.3",
   "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",

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.3",
+  "commit": "9f64917c9c2520b2797f3d5e6a73494879408e26",
+  "builtAt": "2026-09-22T05:04:08.797Z"
 }

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. */

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

@@ -40,6 +40,7 @@
 // the shim Worker imports this by relative path.
 
 import { DAY_MS, DEFAULT_GRANT, GRANT_RENEWALS_MAX, IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
+import { isFindingShape, type Finding } from "../reviewVerdict.js";
 import { DEFAULT_VERBOSITY, isVerbosity, type Verbosity } from "../verbosity.js";
 import {
   applyReturn,
@@ -343,6 +344,8 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
   // they were written (the run record's validator), read here as they are.
   const facts = run as unknown as Omit<Extract<ChildFacts, { finished: true }>, "finished" | "status">;
   const {
+    finishedAt,
+    reviewAskedAt,
     finalReply,
     pr,
     headSha,
@@ -367,6 +370,8 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
     run: {
       finished: true,
       status: run.status as Extract<ChildFacts, { finished: true }>["status"],
+      ...(typeof finishedAt === "number" ? { finishedAt } : {}),
+      ...(typeof reviewAskedAt === "number" ? { reviewAskedAt } : {}),
       ...(finalReply !== undefined ? { finalReply } : {}),
       ...(pr !== undefined ? { pr } : {}),
       ...(headSha !== undefined ? { headSha } : {}),
@@ -403,6 +408,33 @@ function isCommitChecks(v: unknown): v is { total: number; pending: string[]; fa
   return typeof c.total === "number" && names(c.pending) && names(c.failed);
 }
 
+function entryHumanGate(v: unknown):
+  | {
+      round: number;
+      findings: Finding[];
+      verdict: "approve" | "request_changes";
+      answer: string;
+      author: string;
+      commentId: string;
+    }
+  | undefined {
+  if (typeof v !== "object" || v === null) return undefined;
+  const row = v as Record<string, unknown>;
+  if (typeof row.round !== "number" || !Number.isInteger(row.round) || row.round < 1) return undefined;
+  if (!Array.isArray(row.findings) || !row.findings.every(isFindingShape)) return undefined;
+  if (row.verdict !== "approve" && row.verdict !== "request_changes") return undefined;
+  if (typeof row.answer !== "string" || typeof row.author !== "string" || typeof row.commentId !== "string")
+    return undefined;
+  return {
+    round: row.round,
+    findings: row.findings,
+    verdict: row.verdict,
+    answer: row.answer,
+    author: row.author,
+    commentId: row.commentId,
+  };
+}
+
 function prCheckReturn(step: string, a: BotAnswer): StepReturn {
   const { ok, state, prNumber, url, headSha, sha, mergedAt, at } = a.body;
   if (ok === true && state === "none") {
@@ -448,6 +480,7 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
         // The base's merge-queue rule beside the checks (issue 2011): the
         // merge:person report says the person's merge is queued.
         ...(typeof a.body.baseHasMergeQueue === "boolean" ? { baseHasMergeQueue: a.body.baseHasMergeQueue } : {}),
+        ...(entryHumanGate(a.body.humanGate) !== undefined ? { humanGate: entryHumanGate(a.body.humanGate)! } : {}),
       },
       at,
     };
@@ -961,6 +994,7 @@ async function runUnit(
                     ...(note.ending.from !== undefined ? { from: note.ending.from } : {}),
                     spendUsd: note.ending.spendUsd,
                     ...(note.ending.handoff !== undefined ? { handoff: note.ending.handoff } : {}),
+                    ...(note.ending.humanGate !== undefined ? { humanGate: note.ending.humanGate } : {}),
                   }
                 : {}),
             },
@@ -1171,6 +1205,7 @@ async function waitOnIdle(
         ...(answer.runId !== undefined ? { previousRunId: answer.runId } : {}),
         ...(answer.handoff !== undefined ? { previousHandoff: answer.handoff } : {}),
         ...(answer.texts.length > 0 ? { texts: answer.texts } : {}),
+        ...(answer.humanGate !== undefined ? { humanGate: answer.humanGate } : {}),
         ...(answer.leaseMs !== undefined
           ? { resume: { leaseMs: answer.leaseMs, attempt: (currentSession?.resume?.attempt ?? 0) + 1 } }
           : {}),
@@ -1240,7 +1275,7 @@ async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string):
           next,
           stepPrefixOf(next, session),
           ending,
-          plan.idleDays,
+          ending.parkDays ?? plan.idleDays,
           session,
         );
         if (parked.kind === "ending") {