gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.ffbcc03

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Regression tests for PR #4288 — auto-retry bug, .mcp.json churn, and MCP
+ * worktree routing fixes.
+ *
+ * Covers four source-file changes:
+ *   1. src/resources/extensions/gsd/safety/evidence-collector.ts (functional)
+ *   2. src/resources/extensions/gsd/bootstrap/register-hooks.ts (source shape)
+ *   3. src/resources/extensions/gsd/auto-recovery.ts (source shape)
+ *   4. packages/mcp-server/src/workflow-tools.ts (source shape)
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  resetEvidence,
+  getEvidence,
+  recordToolCall,
+  recordToolResult,
+  type BashEvidence,
+} from "../safety/evidence-collector.js";
+
+// ─── 1. evidence-collector: functional ─────────────────────────────────────
+
+describe("evidence-collector: toolCallId-based matching (A-3)", () => {
+  beforeEach(() => {
+    resetEvidence();
+  });
+
+  it("records bash calls with their toolCallId at dispatch time", () => {
+    recordToolCall("tc-1", "bash", { command: "ls -la" });
+    recordToolCall("tc-2", "bash", { command: "git status" });
+
+    const entries = getEvidence();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].toolCallId, "tc-1");
+    assert.equal(entries[1].toolCallId, "tc-2");
+  });
+
+  it("matches results to the correct entry by toolCallId, not insertion order", () => {
+    // Simulate two parallel bash calls dispatched in order tc-1, tc-2.
+    recordToolCall("tc-1", "bash", { command: "slow-thing" });
+    recordToolCall("tc-2", "bash", { command: "fast-thing" });
+
+    // Results arrive out of order: tc-2 first (fast), then tc-1 (slow).
+    // With the old empty-string-matching strategy, tc-2's result would be
+    // stapled to tc-1's entry because findLastUnresolved scanned backwards
+    // for empty ids. Now we match by id directly.
+    recordToolResult("tc-2", "bash", "Command exited with code 0\nfast-output", false);
+    recordToolResult("tc-1", "bash", "Command exited with code 1\nslow-failure", true);
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    const tc1 = entries.find(e => e.toolCallId === "tc-1") as BashEvidence | undefined;
+    const tc2 = entries.find(e => e.toolCallId === "tc-2") as BashEvidence | undefined;
+
+    assert.ok(tc1, "tc-1 entry must exist");
+    assert.ok(tc2, "tc-2 entry must exist");
+
+    // The original command stays attached to the entry it was recorded with,
+    // and the result matches the id it was reported for.
+    assert.equal(tc1.command, "slow-thing");
+    assert.equal(tc1.exitCode, 1);
+    assert.ok(tc1.outputSnippet.includes("slow-failure"));
+
+    assert.equal(tc2.command, "fast-thing");
+    assert.equal(tc2.exitCode, 0);
+    assert.ok(tc2.outputSnippet.includes("fast-output"));
+  });
+
+  it("ignores results with unknown toolCallIds rather than corrupting nearby entries", () => {
+    recordToolCall("tc-1", "bash", { command: "real" });
+    recordToolResult("tc-UNKNOWN", "bash", "Command exited with code 0\n", false);
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].toolCallId, "tc-1");
+    // tc-1 must be untouched — no result was reported for it.
+    assert.equal(entries[0].exitCode, -1);
+    assert.equal(entries[0].outputSnippet, "");
+  });
+
+  it("records write/edit entries with their toolCallId", () => {
+    recordToolCall("tc-write", "write", { file_path: "/tmp/a.md" });
+    recordToolCall("tc-edit", "edit", { file_path: "/tmp/b.md" });
+
+    const entries = getEvidence();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].kind, "write");
+    assert.equal(entries[0].toolCallId, "tc-write");
+    assert.equal(entries[1].kind, "edit");
+    assert.equal(entries[1].toolCallId, "tc-edit");
+  });
+});
+
+// ─── 2. register-hooks: MCP auto-prep gated inside auto-worktrees (A-1) ────
+
+describe("register-hooks: skip prepareWorkflowMcpForProject inside auto-worktrees (A-1)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "bootstrap", "register-hooks.ts"),
+    "utf-8",
+  );
+
+  it("session_start hook is gated on isInAutoWorktree", () => {
+    const idx = src.indexOf('pi.on("session_start"');
+    assert.ok(idx !== -1, "session_start handler must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("isInAutoWorktree"),
+      "session_start must consult isInAutoWorktree before preparing MCP",
+    );
+    assert.ok(
+      block.includes("prepareWorkflowMcpForProject"),
+      "session_start still prepares MCP for non-worktree paths",
+    );
+  });
+
+  it("session_switch hook is gated on isInAutoWorktree", () => {
+    const idx = src.indexOf('pi.on("session_switch"');
+    assert.ok(idx !== -1, "session_switch handler must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("isInAutoWorktree"),
+      "session_switch must consult isInAutoWorktree before preparing MCP",
+    );
+  });
+
+  it("tool_call hook forwards event.toolCallId into safetyRecordToolCall (A-3)", () => {
+    // Find the call site (skip the import line by looking for the opening paren).
+    const idx = src.indexOf("safetyRecordToolCall(");
+    assert.ok(idx !== -1, "safetyRecordToolCall call must exist");
+    const line = src.slice(idx, src.indexOf("\n", idx));
+    assert.ok(
+      line.includes("event.toolCallId"),
+      "safetyRecordToolCall must receive event.toolCallId as the first argument",
+    );
+  });
+});
+
+// ─── 3. auto-recovery: verify-fail instrumentation ─────────────────────────
+
+describe("verifyExpectedArtifact: verify-fail exit-point logging (Phase B diag)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "auto-recovery.ts"),
+    "utf-8",
+  );
+
+  it("logs a verify-fail warning on the null-absPath exit", () => {
+    assert.ok(
+      src.includes('verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null'),
+      "null-absPath branch must emit a diagnostic line",
+    );
+  });
+
+  it("logs a verify-fail warning on the existsSync-false exit", () => {
+    assert.ok(
+      src.includes("verify-fail ${unitType} ${unitId}: existsSync false"),
+      "existsSync-false branch must emit a diagnostic line",
+    );
+  });
+
+  it("logs a verify-fail warning on the plan-slice no-task-entry exit", () => {
+    assert.ok(
+      src.includes("verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading"),
+      "plan-slice no-task branch must emit a diagnostic line",
+    );
+  });
+
+  it("plan-slice task-plan-files check fails fast on missing tasks dir (hardening)", () => {
+    // The original check silently passed when resolveTasksDir returned null.
+    // The new check returns false with a diagnostic, which is correct — if
+    // the tool successfully planned tasks, the tasks/ dir must exist.
+    const idx = src.indexOf('verify-fail ${unitType} ${unitId}: resolveTasksDir returned null');
+    assert.ok(
+      idx !== -1,
+      "resolveTasksDir-null branch must emit a diagnostic and return false",
+    );
+  });
+});
+
+// ─── 4. workflow-tools (mcp-server): guard + optional projectDir + routing ─
+
+describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "packages", "mcp-server", "src", "workflow-tools.ts"),
+    "utf-8",
+  );
+
+  it("projectDirParam is optional and documents the default", () => {
+    const idx = src.indexOf("const projectDirParam");
+    assert.ok(idx !== -1, "projectDirParam definition must exist");
+    const block = src.slice(idx, idx + 600);
+    assert.ok(
+      block.includes(".optional()"),
+      "projectDirParam must be optional so the agent stops deliberating",
+    );
+    assert.ok(
+      /Omit this field/i.test(block),
+      "description must tell the agent to omit the field",
+    );
+  });
+
+  it("parseWorkflowArgs defaults projectDir to process.cwd() when omitted", () => {
+    const idx = src.indexOf("function parseWorkflowArgs");
+    assert.ok(idx !== -1, "parseWorkflowArgs must exist");
+    const block = src.slice(idx, idx + 1500);
+    assert.ok(
+      block.includes("parsed.projectDir ?? process.cwd()"),
+      "parseWorkflowArgs must fall back to process.cwd() when projectDir is omitted",
+    );
+  });
+
+  it("validateProjectDir accepts external-state worktree paths via .gsd symlink target", () => {
+    const idx = src.indexOf("function validateProjectDir");
+    assert.ok(idx !== -1, "validateProjectDir must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("resolveExternalStateRoot"),
+      "validateProjectDir must consult resolveExternalStateRoot for external-state layouts",
+    );
+
+    const helperIdx = src.indexOf("function resolveExternalStateRoot");
+    assert.ok(helperIdx !== -1, "resolveExternalStateRoot helper must exist");
+    const helperBlock = src.slice(helperIdx, helperIdx + 600);
+    assert.ok(
+      helperBlock.includes("realpathSync"),
+      "resolveExternalStateRoot must use realpathSync to follow the symlink",
+    );
+    assert.ok(
+      /join\([^)]*\.gsd/.test(helperBlock),
+      "resolveExternalStateRoot must resolve <allowedRoot>/.gsd",
+    );
+  });
+
+  it("parseWorkflowArgs routes tool writes to the active worktree when one exists", () => {
+    // This is the Phase B root-cause fix: when the tool call is scoped to a
+    // milestone that has an auto-worktree at <projectRoot>/.gsd/worktrees/<MID>/,
+    // tool writes must go to the worktree .gsd rather than the shared project .gsd.
+    const parseIdx = src.indexOf("function parseWorkflowArgs");
+    const parseBlock = src.slice(parseIdx, parseIdx + 2500);
+    assert.ok(
+      parseBlock.includes("resolveActiveWorktreeBasePath"),
+      "parseWorkflowArgs must consult resolveActiveWorktreeBasePath",
+    );
+    assert.ok(
+      parseBlock.includes("extractMilestoneId"),
+      "parseWorkflowArgs must extract the milestoneId to locate the worktree",
+    );
+  });
+
+  it("resolveActiveWorktreeBasePath checks .git presence to avoid hijacking stray directories", () => {
+    const idx = src.indexOf("function resolveActiveWorktreeBasePath");
+    assert.ok(idx !== -1, "resolveActiveWorktreeBasePath helper must exist");
+    const block = src.slice(idx, idx + 1200);
+    assert.ok(
+      block.includes('existsSync(join(wtPath, ".git"))'),
+      "resolveActiveWorktreeBasePath must verify a .git file exists in the worktree",
+    );
+  });
+
+  it("extractMilestoneId handles camelCase, snake_case, and short aliases", () => {
+    const idx = src.indexOf("function extractMilestoneId");
+    assert.ok(idx !== -1, "extractMilestoneId helper must exist");
+    const block = src.slice(idx, idx + 600);
+    assert.ok(block.includes("milestoneId"), "must check milestoneId");
+    assert.ok(block.includes("milestone_id"), "must check milestone_id");
+    assert.ok(block.includes("mid"), "must check mid");
+  });
+});

package/src/resources/extensions/gsd/tests/cold-resume-db-reopen.test.ts

@@ -25,8 +25,12 @@ console.log("\n=== resume path refreshes resources and opens DB before rebuildSt
 const resumeSectionStart = autoSrc.indexOf("if (s.paused) {", autoSrc.indexOf("// If resuming from paused state"));
 assertTrue(resumeSectionStart > 0, "auto.ts has the paused-session resume block");
 
-const resumeSectionEnd = autoSrc.indexOf("await autoLoop(", resumeSectionStart);
-assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches autoLoop");
+const resumeSectionEndCandidates = [
+  autoSrc.indexOf("await runAutoLoopWithUok(", resumeSectionStart),
+  autoSrc.indexOf("await autoLoop(", resumeSectionStart),
+].filter((idx) => idx > resumeSectionStart);
+const resumeSectionEnd = resumeSectionEndCandidates.length > 0 ? Math.min(...resumeSectionEndCandidates) : -1;
+assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches the dispatch loop");
 
 const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionEnd);
 

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

@@ -0,0 +1,340 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  parseExtractLearningsArgs,
+  buildLearningsOutputPath,
+  resolvePhaseArtifacts,
+  buildExtractLearningsPrompt,
+  buildFrontmatter,
+  extractProjectName,
+} from "../commands-extract-learnings.js";
+
+// ─── parseExtractLearningsArgs ────────────────────────────────────────────────
+
+describe("parseExtractLearningsArgs", () => {
+  it("parses a milestone ID", () => {
+    const result = parseExtractLearningsArgs("M001");
+    assert.deepEqual(result, { milestoneId: "M001" });
+  });
+
+  it("returns null milestoneId for empty string", () => {
+    const result = parseExtractLearningsArgs("");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("returns null milestoneId for whitespace-only string", () => {
+    const result = parseExtractLearningsArgs("  ");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("trims whitespace from milestone ID", () => {
+    const result = parseExtractLearningsArgs("  M002  ");
+    assert.deepEqual(result, { milestoneId: "M002" });
+  });
+});
+
+// ─── buildLearningsOutputPath ─────────────────────────────────────────────────
+
+describe("buildLearningsOutputPath", () => {
+  it("builds the correct output path", () => {
+    const result = buildLearningsOutputPath("/base/.gsd/milestones/M001", "M001");
+    assert.equal(result, "/base/.gsd/milestones/M001/M001-LEARNINGS.md");
+  });
+
+  it("builds path for different milestone ID", () => {
+    const result = buildLearningsOutputPath("/project/.gsd/milestones/M005", "M005");
+    assert.equal(result, "/project/.gsd/milestones/M005/M005-LEARNINGS.md");
+  });
+});
+
+// ─── resolvePhaseArtifacts ────────────────────────────────────────────────────
+
+describe("resolvePhaseArtifacts", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-learnings-test-${randomUUID()}`);
+    mkdirSync(tmpBase, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("finds required PLAN and SUMMARY when both present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# M001 Plan content", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# M001 Summary content", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.plan, join(tmpBase, "M001-PLAN.md"));
+    assert.equal(result.summary, join(tmpBase, "M001-SUMMARY.md"));
+    assert.deepEqual(result.missingRequired, []);
+  });
+
+  it("reports missing PLAN as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.equal(result.plan, null);
+  });
+
+  it("reports missing SUMMARY as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+    assert.equal(result.summary, null);
+  });
+
+  it("reports both required files missing when neither present", () => {
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.missingRequired.length, 2);
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+  });
+
+  it("finds optional VERIFICATION when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-VERIFICATION.md"), "# Verification", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, join(tmpBase, "M001-VERIFICATION.md"));
+  });
+
+  it("returns null for optional VERIFICATION when absent", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, null);
+  });
+
+  it("finds optional UAT when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-UAT.md"), "# UAT", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, join(tmpBase, "M001-UAT.md"));
+  });
+
+  it("returns null for optional UAT when absent, no error", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, null);
+    assert.deepEqual(result.missingRequired, []);
+  });
+});
+
+// ─── buildExtractLearningsPrompt ──────────────────────────────────────────────
+
+describe("buildExtractLearningsPrompt", () => {
+  it("includes milestoneId and outputPath", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/project/.gsd/milestones/M001/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan content",
+      summaryContent: "# Summary content",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("/project/.gsd/milestones/M001/M001-LEARNINGS.md"));
+  });
+
+  it("includes all 4 learning categories", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("Decisions"));
+    assert.ok(result.includes("Lessons"));
+    assert.ok(result.includes("Patterns"));
+    assert.ok(result.includes("Surprises"));
+  });
+
+  it("includes plan and summary content", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "PLAN_CONTENT_UNIQUE_123",
+      summaryContent: "SUMMARY_CONTENT_UNIQUE_456",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("PLAN_CONTENT_UNIQUE_123"));
+    assert.ok(result.includes("SUMMARY_CONTENT_UNIQUE_456"));
+  });
+
+  it("includes optional artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: "VERIFICATION_UNIQUE_789",
+      uatContent: "UAT_UNIQUE_012",
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("VERIFICATION_UNIQUE_789"));
+    assert.ok(result.includes("UAT_UNIQUE_012"));
+  });
+
+  it("lists missing artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: ["M001-VERIFICATION.md"],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+  });
+});
+
+// ─── buildFrontmatter ─────────────────────────────────────────────────────────
+
+describe("buildFrontmatter", () => {
+  it("starts with --- and ends with ---", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.startsWith("---\n"));
+    assert.ok(result.endsWith("---"));
+  });
+
+  it("includes required fields", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 3, lessons: 2, patterns: 1, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("phase:"));
+    assert.ok(result.includes("phase_name:"));
+    assert.ok(result.includes("project:"));
+    assert.ok(result.includes("generated:"));
+    assert.ok(result.includes("counts:"));
+    assert.ok(result.includes("missing_artifacts:"));
+  });
+
+  it("includes milestoneId as phase value", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Auth System",
+      projectName: "MyApp",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("Auth System"));
+    assert.ok(result.includes("MyApp"));
+    assert.ok(result.includes("2026-04-15T10:00:00Z"));
+  });
+
+  it("includes missing artifacts list", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test",
+      projectName: "Proj",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: ["M001-VERIFICATION.md", "M001-UAT.md"],
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+    assert.ok(result.includes("M001-UAT.md"));
+  });
+});
+
+// ─── extractProjectName ───────────────────────────────────────────────────────
+
+describe("extractProjectName", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-projname-test-${randomUUID()}`);
+    mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("reads name from PROJECT.md frontmatter", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nname: My Cool Project\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, "My Cool Project");
+  });
+
+  it("falls back to directory name when PROJECT.md absent", () => {
+    const result = extractProjectName(tmpBase);
+    // Should return the last path segment of tmpBase
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+
+  it("falls back to directory name when PROJECT.md has no name field", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+});

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

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

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

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(