@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -12,6 +12,7 @@ import {
   getArtifact,
   getAssessment,
   insertAssessment,
+  insertMilestone,
   upsertRequirement,
   getAllMilestones,
 } from "../gsd-db.ts";
@@ -153,9 +154,9 @@ test("executeSummarySave persists artifact and returns computed path", async ()
     }, base));
 
     assert.equal(result.details.operation, "save_summary");
-    assert.equal(result.details.path, "milestones/M001/slices/S01/S01-SUMMARY.md");
+    assert.equal(result.details.path, "phases/01-m001/01-01-SUMMARY.md");
 
-    const filePath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    const filePath = join(base, ".gsd", "phases", "01-m001", "01-01-SUMMARY.md");
     assert.ok(existsSync(filePath), "summary artifact should be written to disk");
     assert.match(readFileSync(filePath, "utf-8"), /# Summary/);
   } finally {
@@ -180,7 +181,7 @@ test("executeSummarySave mirrors milestone artifacts into the active worktree pr
     }, worktree));
 
     assert.equal(result.details.operation, "save_summary");
-    const relPath = "milestones/M001/slices/S02/S02-RESEARCH.md";
+    const relPath = "phases/01-m001/01-02-RESEARCH.md";
     const projectPath = join(base, ".gsd", relPath);
     const worktreePath = join(worktree, ".gsd", relPath);
     assert.equal(existsSync(projectPath), true, "canonical artifact should be written");
@@ -889,7 +890,7 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
     assert.equal(attempt.browserToolsPresented, false);
     assert.deepEqual(attempt.modePolicy?.requiredAnyModes, ["runtime"]);
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-02-ASSESSMENT.md"),
       "utf-8",
     );
     assert.match(assessment, /runId: uat:M001:S02:attempt-1/);
@@ -897,7 +898,7 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
     assert.match(assessment, /Runtime path C:\\\\tmp\\\|uat evidence/);
     assert.match(assessment, /backslash \\\\ and pipe \\\|/);
 
-    const artifactPath = "milestones/M001/slices/S02/S02-ASSESSMENT.md";
+    const artifactPath = "phases/01-m001/01-02-ASSESSMENT.md";
     const assessmentPath = `.gsd/${artifactPath}`;
     assert.equal(getArtifact(artifactPath)?.artifact_type, "ASSESSMENT");
     assert.equal(getAssessment(assessmentPath)?.scope, "run-uat");
@@ -1158,7 +1159,7 @@ test("executeUatResultSave surfaces the worktree validation path for NEEDS-HUMAN
     assert.ok(returnedText.includes(worktree), "tool return should include the worktree path");
 
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S07", "S07-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-07-ASSESSMENT.md"),
       "utf-8",
     );
     assert.match(assessment, /## Manual Validation/);
@@ -1217,7 +1218,7 @@ test("executeUatResultSave omits manual-validation guidance when no human checks
     assert.equal(returnedText.includes("Manual validation needed"), false);
 
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S08", "S08-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-08-ASSESSMENT.md"),
       "utf-8",
     );
     assert.equal(assessment.includes("## Manual Validation"), false);
@@ -1746,7 +1747,8 @@ test("executeSaveGateResult validates inputs and persists verdicts", async () =>
     assert.equal(row?.status, "complete");
     assert.equal(row?.verdict, "pass");
     assert.equal(row?.rationale, "Looks good.");
-    const planPath = join(base, ".gsd", "milestones", "M005", "slices", "S05", "S05-PLAN.md");
+    // Flat-phase: M005 title "Milestone Five" → phases/05-milestone-five/05-05-PLAN.md
+    const planPath = join(base, ".gsd", "phases", "05-milestone-five", "05-05-PLAN.md");
     assert.match(readFileSync(planPath, "utf-8"), /No issues found\./);
   } finally {
     closeDatabase();
@@ -2047,6 +2049,60 @@ test("executeSummarySave registers PROJECT milestone sequence for the next run",
   }
 });
 
+test("executeSummarySave reconciles bare PROJECT milestone IDs onto existing unique-ID rows (no phantom row) (#807)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    // Planner already minted a unique-ID milestone for sequence 1.
+    insertMilestone({ id: "M001-b1nole", title: "Foundation", status: "active" });
+
+    // A faithfully-authored PROJECT.md uses the template's bare sequence IDs.
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: [
+        "# Project",
+        "",
+        "## What This Is",
+        "",
+        "Deep project setup output.",
+        "",
+        "## Project Shape",
+        "",
+        "**Complexity:** complex",
+        "**Why:** It spans multiple delivery steps.",
+        "",
+        "## Capability Contract",
+        "",
+        "See .gsd/REQUIREMENTS.md.",
+        "",
+        "## Milestone Sequence",
+        "",
+        "- [ ] M001: Foundation - Establish the first runnable slice.",
+        "- [ ] M002: Polish - Follow-up experience work.",
+        "",
+      ].join("\n"),
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    // Bare M001 maps onto the planner's canonical row; M002 is genuinely new.
+    assert.deepEqual(result.details.registeredMilestones, ["M001-b1nole", "M002"]);
+
+    const milestones = getAllMilestones();
+    // No phantom bare "M001" row — the unique-ID row is preserved and not demoted.
+    assert.deepEqual(
+      milestones.map((m) => [m.id, m.title, m.status]).sort(),
+      [
+        ["M001-b1nole", "Foundation", "active"],
+        ["M002", "Polish", "queued"],
+      ].sort(),
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSummarySave hard-fails when milestone registration throws so silent No-Active-Milestone is impossible", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/worktree-health.test.ts

@@ -5,13 +5,14 @@
  * that getWorktreeHealth and formatWorktreeStatusLine return correct results.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
+import { getAllWorktreeHealth, getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
 import { listWorktrees } from "../worktree-manager.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -173,6 +174,45 @@ describe('worktree-health', async () => {
       assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
     }
 
+    // ─── Test: batch health detects main branch once ───────────────────
+    console.log("\n=== worktree health: batch main branch detection ===");
+    {
+      const dir = createBaseRepo();
+      cleanups.push(dir);
+
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b worktree/batch-a .gsd/worktrees/batch-a", dir);
+      run("git worktree add -b worktree/batch-b .gsd/worktrees/batch-b", dir);
+
+      const bin = mkdtempSync(join(tmpdir(), "wt-health-git-shim-"));
+      cleanups.push(bin);
+      const logPath = join(bin, "git.log");
+      const realGit = execSync("command -v git", { encoding: "utf-8" }).trim();
+      const shim = join(bin, "git");
+      writeFileSync(shim, `#!/bin/sh\nprintf '%s\\n' "$*" >> ${JSON.stringify(logPath)}\nexec ${JSON.stringify(realGit)} "$@"\n`, "utf-8");
+      chmodSync(shim, 0o755);
+
+      const originalPath = process.env.PATH ?? "";
+      const originalGitEnvPath = GIT_NO_PROMPT_ENV.PATH;
+      try {
+        process.env.PATH = `${bin}${delimiter}${originalPath}`;
+        GIT_NO_PROMPT_ENV.PATH = process.env.PATH;
+
+        const health = getAllWorktreeHealth(dir);
+        assert.equal(health.length, 2, "both worktrees have health entries");
+      } finally {
+        process.env.PATH = originalPath;
+        GIT_NO_PROMPT_ENV.PATH = originalGitEnvPath;
+      }
+
+      const invocations = readFileSync(logPath, "utf-8")
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+      const mainBranchDetections = invocations.filter(line => line === "symbolic-ref refs/remotes/origin/HEAD");
+      assert.equal(mainBranchDetections.length, 1, "batch health detects main branch once");
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

package/src/resources/extensions/gsd/tests/worktree-manager.test.ts

@@ -10,10 +10,12 @@ import {
   listWorktrees,
   removeWorktree,
   diffWorktreeGSD,
+  diffWorktreeNumstat,
   getWorktreeGSDDiff,
   getWorktreeLog,
   worktreeBranchName,
   worktreePath,
+  pruneEphemeralGhostWorktreeDirectories,
 } from "../worktree-manager.ts";
 
 function run(command: string, cwd: string): string {
@@ -290,6 +292,31 @@ describe("diffWorktreeGSD and getWorktreeGSDDiff", () => {
   });
 });
 
+describe("worktree diff target branch override", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+
+    run("git checkout -b integration main", base);
+    writeFileSync(join(base, "TARGET_ONLY.md"), "target branch only\n", "utf-8");
+    run("git add TARGET_ONLY.md", base);
+    run('git commit -m "chore: target branch only"', base);
+    run("git checkout main", base);
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("uses supplied main branch for merge preview helper overrides", () => {
+    const defaultStats = diffWorktreeNumstat(base, "feature-x", undefined, "main");
+    const overrideStats = diffWorktreeNumstat(base, "feature-x", undefined, "integration");
+    const selfLog = getWorktreeLog(base, "feature-x", worktreeBranchName("feature-x"));
+
+    assert.ok(!defaultStats.some(s => s.file === "TARGET_ONLY.md"), "default main stats should not include target-only file");
+    assert.ok(overrideStats.some(s => s.file === "TARGET_ONLY.md"), "override stats should use the supplied target branch");
+    assert.strictEqual(selfLog, "", "override log should use the supplied branch");
+  });
+});
+
 // ─── getWorktreeLog ───────────────────────────────────────────────────────────
 
 describe("getWorktreeLog", () => {
@@ -345,3 +372,38 @@ describe("removeWorktree — missing worktree", () => {
     );
   });
 });
+
+describe("pruneEphemeralGhostWorktreeDirectories", () => {
+  let base: string;
+  beforeEach(() => { base = makeBaseRepo(); });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("removes bg-shell-only ghost milestone directories", () => {
+    const ghostDir = join(base, ".gsd-worktrees", "M009");
+    mkdirSync(join(ghostDir, ".bg-shell"), { recursive: true });
+    writeFileSync(join(ghostDir, ".bg-shell", "manifest.json"), "[]\n", "utf-8");
+
+    const removed = pruneEphemeralGhostWorktreeDirectories(base);
+    assert.deepEqual(removed, [ghostDir]);
+    assert.ok(!existsSync(ghostDir));
+  });
+
+  test("preserves registered git worktrees", () => {
+    createWorktree(base, "M001");
+    const livePath = worktreePath(base, "M001");
+
+    const removed = pruneEphemeralGhostWorktreeDirectories(base);
+    assert.deepEqual(removed, []);
+    assert.ok(existsSync(livePath));
+  });
+
+  test("preserves unregistered dirs with source content", () => {
+    const staleDir = join(base, ".gsd-worktrees", "M020");
+    mkdirSync(staleDir, { recursive: true });
+    writeFileSync(join(staleDir, "orphan.txt"), "salvage me\n", "utf-8");
+
+    const removed = pruneEphemeralGhostWorktreeDirectories(base);
+    assert.deepEqual(removed, []);
+    assert.ok(existsSync(staleDir));
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-safety.test.ts

@@ -307,22 +307,26 @@ describe("Worktree Safety module", () => {
     assert.equal(result.kind, "worktree-unregistered");
   });
 
-  test("attempts prune recovery once for unregistered worktrees and tracks failed roots", () => {
+  test("removes an orphaned worktree directory when prune cannot recover it", () => {
     let pruneCalls = 0;
-    let listCalls = 0;
+    let removeCalls = 0;
+    let removedUnitRoot: string | undefined;
+    let removedMilestoneId: string | undefined;
     const safety = createWorktreeSafetyModule({
       existsSync: () => true,
       lstatSync: () => ({ isFile: () => true }),
       pruneRegisteredWorktrees: () => {
         pruneCalls += 1;
       },
-      listRegisteredWorktrees: () => {
-        listCalls += 1;
-        return [];
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: (root, milestoneId) => {
+        removeCalls += 1;
+        removedUnitRoot = root;
+        removedMilestoneId = milestoneId;
       },
     });
 
-    const first = safety.validateUnitRoot({
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -330,14 +334,32 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(first.ok, false);
-    assert.equal(first.kind, "worktree-unregistered");
-    assert.equal(first.details?.attemptedPrune, true);
-    assert.equal(first.details?.trackedAsFailed, true);
+
+    // Orphaned directory is cleaned up and the failure degrades to the
+    // recoverable worktree-missing kind so the next dispatch can recreate it,
+    // instead of looping forever on worktree-unregistered (#803).
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-missing");
+    assert.equal(result.details?.removedStaleDirectory, true);
+    assert.equal(result.details?.attemptedPrune, true);
     assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 2);
+    assert.equal(removeCalls, 1);
+    assert.equal(removedUnitRoot, unitRoot);
+    assert.equal(removedMilestoneId, "M001");
+  });
 
-    const second = safety.validateUnitRoot({
+  test("keeps worktree-unregistered when the orphaned directory cannot be removed", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      pruneRegisteredWorktrees: () => {},
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: () => {
+        throw new Error("directory may be locked by another process");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -345,12 +367,11 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(second.ok, false);
-    assert.equal(second.kind, "worktree-unregistered");
-    assert.equal(second.details?.attemptedPrune, false);
-    assert.equal(second.details?.trackedAsFailed, true);
-    assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 3);
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-unregistered");
+    assert.equal(result.details?.removedStaleDirectory, false);
+    assert.match(String(result.details?.error), /locked by another process/);
   });
 
   test("converts registered worktree list failures into typed failures", () => {

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

@@ -16,7 +16,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { shouldBlockWorktreeWrite } from "../bootstrap/write-gate.js";
+import { shouldBlockWorktreeBash, shouldBlockWorktreeWrite } from "../bootstrap/write-gate.js";
 import { invalidateAllCaches } from "../cache.js";
 
 function makeProject(isolation: "none" | "worktree" | "branch" | null): string {
@@ -163,6 +163,40 @@ describe("shouldBlockWorktreeWrite (#5199)", () => {
     assert.match(result.reason ?? "", /HARD BLOCK/);
   });
 
+  test("Case 7c: auto active in worktree blocks absolute project-root source writes", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd-worktrees", "M004");
+    mkdirSync(inside, { recursive: true });
+    writeFileSync(join(projectRoot, "style.css"), "/* root */\n");
+
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "style.css"),
+      inside,
+      /* isAutoLive */ true,
+      "execute-task",
+    );
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /outside the active milestone worktree/);
+    assert.match(result.reason ?? "", /style\.css/);
+  });
+
+  test("Case 7d: auto active in canonical .gsd-worktrees/ blocks root-relative escape via ..", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd-worktrees", "M004");
+    mkdirSync(inside, { recursive: true });
+
+    const result = shouldBlockWorktreeWrite(
+      "edit",
+      join(inside, "..", "..", "app.js"),
+      inside,
+      /* isAutoLive */ true,
+      "execute-task",
+    );
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /outside the active milestone worktree/);
+  });
+
   test("Case 8: bootstrap unit type active → allow", () => {
     projectRoot = makeProject("worktree");
     for (const unitType of ["discuss-milestone", "plan-milestone", "init"]) {
@@ -190,7 +224,7 @@ describe("shouldBlockWorktreeWrite (#5199)", () => {
     assert.equal(result.block, false);
   });
 
-  test("non-planning tools (read/grep/bash) pass through unconditionally", () => {
+  test("non-planning tools (read/grep/bash) pass through unconditionally when not in active worktree auto", () => {
     projectRoot = makeProject("worktree");
     for (const tool of ["read", "grep", "bash", "ls"]) {
       const result = shouldBlockWorktreeWrite(
@@ -200,7 +234,45 @@ describe("shouldBlockWorktreeWrite (#5199)", () => {
         false,
         null,
       );
-      assert.equal(result.block, false, `tool ${tool} must not be gated`);
+      assert.equal(result.block, false, `tool ${tool} must not be gated by write guard`);
     }
   });
+
+  test("bash blocks project-root path references during active worktree auto-mode", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd-worktrees", "M004");
+    mkdirSync(inside, { recursive: true });
+
+    const blocked = shouldBlockWorktreeBash(
+      `sed -i '' 's/foo/bar/' ${join(projectRoot, "style.css")}`,
+      inside,
+      /* isAutoLive */ true,
+      "execute-task",
+    );
+    assert.equal(blocked.block, true);
+    assert.match(blocked.reason ?? "", /outside the active milestone worktree/);
+
+    const allowed = shouldBlockWorktreeBash(
+      "npm test",
+      inside,
+      /* isAutoLive */ true,
+      "execute-task",
+    );
+    assert.equal(allowed.block, false);
+  });
+
+  test("bash blocks project-root path references from worktree cwd without live auto (subagent children)", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd-worktrees", "M004");
+    mkdirSync(inside, { recursive: true });
+
+    const blocked = shouldBlockWorktreeBash(
+      `cd ${projectRoot} && npm test`,
+      inside,
+      /* isAutoLive */ false,
+      null,
+    );
+    assert.equal(blocked.block, true);
+    assert.match(blocked.reason ?? "", /outside the active milestone worktree/);
+  });
 });

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

@@ -431,7 +431,10 @@ test('auto-unit scope: execute-task blocks slice and milestone lifecycle aliases
   assert.match(reopen.reason!, /gsd_milestone_reopen/);
 });
 
-test('auto-unit scope: complete-slice blocks milestone validation and native Workflow', () => {
+test('auto-unit scope: complete-slice allows milestone status but blocks milestone validation and native Workflow', () => {
+  const status = shouldBlockPlanningUnit('gsd_milestone_status', '', BASE, 'complete-slice', ALL);
+  assert.strictEqual(status.block, false);
+
   const closeSlice = shouldBlockPlanningUnit('gsd_slice_complete', '', BASE, 'complete-slice', ALL);
   assert.strictEqual(closeSlice.block, false);
 

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

@@ -140,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');
@@ -347,6 +348,7 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
 import {
   applyAskUserQuestionsGateResult,
   formatPendingAskUserQuestionsGateMessage,
+  formatTimedOutAskUserQuestionsGateMessage,
   isGateQuestionId,
   shouldBlockPendingGate,
   shouldBlockPendingGateBash,
@@ -523,6 +525,107 @@ test('write-gate: applyAskUserQuestionsGateResult keeps empty-selection pending
   }
 });
 
+// ─── 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', () => {