gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

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

@@ -223,6 +223,84 @@ test("selectAndApplyModel honors explicit phase models without downgrading (#361
   }
 });
 
+test("selectAndApplyModel escalates dynamic routing tier when retry metadata is provided", async (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-retry-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-retry-home-");
+  const setModelCalls: string[] = [];
+  const notifications: Array<{ message: string; level: string }> = [];
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "dynamic_routing:",
+      "  enabled: true",
+      "  hooks: false",
+      "  budget_pressure: false",
+      "  tier_models:",
+      "    light: claude-haiku-4-5",
+      "    standard: claude-sonnet-4-6",
+      "    heavy: claude-opus-4-6",
+      "---",
+    ].join("\n"),
+    "utf-8",
+  );
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+
+  const availableModels = [
+    { id: "claude-haiku-4-5", provider: "anthropic", api: "anthropic-messages" },
+    { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+    { id: "claude-opus-4-6", provider: "anthropic", api: "anthropic-messages" },
+  ];
+
+  const result = await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => availableModels },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: (message: string, level: string) => notifications.push({ message, level }) },
+      model: { provider: "anthropic", id: "claude-opus-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async (model: { provider: string; id: string }) => {
+        setModelCalls.push(`${model.provider}/${model.id}`);
+        return true;
+      },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-opus-4-6" },
+    { isRetry: true, previousTier: "light" },
+    true,
+  );
+
+  assert.deepEqual(setModelCalls, ["anthropic/claude-sonnet-4-6"]);
+  assert.deepEqual(result.routing, { tier: "standard", modelDowngraded: true });
+  assert.equal(result.appliedModel?.id, "claude-sonnet-4-6");
+  assert.ok(
+    notifications.some(n => n.message.includes("Tier escalation: light") && n.message.includes("standard")),
+    "retry metadata should produce a visible tier escalation notification",
+  );
+});
+
 // ─── resolveModelId tests ─────────────────────────────────────────────────
 
 test("resolveModelId: bare ID resolves to claude-code when session is claude-code (#3772)", () => {

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

@@ -0,0 +1,61 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { runFinalize } from "../auto/phases.ts";
+import { AutoSession } from "../auto/session.ts";
+
+test("runFinalize clears currentUnit after successful finalize", async () => {
+  const s = new AutoSession();
+  s.basePath = "/tmp/gsd-finalize-current-unit";
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  const deps = {
+    clearUnitTimeout() {},
+    buildSnapshotOpts() {
+      return {};
+    },
+    stopAuto: async () => {},
+    pauseAuto: async () => {},
+    updateProgressWidget() {},
+    postUnitPreVerification: async () => "continue",
+    runPostUnitVerification: async () => "continue",
+    postUnitPostVerification: async () => "continue",
+  };
+
+  const result = await runFinalize(
+    {
+      ctx: { ui: { notify() {} } },
+      pi: {},
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "flow-1",
+      nextSeq: () => 1,
+    } as any,
+    {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "",
+      finalPrompt: "",
+      pauseAfterUatDispatch: false,
+      state: {} as any,
+      mid: "M001",
+      midTitle: "Milestone",
+      isRetry: false,
+      previousTier: undefined,
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+
+  assert.equal(result.action, "next");
+  assert.equal(s.currentUnit, null);
+});

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

@@ -657,6 +657,80 @@ test("hasImplementationArtifacts returns true when implementation files committe
   }
 });
 
+test("hasImplementationArtifacts finds milestone implementation commits after retry resumes on main (#4699)", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit after plan-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# Summary");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "present", "main self-diff retry should find production execute-task commits");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts rejects milestone-scoped main history with only .gsd commits (#4699)", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Summary");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit after complete-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "milestone-scoped fallback must not treat .gsd-only commits as implementation");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts treats empty non-integration branch diff as absent (#4699)", () => {
+  const base = makeGitBase();
+  try {
+    execFileSync("git", ["checkout", "-b", "feat/empty-milestone"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "empty milestone branch diffs should not use main retry fallback");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts uses milestone path history instead of rolling depth (#4699)", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# Summary");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: old milestone implementation\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    mkdirSync(join(base, "docs"), { recursive: true });
+    for (let i = 0; i < 205; i++) {
+      writeFileSync(join(base, "docs", `note-${i}.md`), `# Note ${i}\n`);
+      execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+      execFileSync("git", ["commit", "-m", `docs: filler ${i}`], { cwd: base, stdio: "ignore" });
+    }
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "present", "milestone evidence should not age out after 200 unrelated commits");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts returns true on non-git directory (fail-open)", () => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });
@@ -706,6 +780,98 @@ test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)",
   }
 });
 
+test("verifyExpectedArtifact complete-milestone passes on main retry with milestone implementation commits (#4699)", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    mkdirSync(join(base, "src"), { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# Summary");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: implementation already on main\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, true, "complete-milestone should not fail solely because HEAD vs main is a self-diff");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact complete-milestone fails when DB milestone is not complete (#4658)", () => {
+  const base = makeGitBase();
+  try {
+    execFileSync("git", ["checkout", "-b", "feat/ms-db-active"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nverification FAILED — not complete.");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: implementation with failed summary"], { cwd: base, stdio: "ignore" });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, false, "complete-milestone must fail when DB status is not complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact complete-milestone passes when DB milestone is complete (#4658)", () => {
+  const base = makeGitBase();
+  try {
+    execFileSync("git", ["checkout", "-b", "feat/ms-db-complete"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: implementation complete"], { cwd: base, stdio: "ignore" });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, true, "complete-milestone should pass when DB status is complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact complete-milestone tolerates transient DB lag when SUMMARY is canonical success (#4658)", () => {
+  const base = makeGitBase();
+  try {
+    execFileSync("git", ["checkout", "-b", "feat/ms-db-lag-success"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+      [
+        "---",
+        "id: M001",
+        "status: complete",
+        "---",
+        "",
+        "# M001: Success",
+      ].join("\n"),
+    );
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: implementation with stale db"], { cwd: base, stdio: "ignore" });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, true, "canonical success SUMMARY should pass verification during transient DB lag");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("verifyExpectedArtifact checks pending gate-evaluate artifacts without ESM require failures", () => {
   const base = makeTmpProject();
 

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -15,6 +15,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -43,7 +44,9 @@ describe('auto-remediate stale slice status (#3673)', () => {
     assert.match(before, /try\s*\{/,
       'updateSliceStatus should be inside a try block');
 
-    const after = source.slice(updateIdx, updateIdx + 300);
+    // Bound the region to stop before the rogue fallback so /catch/ only
+    // matches this try block's catch, not an unrelated later one.
+    const after = extractSourceRegion(source, 'updateSliceStatus(mid, sid', 'rogues.push({');
     assert.match(after, /catch/,
       'try block should have a catch for fallback');
   });

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

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

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -0,0 +1,64 @@
+// GSD-2 auto-start regression test: cleanStaleRuntimeUnits is DB-gated (#4663)
+//
+// Source-level structural check that the stale-runtime-cleanup predicate in
+// auto-start.ts consults DB status when available instead of treating a
+// SUMMARY-file on disk as proof of milestone completion. Pairs with #4658 /
+// PR #4660 fix in auto-dispatch + auto-recovery.
+
+import { describe, test } from "node:test";
+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));
+const sourceFile = join(__dirname, "..", "auto-start.ts");
+
+describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports isClosedStatus for DB-status check", () => {
+    assert.match(
+      source,
+      /import\s*\{\s*isClosedStatus\s*\}\s*from\s*["']\.\/status-guards/,
+    );
+  });
+
+  test("cleanStaleRuntimeUnits is called after openProjectDbIfPresent", () => {
+    const openDbIdx = source.indexOf("await openProjectDbIfPresent(base)");
+    assert.ok(openDbIdx > -1, "openProjectDbIfPresent should be called in auto-start");
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(", openDbIdx);
+    assert.ok(
+      cleanIdx > -1,
+      "cleanStaleRuntimeUnits must run AFTER openProjectDbIfPresent so predicate can consult DB",
+    );
+  });
+
+  test("cleanStaleRuntimeUnits predicate consults DB status when available", () => {
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
+    assert.ok(cleanIdx > -1);
+    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
+    assert.match(
+      snippet,
+      /isDbAvailable\(\)/,
+      "predicate must branch on DB availability",
+    );
+    assert.match(
+      snippet,
+      /isClosedStatus\(/,
+      "predicate must check DB status via isClosedStatus",
+    );
+  });
+
+  test("cleanStaleRuntimeUnits predicate still falls back to SUMMARY-file when DB unavailable", () => {
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
+    assert.ok(cleanIdx > -1);
+    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
+    assert.match(
+      snippet,
+      /resolveMilestoneFile\(base,\s*mid,\s*["']SUMMARY["']\)/,
+      "legacy FS-fallback branch should still use SUMMARY file presence",
+    );
+  });
+});