gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -0,0 +1,186 @@
+/**
+ * clean-root-preflight.test.ts — Regression tests for #2909.
+ *
+ * Tests that preflightCleanRoot warns + stashes on dirty trees,
+ * is a no-op on clean trees, and that postflightPopStash restores
+ * stashed changes after a merge.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { preflightCleanRoot, postflightPopStash } from "../clean-root-preflight.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-preflight-test-")));
+  run("git init", dir);
+  run("git config user.email test@example.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+// ── Clean tree: fast-path returns immediately without stashing ─────────────
+
+test("preflightCleanRoot — clean tree returns stashPushed=false and emits no notifications", () => {
+  const repo = createTempRepo();
+  try {
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const result = preflightCleanRoot(repo, "M001", (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(result.stashPushed, false, "stashPushed must be false for clean tree");
+    assert.equal(result.summary, "", "summary must be empty for clean tree");
+    assert.equal(notifications.length, 0, "no notifications on clean tree");
+
+    // Verify no stash was created
+    const stashList = run("git stash list", repo);
+    assert.equal(stashList, "", "no stash entry on clean tree");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+// ── Dirty tree: warns, stashes, returns stashPushed=true ──────────────────
+
+test("preflightCleanRoot — dirty tree warns user and auto-stashes", () => {
+  const repo = createTempRepo();
+  try {
+    // Dirty an existing tracked file
+    writeFileSync(join(repo, "README.md"), "# locally modified\n");
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const result = preflightCleanRoot(repo, "M002", (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(result.stashPushed, true, "stashPushed must be true when tree was dirty");
+    assert.ok(result.summary.length > 0, "summary must be non-empty when stash was pushed");
+
+    // A warning notification must have been emitted before stashing
+    assert.ok(
+      notifications.some(n => n.level === "warning" && n.msg.includes("M002")),
+      "warning notification must mention the milestone ID",
+    );
+
+    // Working tree must now be clean (stash pushed)
+    const status = run("git status --porcelain", repo);
+    assert.equal(status, "", "working tree must be clean after stash push");
+
+    // The stash entry must exist
+    const stashList = run("git stash list", repo);
+    assert.ok(stashList.includes("gsd-preflight-stash"), "stash entry must be named gsd-preflight-stash");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+// ── Untracked files are also stashed ─────────────────────────────────────
+
+test("preflightCleanRoot — untracked file triggers stash with --include-untracked", () => {
+  const repo = createTempRepo();
+  try {
+    // Add an untracked file
+    writeFileSync(join(repo, "untracked.ts"), "export const x = 1;\n");
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const result = preflightCleanRoot(repo, "M003", (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(result.stashPushed, true, "stashPushed must be true for untracked file");
+
+    const status = run("git status --porcelain", repo);
+    assert.equal(status, "", "working tree must be clean after stash push");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+// ── postflightPopStash: restores stashed changes ──────────────────────────
+
+test("postflightPopStash — restores stashed changes and emits info notification", () => {
+  const repo = createTempRepo();
+  try {
+    // Dirty the working tree
+    writeFileSync(join(repo, "README.md"), "# stash me\n");
+
+    const preNotifications: Array<{ msg: string; level: string }> = [];
+    const preflight = preflightCleanRoot(repo, "M004", (msg, level) => {
+      preNotifications.push({ msg, level });
+    });
+    assert.equal(preflight.stashPushed, true, "preflight must have stashed");
+
+    // Simulate the merge (just a no-op commit here)
+    writeFileSync(join(repo, "merged.ts"), "export const merged = true;\n");
+    run("git add .", repo);
+    run('git commit -m "simulate merge"', repo);
+
+    const postNotifications: Array<{ msg: string; level: string }> = [];
+    postflightPopStash(repo, "M004", (msg, level) => {
+      postNotifications.push({ msg, level });
+    });
+
+    // The stashed README.md change must be restored
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# stash me\n", "stashed file must be restored");
+
+    // An info notification must have been emitted
+    assert.ok(
+      postNotifications.some(n => n.level === "info" && n.msg.includes("M004")),
+      "info notification must mention milestone ID after pop",
+    );
+
+    // Stash list must be empty
+    const stashList = run("git stash list", repo);
+    assert.equal(stashList, "", "stash list must be empty after pop");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+// ── Round-trip: preflight + merge + postflight preserves changes ──────────
+
+test("preflight + merge + postflight round-trip preserves uncommitted changes", () => {
+  const repo = createTempRepo();
+  try {
+    const originalContent = "# my local work\n";
+    writeFileSync(join(repo, "README.md"), originalContent);
+
+    // Preflight: stash
+    const preflight = preflightCleanRoot(repo, "M005", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed");
+
+    // Merge: introduce a new file (no overlap with README.md)
+    writeFileSync(join(repo, "feature.ts"), "export const feature = true;\n");
+    run("git add feature.ts", repo);
+    run('git commit -m "feat: add feature"', repo);
+
+    // Postflight: pop stash
+    postflightPopStash(repo, "M005", () => {});
+
+    // README.md must still have our local content
+    const restored = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(restored.replace(/\r\n/g, "\n"), originalContent, "local changes must survive merge");
+
+    // feature.ts must also exist (the merge commit landed)
+    const featureContent = readFileSync(join(repo, "feature.ts"), "utf-8");
+    assert.ok(featureContent.includes("feature"), "merged feature must be present");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

package/src/resources/extensions/gsd/tests/cmux.test.ts

@@ -14,7 +14,7 @@ import {
   shouldPromptToEnableCmux,
 } from "../../cmux/index.ts";
 import { autoEnableCmuxPreferences } from "../commands-cmux.ts";
-import type { GSDState } from "../types.ts";
+import type { CmuxStateInput } from "../../shared/cmux-events.ts";
 
 test("detectCmuxEnvironment requires workspace, surface, and socket", () => {
   const detected = detectCmuxEnvironment(
@@ -146,15 +146,11 @@ describe("autoEnableCmuxPreferences", () => {
 });
 
 test("buildCmuxStatusLabel and progress prefer deepest active unit", () => {
-  const state: GSDState = {
-    activeMilestone: { id: "M001", title: "Milestone" },
-    activeSlice: { id: "S02", title: "Slice" },
-    activeTask: { id: "T03", title: "Task" },
+  const state: CmuxStateInput = {
+    activeMilestone: { id: "M001" },
+    activeSlice: { id: "S02" },
+    activeTask: { id: "T03" },
     phase: "executing",
-    recentDecisions: [],
-    blockers: [],
-    nextAction: "Keep going",
-    registry: [],
     progress: {
       milestones: { done: 0, total: 1 },
       slices: { done: 1, total: 3 },

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

@@ -0,0 +1,263 @@
+// GSD-2 — #4780: slice-summary excerpts replace full inlining in
+// buildCompleteMilestonePrompt. Verify (a) the excerpt helper emits
+// frontmatter fields + section heads + on-demand path, (b) the closer
+// prompt lists all slice SUMMARY paths under "On-demand Slice Summaries",
+// (c) regression on prompt size.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildSliceSummaryExcerpt, buildCompleteMilestonePrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+// ─── Fixture helpers ──────────────────────────────────────────────────────
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cm-excerpt-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeRoadmap(base: string, content: string): void {
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), content);
+}
+
+function writeSummary(base: string, sid: string, content: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", sid, `${sid}-SUMMARY.md`),
+    content,
+  );
+}
+
+// A summary with enough body narrative that full inlining would balloon the
+// prompt. The excerpt should keep frontmatter + sections but drop the
+// "What Happened" narrative.
+function makeFatSummary(sid: string): string {
+  const narrativePara =
+    "The team discovered several subtle integration issues, traced them to the cache layer, and produced a patch set that threads the cache key through every call site. ".repeat(20);
+  return [
+    "---",
+    `id: ${sid}`,
+    "parent: M001",
+    "milestone: M001",
+    "provides:",
+    "  - compact slice-summary excerpts",
+    "  - on-demand read path registry",
+    "affects:",
+    "  - complete-milestone prompt builder",
+    "key_decisions:",
+    "  - use parseSummary for frontmatter extraction",
+    "  - fall back to full inline when frontmatter fails",
+    "patterns_established:",
+    "  - excerpt-first inlining for closer units",
+    "key_files:",
+    "  - src/resources/extensions/gsd/auto-prompts.ts",
+    "duration: 1h",
+    "verification_result: passed",
+    "completed_at: 2026-04-24",
+    "blocker_discovered: false",
+    "---",
+    "",
+    `# ${sid}: Slice summary`,
+    "**Short one-liner for the slice**",
+    "",
+    "## What Happened",
+    "",
+    narrativePara,
+    "",
+    "## Deviations",
+    "",
+    "Extended the excerpt helper scope at review time.",
+    "",
+    "## Known Limitations",
+    "",
+    "Does not yet cover validate-milestone — follow-up.",
+    "",
+    "## Follow-ups",
+    "",
+    "- Wire the same excerpt into buildValidateMilestonePrompt",
+  ].join("\n");
+}
+
+function makeRoadmap(): string {
+  return [
+    "# M001 Roadmap",
+    "## Slices",
+    "- [x] **S01: Excerpt helper** `risk:medium` `depends:[]`",
+    "- [x] **S02: Closer wiring** `risk:low` `depends:[S01]`",
+  ].join("\n");
+}
+
+// ─── buildSliceSummaryExcerpt unit tests ──────────────────────────────────
+
+test("#4780 excerpt: emits compact block with frontmatter fields + section heads", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  const relPath = ".gsd/milestones/M001/slices/S01/S01-SUMMARY.md";
+  writeSummary(base, "S01", makeFatSummary("S01"));
+
+  const out = await buildSliceSummaryExcerpt(absPath, relPath, "S01");
+
+  // Compact header with source path for on-demand Read
+  assert.match(out, /### S01 Summary \(excerpt\)/);
+  assert.match(out, /Source: `\.gsd\/milestones\/M001\/slices\/S01\/S01-SUMMARY\.md`/);
+
+  // Frontmatter fields surfaced
+  assert.match(out, /\*\*Title:\*\* S01: Slice summary/);
+  assert.match(out, /\*\*One-liner:\*\*/);
+  assert.match(out, /\*\*Verification:\*\* `passed`/);
+  assert.match(out, /\*\*Blockers:\*\* none/);
+  assert.match(out, /\*\*Provides:\*\* compact slice-summary excerpts;/);
+  assert.match(out, /\*\*Key decisions:\*\* use parseSummary/);
+  assert.match(out, /\*\*Patterns established:\*\* excerpt-first inlining/);
+
+  // Section heads included (body-section markdown), not whole sections inlined
+  assert.match(out, /#### Deviations/);
+  assert.match(out, /#### Known limitations/);
+  assert.match(out, /#### Follow-ups/);
+
+  // On-demand instruction present
+  assert.match(out, /On-demand.*read.*for the full "What Happened"/);
+
+  // Bulk narrative is NOT inlined — excerpt is meaningfully shorter than full
+  // A 20x-repeated paragraph produces ~2.5KB; excerpt should come in well under.
+  const fullSize = makeFatSummary("S01").length;
+  assert.ok(
+    out.length < fullSize * 0.6,
+    `excerpt length ${out.length} should be < 60% of full summary length ${fullSize}`,
+  );
+});
+
+test("#4780 excerpt: blocker_discovered=true surfaces prominent marker", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  const content = [
+    "---",
+    "id: S01",
+    "parent: M001",
+    "milestone: M001",
+    "blocker_discovered: true",
+    "---",
+    "# S01",
+    "**One-liner**",
+    "",
+    "## What Happened",
+    "content",
+  ].join("\n");
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  writeSummary(base, "S01", content);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel", "S01");
+  assert.match(out, /Blockers:\*\* ⚠️ blocker recorded/);
+});
+
+test("#4780 excerpt: fall back to full inline when frontmatter is unrecognizable", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  // No frontmatter, no id — parser returns empty id, triggering fallback
+  const garbage = "# S99\n\nJust a wall of text with no frontmatter at all.\n";
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S99-SUMMARY.md");
+  writeFileSync(absPath, garbage);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel/path.md", "S99");
+  // Full content preserved (no excerpt wrapper), no data-loss
+  assert.match(out, /Just a wall of text/);
+  assert.match(out, /### S99 Summary/);
+});
+
+test("#4780 excerpt: missing file reports not-found fallback", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+
+  const out = await buildSliceSummaryExcerpt(null, "rel/missing.md", "S42");
+  assert.match(out, /### S42 Summary \(excerpt\)/);
+  assert.match(out, /not found — file does not exist yet/);
+});
+
+test("#4780 excerpt: section bodies are capped (coderabbit review)", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  // Long Follow-ups section (~4.8KB) would balloon the excerpt without
+  // the cap — regression coverage for the coderabbit finding on #4908.
+  const longFollowUps = "A verbose follow-up bullet that keeps restating the same point. ".repeat(60);
+  const content = [
+    "---",
+    "id: S01",
+    "parent: M001",
+    "milestone: M001",
+    "---",
+    "# S01: Test",
+    "**One-liner**",
+    "",
+    "## Follow-ups",
+    longFollowUps,
+  ].join("\n");
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  writeSummary(base, "S01", content);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel/path.md", "S01");
+
+  assert.match(out, /\(truncated — see full `rel\/path\.md`\)/);
+  assert.ok(
+    out.length < 2000,
+    `excerpt length ${out.length} should be well under 2KB when one section hits the cap`,
+  );
+});
+
+// ─── buildCompleteMilestonePrompt integration test ─────────────────────────
+
+test("#4780 closer prompt: uses excerpts + lists on-demand slice SUMMARY paths", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  writeRoadmap(base, makeRoadmap());
+  writeSummary(base, "S01", makeFatSummary("S01"));
+  writeSummary(base, "S02", makeFatSummary("S02"));
+
+  const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+
+  // Excerpt markers present for each slice
+  assert.match(prompt, /### S01 Summary \(excerpt\)/);
+  assert.match(prompt, /### S02 Summary \(excerpt\)/);
+
+  // On-demand path section exists with both slice paths
+  assert.match(prompt, /### On-demand Slice Summaries/);
+  assert.match(prompt, /S01-SUMMARY\.md/);
+  assert.match(prompt, /S02-SUMMARY\.md/);
+
+  // Fat narrative (the 20x-repeated paragraph) is NOT inlined
+  assert.ok(
+    !prompt.includes("threads the cache key through every call site."),
+    "closer prompt must not inline full 'What Happened' narrative after #4780",
+  );
+
+  // Prompt size is bounded — the two fat summaries' narratives alone would
+  // have exceeded ~4KB each. Post-fix closer prompt should be meaningfully
+  // smaller than their combined raw size.
+  const rawSize = makeFatSummary("S01").length + makeFatSummary("S02").length;
+  // Prompt includes roadmap, templates, and other inlines, so it may still
+  // be sizable — the guard is specifically that the fat narrative is gone.
+  // Use a soft bound: prompt - overhead should be less than 2x one summary.
+  assert.ok(
+    prompt.length < rawSize + 20_000,
+    `closer prompt length ${prompt.length} should be < raw summary size ${rawSize} + 20KB headroom`,
+  );
+});

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

@@ -1,11 +1,14 @@
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { invalidateAllCaches } from '../cache.ts';
 import { parseUnitId } from "../unit-id.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { clearPathCache } from "../paths.ts";
+import { clearParseCache } from "../files.ts";
 
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
 // In a worktree the file may not exist there yet, so we resolve prompts
@@ -404,6 +407,63 @@ describe("complete-milestone", () => {
     }
   });
 
+  test("handleCompleteMilestone does not overwrite existing SUMMARY.md on re-dispatch (#4598)", async () => {
+    // This test verifies that when SUMMARY.md already exists (from a prior completion),
+    // re-calling handleCompleteMilestone does not overwrite it.
+    // Before the fix this test FAILS because the handler unconditionally writes SUMMARY.md.
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    const mid = "M001";
+    const dbPath = join(base, ".gsd", "gsd.db");
+    try {
+      // Set up DB with milestone and a complete slice + task
+      openDatabase(dbPath);
+      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
+
+      // Pre-write an existing SUMMARY.md to simulate a prior completion
+      const milestoneDir = join(base, ".gsd", "milestones", mid);
+      mkdirSync(milestoneDir, { recursive: true });
+      const summaryPath = join(milestoneDir, `${mid}-SUMMARY.md`);
+      const originalContent = "original content — must not be overwritten";
+      writeFileSync(summaryPath, originalContent, "utf-8");
+
+      // Call handleCompleteMilestone — this is the re-dispatch scenario
+      const params = {
+        milestoneId: mid,
+        title: "Test Milestone",
+        oneLiner: "Re-dispatched",
+        narrative: "This is a re-dispatch",
+        successCriteriaResults: "Met",
+        definitionOfDoneResults: "Done",
+        requirementOutcomes: "Covered",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        verificationPassed: true,
+      };
+
+      const result = await handleCompleteMilestone(params, base);
+
+      // The call may return an error (milestone already complete) or success
+      // but in either case the SUMMARY.md must NOT be overwritten.
+      const actualContent = readFileSync(summaryPath, "utf-8");
+      assert.strictEqual(
+        actualContent,
+        originalContent,
+        "existing SUMMARY.md must not be overwritten on re-dispatch (#4598)",
+      );
+    } finally {
+      try { closeDatabase(); } catch { /* */ }
+      clearPathCache();
+      clearParseCache();
+      cleanup(base);
+    }
+  });
+
   test("deriveState completing-milestone integration", async () => {
     const { deriveState, isMilestoneComplete } = await import("../state.ts");
     const { invalidateAllCaches: invalidateAllCachesDynamic } = await import("../cache.ts");