gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -178,6 +178,33 @@ test("init-wizard: multiple project files detected together", (t) => {
   }
 });
 
+// ─── Git init + initial commit regression (#4530) ───────────────────────────
+
+import { execFileSync } from "node:child_process";
+import { nativeInit, nativeAddAll, nativeCommit } from "../native-git-bridge.ts";
+
+test("init-wizard: nativeInit + nativeAddAll + nativeCommit produces a reachable HEAD (#4530)", (t) => {
+  // Regression: showProjectInit called nativeInit but never committed, leaving
+  // the branch unborn. git log and git worktree add both fail on zero-commit repos.
+  const dir = makeTempDir("git-init-commit");
+  t.after(() => { cleanup(dir); });
+
+  nativeInit(dir, "main");
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+  writeFileSync(join(dir, ".gitignore"), "*.log\n", "utf-8");
+
+  nativeAddAll(dir);
+  nativeCommit(dir, "chore: init project");
+
+  // git log must succeed (was: fatal: your current branch 'main' does not have any commits yet)
+  const subject = execFileSync("git", ["log", "-1", "--format=%s"], {
+    cwd: dir,
+    encoding: "utf-8",
+  }).trim();
+  assert.equal(subject, "chore: init project");
+});
+
 test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
   const dir = makeTempDir("both-v1-v2");
   try {

package/src/resources/extensions/gsd/tests/integration/all-milestones-complete-merge.test.ts

@@ -21,10 +21,9 @@ import {
   realpathSync,
   readFileSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 
 import {
   createAutoWorktree,
@@ -33,8 +32,6 @@ import {
   mergeMilestoneToMain,
 } from "../../auto-worktree.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 function run(command: string, cwd: string): string {
   return execSync(command, {
     cwd,
@@ -75,58 +72,12 @@ function createMilestoneArtifacts(dir: string, mid: string): void {
   writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
 }
 
-// ─── Source-level: verify the merge code exists in the "all complete" path ────
-
-test("auto-loop 'all milestones complete' path merges before stopping (#962)", () => {
-  const loopSrc = readFileSync(join(__dirname, "../..", "auto", "phases.ts"), "utf-8");
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // Find the "incomplete.length === 0" block
-  const incompleteIdx = loopSrc.indexOf("incomplete.length === 0");
-  assert.ok(
-    incompleteIdx > -1,
-    "auto/phases.ts should have 'incomplete.length === 0' check",
-  );
-
-  // The merge call must appear BETWEEN the incomplete check and the stopAuto call.
-  const blockAfterIncomplete = loopSrc.slice(
-    incompleteIdx,
-    incompleteIdx + 3000,
-  );
-
-  assert.ok(
-    blockAfterIncomplete.includes("deps.resolver.mergeAndExit"),
-    "auto/phases.ts should call resolver.mergeAndExit in the 'all milestones complete' path",
-  );
-
-  // The merge should come before stopAuto in this block
-  const mergePos = blockAfterIncomplete.indexOf("deps.resolver.mergeAndExit");
-  const stopPos = blockAfterIncomplete.indexOf("stopAuto");
-  assert.ok(
-    mergePos < stopPos,
-    "resolver.mergeAndExit should be called before stopAuto in the 'all complete' path",
-  );
-
-  const helperIdx = resolverSrc.indexOf("mergeAndExit(milestoneId");
-  assert.ok(
-    helperIdx > -1,
-    "WorktreeResolver.mergeAndExit helper should exist",
-  );
-  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
-  assert.ok(
-    helperBlock.includes('mode === "worktree"') ||
-      helperBlock.includes('mode: "worktree"'),
-    "WorktreeResolver.mergeAndExit should handle worktree mode",
-  );
-  assert.ok(
-    helperBlock.includes('mode === "branch"') ||
-      helperBlock.includes('mode: "branch"'),
-    "WorktreeResolver.mergeAndExit should handle branch mode",
-  );
-});
+// Note: the prior phases.ts / worktree-resolver.ts source-grep block was
+// removed under #4825 — it asserted `deps.resolver.mergeAndExit` appears
+// before `stopAuto` via indexOf positions in the source text, which broke
+// on any helper refactor without catching a real regression. The two
+// integration tests below exercise the merge-before-stop behaviour end
+// to end through real git worktrees.
 
 // ─── Integration: single milestone completes → merged to main ────────────────
 

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

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/doctor-git-symlink-cwd.test.ts

@@ -43,6 +43,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
 
   run("git add -A", dir);

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

@@ -16,6 +16,7 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { runGSDDoctor } from "../../doctor.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../../gsd-db.ts";
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -55,6 +56,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+  writeFileSync(join(msDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
 
   // Commit .gsd files
@@ -64,6 +76,47 @@ _None_
   return dir;
 }
 
+/** Create a repo whose slices are done but milestone closeout is still pending. */
+function createRepoWithSlicesDoneButNoMilestoneSummary(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const msDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Completing Milestone"
+---
+
+# M001: Completing Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m \"add completing milestone\"", dir);
+
+  return dir;
+}
+
 /** Write a .gsd/PREFERENCES.md with the given git isolation mode. */
 function writePreferencesFile(dir: string, isolation: "none" | "worktree" | "branch"): void {
   const gsdDir = join(dir, ".gsd");
@@ -299,6 +352,31 @@ describe('doctor-git', async () => {
     } else {
     }
 
+    // ─── Test 6b: completing-milestone worktree NOT flagged ────────────
+    if (process.platform !== "win32") {
+    test('completing-milestone worktree safety (DB-backed, no summary)', async () => {
+      const dir = createRepoWithSlicesDoneButNoMilestoneSummary();
+      cleanups.push(dir);
+
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const dbPath = join(dir, ".gsd", "gsd.db");
+      assert.equal(openDatabase(dbPath), true, "opens gsd.db");
+      try {
+        insertMilestone({ id: "M001", title: "Completing Milestone", status: "active" });
+        insertSlice({ id: "S01", milestoneId: "M001", title: "Test slice", status: "complete", risk: "low", depends: [] });
+
+        const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
+        const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+        assert.deepStrictEqual(orphanIssues.length, 0, "completing milestone NOT flagged as orphaned");
+      } finally {
+        closeDatabase();
+      }
+    });
+    } else {
+    }
+
     // ─── Test 7: none-mode skips orphaned worktree check ───────────────
     // NOTE: loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH
     // at module load time from process.cwd(). We write the prefs file to

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

@@ -161,11 +161,27 @@ describe('doctor-proactive', async () => {
     });
 
     test('escalation: no double escalation', () => {
-      // Don't reset — should already be escalated from previous test
+      // Self-contained: drive the escalated state from scratch in this test.
+      // Previously this relied on module-singleton state left over from the
+      // preceding 'escalation: at threshold' test, which silently broke under
+      // filtered/parallel/reordered runs (the fallback `shouldEscalate: false`
+      // path was satisfied by the wrong reason — see #4828).
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0); // older clean snapshots
+      }
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(2, 1, 0); // recent error snapshots → degrading trend
+      }
+      // First check: trigger escalation.
+      const first = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
+      assert.deepStrictEqual(first.shouldEscalate, true, "precondition: first call escalates");
+
+      // Second check: same session, must NOT double-escalate.
       recordHealthSnapshot(2, 0, 0);
       const result = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
       assert.deepStrictEqual(result.shouldEscalate, false, "no double escalation in same session");
-      assert.ok(result.reason.includes("already escalated"), "reason explains why no escalation");
+      assert.ok(result.reason.includes("already escalated"), `reason must explain no-re-escalation (got: ${result.reason})`);
     });
 
     test('escalation: deferred when improving', () => {

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

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
@@ -1235,6 +1236,7 @@ describe('git-service', async () => {
     const content = readFileSync(join(repo, ".gitignore"), "utf-8");
     const lines = content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
     assert.ok(lines.includes(".gsd"), "ensureGitignore: .gitignore contains .gsd");
+    assert.ok(lines.includes(".mcp.json"), "ensureGitignore: .gitignore contains .mcp.json");
 
     // Idempotent — calling again doesn't add duplicates
     const modified2 = ensureGitignore(repo);

package/src/resources/extensions/gsd/tests/integration/gitignore-tracked-gsd.test.ts

@@ -107,6 +107,7 @@ test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (
     // Other baseline patterns should still be present
     assert.ok(lines.includes(".DS_Store"), "Expected .DS_Store in .gitignore");
     assert.ok(lines.includes("node_modules/"), "Expected node_modules/ in .gitignore");
+    assert.ok(lines.includes(".mcp.json"), "Expected .mcp.json in .gitignore");
   } finally {
     cleanup(dir);
   }

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

@@ -442,3 +442,33 @@ test('writeBlockerPlaceholder: updates DB slice status for complete-slice (#2653
     cleanup(base);
   }
 });
+
+test('writeBlockerPlaceholder: inserts placeholder slice for plan-milestone so deriveState exits pre-planning (#4378)', async () => {
+  const base = createFixtureBase();
+  try {
+    const { openDatabase, closeDatabase, insertMilestone, getMilestoneSlices, isDbAvailable } =
+      await import("../../gsd-db.ts");
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+    openDatabase(dbPath);
+    try {
+      insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+      // Before fix: writeBlockerPlaceholder wrote the placeholder ROADMAP.md but
+      // never updated the DB, so activeMilestoneSlices.length === 0 on next deriveState
+      // call → state.phase stays 'pre-planning' → plan-milestone dispatches again → infinite loop
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "idle recovery exhausted");
+
+      const slices = getMilestoneSlices("M001");
+      assert.ok(slices.length > 0,
+        "writeBlockerPlaceholder must insert a placeholder slice for plan-milestone so " +
+        "deriveState sees activeMilestoneSlices.length > 0 and exits pre-planning phase (#4378)");
+    } finally {
+      if (isDbAvailable()) closeDatabase();
+    }
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/integration/queue-completed-milestone-perf.test.ts

@@ -140,12 +140,18 @@ for (let i = 1; i <= COMPLETED_COUNT; i++) {
 
 // ─── Test: the overall context should be reasonable in size ──────────────
 
-// With 25 completed milestones NOT loading files, the context should be
-// significantly smaller than if all files were loaded
+// Invariant (not absolute budget): the per-completed-milestone line
+// contribution should stay small and CONSTANT (not proportional to the
+// size of its CONTEXT.md / SUMMARY.md). With 50 lines of fixture text
+// per completed CONTEXT.md, a naive loader would produce >=50 lines per
+// completed milestone (>1250 lines for 25 milestones). The fix emits a
+// short summary section plus separator per completed milestone, which
+// stays well under 10 lines/milestone regardless of CONTEXT.md size.
 const contextLines = context.split("\n").length;
+const avgLinesPerCompletedMilestone = contextLines / COMPLETED_COUNT;
 assertTrue(
-  contextLines < 200,
-  `Context should be concise (got ${contextLines} lines); completed milestones should not inflate it`,
+  avgLinesPerCompletedMilestone < 10,
+  `Completed milestones should not inflate the context: got ${contextLines} lines across ${COMPLETED_COUNT} completed milestones (~${avgLinesPerCompletedMilestone.toFixed(1)}/milestone)`,
 );
 
 // ─── Cleanup ──────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -1155,7 +1155,7 @@ describe("dispatch guard integration", () => {
     assert.ok(existsSync(validationPath), "VALIDATION file should be written");
     const content = readFileSync(validationPath, "utf-8");
     assert.ok(content.includes("verdict: pass"), "should contain pass verdict");
-    assert.ok(content.includes("skipped by preference"), "should note it was skipped");
+    assert.ok(content.includes("`skip_milestone_validation` preference"), "should note it was skipped via the preference path (#4781)");
   });
 
   test("rewrite-docs circuit breaker: exceeding MAX attempts resolves all overrides", async () => {

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

@@ -200,6 +200,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+      writeFileSync(join(msDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
       run("git add -A", repo);
       run("git commit -m \"add milestone\"", repo);

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -62,7 +63,7 @@ describe("interactive routing bypass (#3962)", () => {
     );
     // The function should check isAutoMode before routing synthesis
     const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = modelSelectionSrc.slice(fnIdx, fnIdx + 600);
+    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
     assert.ok(
       fnBody.includes("isAutoMode"),
       "resolvePreferredModelConfig should accept isAutoMode parameter",
@@ -137,8 +138,13 @@ describe("model downgrade notifications always visible (#3962)", () => {
     const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
     assert.ok(escalatedIdx > 0, "escalation block should exist");
 
-    // Get the block from "if (escalated)" to the next closing brace pattern
-    const block = modelSelectionSrc.slice(escalatedIdx, escalatedIdx + 400);
+    // Get the block from "if (escalated)" to the next distinctive marker
+    // (the capability-override loading that immediately follows).
+    const block = extractSourceRegion(
+      modelSelectionSrc,
+      "if (escalated)",
+      "// Load user capability overrides",
+    );
     assert.ok(
       block.includes("Tier escalation:"),
       "escalation block should contain the notification",

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -126,11 +126,8 @@ test("guided-flow stale paused-session scenario is suppressed when no resumable
   }
 });
 
-test("guided-flow source uses step-aware resume and clears stale paused metadata without changing discuss handoff semantics", () => {
-  const source = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  assert.ok(source.includes('const interrupted = await assessInterruptedSession(basePath);'));
-  assert.ok(source.includes('resumeLabel = interrupted.pausedSession?.stepMode'));
-  assert.ok(source.includes('step: interrupted.pausedSession?.stepMode ?? false'));
-  assert.ok(source.includes('unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"))'));
-  assert.ok(source.includes('pendingAutoStartMap.set(basePath,'));
-});
+// Note: the prior source-grep test that scanned guided-flow.ts for five
+// string literals was removed under #4827. The invariants it encoded
+// (step-aware resume + stale paused-session cleanup + pendingAutoStartMap
+// side effect) should be covered by a runtime drive of guided-flow —
+// tracked as a follow-up.

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -42,7 +42,7 @@ describe('isolation:none stale branch guard (#3675)', () => {
   });
 
   test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\(\)\s*===\s*["']none["']/,
+    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
       'guard should only activate when isolation mode is "none"');
   });