gsd-pi 2.24.0 → 2.26.0

package/src/resources/extensions/gsd/prompts/discuss-headless.md

@@ -51,11 +51,11 @@ Use these templates exactly:
 5. Write `{{roadmapPath}}` (using Roadmap template) — decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice.
 6. Seed `.gsd/DECISIONS.md` (using Decisions template)
 7. Update `.gsd/STATE.md`
-8. Commit: `docs({{milestoneId}}): context, requirements, and roadmap`
+8. {{commitInstruction}}
 9. Say exactly: "Milestone {{milestoneId}} ready."
 
 **For multi-milestone**, write in this order:
-1. Create all milestone directories: `mkdir -p .gsd/milestones/{M###}/slices` for each
+1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices` for each.
 2. Write `.gsd/PROJECT.md` — full vision across ALL milestones (using Project template)
 3. Write `.gsd/REQUIREMENTS.md` — full capability contract (using Requirements template)
 4. Seed `.gsd/DECISIONS.md` (using Decisions template)
@@ -71,7 +71,7 @@ Use these templates exactly:
    ```
    Each context file should be rich enough that a future agent — with no memory of this conversation — can understand the intent, constraints, dependencies, what the milestone unlocks, and what "done" looks like.
 8. Update `.gsd/STATE.md`
-9. Commit: `docs: project plan — N milestones`
+9. {{multiMilestoneCommitInstruction}}
 10. Say exactly: "Milestone {{milestoneId}} ready."
 
 ## Critical Rules
@@ -82,5 +82,5 @@ Use these templates exactly:
 - **Investigate before writing** — always scout the codebase first
 - **Use depends_on frontmatter** for multi-milestone sequences (the state machine reads this field to determine execution order)
 - **Anti-reduction rule** — if the spec describes a big vision, plan the big vision. Do not ask "what's the minimum viable version?" or reduce scope. Phase complex/risky work into later milestones — do not cut it.
-- **Naming convention** — directories use bare IDs (`M001/`, `S01/`), files use ID-SUFFIX format (`M001-CONTEXT.md`, `M001-ROADMAP.md`)
+- **Naming convention** — always use `gsd_generate_milestone_id` to get milestone IDs. Directories use bare IDs (e.g. `M001/` or `M001-r5jzab/`), files use ID-SUFFIX format (e.g. `M001-CONTEXT.md` or `M001-r5jzab-CONTEXT.md`). Never invent milestone IDs manually.
 - **End with "Milestone {{milestoneId}} ready."** — this triggers auto-start detection

package/src/resources/extensions/gsd/prompts/discuss.md

@@ -201,9 +201,9 @@ When writing context.md, preserve the user's exact terminology, emphasis, and sp
 5. Write `{{roadmapPath}}` — use the **Roadmap** output template below. Decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment.
 6. Seed `.gsd/DECISIONS.md` — use the **Decisions** output template below. Append rows for any architectural or pattern decisions made during discussion.
 7. Update `.gsd/STATE.md`
-8. Commit: `docs({{milestoneId}}): context, requirements, and roadmap`
+8. {{commitInstruction}}
 
-After writing the files and committing, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
 
@@ -211,7 +211,7 @@ Once the user confirms the milestone split:
 
 #### Phase 1: Shared artifacts
 
-1. `mkdir -p .gsd/milestones/{{milestoneId}}/slices` for each milestone
+1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/PROJECT.md` — use the **Project** output template below.
 3. Write `.gsd/REQUIREMENTS.md` — use the **Requirements** output template below. Capture Active, Deferred, Out of Scope, and any already Validated requirements. Later milestones may have provisional ownership where slice plans do not exist yet.
 4. Seed `.gsd/DECISIONS.md` — use the **Decisions** output template below.
@@ -271,8 +271,8 @@ For single-milestone projects, do NOT write this file — it is only for multi-m
 #### Phase 4: Finalize
 
 7. Update `.gsd/STATE.md`
-8. Commit: `docs: project plan — N milestones` (replace N with the actual milestone count)
+8. {{multiMilestoneCommitInstruction}}
 
-After writing the files and committing, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
+After writing the files, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
 
 {{inlinedTemplates}}

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -63,7 +63,7 @@ Then:
 14. Read the template at `~/.gsd/agent/extensions/gsd/templates/task-summary.md`
 15. Write `{{taskSummaryPath}}`
 16. Mark {{taskId}} done in `{{planPath}}` (change `[ ]` to `[x]`)
-17. Do not commit manually — the system auto-commits your changes after this unit completes.
+17. Do not run git commands — the system reads your task summary after completion and creates a meaningful commit from it (type inferred from title, message from your one-liner, key files from frontmatter). Write a clear, specific one-liner in the summary — it becomes the commit message.
 18. Update `.gsd/STATE.md`
 
 All work stays in your working directory: `{{workingDirectory}}`.

package/src/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -104,5 +104,5 @@ Once the user confirms depth:
 1. Use the **Context** output template below
 2. `mkdir -p` the milestone directory if needed
 3. Write `{{milestoneId}}-CONTEXT.md` — preserve the user's exact terminology, emphasis, and framing. Do not paraphrase nuance into generic summaries. The context file is downstream agents' only window into this conversation.
-4. Commit: `git add {{milestoneId}}-CONTEXT.md && git commit -m "docs({{milestoneId}}): milestone context from discuss"`
+4. {{commitInstruction}}
 5. Say exactly: `"{{milestoneId}} context written."` — nothing else.

package/src/resources/extensions/gsd/prompts/guided-discuss-slice.md

@@ -55,7 +55,7 @@ Once the user is ready to wrap up:
    - **Constraints** — anything the user flagged as a hard constraint
    - **Integration Points** — what this slice consumes and produces
    - **Open Questions** — anything still unresolved, with current thinking
-4. Commit: `git -C {{projectRoot}} add {{contextPath}} && git -C {{projectRoot}} commit -m "docs({{milestoneId}}/{{sliceId}}): slice context from discuss"`
+4. {{commitInstruction}}
 5. Say exactly: `"{{sliceId}} context written."` — nothing else.
 
 {{inlinedTemplates}}

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -59,7 +59,7 @@ Then:
     - **Scope sanity:** Target 2–5 steps and 3–8 files per task. 10+ steps or 12+ files — must split. Each task must be completable in a single fresh context window.
     - **Feature completeness:** Every task produces real, user-facing progress — not just internal scaffolding.
 9. If planning produced structural decisions, append them to `.gsd/DECISIONS.md`
-10. Commit: `docs({{sliceId}}): add slice plan`
+10. {{commitInstruction}}
 11. Update `.gsd/STATE.md`
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir. All work stays in your working directory: `{{workingDirectory}}`.

package/src/resources/extensions/gsd/prompts/queue.md

@@ -79,9 +79,9 @@ Determine where the new milestones should go in the overall sequence. Consider d
 
 ## Output Phase
 
-Once the user is satisfied, in a single pass for **each** new milestone (starting from {{nextId}}):
+Once the user is satisfied, in a single pass for **each** new milestone:
 
-1. `mkdir -p .gsd/milestones/<ID>/slices`
+1. Call `gsd_generate_milestone_id` to get the milestone ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, add YAML frontmatter with `depends_on`:**
    ```yaml
    ---
@@ -96,7 +96,7 @@ Then, after all milestone directories and context files are written:
 4. If `.gsd/REQUIREMENTS.md` exists and the queued work introduces new in-scope capabilities or promotes Deferred items, update it.
 5. If discussion produced decisions relevant to existing work, append to `.gsd/DECISIONS.md`.
 6. Append to `.gsd/QUEUE.md`.
-7. Commit: `docs: queue <milestone list>`
+7. {{commitInstruction}}
 
 **Do NOT write roadmaps for queued milestones.**
 **Do NOT update `.gsd/STATE.md`.**

package/src/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -57,7 +57,7 @@ Write `{{assessmentPath}}` with a brief confirmation that roadmap coverage still
 1. Rewrite the remaining (unchecked) slices in `{{roadmapPath}}`. Keep completed slices exactly as they are (`[x]`). Update the boundary map for changed slices. Update the proof strategy if risks changed. Update requirement coverage if ownership or scope changed.
 2. Write `{{assessmentPath}}` explaining what changed and why — keep it brief and concrete.
 3. If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
-4. Commit: `docs({{milestoneId}}): reassess roadmap after {{completedSliceId}}`
+4. {{commitInstruction}}
 
 **You MUST write the file `{{assessmentPath}}` before finishing.**
 

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -53,7 +53,12 @@ function extractSlicesSection(content: string): string {
 export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   const slicesSection = extractSlicesSection(content);
   const slices: RoadmapSliceEntry[] = [];
-  if (!slicesSection) return slices;
+  if (!slicesSection) {
+    // Fallback: detect prose-style slice headers (## Slice S01: Title)
+    // when the LLM writes freeform prose instead of the ## Slices checklist.
+    // This prevents a permanent "No slice eligible" block (#807).
+    return parseProseSliceHeaders(content);
+  }
 
   const checkboxItems = slicesSection.split("\n");
   let currentSlice: RoadmapSliceEntry | null = null;
@@ -88,3 +93,42 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   if (currentSlice) slices.push(currentSlice);
   return slices;
 }
+
+/**
+ * Fallback parser for prose-style roadmaps where the LLM wrote
+ * `## Slice S01: Title` headers instead of the machine-readable
+ * `## Slices` checklist. Extracts slice IDs and titles so auto-mode
+ * can at least identify slices and plan them.
+ *
+ * Also handles `## S01: Title` and `## S01 — Title` variants.
+ */
+function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
+  const slices: RoadmapSliceEntry[] = [];
+  const headerPattern = /^##\s+(?:Slice\s+)?(S\d+)[:\s—–-]+\s*(.+)/gm;
+  let match: RegExpExecArray | null;
+
+  while ((match = headerPattern.exec(content)) !== null) {
+    const id = match[1]!;
+    const title = match[2]!.trim();
+
+    // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
+    const afterHeader = content.slice(match.index + match[0].length);
+    const nextHeader = afterHeader.search(/^##\s/m);
+    const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
+
+    const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
+    let depends: string[] = [];
+    if (depsMatch) {
+      const rawDeps = depsMatch[1]!.replace(/none/i, "").trim();
+      if (rawDeps) {
+        depends = expandDependencies(
+          rawDeps.split(/[,;]/).map(s => s.trim().replace(/[^A-Za-z0-9]/g, "")).filter(Boolean)
+        );
+      }
+    }
+
+    slices.push({ id, title, risk: "medium" as RiskLevel, depends, done: false, demo: "" });
+  }
+
+  return slices;
+}

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

@@ -62,7 +62,11 @@ export function isValidationTerminal(validationContent: string): boolean {
   if (!match) return false;
   const verdict = match[1].match(/verdict:\s*(\S+)/);
   if (!verdict) return false;
-  return verdict[1] === 'pass' || verdict[1] === 'needs-attention';
+  // 'pass' and 'needs-attention' are always terminal.
+  // 'needs-remediation' is treated as terminal to prevent infinite loops
+  // when no remediation slices exist in the roadmap (#832). The validation
+  // report is preserved on disk for manual review.
+  return verdict[1] === 'pass' || verdict[1] === 'needs-attention' || verdict[1] === 'needs-remediation';
 }
 
 // ─── State Derivation ──────────────────────────────────────────────────────
@@ -290,19 +294,26 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
 
     if (complete) {
       // All slices done — check validation and summary state
+      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
       const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
       const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
       const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
-      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
 
-      if (!validationTerminal && !activeMilestoneFound) {
-        // No terminal validation yet → validating-milestone
+      if (summaryFile) {
+        // Summary exists → milestone is complete regardless of validation state.
+        // The summary is the terminal artifact (#864).
+        registry.push({ id: mid, title, status: 'complete' });
+      } else if (!validationTerminal && !activeMilestoneFound) {
+        // No summary and no terminal validation → validating-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;
         registry.push({ id: mid, title, status: 'active' });
-      } else if (!summaryFile && !activeMilestoneFound) {
-        // Validated but no summary written yet → completing-milestone
+      } else if (!validationTerminal && activeMilestoneFound) {
+        // No summary and no terminal validation, but another milestone is already active
+        registry.push({ id: mid, title, status: 'pending' });
+      } else if (!activeMilestoneFound) {
+        // Terminal validation but no summary → completing-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;

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

@@ -17,6 +17,8 @@ import {
   loadPersistedKeys,
 } from "../auto-recovery.ts";
 import { parseRoadmap, clearParseCache } from "../files.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -584,3 +586,55 @@ test("selfHealRuntimeRecords clears stale record when artifact exists at worktre
     cleanup(mainBase);
   }
 });
+
+// ─── #793: invalidateAllCaches unblocks skip-loop ─────────────────────────
+// When the skip-loop breaker fires, it must call invalidateAllCaches() (not
+// just invalidateStateCache()) to clear path/parse caches that deriveState
+// depends on. Without this, even after cache invalidation, deriveState reads
+// stale directory listings and returns the same unit, looping forever.
+test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk state", async () => {
+  const base = makeTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    const planDir = join(base, ".gsd", "milestones", mid, "slices", sid);
+    const tasksDir = join(planDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+
+    writeFileSync(
+      join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`),
+      `# M001: Test Milestone\n\n**Vision:** test.\n\n## Slices\n\n- [ ] **${sid}: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: done.\n`,
+    );
+    const planUnchecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [ ] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planUnchecked);
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01: Task One\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02: Task Two\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+
+    // Warm all caches
+    const state1 = await deriveState(base);
+    assert.equal(state1.activeTask?.id, "T01", "initial: T01 is active");
+
+    // Simulate task completion on disk (what the LLM does)
+    const planChecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [x] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planChecked);
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "---\nid: T01\n---\n# Summary\n");
+
+    // invalidateStateCache alone: _stateCache cleared but path/parse caches warm
+    invalidateStateCache();
+
+    // invalidateAllCaches: all caches cleared — deriveState must re-read disk
+    invalidateAllCaches();
+    const state2 = await deriveState(base);
+
+    // After full invalidation, T01 should be complete and T02 should be next
+    assert.notEqual(state2.activeTask?.id, "T01", "#793: T01 not re-dispatched after full invalidation");
+
+    // Verify the caches are truly cleared by calling clearParseCache and clearPathCache
+    // do not throw (they should be no-ops after invalidateAllCaches already cleared them)
+    clearParseCache(); // no-op, but should not throw
+    assert.ok(true, "clearParseCache after invalidateAllCaches is safe");
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -153,6 +153,64 @@ async function main(): Promise<void> {
     // After teardown, originalBase should be null
     assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
+    // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
+    console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
+    {
+      // Simulate: T01 [x] was committed to milestone branch, T02 [x] was
+      // written to project root by syncStateToProjectRoot() but the
+      // auto-commit crashed before it fired. On restart the worktree is
+      // re-created from the milestone branch HEAD (T02 still [ ]).
+      // reconcilePlanCheckboxes should forward-apply T02 [x] from the root.
+
+      const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
+      const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
+      const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
+
+      // Plan on integration branch (project root): T01 [x], T02 [x]
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Write integration-branch plan to git so milestone branch starts from it
+      run(`git add .`, tempDir);
+      run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
+
+      // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
+      const milestoneBranch = "milestone/M004";
+      run(`git checkout -b ${milestoneBranch}`, tempDir);
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+      run(`git add .`, tempDir);
+      run(`git commit -m "milestone: only T01 checked"`, tempDir);
+      run(`git checkout main`, tempDir);
+
+      // Restore project root plan (T01+T02 [x]) — simulates syncStateToProjectRoot
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
+      const wtPath = createAutoWorktree(tempDir, "M004");
+
+      try {
+        const wtPlanPath = join(wtPath, planRelPath);
+        assertTrue(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+
+        const wtPlan = read(wtPlanPath, "utf-8");
+        assertTrue(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
+        assertTrue(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
+        assertTrue(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
+      } finally {
+        teardownAutoWorktree(tempDir, "M004");
+      }
+    }
+
   } finally {
     // Always restore cwd and clean up
     process.chdir(savedCwd);

package/src/resources/extensions/gsd/tests/derive-state.test.ts

@@ -700,6 +700,76 @@ slice: S01
     }
   }
 
+  // ─── Test: completed M001 (summary, no validation) skipped for active M003 (#864) ────
+  console.log('\n=== completed milestone with summary but no validation is not active (#864) ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: all slices done, has summary, no validation
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Done.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed.**');
+      // M003: incomplete, should be active
+      writeRoadmap(base, 'M003', `# M003: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n  > Needs work.\n`);
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M003', 'active milestone is M003, not completed M001');
+      const m001Entry = state.registry.find(e => e.id === 'M001');
+      assertEq(m001Entry?.status, 'complete', 'M001 is marked complete despite no validation');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: completed M001 with summary AND validation is complete (#864) ────
+  console.log('\n=== completed milestone with summary and validation is complete ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Done.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed.**');
+      writeMilestoneValidation(base, 'M001', 'pass');
+      writeRoadmap(base, 'M003', `# M003: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n  > Needs work.\n`);
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M003', 'active milestone is M003');
+      const m001Entry = state.registry.find(e => e.id === 'M001');
+      assertEq(m001Entry?.status, 'complete', 'M001 with both summary and validation is complete');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: all slices done, no summary, no validation → needs validation (#864) ────
+  console.log('\n=== all slices done, no summary, no validation → validating-milestone ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Validate me.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      // No summary, no validation — this should be active for validation
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M001', 'M001 is active for validation');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: all slices done, validation pass, no summary → needs completion (#864) ────
+  console.log('\n=== all slices done, validation pass, no summary → completing-milestone ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Complete me.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneValidation(base, 'M001', 'pass');
+      // No summary — validated but not yet completed
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M001', 'M001 is active for completion');
+    } finally {
+      cleanup(base);
+    }
+  }
+
   report();
 }
 

package/src/resources/extensions/gsd/tests/doctor-proactive.test.ts

@@ -188,7 +188,7 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes on clean state");
       assertEq(result.issues.length, 0, "no issues on clean state");
     }
@@ -206,7 +206,7 @@ async function main(): Promise<void> {
         unitStartedAt: "2026-03-10T00:01:00Z", completedUnits: 3,
       }));
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes after auto-clearing stale lock");
       assertTrue(result.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "reports lock cleared");
       assertTrue(!existsSync(join(dir, ".gsd", "auto.lock")), "lock file removed");
@@ -222,7 +222,7 @@ async function main(): Promise<void> {
       const headHash = run("git rev-parse HEAD", dir);
       writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes after auto-healing merge state");
       assertTrue(result.fixesApplied.some(f => f.includes("cleaned merge state")), "reports merge state cleaned");
       assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed");
@@ -231,6 +231,26 @@ async function main(): Promise<void> {
       console.log("  (skipped on Windows)");
     }
 
+    console.log("\n=== health gate: STATE.md missing — auto-healed ===");
+    {
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
+      cleanups.push(dir);
+      // Minimal .gsd structure: milestones dir exists but no STATE.md
+      mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+
+      const stateFile = join(dir, ".gsd", "STATE.md");
+      assertTrue(!existsSync(stateFile), "STATE.md does not exist before gate");
+
+      const result = await preDispatchHealthGate(dir);
+      assertTrue(result.proceed, "gate passes after rebuilding STATE.md");
+      assertTrue(
+        result.fixesApplied.some(f => f.includes("rebuilt missing STATE.md")),
+        "reports STATE.md rebuilt",
+      );
+      assertTrue(existsSync(stateFile), "STATE.md created by auto-heal");
+      assertTrue(result.issues.length === 0, "no blocking issues after heal");
+    }
+
   } finally {
     resetProactiveHealing();
     for (const dir of cleanups) {

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -5,6 +5,7 @@ import { execSync } from "node:child_process";
 
 import {
   inferCommitType,
+  buildTaskCommitMessage,
   GitServiceImpl,
   RUNTIME_EXCLUSION_PATHS,
   VALID_BRANCH_NAME,
@@ -14,6 +15,7 @@ import {
   type GitPreferences,
   type CommitOptions,
   type PreMergeCheckResult,
+  type TaskCommitContext,
 } from "../git-service.ts";
 import { createTestContext } from './test-helpers.ts';
 
@@ -188,6 +190,58 @@ async function main(): Promise<void> {
     "'prefix' does not match 'fix' — word boundary prevents partial match"
   );
 
+  // ─── inferCommitType with oneLiner ──────────────────────────────────────
+
+  console.log("\n=== inferCommitType with oneLiner ===");
+
+  assertEq(
+    inferCommitType("implement dashboard", "Fixed rendering bug in sidebar"),
+    "fix",
+    "one-liner with 'fixed' overrides generic title → fix"
+  );
+
+  assertEq(
+    inferCommitType("add search", "Optimized query performance with caching"),
+    "perf",
+    "one-liner with 'performance' and 'caching' → perf"
+  );
+
+  // ─── buildTaskCommitMessage ─────────────────────────────────────────────
+
+  console.log("\n=== buildTaskCommitMessage ===");
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S01/T02",
+      taskTitle: "implement user authentication",
+      oneLiner: "Added JWT-based auth with refresh token rotation",
+      keyFiles: ["src/auth.ts", "src/middleware/jwt.ts"],
+    });
+    assertTrue(msg.startsWith("feat(S01/T02):"), "message starts with type(scope)");
+    assertTrue(msg.includes("JWT-based auth"), "message includes one-liner content");
+    assertTrue(msg.includes("- src/auth.ts"), "message body includes key files");
+    assertTrue(msg.includes("- src/middleware/jwt.ts"), "message body includes second key file");
+  }
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S02/T01",
+      taskTitle: "fix login redirect bug",
+    });
+    assertTrue(msg.startsWith("fix(S02/T01):"), "infers fix type from title");
+    assertTrue(msg.includes("fix login redirect bug"), "uses task title when no one-liner");
+    assertTrue(!msg.includes("\n"), "no body when no key files");
+  }
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S01/T03",
+      taskTitle: "add tests",
+      oneLiner: "Unit tests for auth module with coverage",
+    });
+    assertTrue(msg.startsWith("test(S01/T03):"), "infers test type");
+  }
+
   // ─── RUNTIME_EXCLUSION_PATHS ───────────────────────────────────────────
 
   console.log("\n=== RUNTIME_EXCLUSION_PATHS ===");
@@ -430,13 +484,25 @@ async function main(): Promise<void> {
     const svc = new GitServiceImpl(repo);
 
     createFile(repo, "src/new-feature.ts", "export const x = 1;");
-    const msg = svc.autoCommit("task", "T01");
 
-    assertEq(msg, "chore(T01): auto-commit after task", "autoCommit returns correct message format");
+    // Without task context, autoCommit uses generic chore message
+    const msg = svc.autoCommit("task", "T01");
+    assertEq(msg, "chore(T01): auto-commit after task", "autoCommit returns generic format without task context");
 
-    // Verify the commit exists
     const log = run("git log --oneline -1", repo);
-    assertTrue(log.includes("chore(T01): auto-commit after task"), "commit message is in git log");
+    assertTrue(log.includes("chore(T01): auto-commit after task"), "generic commit message is in git log");
+
+    // With task context, autoCommit uses meaningful message
+    createFile(repo, "src/auth.ts", "export function login() {}");
+    const msg2 = svc.autoCommit("task", "S01/T02", [], {
+      taskId: "S01/T02",
+      taskTitle: "implement user authentication endpoint",
+      oneLiner: "Added JWT-based auth with refresh token rotation",
+      keyFiles: ["src/auth.ts"],
+    });
+    assertTrue(msg2 !== null, "autoCommit with task context returns a message");
+    assertTrue(msg2!.startsWith("feat(S01/T02):"), "meaningful commit uses feat type and scope");
+    assertTrue(msg2!.includes("JWT-based auth"), "meaningful commit includes one-liner content");
 
     rmSync(repo, { recursive: true, force: true });
   }

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

@@ -65,8 +65,8 @@ console.log('\n=== gsd-db: fresh DB schema init (memory) ===');
 
   // Check schema_version table
   const adapter = _getAdapter()!;
-  const version = adapter.prepare('SELECT version FROM schema_version').get();
-  assertEq(version?.['version'], 2, 'schema version should be 2');
+  const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
+  assertEq(version?.['version'], 3, 'schema version should be 3');
 
   // Check tables exist by querying them
   const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -350,12 +350,11 @@ console.log('=== md-importer: missing file handling ===');
 console.log('=== md-importer: schema v1→v2 migration ===');
 
 {
-  // This test verifies that opening a v1 DB auto-migrates to v2
-  // (The actual migration is tested via the gsd-db.test.ts schema version assertion = 2)
+  // This test verifies that opening a fresh DB auto-migrates to current schema version
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.v, 2, 'new DB should be at schema version 2');
+  assertEq(version?.v, 3, 'new DB should be at schema version 3');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();