gsd-pi 2.29.0-dev.953d788 → 2.29.0-dev.f08b4fe

package/dist/resources/extensions/gsd/tests/mechanical-completion.test.ts

@@ -0,0 +1,356 @@
+/**
+ * Mechanical Completion — unit tests (ADR-003).
+ *
+ * Tests deterministic slice/milestone completion using fixture data.
+ * Uses node:test + node:assert for consistency with token-profile.test.ts.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+
+// ─── Fixture Helpers ──────────────────────────────────────────────────────────
+
+function createTmpBase(): string {
+  const base = join(tmpdir(), `gsd-mech-test-${randomBytes(4).toString("hex")}`);
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+
+function scaffold(base: string, mid: string, sid: string, taskSummaries: Array<{ tid: string; content: string }>) {
+  const gsdRoot = join(base, ".gsd");
+  const mDir = join(gsdRoot, "milestones", mid);
+  const sDir = join(mDir, "slices", sid);
+  const tDir = join(sDir, "tasks");
+  mkdirSync(tDir, { recursive: true });
+
+  for (const { tid, content } of taskSummaries) {
+    writeFileSync(join(tDir, `${tid}-SUMMARY.md`), content, "utf-8");
+  }
+
+  return { gsdRoot, mDir, sDir, tDir };
+}
+
+function makeTaskSummary(tid: string, opts: {
+  oneLiner?: string;
+  provides?: string[];
+  key_files?: string[];
+  key_decisions?: string[];
+  verification_result?: string;
+}): string {
+  const lines: string[] = [
+    "---",
+    `id: ${tid}`,
+    `parent: S01`,
+    `milestone: M001`,
+  ];
+  if (opts.provides?.length) lines.push(`provides:\n${opts.provides.map(p => `  - ${p}`).join("\n")}`);
+  if (opts.key_files?.length) lines.push(`key_files:\n${opts.key_files.map(f => `  - ${f}`).join("\n")}`);
+  if (opts.key_decisions?.length) lines.push(`key_decisions:\n${opts.key_decisions.map(d => `  - ${d}`).join("\n")}`);
+  lines.push(`verification_result: ${opts.verification_result ?? "passed"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${tid}: Test Task`);
+  lines.push("");
+  if (opts.oneLiner) lines.push(`**${opts.oneLiner}**`);
+  lines.push("");
+  lines.push("## What Happened");
+  lines.push("");
+  lines.push(`Implemented the feature described in ${tid}. This was a significant change that modified multiple files across the codebase to support the new functionality.`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ─── Source-level structural tests ────────────────────────────────────────────
+
+const mechanicalSrc = readFileSync(
+  join(import.meta.dirname!, "..", "mechanical-completion.ts"),
+  "utf-8",
+);
+
+test("mechanical-completion: exports mechanicalSliceCompletion", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function mechanicalSliceCompletion"),
+    "should export mechanicalSliceCompletion",
+  );
+});
+
+test("mechanical-completion: exports aggregateMilestoneVerification", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function aggregateMilestoneVerification"),
+    "should export aggregateMilestoneVerification",
+  );
+});
+
+test("mechanical-completion: exports generateMilestoneSummary", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function generateMilestoneSummary"),
+    "should export generateMilestoneSummary",
+  );
+});
+
+test("mechanical-completion: exports appendNewDecisions", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function appendNewDecisions"),
+    "should export appendNewDecisions",
+  );
+});
+
+test("mechanical-completion: uses atomicWriteSync for file writes", () => {
+  assert.ok(
+    mechanicalSrc.includes("atomicWriteSync"),
+    "should use atomicWriteSync for safe file writes",
+  );
+});
+
+test("mechanical-completion: quality gate checks summary length for multi-task slices", () => {
+  assert.ok(
+    mechanicalSrc.includes("totalContent.length < 200"),
+    "should have quality gate for summary content length",
+  );
+});
+
+test("mechanical-completion: marks slice [x] in roadmap", () => {
+  assert.ok(
+    mechanicalSrc.includes("markSliceInRoadmap"),
+    "should mark slice done in roadmap",
+  );
+});
+
+test("mechanical-completion: aggregates VERIFY.json files for milestone validation", () => {
+  assert.ok(
+    mechanicalSrc.includes("resolveTaskJsonFiles") && mechanicalSrc.includes("VERIFY"),
+    "should read VERIFY.json files for milestone validation",
+  );
+});
+
+test("mechanical-completion: deduplicates decisions against existing DECISIONS.md", () => {
+  assert.ok(
+    mechanicalSrc.includes("existing.includes(d.trim())"),
+    "should deduplicate decisions against existing content",
+  );
+});
+
+test("mechanical-completion: produces VALIDATION.md with verdict frontmatter", () => {
+  assert.ok(
+    mechanicalSrc.includes("verdict:") && mechanicalSrc.includes("remediation_round: 0"),
+    "VALIDATION.md should have verdict and remediation_round frontmatter",
+  );
+});
+
+// ─── Integration tests with fixture data ──────────────────────────────────────
+
+test("mechanical: slice completion with 2 task summaries produces SUMMARY.md", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+
+    // Scaffold task summaries
+    scaffold(base, mid, sid, [
+      {
+        tid: "T01",
+        content: makeTaskSummary("T01", {
+          oneLiner: "Set up project structure",
+          provides: ["project-scaffold"],
+          key_files: ["src/index.ts", "package.json"],
+          verification_result: "passed",
+        }),
+      },
+      {
+        tid: "T02",
+        content: makeTaskSummary("T02", {
+          oneLiner: "Add core API endpoints",
+          provides: ["api-endpoints"],
+          key_files: ["src/api.ts"],
+          key_decisions: ["Used Express over Fastify"],
+          verification_result: "passed",
+        }),
+      },
+    ]);
+
+    // Write a roadmap with the slice unchecked
+    const roadmapPath = join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`);
+    writeFileSync(roadmapPath, `# Roadmap\n\n- [ ] **${sid}: First Slice**\n`, "utf-8");
+
+    // Write a slice plan with Verification section
+    const planPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
+    writeFileSync(planPath, `# Plan\n\n## Verification\n\n- Run \`npm test\`\n- Check output\n`, "utf-8");
+
+    // Dynamic import to get the actual module
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+
+    assert.ok(ok, "should return true for valid slice completion");
+
+    // Check SUMMARY.md was written
+    const summaryPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-SUMMARY.md`);
+    assert.ok(existsSync(summaryPath), "SUMMARY.md should exist");
+
+    const summaryContent = readFileSync(summaryPath, "utf-8");
+    assert.ok(summaryContent.includes("T01"), "summary should reference T01");
+    assert.ok(summaryContent.includes("T02"), "summary should reference T02");
+    assert.ok(summaryContent.includes("verification_result: passed"), "should have passed verification");
+
+    // Check roadmap was updated
+    const updatedRoadmap = readFileSync(roadmapPath, "utf-8");
+    assert.ok(updatedRoadmap.includes("[x]"), "roadmap should have [x] checkbox");
+
+    // Check UAT was written
+    const uatPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-UAT.md`);
+    assert.ok(existsSync(uatPath), "UAT.md should exist");
+    const uatContent = readFileSync(uatPath, "utf-8");
+    assert.ok(uatContent.includes("npm test"), "UAT should contain verification content");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: returns false for empty task summaries", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    scaffold(base, mid, sid, []);
+
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+    assert.ok(!ok, "should return false when no summaries exist");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: returns false for insufficient summary content in multi-task slice", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+
+    // Two tasks but with very short content (under 200 chars)
+    scaffold(base, mid, sid, [
+      { tid: "T01", content: "---\nid: T01\nparent: S01\nmilestone: M001\n---\n\n# T01: A\n\n**Short**\n" },
+      { tid: "T02", content: "---\nid: T02\nparent: S01\nmilestone: M001\n---\n\n# T02: B\n\n**Brief**\n" },
+    ]);
+
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+    assert.ok(!ok, "should return false when summaries are too short");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: milestone verification aggregates VERIFY.json files", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    const { tDir } = scaffold(base, mid, sid, []);
+
+    // Write VERIFY.json files
+    const evidence = {
+      schemaVersion: 1,
+      taskId: "T01",
+      unitId: "M001/S01/T01",
+      timestamp: Date.now(),
+      passed: true,
+      discoverySource: "plan",
+      checks: [
+        { command: "npm test", exitCode: 0, durationMs: 1500, verdict: "pass", blocking: true },
+      ],
+    };
+    writeFileSync(join(tDir, "T01-VERIFY.json"), JSON.stringify(evidence), "utf-8");
+
+    const evidence2 = { ...evidence, taskId: "T02", passed: false, checks: [
+      { command: "npm test", exitCode: 1, durationMs: 500, verdict: "fail", blocking: true },
+    ]};
+    writeFileSync(join(tDir, "T02-VERIFY.json"), JSON.stringify(evidence2), "utf-8");
+
+    const { aggregateMilestoneVerification } = await import("../mechanical-completion.js");
+    const result = await aggregateMilestoneVerification(base, mid);
+
+    assert.equal(result.verdict, "mixed", "should be mixed when some pass and some fail");
+    assert.equal(result.checks.length, 2, "should have 2 checks");
+
+    // Check VALIDATION.md was written
+    const validationPath = join(base, ".gsd", "milestones", mid, `${mid}-VALIDATION.md`);
+    assert.ok(existsSync(validationPath), "VALIDATION.md should exist");
+    const validationContent = readFileSync(validationPath, "utf-8");
+    assert.ok(validationContent.includes("verdict: mixed"), "should have mixed verdict in frontmatter");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: milestone summary aggregates slice summaries", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+
+    // Create two slices with summaries
+    for (const sid of ["S01", "S02"]) {
+      const sDir = join(base, ".gsd", "milestones", mid, "slices", sid);
+      mkdirSync(sDir, { recursive: true });
+      writeFileSync(
+        join(sDir, `${sid}-SUMMARY.md`),
+        `---\nid: ${sid}\nprovides:\n  - feature-${sid.toLowerCase()}\nkey_files:\n  - src/${sid.toLowerCase()}.ts\n---\n\n# ${sid}: Slice\n\n**${sid} implemented**\n`,
+        "utf-8",
+      );
+    }
+
+    const { generateMilestoneSummary } = await import("../mechanical-completion.js");
+    const content = await generateMilestoneSummary(base, mid);
+
+    assert.ok(content.includes("S01"), "should reference S01");
+    assert.ok(content.includes("S02"), "should reference S02");
+    assert.ok(content.includes("feature-s01"), "should aggregate provides");
+    assert.ok(content.includes("feature-s02"), "should aggregate provides");
+
+    const summaryPath = join(base, ".gsd", "milestones", mid, `${mid}-SUMMARY.md`);
+    assert.ok(existsSync(summaryPath), "M##-SUMMARY.md should exist");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: decision deduplication skips existing decisions", async () => {
+  const base = createTmpBase();
+  try {
+    const gsdRoot = join(base, ".gsd");
+    mkdirSync(gsdRoot, { recursive: true });
+
+    // Write existing decisions
+    const decisionsPath = join(gsdRoot, "DECISIONS.md");
+    writeFileSync(decisionsPath, "# Decisions\n\n- Used TypeScript for type safety\n", "utf-8");
+
+    const { appendNewDecisions } = await import("../mechanical-completion.js");
+
+    // Call with one existing and one new decision
+    const mockSummaries = [
+      {
+        frontmatter: {
+          id: "T01", parent: "S01", milestone: "M001",
+          provides: [], requires: [], affects: [],
+          key_files: [], key_decisions: ["Used TypeScript for type safety", "Chose Express over Koa"],
+          patterns_established: [], drill_down_paths: [], observability_surfaces: [],
+          duration: "", verification_result: "passed", completed_at: "", blocker_discovered: false,
+        },
+        title: "T01", oneLiner: "", whatHappened: "", deviations: "", filesModified: [],
+      },
+    ];
+
+    await appendNewDecisions(base, mockSummaries as any);
+
+    const updated = readFileSync(decisionsPath, "utf-8");
+    assert.ok(updated.includes("Chose Express over Koa"), "should append new decision");
+    // The existing decision should not be duplicated
+    const matches = updated.match(/Used TypeScript for type safety/g);
+    assert.equal(matches?.length, 1, "should not duplicate existing decision");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/dist/resources/extensions/gsd/tests/parallel-workers-multi-milestone-e2e.test.ts

@@ -30,7 +30,7 @@ import {
   getBudgetAlertLevel,
   getNewBudgetAlertLevel,
   getBudgetEnforcementAction,
-} from '../auto.ts';
+} from '../auto-budget.ts';
 import {
   type UnitMetrics,
   type MetricsLedger,

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

@@ -25,6 +25,7 @@ const BASE_VARS = {
   outputPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/S01-PLAN.md",
   inlinedContext: "--- test inlined context ---",
   dependencySummaries: "", executorContextConstraints: "",
+  sourceFilePaths: "- **Requirements**: `.gsd/REQUIREMENTS.md`",
 };
 
 test("plan-slice prompt: commit step present when commit_docs=true", () => {

package/dist/resources/extensions/gsd/tests/token-profile.test.ts

@@ -53,6 +53,7 @@ test("types: PhaseSkipPreferences interface exported", () => {
   assert.ok(typesSrc.includes("skip_research"), "should include skip_research");
   assert.ok(typesSrc.includes("skip_reassess"), "should include skip_reassess");
   assert.ok(typesSrc.includes("skip_slice_research"), "should include skip_slice_research");
+  assert.ok(typesSrc.includes("reassess_after_slice"), "should include reassess_after_slice");
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -113,24 +114,21 @@ test("profile: budget profile sets phase skips to true", () => {
   assert.ok(budgetBlock.includes("skip_slice_research: true"), "budget should skip slice research");
 });
 
-test("profile: balanced profile skips only slice research", () => {
+test("profile: balanced profile skips research, reassess, and slice research (ADR-003)", () => {
   const balancedIdx = preferencesSrc.indexOf('case "balanced":');
   const qualityIdx = preferencesSrc.indexOf('case "quality":');
   const balancedBlock = preferencesSrc.slice(balancedIdx, qualityIdx);
   assert.ok(balancedBlock.includes("skip_slice_research: true"), "balanced should skip slice research");
-  assert.ok(!balancedBlock.includes("skip_research: true"), "balanced should NOT skip milestone research");
-  assert.ok(!balancedBlock.includes("skip_reassess: true"), "balanced should NOT skip reassess");
+  assert.ok(balancedBlock.includes("skip_research: true"), "balanced should skip milestone research");
+  assert.ok(balancedBlock.includes("skip_reassess: true"), "balanced should skip reassess");
 });
 
-test("profile: quality profile has empty phases (no skips)", () => {
+test("profile: quality profile skips research, slice research, and reassess (ADR-003)", () => {
   const qualityIdx = preferencesSrc.indexOf('case "quality":');
-  const qualityEnd = preferencesSrc.indexOf("}", qualityIdx + 50);
-  // Look for the return block after case "quality":
-  const qualityReturn = preferencesSrc.slice(qualityIdx, qualityIdx + 200);
-  assert.ok(
-    qualityReturn.includes("phases: {}"),
-    "quality should have empty phases object (no skips)",
-  );
+  const qualityBlock = preferencesSrc.slice(qualityIdx, qualityIdx + 300);
+  assert.ok(qualityBlock.includes("skip_research: true"), "quality should skip research");
+  assert.ok(qualityBlock.includes("skip_slice_research: true"), "quality should skip slice research");
+  assert.ok(qualityBlock.includes("skip_reassess: true"), "quality should skip reassess");
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -253,10 +251,10 @@ test("dispatch: research-slice rule has skip guards", () => {
   );
 });
 
-test("dispatch: reassess-roadmap rule has skip_reassess guard", () => {
+test("dispatch: reassess-roadmap rule has reassess_after_slice opt-in guard (ADR-003)", () => {
   assert.ok(
-    dispatchSrc.includes("skip_reassess") && dispatchSrc.includes("reassess-roadmap"),
-    "reassess-roadmap dispatch rule should check phases.skip_reassess",
+    dispatchSrc.includes("reassess_after_slice") && dispatchSrc.includes("reassess-roadmap"),
+    "reassess-roadmap dispatch rule should check phases.reassess_after_slice",
   );
 });
 
@@ -265,6 +263,6 @@ test("dispatch: phase skip guards return null (not stop)", () => {
   const researchGuard = dispatchSrc.match(/skip_research\).*?return null/s);
   assert.ok(researchGuard, "skip_research guard should return null (fall-through)");
 
-  const reassessGuard = dispatchSrc.match(/skip_reassess\).*?return null/s);
-  assert.ok(reassessGuard, "skip_reassess guard should return null (fall-through)");
+  const reassessGuard = dispatchSrc.match(/reassess_after_slice\).*?return null/s);
+  assert.ok(reassessGuard, "reassess_after_slice guard should return null (fall-through)");
 });

package/dist/resources/extensions/gsd/tests/workflow-templates.test.ts

@@ -0,0 +1,173 @@
+// GSD Workflow Templates — Unit Tests
+//
+// Tests registry loading, template resolution, auto-detection, and listing.
+
+import { createTestContext } from './test-helpers.ts';
+import {
+  loadRegistry,
+  resolveByName,
+  autoDetect,
+  listTemplates,
+  getTemplateInfo,
+  loadWorkflowTemplate,
+} from '../workflow-templates.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Registry Loading
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Registry Loading ──');
+
+{
+  const registry = loadRegistry();
+  assertTrue(registry !== null, 'Registry should load');
+  assertEq(registry.version, 1, 'Registry version should be 1');
+  assertTrue(Object.keys(registry.templates).length >= 8, 'Should have at least 8 templates');
+
+  // Verify required template keys exist
+  const expectedIds = ['full-project', 'bugfix', 'small-feature', 'refactor', 'spike', 'hotfix', 'security-audit', 'dep-upgrade'];
+  for (const id of expectedIds) {
+    assertTrue(id in registry.templates, `Template "${id}" should exist in registry`);
+  }
+
+  // Verify each template has required fields
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    assertTrue(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
+    assertTrue(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
+    assertTrue(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
+    assertTrue(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
+    assertTrue(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Resolve by Name
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Resolve by Name ──');
+
+{
+  // Exact match
+  const bugfix = resolveByName('bugfix');
+  assertTrue(bugfix !== null, 'Should resolve "bugfix"');
+  assertEq(bugfix!.id, 'bugfix', 'ID should be "bugfix"');
+  assertEq(bugfix!.confidence, 'exact', 'Exact name should have exact confidence');
+
+  // Case-insensitive name match
+  const spike = resolveByName('Research Spike');
+  assertTrue(spike !== null, 'Should resolve "Research Spike" by name');
+  assertEq(spike!.id, 'spike', 'Should resolve to spike');
+
+  // Alias match
+  const bug = resolveByName('bug');
+  assertTrue(bug !== null, 'Should resolve "bug" alias');
+  assertEq(bug!.id, 'bugfix', 'Alias "bug" should map to bugfix');
+
+  const feat = resolveByName('feat');
+  assertTrue(feat !== null, 'Should resolve "feat" alias');
+  assertEq(feat!.id, 'small-feature', 'Alias "feat" should map to small-feature');
+
+  const deps = resolveByName('deps');
+  assertTrue(deps !== null, 'Should resolve "deps" alias');
+  assertEq(deps!.id, 'dep-upgrade', 'Alias "deps" should map to dep-upgrade');
+
+  // No match
+  const missing = resolveByName('nonexistent-template');
+  assertTrue(missing === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Auto-Detection
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Auto-Detection ──');
+
+{
+  // Should detect bugfix from "fix" keyword
+  const fixMatches = autoDetect('fix the login button');
+  assertTrue(fixMatches.length > 0, 'Should detect matches for "fix the login button"');
+  assertTrue(fixMatches.some(m => m.id === 'bugfix'), 'Should include bugfix in matches');
+
+  // Should detect spike from "research" keyword
+  const researchMatches = autoDetect('research authentication libraries');
+  assertTrue(researchMatches.length > 0, 'Should detect matches for "research"');
+  assertTrue(researchMatches.some(m => m.id === 'spike'), 'Should include spike in matches');
+
+  // Should detect hotfix from "urgent" keyword
+  const urgentMatches = autoDetect('urgent production is down');
+  assertTrue(urgentMatches.length > 0, 'Should detect matches for "urgent"');
+  assertTrue(urgentMatches.some(m => m.id === 'hotfix'), 'Should include hotfix in matches');
+
+  // Should detect dep-upgrade from "upgrade" keyword
+  const upgradeMatches = autoDetect('upgrade react to v19');
+  assertTrue(upgradeMatches.length > 0, 'Should detect matches for "upgrade"');
+  assertTrue(upgradeMatches.some(m => m.id === 'dep-upgrade'), 'Should include dep-upgrade in matches');
+
+  // Multi-word triggers should score higher
+  const projectMatches = autoDetect('create a new project from scratch');
+  const projectMatch = projectMatches.find(m => m.id === 'full-project');
+  assertTrue(projectMatch !== undefined, 'Should detect full-project for "from scratch"');
+
+  // Empty input should return no matches
+  const emptyMatches = autoDetect('');
+  assertEq(emptyMatches.length, 0, 'Empty input should return no matches');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// List Templates
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── List Templates ──');
+
+{
+  const output = listTemplates();
+  assertTrue(output.includes('Workflow Templates'), 'Should have header');
+  assertTrue(output.includes('bugfix'), 'Should list bugfix');
+  assertTrue(output.includes('spike'), 'Should list spike');
+  assertTrue(output.includes('hotfix'), 'Should list hotfix');
+  assertTrue(output.includes('/gsd start'), 'Should include usage hint');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Template Info
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Template Info ──');
+
+{
+  const info = getTemplateInfo('bugfix');
+  assertTrue(info !== null, 'Should return info for bugfix');
+  assertTrue(info!.includes('Bug Fix'), 'Should include template name');
+  assertTrue(info!.includes('triage'), 'Should include phase names');
+  assertTrue(info!.includes('Triggers'), 'Should include triggers section');
+
+  const missing = getTemplateInfo('nonexistent');
+  assertTrue(missing === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Load Workflow Template Content
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Load Workflow Template ──');
+
+{
+  const content = loadWorkflowTemplate('bugfix');
+  assertTrue(content !== null, 'Should load bugfix template');
+  assertTrue(content!.includes('Bugfix Workflow'), 'Should contain workflow title');
+  assertTrue(content!.includes('Phase 1: Triage'), 'Should contain triage phase');
+  assertTrue(content!.includes('Phase 4: Ship'), 'Should contain ship phase');
+
+  const hotfixContent = loadWorkflowTemplate('hotfix');
+  assertTrue(hotfixContent !== null, 'Should load hotfix template');
+  assertTrue(hotfixContent!.includes('Hotfix Workflow'), 'Should contain hotfix title');
+
+  const missingContent = loadWorkflowTemplate('nonexistent');
+  assertTrue(missingContent === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/dist/resources/extensions/gsd/triage-resolution.ts

@@ -12,6 +12,7 @@
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
 import type { Classification, CaptureEntry } from "./captures.js";
 import {
   loadPendingCaptures,
@@ -36,7 +37,7 @@ export function executeInject(
 ): string | null {
   try {
     // Resolve the plan file path
-    const planPath = join(basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
+    const planPath = join(gsdRoot(basePath), "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
     if (!existsSync(planPath)) return null;
 
     const content = readFileSync(planPath, "utf-8");

package/dist/resources/extensions/gsd/types.ts

@@ -304,6 +304,8 @@ export interface PhaseSkipPreferences {
   skip_reassess?: boolean;
   skip_slice_research?: boolean;
   skip_milestone_validation?: boolean;
+  /** When true, reassess-roadmap fires after each slice completion. Opt-in. */
+  reassess_after_slice?: boolean;
   /** When true, auto-mode pauses before each slice for discussion (#789). */
   require_slice_discussion?: boolean;
 }