@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

package/src/resources/extensions/gsd/tests/forensics-tool-scope.test.ts

@@ -0,0 +1,69 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies /gsd forensics scopes issue-filing tools for its queued turn.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyForensicsToolScope,
+  buildForensicsToolingSection,
+  createForensicsToolScope,
+  restoreForensicsToolScope,
+} from "../forensics.ts";
+
+function tool(name: string): { name: string } {
+  return { name };
+}
+
+test("forensics adds registered filing tools for the queued turn and restores the prior tools", () => {
+  const originalTools = ["read"];
+  let activeTools = [...originalTools];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "bash", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.savedTools, originalTools);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "bash", "write"]);
+  assert.deepEqual(scope.availableFilingTools, ["bash", "write"]);
+  assert.deepEqual(scope.missingFilingTools, []);
+  assert.equal(scope.toolsChanged, true);
+  assert.deepEqual(activeTools, originalTools, "scope creation must not mutate active tools");
+
+  applyForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, ["read", "bash", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: available/);
+  assert.match(toolingSection, /`write`: available/);
+  assert.match(toolingSection, /GitHub duplicate-check and issue-creation protocols/);
+
+  restoreForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, originalTools);
+});
+
+test("forensics tooling guidance falls back when bash is not registered", () => {
+  let activeTools = ["read"];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.availableFilingTools, ["write"]);
+  assert.deepEqual(scope.missingFilingTools, ["bash"]);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: unavailable/);
+  assert.match(toolingSection, /paste-once shell script fallback/);
+});

package/src/resources/extensions/gsd/tests/gsd-rebuild.test.ts

@@ -0,0 +1,199 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handleRebuild } from "../commands-maintenance.ts";
+import {
+  closeDatabase,
+  getTask,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+type Note = { message: string; kind: string };
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-rebuild-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), {
+    recursive: true,
+  });
+  return base;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  invalidateStateCache();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function makeCtx(): { ctx: any; notes: Note[] } {
+  const notes: Note[] = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+      },
+    },
+    notes,
+  };
+}
+
+function seedOpenTask(): void {
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Slice",
+    status: "in_progress",
+    risk: "low",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task",
+    status: "pending",
+  });
+}
+
+function listFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else {
+        out.push(full);
+      }
+    }
+  }
+  return out.sort();
+}
+
+test("handleRebuild quarantines stale completion projections without mutating DB state", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nDisk-only completion.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "markdown");
+
+    assert.equal(existsSync(summaryPath), false, "stale SUMMARY projection should be moved aside");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "DB task status remains authoritative");
+    assert.equal(task?.full_summary_md, "", "disk summary must not be imported into DB");
+
+    const quarantined = listFiles(join(base, ".gsd", "quarantine", "projections"));
+    assert.equal(quarantined.length, 1);
+    assert.match(readFileSync(quarantined[0]!, "utf-8"), /Disk-only completion/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+1/);
+    assert.equal(notes.at(-1)?.kind, "success");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild re-renders missing task summary projections from DB", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task",
+      status: "complete",
+      oneLiner: "Task complete",
+      narrative: "Finished through the DB.",
+      verificationResult: "passed",
+      fullSummaryMd: "# T01 Summary\n\nRendered from DB.\n",
+    });
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    rmSync(summaryPath, { force: true });
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base);
+
+    assert.equal(existsSync(summaryPath), true, "missing SUMMARY projection should be regenerated");
+    assert.equal(readFileSync(summaryPath, "utf-8"), "# T01 Summary\n\nRendered from DB.\n");
+    assert.match(notes.at(-1)?.message ?? "", /rebuilt markdown projections from the canonical DB/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+0/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild database target is reserved and does not import markdown", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nShould not import.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "database");
+
+    assert.equal(existsSync(summaryPath), true, "reserved DB rebuild must not move projection files");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "reserved DB rebuild must not mutate task status");
+    assert.equal(task?.full_summary_md, "", "reserved DB rebuild must not import markdown");
+    assert.match(notes.at(-1)?.message ?? "", /reserved/);
+    assert.match(notes.at(-1)?.message ?? "", /\/gsd recover --confirm/);
+    assert.equal(notes.at(-1)?.kind, "warning");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/gsd-recover.test.ts

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
 import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import { handleRecover } from '../commands-maintenance.ts';
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -42,6 +43,22 @@ function cleanup(base: string): void {
   rmSync(base, { recursive: true, force: true });
 }
 
+function makeCtx(confirm?: () => Promise<boolean>): {
+  ctx: any;
+  notes: Array<{ message: string; kind: string }>;
+} {
+  const notes: Array<{ message: string; kind: string }> = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+        ...(confirm ? { confirm: async () => confirm() } : {}),
+      },
+    },
+    notes,
+  };
+}
+
 // ─── Fixture Content ──────────────────────────────────────────────────────
 
 const ROADMAP_M001 = `# M001: Recovery Test
@@ -437,4 +454,62 @@ describe('gsd-recover', async () => {
       cleanup(base);
     }
   });
+
+  test('handleRecover warns and does not import markdown without confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is unconfirmed');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported without confirmation');
+      assert.equal(notes.at(-1)?.kind, 'warning');
+      assert.match(notes.at(-1)?.message ?? '', /\/gsd recover --confirm/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover interactive cancellation leaves DB unchanged', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx(async () => false);
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is cancelled');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported after cancellation');
+      assert.match(notes.at(-1)?.message ?? '', /cancelled/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover imports markdown after explicit confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base, '--confirm');
+
+      assert.equal(getMilestone('M999'), null, 'confirmed recover clears old hierarchy rows');
+      assert.ok(getMilestone('M001'), 'confirmed recover imports markdown hierarchy');
+      assert.equal(notes.at(-1)?.kind, 'success');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
 });

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

@@ -3,10 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VISION_ASK_VARIANTS } from "../vision-ask.ts";
+import { buildDiscussMilestonePrompt } from "../auto-prompts.ts";
 
 test("guided milestone prompt renders compact interview and context guidance", async (t) => {
   const previousGsdHome = process.env.GSD_HOME;
@@ -47,3 +48,41 @@ test("guided milestone prompt renders compact interview and context guidance", a
   assert.match(prompt, /milestone_id: M001/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });
+
+test("guided milestone prompt builder preloads milestone planning context", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-context-"));
+  try {
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    const priorDir = join(milestonesRoot, "M001");
+    const currentDir = join(milestonesRoot, "M002");
+    const futureDir = join(milestonesRoot, "M003");
+    mkdirSync(priorDir, { recursive: true });
+    mkdirSync(currentDir, { recursive: true });
+    mkdirSync(futureDir, { recursive: true });
+
+    writeFileSync(join(base, ".gsd", "DECISIONS.md"), "# Decisions\n\nDECISION-SIGNAL", "utf-8");
+    writeFileSync(join(priorDir, "M001-SUMMARY.md"), "# M001 Summary\n\nPRIOR-SUMMARY-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-ROADMAP.md"), "# M002 Roadmap\n\nROADMAP-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-CONTEXT.md"), "# M002 Context\n\nCONTEXT-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-RESEARCH.md"), "# M002 Research\n\nRESEARCH-SIGNAL", "utf-8");
+    writeFileSync(join(futureDir, "M003-SUMMARY.md"), "# M003 Summary\n\nFUTURE-SUMMARY-SIGNAL", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M002", "Checkout Polish", base, "true");
+
+    assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+    assert.match(prompt, /### Milestone Roadmap/);
+    assert.match(prompt, /ROADMAP-SIGNAL/);
+    assert.match(prompt, /### Milestone Context/);
+    assert.match(prompt, /CONTEXT-SIGNAL/);
+    assert.match(prompt, /### Milestone Research/);
+    assert.match(prompt, /RESEARCH-SIGNAL/);
+    assert.match(prompt, /### Decisions Register/);
+    assert.match(prompt, /DECISION-SIGNAL/);
+    assert.match(prompt, /### M001 Prior Milestone Summary/);
+    assert.match(prompt, /PRIOR-SUMMARY-SIGNAL/);
+    assert.doesNotMatch(prompt, /FUTURE-SUMMARY-SIGNAL/);
+    assert.match(prompt, /### Output Template: Context/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -104,3 +104,89 @@ test("guided dispatch passes the explicit project root through model and compati
     rmSync(otherRoot, { recursive: true, force: true });
   }
 });
+
+test("guided dispatch accepts workflow MCP tools absent from parent active tool surface", async () => {
+  const explicitRoot = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-surface-"));
+  const workflowPath = join(explicitRoot, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalMcpCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+  const notifications: string[] = [];
+  let sent = false;
+
+  const ctx = {
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+    },
+    ui: {
+      notify: (message: string) => {
+        notifications.push(message);
+      },
+    },
+  };
+
+  let activeTools = [
+    "ScheduleWakeup",
+    "ToolSearch",
+    "ask_user_questions",
+    "bash",
+    "read",
+    "write",
+  ];
+
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+    sendMessage: () => {
+      sent = true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Discuss the milestone.",
+      "gsd-discuss",
+      ctx as any,
+      "discuss-milestone",
+      {
+        basePath: explicitRoot,
+        deps: {
+          loadPreferences: () => ({ preferences: {} }) as any,
+          selectModel: (async () => ({
+            routing: null,
+            appliedModel: {
+              provider: "claude-code",
+              id: "claude-opus-4-8",
+              baseUrl: "local://claude-code",
+            },
+          })) as any,
+        },
+      },
+    );
+
+    assert.equal(sent, true);
+    assert.equal(
+      notifications.some((message) => message.includes("cannot run guided flow")),
+      false,
+    );
+  } finally {
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    if (originalMcpCommand === undefined) {
+      delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+    } else {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = originalMcpCommand;
+    }
+    rmSync(explicitRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -8,14 +8,17 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
-  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
 
-  assert.equal(calls.length, 8, "all guided-flow guided-discuss-milestone callsites should be covered");
-  for (const call of calls) {
-    assert.match(
-      call[1] ?? "",
-      /\bworkingDirectory:\s*basePath\b/,
-      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
-    );
-  }
+  // All guided-discuss-milestone dispatches now go through buildDiscussMilestonePrompt,
+  // which centralises the loadPrompt call and always passes workingDirectory.
+  // Verify no callsite bypasses the builder by calling loadPrompt directly.
+  const directCalls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone"/g)];
+  assert.equal(
+    directCalls.length,
+    0,
+    'guided-flow.ts must not call loadPrompt("guided-discuss-milestone") directly — use buildDiscussMilestonePrompt',
+  );
+
+  const calls = [...source.matchAll(/\bawait buildDiscussMilestonePrompt\(/g)];
+  assert.equal(calls.length, 9, "all guided-flow guided-discuss-milestone callsites should be covered");
 });

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -119,8 +119,8 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 // ─── run-uat artifact path contract (#2873) ──────────────────────────────
 
 test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
-  // The run-uat prompt instructs the agent to call gsd_summary_save with
-  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
+  // The run-uat prompt instructs the agent to call gsd_uat_result_save, which
+  // writes S##-ASSESSMENT.md through the workflow persistence path. The artifact
   // verification path must match — otherwise verification fails and auto-mode
   // retries the unit in an infinite loop.
   const base = makeTmpBase();
@@ -147,12 +147,12 @@ test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) =
 });
 
 test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
-  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
+  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_uat_result_save,
   // but verification looked for S##-UAT.md, causing false stuck retries.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
+  // Write the ASSESSMENT file (what gsd_uat_result_save actually produces)
   const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
   writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");