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

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -363,7 +363,7 @@ test("handleVerdict pass override works when validation only exists in DB", asyn
     const { ctx, calls } = makeMockCtx();
     await handleVerdict('pass --milestone M001 --rationale "reviewed and accepted"', ctx, base);
 
-    const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    const validationPath = join(base, ".gsd", "phases", "01-m001", "01-VALIDATION.md");
     const rewritten = readFileSync(validationPath, "utf-8");
     assert.match(rewritten, /^verdict: pass$/m, "DB-backed validation should be rewritten as pass");
     assert.match(rewritten, /reviewed and accepted/, "explicit rationale should be persisted");

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

@@ -0,0 +1,102 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for formatCompatHealthLine (doctor compat output).
+// Covers the per-section "no baseline" signal introduced to fix COMMENT:3449128458.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { formatCompatHealthLine } from "../commands-handlers.ts";
+import { writeCompatMarker } from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-chl-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+afterEach(() => {
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+test("returns unified no-baseline when projections empty and planning inactive", async () => {
+  const base = makeTmpBase();
+  // No marker written → EMPTY_MARKER → projections={}, planning.active=false
+  const line = await formatCompatHealthLine(base);
+  assert.ok(line.includes("no baseline"), `expected no-baseline, got: ${line}`);
+  // Should be the unified single line, not separate .gsd/.planning sections.
+  assert.ok(!line.includes("(.gsd)"), `expected unified line, got: ${line}`);
+});
+
+test("returns per-section no-baseline for .gsd when planning active but gsd projections empty", async () => {
+  // Regression: COMMENT:3449128458 — after auto-activation, marker has
+  // planning.active=true but marker.projections={} (no .gsd/ baseline yet).
+  // Old code reported ".gsd: OK" (misleading). New code: per-section no-baseline.
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "",
+    projections: {},
+    planning: { active: true, layout: "flat-phases", projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  // Both sections should show no-baseline.
+  const gsdLine = line.split("\n").find((l) => l.includes("(.gsd)"));
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(gsdLine, "expected a (.gsd) line");
+  assert.ok(planningLine, "expected a (.planning) line");
+  assert.ok(gsdLine!.includes("no baseline"), `(.gsd) should say no baseline, got: ${gsdLine}`);
+  assert.ok(planningLine!.includes("no baseline"), `(.planning) should say no baseline, got: ${planningLine}`);
+});
+
+test("returns no-baseline for .planning section when active but planning projections empty", async () => {
+  // Mixed: .gsd/ has a baseline but .planning/ has been auto-activated with
+  // empty projections (sync ran for .gsd but not yet for .planning/).
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "milestones/M001/M001-ROADMAP.md": { sha: "abc123", entities: ["M001"] },
+    },
+    planning: { active: true, layout: "flat-phases", projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  const gsdLine = line.split("\n").find((l) => l.includes("(.gsd)"));
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(gsdLine, "expected a (.gsd) line");
+  assert.ok(planningLine, "expected a (.planning) line");
+  // .gsd/ has a baseline (1 entry), file is absent → 0 drift → OK
+  assert.ok(gsdLine!.includes("OK"), `(.gsd) should say OK, got: ${gsdLine}`);
+  // .planning/ has no SHAs at all → no baseline
+  assert.ok(planningLine!.includes("no baseline"), `(.planning) should say no baseline, got: ${planningLine}`);
+});
+
+test("reports not-active for .planning when planning is inactive", async () => {
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "milestones/M001/M001-ROADMAP.md": { sha: "abc123", entities: ["M001"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(planningLine, "expected a (.planning) line");
+  assert.ok(planningLine!.includes("not active"), `(.planning) should say not active, got: ${planningLine}`);
+});

package/src/resources/extensions/gsd/tests/compat-marker-invalidation.test.ts

@@ -0,0 +1,51 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies that projection writes update .gsd/.compat.json.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { renderRoadmapFromDb } from "../markdown-renderer.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { readCompatMarker } from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+function makeTmp(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-inv-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertSlice({ milestoneId: "M001", id: "S01", title: "T", status: "pending", risk: "low", depends: [] });
+  tmpDirs.push(base);
+  return base;
+}
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+test("renderRoadmapFromDb writes a compat marker entry for the roadmap file", async () => {
+  const base = makeTmp();
+  await renderRoadmapFromDb(base, "M001");
+  const marker = readCompatMarker(base);
+  const rels = Object.keys(marker.projections);
+  assert.ok(
+    rels.some((r) => r.includes("M001") && r.endsWith("ROADMAP.md")),
+    `expected roadmap entry, got ${JSON.stringify(rels)}`,
+  );
+  // Marker should record gsd-pi as last writer and a non-empty timestamp.
+  assert.equal(marker.lastWriter, "gsd-pi");
+  assert.ok(marker.lastProjectedAt.length > 0, "expected non-empty lastProjectedAt");
+});
+
+test("re-rendering the same file updates the marker entry (not duplicates)", async () => {
+  const base = makeTmp();
+  await renderRoadmapFromDb(base, "M001");
+  await renderRoadmapFromDb(base, "M001");
+  const marker = readCompatMarker(base);
+  const roadmapEntries = Object.keys(marker.projections).filter((r) => r.endsWith("ROADMAP.md"));
+  assert.equal(roadmapEntries.length, 1, "expected exactly one roadmap entry after re-render");
+});

package/src/resources/extensions/gsd/tests/compat-marker.test.ts

@@ -0,0 +1,105 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for the gsd-core compat marker (`.gsd/.compat.json`).
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  readCompatMarker,
+  writeCompatMarker,
+  normalizeForHash,
+  computeProjectionSha,
+  EMPTY_MARKER,
+  compatMarkerPath,
+} from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-compat-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+  }
+  tmpDirs.length = 0;
+});
+
+test("readCompatMarker returns EMPTY_MARKER when file is missing", () => {
+  const base = makeTmpBase();
+  const marker = readCompatMarker(base);
+  assert.deepEqual(marker, EMPTY_MARKER);
+});
+
+test("writeCompatMarker then readCompatMarker round-trips", () => {
+  const base = makeTmpBase();
+  const marker = {
+    schema: 2,
+    lastWriter: "gsd-pi" as const,
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "roadmap.md": { sha: "abc123", entities: ["m1"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  };
+  writeCompatMarker(base, marker);
+  const read = readCompatMarker(base);
+  assert.deepEqual(read, marker);
+});
+
+test("readCompatMarker quarantines malformed JSON and returns EMPTY_MARKER", () => {
+  const base = makeTmpBase();
+  writeFileSync(compatMarkerPath(base), "{ not valid json", "utf-8");
+  const marker = readCompatMarker(base);
+  assert.deepEqual(marker, EMPTY_MARKER);
+  const files = readdirSync(join(base, ".gsd"));
+  // Quarantine backup should exist.
+  const quarantined = files.some((f: string) => f.startsWith(".compat.json.bad-"));
+  assert.ok(quarantined, "expected a quarantined .compat.json.bad-* file");
+  // Original should be gone — the quarantine fix removes it so repeated reads
+  // don't accumulate unbounded .bad-* files.
+  assert.ok(!files.includes(".compat.json"), "corrupt original should be deleted after quarantine");
+});
+
+test("quarantine does not grow unbounded .bad-* files on repeated reads", () => {
+  const base = makeTmpBase();
+  writeFileSync(compatMarkerPath(base), "not valid json at all", "utf-8");
+
+  // First read quarantines and removes the original.
+  readCompatMarker(base);
+  const filesAfterFirst = readdirSync(join(base, ".gsd"));
+  const badCountAfterFirst = filesAfterFirst.filter((f: string) => f.startsWith(".compat.json.bad-")).length;
+  assert.equal(badCountAfterFirst, 1, "expected exactly one .bad-* file after first read");
+  assert.ok(!filesAfterFirst.includes(".compat.json"), "corrupt original should be gone after first read");
+
+  // Second read sees no file → EMPTY_MARKER fast path, no new .bad-* created.
+  readCompatMarker(base);
+  const filesAfterSecond = readdirSync(join(base, ".gsd"));
+  const badCountAfterSecond = filesAfterSecond.filter((f: string) => f.startsWith(".compat.json.bad-")).length;
+  assert.equal(badCountAfterSecond, 1, "second read must not create an additional .bad-* file");
+});
+
+test("normalizeForHash trims trailing whitespace and converts CRLF to LF", () => {
+  const input = "line one  \r\nline two\r\n";
+  const out = normalizeForHash(input);
+  assert.equal(out, "line one\nline two\n");
+});
+
+test("computeProjectionSha is stable for cosmetically different but equivalent content", () => {
+  const a = computeProjectionSha("hello\r\nworld  \n");
+  const b = computeProjectionSha("hello\nworld\n");
+  assert.equal(a, b);
+});
+
+test("compatMarkerPath resolves under .gsd", () => {
+  const base = makeTmpBase();
+  assert.equal(compatMarkerPath(base), join(base, ".gsd", ".compat.json"));
+});

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -42,7 +42,11 @@ test("complete milestone prompt renders compact verification and completion guid
   assert.match(prompt, /Decision Re-evaluation/);
   assert.match(prompt, /self-diff/i);
   assert.match(prompt, /GSD-(?:Task|Unit)/);
-  assert.match(prompt, /Milestone M001 complete/);
-  assert.match(prompt, /Do not add a second final-status block/);
+  assert.match(prompt, /Closeout messaging \(auto-mode\)/);
+  assert.match(prompt, /Never say "Milestone M001 is complete"/);
+  assert.match(prompt, /Milestone M001 closeout submitted/);
+  assert.match(prompt, /Do not say the milestone is complete/);
+  assert.match(prompt, /VERIFICATION FAILED/);
+  assert.doesNotMatch(prompt, /emit only one closeout line: "Milestone M001 complete\."/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });

package/src/resources/extensions/gsd/tests/complete-slice-reopen-handoff.test.ts

@@ -67,6 +67,46 @@ test("complete-slice with gsd_task_reopen handoff continues instead of artifact-
   }
 });
 
+test("complete-slice text mentioning gsd_task_reopen does not count as a handoff", async () => {
+  const base = makeTempRepo("gsd-complete-slice-reopen-text-");
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const result = await postUnitPreVerification(
+      makePostUnitContext(base, s, notifications),
+      {
+        skipSettleDelay: true,
+        skipWorktreeSync: true,
+        agentEndMessages: [
+          {
+            role: "assistant",
+            content: "I should call gsd_task_reopen for T01, then stop.",
+          },
+        ],
+      },
+    );
+
+    assert.equal(result, "continue");
+    assert.equal(s.pendingVerificationRetry, null);
+    assert.ok(
+      notifications.every((message) => !message.includes("handed off via reopen/replan")),
+      `plain text must not be treated as handoff, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("DB unavailable")),
+      `expected DB-unavailable fallback, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("complete-slice with gsd_replan_slice tool result continues instead of artifact-retrying", async () => {
   const base = makeTempRepo("gsd-complete-slice-replan-");
   try {
@@ -111,6 +151,48 @@ test("complete-slice with gsd_replan_slice tool result continues instead of arti
   }
 });
 
+test("complete-slice text mentioning gsd_replan_slice does not count as a valid replan outcome", async () => {
+  const base = makeTempRepo("gsd-complete-slice-replan-text-");
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-REPLAN.md"), "# Replan\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const result = await postUnitPreVerification(
+      makePostUnitContext(base, s, notifications),
+      {
+        skipSettleDelay: true,
+        skipWorktreeSync: true,
+        agentEndMessages: [
+          {
+            role: "assistant",
+            content: "I will use gsd_replan_slice and let execution follow up.",
+          },
+        ],
+      },
+    );
+
+    assert.equal(result, "continue");
+    assert.equal(s.pendingVerificationRetry, null);
+    assert.ok(
+      notifications.every((message) => !message.includes("valid replan outcome")),
+      `plain text must not be treated as replan outcome, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("DB unavailable")),
+      `expected DB-unavailable fallback, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("complete-slice with gsd_replan_slice but no REPLAN artifact retries", async () => {
   const base = makeTempRepo("gsd-complete-slice-replan-missing-artifact-");
   try {

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -61,11 +61,11 @@ function cleanupDir(dirPath: string): void {
  */
 function createTempProject(): { basePath: string; roadmapPath: string } {
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-slice-handler-'));
-  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const sliceDir = path.join(basePath, '.gsd', 'phases', '01-test');
   const tasksDir = path.join(sliceDir, 'tasks');
   fs.mkdirSync(tasksDir, { recursive: true });
 
-  const roadmapPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+  const roadmapPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
   fs.writeFileSync(roadmapPath, `# M001: Test Milestone
 
 ## Slices
@@ -211,8 +211,8 @@ console.log('\n=== complete-slice: handler happy path ===');
   if (!('error' in result)) {
     assertEq(result.sliceId, 'S01', 'result sliceId');
     assertEq(result.milestoneId, 'M001', 'result milestoneId');
-    assertTrue(result.summaryPath.endsWith('S01-SUMMARY.md'), 'summaryPath should end with S01-SUMMARY.md');
-    assertTrue(result.uatPath.endsWith('S01-UAT.md'), 'uatPath should end with S01-UAT.md');
+    assertTrue(result.summaryPath.endsWith('01-01-SUMMARY.md'), 'summaryPath should end with 01-01-SUMMARY.md');
+    assertTrue(result.uatPath.endsWith('01-01-UAT.md'), 'uatPath should end with 01-01-UAT.md');
 
     // (a) Verify SUMMARY.md exists on disk with correct YAML frontmatter
     assertTrue(fs.existsSync(result.summaryPath), 'summary file should exist on disk');
@@ -416,8 +416,8 @@ console.log('\n=== complete-slice: handler idempotency ===');
   if (!('error' in r2)) {
     assertEq(r2.duplicate, true, 'second call should be marked duplicate');
     assertEq(
-      fs.readFileSync(r2.summaryPath, 'utf-8'),
-      summaryBefore,
+      fs.readFileSync(r2.summaryPath, 'utf-8').replace(/completed_at: "[^"]*"/g, 'completed_at: "<ts>"'),
+      summaryBefore.replace(/completed_at: "[^"]*"/g, 'completed_at: "<ts>"'),
       'healthy duplicate should not rewrite the existing summary',
     );
   }
@@ -488,7 +488,7 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
 
   // Create a temp dir WITHOUT a roadmap file
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-no-roadmap-'));
-  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const sliceDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(sliceDir, { recursive: true });
 
   // Set up DB state

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -60,10 +60,10 @@ function cleanupDir(dirPath: string): void {
  */
 function createTempProject(): { basePath: string; planPath: string } {
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-handler-'));
-  const tasksDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  const tasksDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(tasksDir, { recursive: true });
 
-  const planPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+  const planPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
   fs.writeFileSync(planPath, `# S01: Test Slice
 
 ## Tasks
@@ -359,9 +359,9 @@ console.log('\n=== complete-task: handler happy path ===');
 
     // (d) Verify plan checkbox changed to [x]
     const planContent = fs.readFileSync(planPath, 'utf-8');
-    assertMatch(planContent, /\[x\]\s+\*\*T01:/, 'T01 should be checked in plan');
+    assertMatch(planContent, /\[x\]\s+\*\*T01\*\*/, 'T01 should be checked in plan');
     // T02 should still be unchecked
-    assertMatch(planContent, /\[ \]\s+\*\*T02:/, 'T02 should still be unchecked in plan');
+    assertMatch(planContent, /\[ \]\s+\*\*T02\*\*/, 'T02 should still be unchecked in plan');
 
     // (e) Verify full_summary_md stored in DB for D004 recovery
     const taskAfter = getTask('M001', 'S01', 'T01');
@@ -584,7 +584,7 @@ console.log('\n=== complete-task: handler with missing plan file ===');
 
   // Create a temp dir WITHOUT a plan file
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-no-plan-'));
-  const tasksDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  const tasksDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(tasksDir, { recursive: true });
 
   // Seed milestone + slice so state machine guards pass
@@ -598,9 +598,9 @@ console.log('\n=== complete-task: handler with missing plan file ===');
   assertTrue(!('error' in result), 'handler should succeed without plan file');
   if (!('error' in result)) {
     assertTrue(fs.existsSync(result.summaryPath), 'summary should be written even without plan file');
-    const planPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    const planPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
     assertTrue(fs.existsSync(planPath), 'missing plan projection should be regenerated from DB');
-    assertTrue(fs.readFileSync(planPath, 'utf-8').includes('[x] **T01:'), 'regenerated plan should reflect DB task completion');
+    assertTrue(fs.readFileSync(planPath, 'utf-8').includes('[x] **T01**'), 'regenerated plan should reflect DB task completion');
   }
 
   cleanupDir(basePath);

package/src/resources/extensions/gsd/tests/consent-question.test.ts

@@ -83,6 +83,8 @@ const POLICY_TABLE: Row[] = [
   { name: "gate × missing response → waiting", question: gateQ, details: {}, expected: "waiting" },
   { name: "gate × notes-only → waiting (notes never satisfy a gate)", question: gateQ, details: { response: { answers: { [gateQ.id]: { notes: "looks fine" } } } }, expected: "waiting" },
   { name: "gate × cancelled → cancelled", question: gateQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+  { name: "gate × timed_out → timeout (#852)", question: gateQ, details: { cancelled: true, timed_out: true, response: null }, expected: "timeout" },
+  { name: "gate × timed_out + interrupted → timeout (timeout wins, #852)", question: gateQ, details: { cancelled: true, timed_out: true, interrupted: true, response: null }, expected: "timeout" },
   // consent
   { name: "consent × valid selected → answered", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "Option B" } } } }, expected: "answered" },
   { name: "consent × empty selected → waiting (#528)", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "" } } } }, expected: "waiting" },
@@ -90,6 +92,7 @@ const POLICY_TABLE: Row[] = [
   { name: "consent × missing response → waiting", question: consentQ, details: {}, expected: "waiting" },
   { name: "consent × notes-only → answered (a real user utterance)", question: consentQ, details: { response: { answers: { [consentQ.id]: { notes: "neither — keep it simple" } } } }, expected: "answered" },
   { name: "consent × cancelled → cancelled", question: consentQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+  { name: "consent × timed_out → timeout (#852)", question: consentQ, details: { cancelled: true, timed_out: true, response: null }, expected: "timeout" },
 ];
 
 for (const row of POLICY_TABLE) {
@@ -124,6 +127,48 @@ test("evaluateAskUserQuestionsRound: most blocking outcome wins", () => {
   assert.equal(evaluateAskUserQuestionsRound([], {}), "answered");
 });
 
+// ── #852: host elicitation timeout → "timeout" round outcome ────────────────
+
+test("#852: timed_out round → timeout (does NOT become waiting/answered)", () => {
+  // A timeout must not be laundered into "waiting" (which tells the model to
+  // re-ask — that just hits the same timeout again) or "answered".
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ], { cancelled: true, timed_out: true, response: null }),
+    "timeout",
+  );
+  assert.equal(
+    evaluateAskUserQuestionsRound([gateQ], { cancelled: true, timed_out: true, response: null }),
+    "timeout",
+  );
+});
+
+test("#852: timeout wins over answered in a mixed round (most blocking)", () => {
+  // One answered question + one timed_out question → the whole round is timeout.
+  const details = {
+    timed_out: true,
+    cancelled: true,
+    response: null,
+  };
+  assert.equal(
+    evaluateAskUserQuestionsRound(
+      [consentQ, { id: "other", options: CONSENT_OPTIONS }],
+      // The timed_out flag is round-level, so even if one question "answered"
+      // the timeout on the round dominates.
+      details,
+    ),
+    "timeout",
+  );
+});
+
+test("#852: cancelled still beats timeout when both flags absent on the round", () => {
+  // Round-level cancelled without timed_out stays cancelled (deliberate user
+  // dismissal is a stronger signal than a host timeout).
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ], { cancelled: true, response: null }),
+    "cancelled",
+  );
+});
+
 // ── Regression: #528 empty selected on a consent question never answers ─────
 
 test("#528: empty selected on a NON-gate question is waiting, not answered", () => {

package/src/resources/extensions/gsd/tests/core-overlay-fallback.test.ts

@@ -13,6 +13,7 @@ function makeCtx(customResult: unknown) {
   const customCalls: Array<{ options: any }> = [];
   return {
     hasUI: true,
+    modelRegistry: { getAvailable: () => [] },
     ui: {
       custom: async (_factory: unknown, options: any) => {
         customCalls.push({ options });

package/src/resources/extensions/gsd/tests/dashboard-overlay.test.ts

@@ -4,10 +4,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { GSDDashboardOverlay } from "../dashboard-overlay.ts";
 import type { UnitMetrics } from "../metrics.ts";
 import { assertFullOuterBorder } from "./tui-border-assertions.ts";
+import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
 
 const fakeTheme = {
   fg: (_color: string, text: string) => text,
@@ -48,6 +52,39 @@ test("GSDDashboardOverlay reuses metrics aggregations until the unit count chang
   assert.equal(increasedCountMetrics.totals.cost, 1.25);
 });
 
+test("GSDDashboardOverlay non-identity refresh avoids reparsing preferences", async (t) => {
+  const basePath = join(
+    tmpdir(),
+    `gsd-dashboard-overlay-refresh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = basePath;
+  autoSession.autoStartTime = Date.now() - 1000;
+  autoSession.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S001/T001",
+    startedAt: Date.now() - 500,
+  });
+
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  t.after(() => {
+    overlay.dispose();
+    autoSession.reset();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  (overlay as any).loadedDashboardIdentity = (overlay as any).computeDashboardIdentity(getAutoRuntimeSnapshot());
+  mkdirSync(join(basePath, ".gsd", "PREFERENCES.md"));
+
+  await assert.doesNotReject(
+    () => (overlay as any).refreshDashboard(false),
+    "unchanged overlay identity should not call getAutoDashboardData or read preferences",
+  );
+});
+
 function makeUnit(id: string, cost: number): UnitMetrics {
   return {
     type: "execute-task",

package/src/resources/extensions/gsd/tests/db-authority-regression.test.ts

@@ -58,7 +58,7 @@ function activeRequirement(id: string): Requirement {
   };
 }
 
-test("DB authority: PROJECT.md and QUEUE-ORDER projections do not choose runtime milestone", async (t) => {
+test("DB authority: PROJECT.md projection does not create runtime milestones from QUEUE-ORDER", async (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));