gsd-pi 2.46.1 → 2.47.0-dev.8cfe772

package/src/resources/extensions/gsd/state.ts

@@ -49,6 +49,7 @@ import {
   getReplanHistory,
   getSlice,
   insertMilestone,
+  updateTaskStatus,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -629,7 +630,38 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── Get tasks from DB ────────────────────────────────────────────────
-  const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+  let tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+
+  // ── Reconcile stale task status (#2514) ──────────────────────────────
+  // When a session disconnects after the agent writes SUMMARY + VERIFY
+  // artifacts but before postUnitPostVerification updates the DB, tasks
+  // remain "pending" in the DB despite being complete on disk. Without
+  // reconciliation, deriveState keeps returning the stale task as active,
+  // causing the dispatcher to re-dispatch the same completed task forever.
+  let reconciled = false;
+  for (const t of tasks) {
+    if (isStatusDone(t.status)) continue;
+    const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+      try {
+        updateTaskStatus(activeMilestone.id, activeSlice.id, t.id, "complete");
+        process.stderr.write(
+          `gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} had SUMMARY on disk but DB status was "${t.status}" — updated to "complete" (#2514)\n`,
+        );
+        reconciled = true;
+      } catch (e) {
+        // DB write failed — continue with stale status rather than crash
+        process.stderr.write(
+          `gsd-reconcile: failed to update task ${t.id}: ${(e as Error).message}\n`,
+        );
+      }
+    }
+  }
+  // Re-fetch tasks if any were reconciled so downstream logic sees fresh status
+  if (reconciled) {
+    tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+  }
+
   const taskProgress = {
     done: tasks.filter(t => isStatusDone(t.status)).length,
     total: tasks.length,

package/src/resources/extensions/gsd/tests/discuss-queued-milestones.test.ts

@@ -0,0 +1,241 @@
+/**
+ * discuss-queued-milestones.test.ts — Tests for #2307.
+ *
+ * /gsd discuss was previously gated on state.activeMilestone, which prevented
+ * users from discussing queued (pending) milestones during roadmap grooming.
+ *
+ * These tests verify:
+ *   1. deriveState correctly identifies pending milestones (the set the picker
+ *      will show when no active milestone is present)
+ *   2. resolveMilestoneFile correctly resolves context artifacts for pending
+ *      milestones so the picker can report their discussion state
+ *   3. The guided-flow.ts source code no longer hard-exits when no active
+ *      milestone exists but pending milestones are present
+ *   4. The helper functions for queued discuss exist in the source
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+import { deriveState } from "../state.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { resolveMilestoneFile } from "../paths.ts";
+
+// ─── Fixture Helpers ──────────────────────────────────────────────────────────
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-discuss-queued-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeMilestoneDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+}
+
+function writeContext(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT.md`), content);
+}
+
+function writeContextDraft(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT-DRAFT.md`), content);
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`), content);
+}
+
+function readGuidedFlowSource(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("discuss-queued-milestones (#2307)", () => {
+
+  test("1. pending milestones appear in registry when active milestone exists", async () => {
+    const base = createBase();
+    try {
+      // M001: active — has context + roadmap with a slice
+      writeContext(base, "M001", "# M001: Active\nContext here.");
+      writeRoadmap(base, "M001",
+        "# M001: Active\n\n## Slices\n- [ ] **S01: Do work** `risk:low` `depends:[]`\n  > After this: works\n");
+
+      // M002: pending — context only, no roadmap
+      writeContext(base, "M002", "# M002: Queued\nFuture work.");
+
+      // M003: pending — draft context only
+      writeContextDraft(base, "M003", "# M003: Draft\nSeed material.");
+
+      invalidateAllCaches();
+      const state = await deriveState(base);
+
+      assert.ok(!!state.activeMilestone, "M001 should be the active milestone");
+      assert.strictEqual(state.activeMilestone?.id, "M001");
+
+      const pendingIds = state.registry
+        .filter(m => m.status === "pending")
+        .map(m => m.id);
+
+      assert.ok(pendingIds.includes("M002"), "M002 should be pending");
+      assert.ok(pendingIds.includes("M003"), "M003 should be pending");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("2. first context-only milestone is active, subsequent ones are pending", async () => {
+    const base = createBase();
+    try {
+      // M001: first milestone with context but no roadmap — deriveState marks it active
+      writeContext(base, "M001", "# M001: First\nContext here.");
+      // M002: will be pending since M001 is active
+      writeContext(base, "M002", "# M002: Second\nMore future work.");
+
+      invalidateAllCaches();
+      const state = await deriveState(base);
+
+      // deriveState makes the first unfinished milestone "active" even without a roadmap
+      assert.ok(!!state.activeMilestone, "first milestone should be active");
+      assert.strictEqual(state.activeMilestone?.id, "M001", "M001 is the active milestone");
+
+      const pendingIds = state.registry
+        .filter(m => m.status === "pending")
+        .map(m => m.id);
+
+      assert.ok(pendingIds.includes("M002"),
+        "M002 should be pending — it comes after the active M001");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("3. resolveMilestoneFile finds CONTEXT.md for pending milestone", (t) => {
+    const base = createBase();
+    try {
+      writeContext(base, "M002", "# M002: Queued\nContent.");
+
+      const contextFile = resolveMilestoneFile(base, "M002", "CONTEXT");
+      assert.ok(contextFile !== null, "resolveMilestoneFile should find CONTEXT.md for M002");
+      assert.ok(contextFile!.endsWith("M002-CONTEXT.md"),
+        "resolved path should point to M002-CONTEXT.md");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("4. resolveMilestoneFile finds CONTEXT-DRAFT.md for pending milestone", (t) => {
+    const base = createBase();
+    try {
+      writeContextDraft(base, "M003", "# M003: Draft\nSeed content.");
+
+      const draftFile = resolveMilestoneFile(base, "M003", "CONTEXT-DRAFT");
+      assert.ok(draftFile !== null, "resolveMilestoneFile should find CONTEXT-DRAFT.md for M003");
+      assert.ok(draftFile!.endsWith("M003-CONTEXT-DRAFT.md"),
+        "resolved path should point to M003-CONTEXT-DRAFT.md");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("5. resolveMilestoneFile returns null when pending milestone has no context", (t) => {
+    const base = createBase();
+    try {
+      writeMilestoneDir(base, "M004");
+
+      const contextFile = resolveMilestoneFile(base, "M004", "CONTEXT");
+      assert.strictEqual(contextFile, null,
+        "resolveMilestoneFile should return null when no CONTEXT.md exists");
+
+      const draftFile = resolveMilestoneFile(base, "M004", "CONTEXT-DRAFT");
+      assert.strictEqual(draftFile, null,
+        "resolveMilestoneFile should return null when no CONTEXT-DRAFT.md exists");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("6. guided-flow no longer hard-exits when no active milestone but pending exist", () => {
+    const source = readGuidedFlowSource();
+
+    // The old guard was a simple early-exit:
+    //   if (!state.activeMilestone) {
+    //     ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
+    //     return;
+    //   }
+    //
+    // The new guard should check for pending milestones and route instead.
+    const oldGuardPattern = /if\s*\(!state\.activeMilestone\)\s*\{\s*ctx\.ui\.notify\("No active milestone/;
+    assert.ok(
+      !oldGuardPattern.test(source),
+      "guided-flow must not unconditionally exit when activeMilestone is null",
+    );
+  });
+
+  test("7. showDiscussQueuedMilestone helper exists in guided-flow", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("showDiscussQueuedMilestone"),
+      "guided-flow must export showDiscussQueuedMilestone helper",
+    );
+  });
+
+  test("8. dispatchDiscussForMilestone helper exists in guided-flow", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("dispatchDiscussForMilestone"),
+      "guided-flow must export dispatchDiscussForMilestone helper",
+    );
+  });
+
+  test("9. dispatchDiscussForMilestone does not set pendingAutoStart", () => {
+    const source = readGuidedFlowSource();
+
+    // Extract the dispatchDiscussForMilestone function body
+    const fnMatch = source.match(
+      /async function dispatchDiscussForMilestone\s*\([^)]*\)[^{]*\{([\s\S]*?)\n\}/,
+    );
+    assert.ok(!!fnMatch, "dispatchDiscussForMilestone function body must be present");
+
+    if (fnMatch) {
+      assert.ok(
+        !fnMatch[1].includes("pendingAutoStart"),
+        "dispatchDiscussForMilestone must NOT set pendingAutoStart — discussing a queued milestone must not activate it",
+      );
+    }
+  });
+
+  test("10. slice picker includes queued milestone option when pending milestones exist", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("discuss_queued_milestone"),
+      "slice picker must include a 'discuss_queued_milestone' action id for queued milestones",
+    );
+    assert.ok(
+      source.includes("Discuss a queued milestone"),
+      "slice picker must label the queued milestone action clearly",
+    );
+  });
+
+  test("11. queued milestone picker labels entries with [queued]", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("[queued]"),
+      "queued milestone picker must label entries with [queued] to distinguish from active",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/forensics-error-filter.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Regression test for #2539: extractTrace should not count benign bash
+ * exit-code-1 (grep no-match) or user skips as errors.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { extractTrace } from "../session-forensics.ts";
+
+/**
+ * Build a minimal JSONL entry pair: assistant tool_use → toolResult.
+ * This is the shape extractTrace() expects from session activity files.
+ */
+function makeToolPair(
+  toolName: string,
+  input: Record<string, unknown>,
+  resultText: string,
+  isError: boolean,
+): unknown[] {
+  const toolCallId = `toolu_${Math.random().toString(36).slice(2, 10)}`;
+  return [
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "toolCall",
+            id: toolCallId,
+            name: toolName,
+            arguments: input,
+          },
+        ],
+      },
+    },
+    {
+      type: "message",
+      message: {
+        role: "toolResult",
+        toolCallId,
+        toolName,
+        isError,
+        content: [{ type: "text", text: resultText }],
+      },
+    },
+  ];
+}
+
+describe("extractTrace error filtering (#2539)", () => {
+  test("grep exit-code-1 (no matches) is not counted as an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "grep -rn 'nonexistent' src/" },
+      "(no output)\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 0, "grep no-match should not be an error");
+  });
+
+  test("user skip is not counted as an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "npm run test" },
+      "Skipped due to queued user message",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 0, "user skip should not be an error");
+  });
+
+  test("real bash error is still counted", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "cat /nonexistent" },
+      "cat: /nonexistent: No such file or directory\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "real error should still be counted");
+    assert.match(trace.errors[0], /No such file or directory/);
+  });
+
+  test("non-bash tool error is still counted", () => {
+    const entries = makeToolPair(
+      "edit",
+      { path: "foo.ts", oldText: "x", newText: "y" },
+      "oldText not found in file",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "non-bash tool errors should still be counted");
+  });
+
+  test("mixed entries: only real errors are counted", () => {
+    const entries = [
+      // benign grep no-match
+      ...makeToolPair("bash", { command: "grep -rn 'pattern' src/" }, "(no output)\nCommand exited with code 1", true),
+      // user skip
+      ...makeToolPair("bash", { command: "npm test" }, "Skipped due to queued user message", true),
+      // real error
+      ...makeToolPair("bash", { command: "node broken.js" }, "SyntaxError: Unexpected token\nCommand exited with code 1", true),
+      // successful command (not an error)
+      ...makeToolPair("bash", { command: "echo hello" }, "hello", false),
+    ];
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "only the real error should be counted");
+    assert.match(trace.errors[0], /SyntaxError/);
+  });
+
+  test("exit code 1 with actual output is still an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "npm run lint" },
+      "src/foo.ts:10:5 - error TS2304: Cannot find name 'x'\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "lint error with output should be counted");
+  });
+});

package/src/resources/extensions/gsd/tests/inherited-repo-home-dir.test.ts

@@ -119,3 +119,73 @@ describe("isInheritedRepo when git root is HOME (#2393)", () => {
     );
   });
 });
+
+describe("isInheritedRepo with stale .gsd at parent git root", () => {
+  let parentRepo: string;
+
+  beforeEach(() => {
+    parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-stale-parent-")));
+    run("git", ["init", "-b", "main"], parentRepo);
+    run("git", ["config", "user.name", "Test"], parentRepo);
+    run("git", ["config", "user.email", "test@example.com"], parentRepo);
+    writeFileSync(join(parentRepo, "README.md"), "# Parent\n", "utf-8");
+    run("git", ["add", "README.md"], parentRepo);
+    run("git", ["commit", "-m", "init"], parentRepo);
+  });
+
+  afterEach(() => {
+    rmSync(parentRepo, { recursive: true, force: true });
+  });
+
+  test("stale .gsd dir at parent git root does not suppress inherited detection", () => {
+    // Simulate a stale .gsd directory at the parent git root (e.g. from a
+    // prior doctor run or accidental init). This is a real directory, NOT
+    // a symlink, and NOT the global GSD home.
+    mkdirSync(join(parentRepo, ".gsd"), { recursive: true });
+
+    const projectDir = join(parentRepo, "my-project");
+    mkdirSync(projectDir, { recursive: true });
+
+    // Without fix: isProjectGsd(join(root, ".gsd")) returns true because
+    // the stale .gsd is a real directory that isn't the global GSD home,
+    // causing isInheritedRepo to return false (false negative).
+    //
+    // The stale .gsd at parent is still treated as a "project .gsd" by
+    // isProjectGsd(), so the git root check at line 128 returns false.
+    // This is the expected behavior for that check — the defense-in-depth
+    // fix in auto-start.ts handles this case by checking for local .git.
+    //
+    // Verify the function behavior is consistent:
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      false,
+      "stale .gsd dir at git root still causes isInheritedRepo to return false " +
+      "(defense-in-depth in auto-start.ts handles this case)",
+    );
+  });
+
+  test("basePath's own .gsd symlink does not suppress inherited detection", () => {
+    // Create a project subdir with its own .gsd symlink (set up during
+    // the discuss phase, before auto-mode bootstrap runs).
+    const projectDir = join(parentRepo, "my-project");
+    mkdirSync(projectDir, { recursive: true });
+
+    const externalState = mkdtempSync(join(tmpdir(), "gsd-ext-state-"));
+    symlinkSync(externalState, join(projectDir, ".gsd"));
+
+    // Before fix: the walk-up loop started at normalizedBase (projectDir),
+    // found .gsd at projectDir, and returned false — even though projectDir
+    // has no .git of its own. The .gsd at basePath is irrelevant to whether
+    // the git repo is inherited from a parent.
+    //
+    // After fix: the walk-up starts at dirname(normalizedBase), skipping
+    // basePath's own .gsd.
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      true,
+      "project's own .gsd symlink must not suppress inherited repo detection",
+    );
+
+    rmSync(externalState, { recursive: true, force: true });
+  });
+});

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

@@ -61,6 +61,18 @@ test("plan-slice prompt: DB-backed tool names survive template substitution", ()
   assert.ok(result.includes("canonical write path"), "canonical write path language should survive substitution");
 });
 
+test("plan-slice prompt: footer references gsd_plan_slice tool, not direct write", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
+  assert.ok(
+    result.includes("MUST call `gsd_plan_slice`"),
+    "footer should instruct calling gsd_plan_slice tool",
+  );
+  assert.ok(
+    !result.includes("MUST write the file"),
+    "footer should not instruct direct file write",
+  );
+});
+
 test("domain-work prompts use skillActivation placeholder", () => {
   const prompts = [
     "research-milestone",
@@ -174,6 +186,34 @@ test("research-milestone prompt substitutes skillActivation", () => {
   assert.ok(!result.includes("{{skillActivation}}"));
 });
 
+test("research-milestone prompt references gsd_summary_save, not direct write", () => {
+  const result = loadPrompt("research-milestone", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    milestoneTitle: "Test Milestone",
+    milestonePath: ".gsd/milestones/M001",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
+    inlinedContext: "Context",
+    skillDiscoveryMode: "manual",
+    skillDiscoveryInstructions: " Discover skills manually.",
+    skillActivation: "Load research skills first.",
+  });
+
+  assert.ok(
+    result.includes("gsd_summary_save"),
+    "research-milestone should reference gsd_summary_save tool",
+  );
+  assert.ok(
+    result.includes('artifact_type: "RESEARCH"'),
+    "research-milestone should specify RESEARCH artifact type",
+  );
+  assert.ok(
+    !result.includes("MUST write the file"),
+    "research-milestone should not instruct direct file write",
+  );
+});
+
 test("research-slice prompt substitutes skillActivation", () => {
   const result = loadPrompt("research-slice", {
     workingDirectory: "/tmp/test-project",

package/src/resources/extensions/gsd/tests/preflight-context-draft-filter.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Regression test for #2473: Pre-flight CONTEXT-DRAFT warning should skip
+ * completed and parked milestones.
+ *
+ * The pre-flight loop in auto-start.ts warns about CONTEXT-DRAFT.md files
+ * so the user knows which milestones will pause for discussion. But completed
+ * milestones with leftover CONTEXT-DRAFT.md files are not actionable — the
+ * warning is noise.
+ *
+ * This test exercises the filtering logic directly: given a set of milestones
+ * with CONTEXT-DRAFT files, only active/pending ones should produce warnings.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  insertMilestone,
+  getMilestone,
+} from "../gsd-db.ts";
+import { resolveMilestoneFile } from "../paths.ts";
+
+describe("pre-flight CONTEXT-DRAFT filter (#2473)", () => {
+  let tmpBase: string;
+  let gsd: string;
+
+  beforeEach(() => {
+    tmpBase = mkdtempSync(join(tmpdir(), "gsd-preflight-draft-"));
+    gsd = join(tmpBase, ".gsd");
+
+    // Create milestone directories with CONTEXT-DRAFT files
+    for (const id of ["M001", "M002", "M003"]) {
+      const msDir = join(gsd, "milestones", id);
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(join(msDir, `${id}-CONTEXT-DRAFT.md`), `# ${id}: Draft\n`);
+    }
+
+    // Open DB and insert milestones with different statuses
+    const dbPath = join(gsd, "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Complete milestone", status: "complete" });
+    insertMilestone({ id: "M002", title: "Active milestone", status: "active" });
+    insertMilestone({ id: "M003", title: "Parked milestone", status: "parked" });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  test("completed milestone is skipped — no warning emitted", () => {
+    assert.ok(isDbAvailable(), "DB should be available");
+    const ms = getMilestone("M001");
+    assert.equal(ms?.status, "complete");
+  });
+
+  test("parked milestone is skipped — no warning emitted", () => {
+    const ms = getMilestone("M003");
+    assert.equal(ms?.status, "parked");
+  });
+
+  test("active milestone with CONTEXT-DRAFT produces warning", () => {
+    const ms = getMilestone("M002");
+    assert.equal(ms?.status, "active");
+
+    const draft = resolveMilestoneFile(tmpBase, "M002", "CONTEXT-DRAFT");
+    assert.ok(draft, "CONTEXT-DRAFT file should be found for active milestone");
+  });
+
+  test("full pre-flight filter produces warnings only for active milestones", () => {
+    const milestoneIds = ["M001", "M002", "M003"];
+    const issues: string[] = [];
+
+    for (const id of milestoneIds) {
+      // Replicate the fixed pre-flight logic from auto-start.ts
+      if (isDbAvailable()) {
+        const ms = getMilestone(id);
+        if (ms?.status === "complete" || ms?.status === "parked") continue;
+      }
+      const draft = resolveMilestoneFile(tmpBase, id, "CONTEXT-DRAFT");
+      if (draft) {
+        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+      }
+    }
+
+    assert.equal(issues.length, 1, "only one warning should be emitted");
+    assert.match(issues[0], /M002/, "warning should be for the active milestone only");
+  });
+
+  test("when DB is unavailable, all milestones with CONTEXT-DRAFT produce warnings (safe fallback)", () => {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), "DB should be unavailable after close");
+
+    const milestoneIds = ["M001", "M002", "M003"];
+    const issues: string[] = [];
+
+    for (const id of milestoneIds) {
+      if (isDbAvailable()) {
+        const ms = getMilestone(id);
+        if (ms?.status === "complete" || ms?.status === "parked") continue;
+      }
+      const draft = resolveMilestoneFile(tmpBase, id, "CONTEXT-DRAFT");
+      if (draft) {
+        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+      }
+    }
+
+    assert.equal(issues.length, 3, "all milestones should warn when DB is unavailable");
+  });
+});

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -228,6 +228,31 @@ test('(k) run-uat prompt template', () => {
   );
 });
 
+test('(k2) run-uat prompt references gsd_summary_save, not direct write', () => {
+  const promptResult = loadPromptFromWorktree('run-uat', {
+    workingDirectory: '/tmp/test-project',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
+    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+    uatType: 'artifact-driven',
+    inlinedContext: '<!-- no context -->',
+  });
+
+  assert.ok(
+    promptResult.includes('gsd_summary_save'),
+    'run-uat prompt should reference gsd_summary_save tool',
+  );
+  assert.ok(
+    promptResult.includes('artifact_type: "ASSESSMENT"'),
+    'run-uat prompt should specify ASSESSMENT artifact type',
+  );
+  assert.ok(
+    !promptResult.includes('MUST write'),
+    'run-uat prompt should not instruct direct file write in footer',
+  );
+});
+
 test('(l) dispatch preconditions via resolveSliceFile', () => {
     const base = createFixtureBase();
     const uatContent = makeUatContent('artifact-driven');