@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

package/src/resources/extensions/gsd/tests/write-gate-seam.test.ts

@@ -0,0 +1,358 @@
+// gsd-pi - Write-gate two-process seam tests.
+/**
+ * Deterministic interleaving tests for the host/child write-gate adapters
+ * (write-gate.ts). The "child" (workflow MCP server) runs in a separate
+ * process in production; these tests simulate its writes by stamping the
+ * snapshot file directly, exactly as childWriteGateAdapter persists it.
+ *
+ * Covered interleavings:
+ *   (a) child verifies on disk while the host holds stale memory — the host
+ *       re-arm must NOT clobber the verification, on BOTH windows
+ *       (tool_execution_start re-arm and the tool_call defer path);
+ *   (b) concurrent writes: every persist is an unconditional read-merge-write
+ *       (read disk → union-merge → mutate → atomic rename), so a write the
+ *       other process landed in between is folded in, never overwritten;
+ *   (c) two basePaths defer approval gates in the same process — both stay
+ *       deferred and both activate (regression for the old single global slot);
+ *   (d) old snapshot files (including ones carrying the retired epoch field)
+ *       keep loading; stale fields are dropped on the next write.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  childWriteGateAdapter,
+  clearDiscussionFlowState,
+  getPendingGate,
+  hostWriteGateAdapter,
+  loadWriteGateSnapshot,
+  markDepthVerified,
+  refreshWriteGateStateFromDisk,
+  setPendingGate,
+  type WriteGateSnapshot,
+} from "../bootstrap/write-gate.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-write-gate-seam-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function snapshotPath(basePath: string): string {
+  return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+}
+
+/** Simulate a write from the OTHER process by stamping the file directly. */
+function foreignProcessWrites(basePath: string, snapshot: Partial<WriteGateSnapshot>): void {
+  mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(snapshotPath(basePath), JSON.stringify({
+    verifiedDepthMilestones: [],
+    verifiedApprovalGates: [],
+    activeQueuePhase: false,
+    pendingGateId: null,
+    ...snapshot,
+  }, null, 2), "utf-8");
+}
+
+function readDiskRaw(basePath: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(snapshotPath(basePath), "utf-8"));
+}
+
+function makeHookHarness(): {
+  handlers: Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>;
+  pi: any;
+} {
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+  return { handlers, pi };
+}
+
+function cleanup(dir: string): void {
+  clearDiscussionFlowState(dir);
+  rmSync(dir, { recursive: true, force: true });
+}
+
+const GATE = "depth_verification_M007_confirm";
+
+// ── (a) verified-on-disk wins over a host re-arm ────────────────────────────
+
+test("seam: host setPending does not clobber a child verification on disk", (t) => {
+  const dir = makeTempDir("no-clobber-adapter");
+  t.after(() => cleanup(dir));
+
+  // Host has stale memory: it armed the gate earlier (persisted to disk).
+  assert.equal(setPendingGate(GATE, dir), true, "fresh gate must arm");
+  assert.equal(getPendingGate(dir), GATE);
+
+  // Child verifies the gate in its own process (newer write on disk).
+  foreignProcessWrites(dir, {
+    verifiedDepthMilestones: ["M007"],
+    verifiedApprovalGates: [GATE],
+    writer: "child",
+  });
+
+  // Host attempts a re-arm — adapter policy: verified on disk wins.
+  assert.equal(hostWriteGateAdapter.setPending(GATE, dir), false, "re-arm must be suppressed");
+  const snapshot = loadWriteGateSnapshot(dir);
+  assert.ok(snapshot.verifiedDepthMilestones.includes("M007"), "verification must survive");
+  assert.ok((snapshot.verifiedApprovalGates ?? []).includes(GATE));
+  assert.equal(getPendingGate(dir), null, "no pending gate after suppressed re-arm");
+});
+
+test("seam: tool_call defer path does not block tools for a gate the child verified", async (t) => {
+  const dir = makeTempDir("no-clobber-defer");
+  t.after(() => cleanup(dir));
+
+  // Child verified the gate before the host ever saw the tool block.
+  foreignProcessWrites(dir, {
+    verifiedDepthMilestones: ["M007"],
+    verifiedApprovalGates: [GATE],
+    writer: "child",
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  // tool_call defer window: ask_user_questions arrives post-hoc with the gate id.
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({
+      toolCallId: "t-gate",
+      toolName: "ask_user_questions",
+      input: { questions: [{ id: GATE }] },
+    }, ctx);
+  }
+
+  // A subsequent tool in the same turn must NOT hit the deferred-gate block.
+  let blocked: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolCallId: "t-next",
+      toolName: "glob",
+      input: { pattern: "*.md" },
+    }, ctx);
+    if (result?.block) blocked = result;
+  }
+  assert.equal(blocked, undefined, "verified gate must not be deferred/blocking");
+  assert.equal(getPendingGate(dir), null);
+  const snapshot = loadWriteGateSnapshot(dir);
+  assert.ok(snapshot.verifiedDepthMilestones.includes("M007"), "verification must survive the defer window");
+});
+
+test("seam: tool_execution_start re-arm window keeps the child verification", async (t) => {
+  const dir = makeTempDir("no-clobber-exec-start");
+  t.after(() => cleanup(dir));
+
+  foreignProcessWrites(dir, {
+    verifiedDepthMilestones: ["M007"],
+    verifiedApprovalGates: [GATE],
+    writer: "child",
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  for (const handler of handlers.get("tool_execution_start") ?? []) {
+    await handler({
+      toolCallId: "t-gate",
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      args: { questions: [{ id: GATE }] },
+    }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "post-hoc replay must not re-arm a verified gate");
+  assert.ok(loadWriteGateSnapshot(dir).verifiedDepthMilestones.includes("M007"));
+});
+
+// ── (b) concurrent writes re-merge instead of overwriting ───────────────────
+
+test("seam: host persist re-merges a concurrent child write (unconditional read-merge-write)", (t) => {
+  const dir = makeTempDir("concurrent-write");
+  t.after(() => cleanup(dir));
+
+  // Host persists its own verification.
+  markDepthVerified("M001", dir);
+
+  // Child lands a different verification on disk while the host is idle.
+  foreignProcessWrites(dir, {
+    verifiedDepthMilestones: ["M002"],
+    writer: "child",
+  });
+
+  // Host persists again — every mutation re-reads the disk snapshot and
+  // union-merges before writing, so the child's verification survives.
+  markDepthVerified("M003", dir);
+  const merged = loadWriteGateSnapshot(dir);
+  assert.deepEqual(merged.verifiedDepthMilestones, ["M001", "M002", "M003"]);
+  assert.equal(readDiskRaw(dir).writer, "host");
+});
+
+test("seam: missing snapshot resets stale in-memory pending gate before mutation", (t) => {
+  const dir = makeTempDir("missing-snapshot-reset");
+  t.after(() => cleanup(dir));
+
+  assert.equal(setPendingGate(GATE, dir), true);
+  rmSync(snapshotPath(dir), { force: true });
+
+  markDepthVerified("M008", dir);
+
+  const snapshot = loadWriteGateSnapshot(dir);
+  assert.equal(snapshot.pendingGateId, null);
+  assert.deepEqual(snapshot.verifiedDepthMilestones, ["M008"]);
+  assert.equal(readDiskRaw(dir).pendingGateId, null);
+});
+
+test("seam: childWriteGateAdapter is write-through and stamps writer provenance", (t) => {
+  const dir = makeTempDir("child-write-through");
+  t.after(() => cleanup(dir));
+
+  foreignProcessWrites(dir, { verifiedDepthMilestones: ["M001"], writer: "host" });
+  childWriteGateAdapter.markDepthVerified("M002", dir);
+
+  const disk = readDiskRaw(dir);
+  assert.deepEqual(disk.verifiedDepthMilestones, ["M001", "M002"], "fresh disk read, then mutate");
+  assert.equal(disk.writer, "child");
+});
+
+// ── (c) per-basePath deferred gates ──────────────────────────────────────────
+
+test("seam: two basePaths defer gates in one process and both activate", async (t) => {
+  const dirA = makeTempDir("defer-a");
+  const dirB = makeTempDir("defer-b");
+  t.after(() => {
+    cleanup(dirA);
+    cleanup(dirB);
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const gateA = "depth_verification_M010_confirm";
+  const gateB = "depth_verification_M020_confirm";
+  const ctxA = { cwd: dirA, ui: { notify: () => undefined } } as any;
+  const ctxB = { cwd: dirB, ui: { notify: () => undefined } } as any;
+
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolCallId: "a-1", toolName: "ask_user_questions", input: { questions: [{ id: gateA }] } }, ctxA);
+  }
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolCallId: "b-1", toolName: "ask_user_questions", input: { questions: [{ id: gateB }] } }, ctxB);
+  }
+
+  // With the old single global slot, project A's deferral was lost the moment
+  // project B deferred. Both must still block follow-up tools.
+  for (const [ctx, label] of [[ctxA, "A"], [ctxB, "B"]] as const) {
+    let blocked: any;
+    for (const handler of handlers.get("tool_call") ?? []) {
+      const result = await handler({ toolCallId: `chk-${label}`, toolName: "glob", input: { pattern: "*" } }, ctx);
+      if (result?.block) blocked = result;
+    }
+    assert.equal(blocked?.block, true, `project ${label} deferred gate must still block`);
+    assert.match(blocked?.reason ?? "", /Approval question/);
+  }
+
+  // Activation happens via tool_execution_start in each project independently.
+  for (const [ctx, gate, dir] of [[ctxA, gateA, dirA], [ctxB, gateB, dirB]] as const) {
+    for (const handler of handlers.get("tool_execution_start") ?? []) {
+      await handler({ toolCallId: "act", toolName: "ask_user_questions", args: { questions: [{ id: gate }] } }, ctx);
+    }
+    assert.equal(getPendingGate(dir), gate, `gate must arm durably for ${dir}`);
+  }
+});
+
+// ── (d) backward compatibility: legacy snapshot fields ──────────────────────
+
+test("seam: old snapshot with a retired epoch field loads and sheds it on write", (t) => {
+  const dir = makeTempDir("legacy-snapshot");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(
+    (mkdirSync(join(dir, ".gsd", "runtime"), { recursive: true }), snapshotPath(dir)),
+    JSON.stringify({
+      verifiedDepthMilestones: ["M001"],
+      verifiedApprovalGates: ["depth_verification_M001_confirm"],
+      activeQueuePhase: false,
+      pendingGateId: null,
+      // Written by an older build that still stamped the write-only epoch.
+      epoch: 7,
+    }),
+    "utf-8",
+  );
+
+  const loaded = loadWriteGateSnapshot(dir);
+  assert.deepEqual(loaded.verifiedDepthMilestones, ["M001"]);
+  assert.equal("epoch" in loaded, false, "retired epoch field is not surfaced");
+
+  const refreshed = refreshWriteGateStateFromDisk(dir);
+  assert.ok(refreshed.verifiedDepthMilestones.includes("M001"));
+
+  markDepthVerified("M002", dir);
+  const upgraded = readDiskRaw(dir);
+  assert.deepEqual(upgraded.verifiedDepthMilestones, ["M001", "M002"]);
+  assert.equal("epoch" in upgraded, false, "retired epoch field is dropped on rewrite");
+  assert.equal(upgraded.writer, "host");
+});
+
+// ── (e) corrupt snapshot is treated as a reset (matches "delete the file") ──
+
+test("seam: corrupt snapshot file resets host state instead of persisting stale pendingGateId", (t) => {
+  const dir = makeTempDir("corrupt-snapshot");
+  t.after(() => cleanup(dir));
+
+  // Host arms a gate; stale pendingGateId now lives in memory and on disk.
+  assert.equal(setPendingGate(GATE, dir), true);
+  assert.equal(getPendingGate(dir), GATE);
+
+  // The snapshot file is corrupted out-of-band (e.g. partial write from a
+  // crashed editor, foreign tool, or filesystem fault).
+  writeFileSync(snapshotPath(dir), "{ not json", "utf-8");
+
+  // refreshWriteGateStateFromDisk must treat the unreadable file the same
+  // as a missing file: full reset, including dropping the stale pending id.
+  const refreshed = refreshWriteGateStateFromDisk(dir);
+  assert.equal(refreshed.pendingGateId, null, "stale pendingGateId must not survive a corrupt snapshot");
+  assert.deepEqual(refreshed.verifiedDepthMilestones, []);
+  assert.deepEqual(refreshed.verifiedApprovalGates, []);
+  assert.equal(getPendingGate(dir), null);
+
+  // A subsequent mutation must not write the stale gate back to disk.
+  markDepthVerified("M042", dir);
+  const persisted = readDiskRaw(dir);
+  assert.equal(persisted.pendingGateId, null, "next persist must not re-stamp the stale pending id");
+  assert.deepEqual(persisted.verifiedDepthMilestones, ["M042"]);
+});
+
+test("seam: mutateWriteGateState reset path drops stale pendingGateId on a corrupt snapshot", (t) => {
+  const dir = makeTempDir("corrupt-snapshot-mutate");
+  t.after(() => cleanup(dir));
+
+  // Host arms a gate first.
+  assert.equal(setPendingGate(GATE, dir), true);
+
+  // Corrupt the snapshot directly (skipping the refresh path so we exercise
+  // the reconcile-on-mutate branch in mutateWriteGateState).
+  writeFileSync(snapshotPath(dir), "}}}", "utf-8");
+
+  // markDepthVerified runs through mutateWriteGateState; the reconcile pass
+  // must reset the in-memory state when the disk read returns null, even
+  // though the file still exists on disk.
+  markDepthVerified("M099", dir);
+
+  const persisted = readDiskRaw(dir);
+  assert.equal(persisted.pendingGateId, null, "stale pending id must not be persisted after a corrupt-snapshot reconcile");
+  assert.deepEqual(persisted.verifiedDepthMilestones, ["M099"]);
+});

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -24,6 +24,7 @@ import {
   setQueuePhaseActive,
 } from '../index.ts';
 import {
+  childWriteGateAdapter,
   markDepthVerified,
   isMilestoneDepthVerified,
   markApprovalGateVerified,
@@ -139,6 +140,7 @@ test('write-gate: blocked reason contains depth_verification keyword and anti-by
   );
   assert.strictEqual(result.block, true);
   assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
+  assert.ok(result.reason!.includes('depth_verification_M999_confirm'), 'reason should mention the exact milestone gate id');
   assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions tool');
   assert.ok(result.reason!.includes('MUST NOT'), 'reason should include anti-bypass language');
   assert.ok(result.reason!.includes('(Recommended)'), 'reason should specify the required confirmation option');
@@ -317,7 +319,11 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
       'precondition: verified approval unlocks the final project artifact',
     );
 
-    setPendingGate('depth_verification_project_confirm', base);
+    // A genuine re-ask originates from the workflow MCP child (where
+    // ask_user_questions executes): the child adapter arms unconditionally,
+    // revoking the prior approval. Host-side setPendingGate is guarded
+    // (verified-on-disk wins) and would deliberately suppress this arm.
+    childWriteGateAdapter.setPending('depth_verification_project_confirm', base);
     clearPendingGate(base);
 
     assert.strictEqual(
@@ -340,6 +346,9 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
 // ═══════════════════════════════════════════════════════════════════════
 
 import {
+  applyAskUserQuestionsGateResult,
+  formatPendingAskUserQuestionsGateMessage,
+  formatTimedOutAskUserQuestionsGateMessage,
   isGateQuestionId,
   shouldBlockPendingGate,
   shouldBlockPendingGateBash,
@@ -379,6 +388,244 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
 
+test('write-gate: applyAskUserQuestionsGateResult keeps cancelled pending gate waiting', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-waiting-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, interrupted: true },
+    });
+
+    assert.deepEqual(result, {
+      status: 'waiting',
+      pendingGateId: gateId,
+      interrupted: true,
+    });
+    assert.strictEqual(getPendingGate(base), gateId, 'cancelled question must leave gate pending');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'cancelled question must not verify depth');
+    assert.match(
+      formatPendingAskUserQuestionsGateMessage(gateId, true),
+      /Re-call ask_user_questions with the same gate question id/,
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult verifies confirmed pending gate', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-verified-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+  const confirmLabel = 'Confirm depth (Recommended)';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: confirmLabel }, { label: 'Needs adjustment' }],
+      }],
+      details: {
+        response: {
+          answers: {
+            [gateId]: { selected: confirmLabel },
+          },
+        },
+      },
+    });
+
+    assert.deepEqual(result, {
+      status: 'verified',
+      gateId,
+      milestoneId: 'M001',
+    });
+    assert.strictEqual(getPendingGate(base), null, 'confirmed gate must clear pending state');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), true, 'confirmed gate must verify milestone depth');
+    assert.ok(
+      loadWriteGateSnapshot(base).verifiedApprovalGates?.includes(gateId) ?? false,
+      'confirmed gate must record verified approval',
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult reports declined pending gate (consent-verdict semantics)', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-declined-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: {
+        response: { answers: { [gateId]: { selected: 'Needs adjustment' } } },
+      },
+    });
+
+    assert.deepEqual(result, { status: 'declined', gateId });
+    assert.strictEqual(getPendingGate(base), gateId, 'declined gate must stay pending');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'declined gate must not verify depth');
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult keeps empty-selection pending gate waiting (consent-verdict semantics)', () => {
+  // An empty selection is never an answer (fail-closed): the round used to
+  // report "answered" here, silently treating a missing selection as resolved.
+  const base = join(tmpdir(), `gsd-write-gate-ask-empty-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: {
+        response: { answers: { [gateId]: { selected: '' } } },
+      },
+    });
+
+    assert.deepEqual(result, { status: 'waiting', pendingGateId: gateId, interrupted: false });
+    assert.strictEqual(getPendingGate(base), gateId, 'unanswered gate must stay pending');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'unanswered gate must not verify depth');
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── Scenario 20d: applyAskUserQuestionsGateResult reports timed_out gate (#852) ──
+//
+// A host elicitation timeout must NOT be laundered into "waiting" (which tells
+// the model to re-ask — that just hits the same timeout again) nor into
+// "verified" (a timeout is never approval). The gate stays pending (fail-
+// closed) but the status is "timeout" so the caller pauses-and-waits.
+
+test('write-gate: applyAskUserQuestionsGateResult reports timed_out pending gate (#852)', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      // A timed-out round is marked cancelled:true + timed_out:true (the
+      // structuredContent the MCP child returns on host timeout).
+      details: { cancelled: true, timed_out: true, interrupted: false },
+    });
+
+    assert.deepEqual(result, {
+      status: 'timeout',
+      pendingGateId: gateId,
+      interrupted: false,
+    });
+    assert.strictEqual(getPendingGate(base), gateId, 'timed-out gate must stay pending (fail-closed)');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'timed-out gate must not verify depth');
+    // The timeout message must NOT tell the model to immediately re-ask.
+    const message = formatTimedOutAskUserQuestionsGateMessage(gateId);
+    assert.match(message, /timed out/, 'message says timed out');
+    assert.doesNotMatch(message, /Re-call ask_user_questions/, 'message must NOT invite immediate re-ask');
+    assert.match(message, /do not re-ask/i, 'message explicitly says do not re-ask');
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult reports timed_out even with interrupted:true', () => {
+  // timed_out wins over the interrupted flag — both are host-side failures,
+  // but timeout is the more specific signal and must reach the caller.
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-interrupted-${randomUUID()}`);
+  const gateId = 'depth_verification_M002_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, timed_out: true, interrupted: true },
+    });
+
+    assert.deepEqual(result, {
+      status: 'timeout',
+      pendingGateId: gateId,
+      interrupted: true,
+    });
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: timed_out gate with no pending gate returns not-gate', () => {
+  // A timed-out round arriving when no gate is armed (e.g. informational
+  // question) is not a gate concern — fail-open here, matching cancelled.
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-nogate-${randomUUID()}`);
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: 'depth_verification_M001_confirm',
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, timed_out: true },
+    });
+
+    assert.deepEqual(result, { status: 'not-gate' });
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 // ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
@@ -710,6 +957,7 @@ test('write-gate: resetWriteGateState persists through dangling .gsd symlink', (
       verifiedApprovalGates: [],
       activeQueuePhase: false,
       pendingGateId: null,
+      writer: 'host',
     });
   } finally {
     if (originalEnv === undefined) {
@@ -724,3 +972,45 @@ test('write-gate: resetWriteGateState persists through dangling .gsd symlink', (
     } catch { /* swallow */ }
   }
 });
+
+// ─── Scenario 31: hydrate in-memory gate state from persisted snapshot (MCP subprocess) ──
+
+test('write-gate: getPendingGate hydrates from disk when workflow MCP verified gate in child process', () => {
+  const base = join(tmpdir(), `gsd-write-gate-mcp-hydrate-${randomUUID()}`);
+  const stateFilePath = join(base, '.gsd', 'runtime', 'write-gate-state.json');
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+  const gateId = 'depth_verification_M005_confirm';
+
+  try {
+    process.env.GSD_PERSIST_WRITE_GATE_STATE = '1';
+    mkdirSync(join(base, '.gsd', 'runtime'), { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    writeFileSync(stateFilePath, JSON.stringify({
+      verifiedDepthMilestones: ['M005'],
+      verifiedApprovalGates: [gateId],
+      activeQueuePhase: false,
+      pendingGateId: null,
+    }, null, 2), 'utf-8');
+
+    assert.strictEqual(getPendingGate(base), null, 'stale in-memory pending must refresh from disk');
+    assert.strictEqual(isMilestoneDepthVerified('M005', base), true, 'verified milestone must hydrate from disk');
+    assert.deepEqual(loadWriteGateSnapshot(base), {
+      verifiedDepthMilestones: ['M005'],
+      verifiedApprovalGates: [gateId],
+      activeQueuePhase: false,
+      pendingGateId: null,
+    });
+  } finally {
+    if (originalEnv === undefined) {
+      delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    } else {
+      process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+    }
+    clearDiscussionFlowState(base);
+    try {
+      rmSync(base, { recursive: true, force: true });
+    } catch { /* swallow */ }
+  }
+});