@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.553dc518

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

@@ -49,6 +49,24 @@ test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exi
   assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
 });
 
+test("recoverFailedMigration removes orphan when .gsd is a real intact directory", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-real-orphan-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const localGsd = join(base, ".gsd");
+  mkdirSync(join(localGsd, "phases"), { recursive: true });
+  mkdirSync(join(localGsd, "activity"), { recursive: true });
+  writeFileSync(join(localGsd, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(localGsd, "gsd.db"), "not empty\n", "utf-8");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(localGsd), ".gsd real directory must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
 test("recoverFailedMigration removes orphan when .gsd is an intact external-state junction", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-migrating-orphan-"));
   const stateDir = mkdtempSync(join(tmpdir(), "gsd-migrating-state-"));

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

@@ -63,6 +63,62 @@ test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models
   }
 });
 
+test("resolvePreferredModelConfig treats token-profile model defaults as synthesized routing", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: quality",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  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 config = resolvePreferredModelConfig(
+      "plan-slice",
+      {
+        provider: "anthropic",
+        id: "claude-sonnet-4-6",
+      },
+      true,
+      tempProject,
+      [
+        "anthropic/claude-haiku-4-5",
+        "anthropic/claude-sonnet-4-6",
+        "anthropic/claude-opus-4-6",
+      ],
+      "anthropic/claude-sonnet-4-6",
+    );
+
+    assert.deepEqual(config, {
+      primary: "claude-opus-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    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 });
+  }
+});
+
 test("resolvePreferredModelConfig falls back to auto start model when heavy tier is absent", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -152,6 +208,128 @@ test("resolvePreferredModelConfig keeps explicit phase models as the ceiling", (
   }
 });
 
+// #1115 regression: a token_profile with dynamic_routing enabled but NO
+// tier_models pins must still resolve the profile's per-phase model as a
+// synthesized routing ceiling. Before the fix, resolvePreferredModelConfig
+// bailed to undefined here (explicit detection skips profile defaults, and the
+// synthesis path required tier_models), so auto dispatch fell back to the
+// start model for every unit and silently discarded the profile.
+test("resolvePreferredModelConfig resolves profile per-phase models as synthesized when tier_models are absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const availableModelIds = [
+      "anthropic/claude-haiku-4-5",
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-opus-4-6",
+    ];
+    const start = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    // preferredModelId is intentionally left undefined so profile tier
+    // resolution is exercised rather than pinning every tier to the session
+    // model (a heavy session model can satisfy every tier).
+    const resolve = (unitType: string) =>
+      resolvePreferredModelConfig(unitType, start, true, tempProject, availableModelIds);
+
+    // budget profile: research=light, planning=standard, execution=standard,
+    // execution_simple=light, completion=light (PROFILE_TIER_MAP).
+    assert.deepEqual(resolve("research-milestone"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("plan-milestone"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task-simple"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("complete-slice"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    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 });
+  }
+});
+
+// #1115 guard: the explicit flat-rate opt-out must suppress synthesized routing
+// even on the profile-derived (no tier_models) path — the opt-out moved ahead
+// of both synthesis branches, so a flat-rate start model with
+// allow_flat_rate_providers:false yields no config (start model is used as-is).
+test("resolvePreferredModelConfig honors flat-rate opt-out on the profile path (no tier_models)", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-flatrate-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-flatrate-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  allow_flat_rate_providers: false",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig(
+      "execute-task",
+      // claude-code is a built-in flat-rate provider.
+      { provider: "claude-code", id: "claude-opus-4-6" },
+      true,
+      tempProject,
+      ["anthropic/claude-haiku-4-5", "anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6"],
+    );
+
+    assert.equal(config, undefined);
+  } finally {
+    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 });
+  }
+});
+
 test("selectAndApplyModel honors explicit phase models without downgrading (#3617)", async () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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

@@ -61,6 +61,7 @@ async function runSuccessfulFinalize(s: AutoSession) {
     },
     stopAuto: async () => {},
     pauseAuto: async () => {},
+    checkpointWorkflowDatabase() {},
     updateProgressWidget() {},
     postUnitPreVerification: async () => "continue",
     runPostUnitVerification: async () => "continue",
@@ -410,9 +411,13 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
   const notifications: Array<{ message: string; level?: string }> = [];
   const stopCalls: Array<{ reason?: string; preserve?: boolean }> = [];
   const mergeCalls: string[] = [];
+  const checkpointCalls: string[] = [];
   const result = await runFinalizeWithDeps(
     s,
     {
+      checkpointWorkflowDatabase() {
+        checkpointCalls.push("checkpoint");
+      },
       stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: { preserveCompletedMilestoneBranch?: boolean }) => {
         stopCalls.push({ reason, preserve: options?.preserveCompletedMilestoneBranch });
       },
@@ -438,16 +443,53 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
 
   assert.equal(result.action, "break");
   assert.equal(result.reason, "root-write-leak");
+  assert.deepEqual(checkpointCalls, ["checkpoint"], "root-write leak should flush DB before stopAuto");
   assert.deepEqual(stopCalls, [{ reason: "Root-write leak during isolated auto-mode", preserve: true }]);
   assert.deepEqual(mergeCalls, [], "root-write leak must stop before merge preflight");
   const message = notifications.find((n) => n.level === "error")?.message ?? "";
   assert.match(message, /execute-task M001\/S01\/T01/);
   assert.match(message, /Project root:/);
   assert.match(message, /Expected worktree:/);
-  assert.match(message, /index\.html/);
+  assert.doesNotMatch(message, /index\.html/);
   assert.match(message, /tests\/verify-s09\.sh/);
 });
 
+test("runFinalize ignores tracked root artifact changes during isolated units", async (t) => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-tracked-"));
+  const worktree = join(root, ".gsd", "worktrees", "M001");
+  t.after(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+  initRepo(root);
+  writeFileSync(join(root, "openapi.json"), "{}\n");
+  runGit(root, ["add", "openapi.json"]);
+  runGit(root, ["commit", "-m", "chore: add generated spec"]);
+  mkdirSync(worktree, { recursive: true });
+
+  const s = new AutoSession();
+  s.basePath = worktree;
+  s.originalBasePath = root;
+  s.currentMilestoneId = "M001";
+  s.rootWriteBaseline = captureRootDirtySnapshot(root);
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  writeFileSync(join(root, "openapi.json"), "{\"generated\":true}\n");
+
+  const stopCalls: string[] = [];
+  const result = await runFinalizeWithDeps(s, {
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string) => {
+      stopCalls.push(reason ?? "");
+    },
+  });
+
+  assert.equal(result.action, "next");
+  assert.deepEqual(stopCalls, []);
+});
+
 test("runFinalize allows root .gsd-only changes during isolated units", async (t) => {
   const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-gsd-"));
   const worktree = join(root, ".gsd", "worktrees", "M001");

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

@@ -838,6 +838,60 @@ test("verifyExpectedArtifact plan-slice fails when a task plan file is missing (
   }
 });
 
+test("verifyExpectedArtifact accepts flat-phase plan-slice with embedded tasks and no task plan files", () => {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  try {
+    const phaseDir = join(base, ".gsd", "phases", "01-test");
+    mkdirSync(join(phaseDir, "tasks"), { recursive: true });
+    writeFileSync(join(phaseDir, "01-01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "- [ ] **T01**: Implement feature _(1h)_",
+      "  - Files: `src/index.ts`",
+      "  - Verify: pnpm test",
+      "- [ ] **T02**: Write tests _(1h)_",
+      "</tasks>",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, true, "flat-phase embedded tasks should not require tasks/T##-PLAN.md files");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact plan-slice still verifies per-task files for legacy ## Tasks plan with a stray empty <tasks> block", () => {
+  const base = makeTmpBase();
+  try {
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    // Legacy layout: real tasks live in a "## Tasks" section with separate
+    // per-task PLAN files, but the plan also carries an empty <tasks></tasks>
+    // block. The empty block must NOT flip the plan into flat-phase mode and
+    // skip the per-task artifact checks.
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "</tasks>",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:1h`",
+      "- [ ] **T02: Second task** `est:2h`",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
+    // Only T01-PLAN.md exists; T02's artifact is missing.
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "a stray <tasks> block must not skip per-task file verification for a legacy ## Tasks plan");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -124,3 +124,44 @@ test("forceStopAutoRemote escalates a live remote PID and releases worker state"
   );
   assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
 });
+
+test("forceStopAutoRemote does not SIGKILL a PID that exits during the grace window", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 525_252;
+  setWorkerPid(workerId, pid);
+  writeLegacyLock(base, pid);
+
+  // The process is alive until it receives SIGTERM, then exits cooperatively
+  // (liveness probe throws ESRCH) — so the grace loop should break before SIGKILL.
+  const signals: Array<NodeJS.Signals | 0> = [];
+  let alive = true;
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    if (signal === 0) {
+      if (!alive) {
+        const err = new Error("no such process") as NodeJS.ErrnoException;
+        err.code = "ESRCH";
+        throw err;
+      }
+      return true;
+    }
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    if (signal === "SIGTERM") alive = false; // cooperative exit on SIGTERM
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(!signals.includes("SIGKILL"), "force stop must not escalate when the PID exits during the grace window");
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});

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

@@ -3,6 +3,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   autoSession,
@@ -11,6 +14,10 @@ import {
   getAutoRuntimeSnapshot,
   recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
+import {
+  readUnitHarnessAbort,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
@@ -81,6 +88,40 @@ test("clearToolInvocationError clears stale tool error state for active auto ses
   autoSession.reset();
 });
 
+test("clearToolInvocationError clears stale tool error even when a harness abort is durable", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-runtime-state-"));
+  const startedAt = 123456;
+  try {
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.setCurrentUnit({
+      type: "gate-evaluate",
+      id: "M001/S01/gates+Q3",
+      startedAt,
+      workspaceRoot: base,
+    });
+    autoSession.lastToolInvocationError = "gsd_save_gate_result: simulated stale tool error";
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "tool-error",
+      reason: "Tool execution failed before the unit could complete its gate evaluation.",
+      toolName: "gsd_uat_exec",
+    });
+
+    clearToolInvocationError();
+
+    assert.equal(autoSession.lastToolInvocationError, null);
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "tool-error",
+      "durable harness abort remains available for result-save blocking",
+    );
+  } finally {
+    autoSession.reset();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
   autoSession.reset();
 

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

@@ -121,8 +121,8 @@ describe("AutoSession.scope — project mode (basePath equals originalBasePath)"
 
     assert.ok(s.scope, "scope should be set");
     const gsd = join(projectDir, ".gsd");
-    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
-    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.contextFile(), join(gsd, "phases", "02-m002", "02-CONTEXT.md"));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "phases", "02-m002", "02-ROADMAP.md"));
     assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
   });
 });
@@ -236,8 +236,8 @@ describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
     assert.ok(ctxM001, "M001 contextFile should be set");
     assert.ok(ctxM002, "M002 contextFile should be set");
     assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
-    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
-    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+    assert.ok(ctxM001.includes("01-m001"), "M001 path should contain its phase directory");
+    assert.ok(ctxM002.includes("02-m002"), "M002 path should contain its phase directory");
   });
 });
 

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -17,14 +17,17 @@ import {
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
 test.afterEach(() => {
+  closeDatabase();
   clearPendingAutoStart();
 });
 
 test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before re-entering auto-mode", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-await-"));
   const notifications: string[] = [];
+  openDatabase(":memory:");
   t.after(() => rmSync(base, { recursive: true, force: true }));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   setPendingAutoStart(base, {

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

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
-import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
+import { cleanStaleRuntimeUnits } from "../auto-worktree-runtime-cleanup.ts";
 
 function makeBase(): string {
   return join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);

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

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { recoverTimedOutUnit } from "../auto-timeout-recovery.ts";
+import {
+  readUnitHarnessAbort,
+  readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
+
+test("timeout recovery retry clears stale harness abort for the same unit run", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-recovery-abort-"));
+  const startedAt = Date.now();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "turn-abort",
+      reason: "Agent turn aborted before the unit could complete its gate evaluation.",
+    });
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "turn-abort",
+      "test setup should start with an abort marker",
+    );
+
+    const messages: Array<{ message: unknown; options: unknown }> = [];
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const result = await recoverTimedOutUnit(
+      { ui: { notify: (message: string, level?: string) => notifications.push({ message, level }) } } as any,
+      { sendMessage: (message: unknown, options: unknown) => messages.push({ message, options }) } as any,
+      "gate-evaluate",
+      "M001/S01/gates+Q3",
+      "idle",
+      {
+        basePath: base,
+        verbose: false,
+        currentUnitStartedAt: startedAt,
+        unitRecoveryCount: new Map(),
+      },
+    );
+
+    assert.equal(result, "recovered");
+    assert.equal(readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt), null);
+    const record = readUnitRuntimeRecord(base, "gate-evaluate", "M001/S01/gates+Q3");
+    assert.equal(record?.phase, "recovered");
+    assert.equal(record?.lastProgressKind, "idle-recovery-retry");
+    assert.equal(messages.length, 1, "retry recovery should send one steering message");
+    assert.equal(notifications.length, 1, "retry recovery should notify once");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -28,12 +28,18 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { buildFlatRateContext } from "../auto-model-selection.ts";
-import { _isSamePath, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { _isSamePath } from "../auto-worktree-path-utils.ts";
 import {
   checkAutoStartAfterDiscuss,
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -89,6 +95,8 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
     mkdirSync(milestoneDir, { recursive: true });
     writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# Context\n", "utf-8");
     writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "M001", status: "queued" });
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
@@ -110,6 +118,7 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
       },
     ]);
   } finally {
+    closeDatabase();
     clearPendingAutoStart(base);
     rmSync(base, { recursive: true, force: true });
   }

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

@@ -11,7 +11,7 @@ import assert from "node:assert/strict";
 import {
   isSafeToAutoResolve,
   SAFE_AUTO_RESOLVE_PATTERNS,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-conflict-auto-resolve.ts";
 
 describe("isSafeToAutoResolve", () => {
   // ─── .gsd/ state files ───────────────────────────────────────────────────