@opengsd/gsd-pi 1.5.0 → 1.6.0

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -360,6 +360,174 @@ test("canonical worktree + project-root legacy dir produces legacy filename (#bu
   }
 });
 
+// ── cursor[bot] 3523932401: bare milestone id must not match a team-suffix ────
+//
+// A bare milestone id (M001, no team-mode suffix) resolves its phase dir by
+// scanning phases/NN-*. Before the guard (commit 8f45bf3),
+// phaseDirMatchesMilestoneId returned true for ANY same-number dir, so a
+// leftover team-mode projection (phases/01-<6char>-.../, from a prior
+// team-suffixed run) matched the bare id too. When that stale dir carried a
+// newer mtime, pickPreferredPhaseDir selected it over the real title dir and
+// resolved the ROADMAP into a directory that has no ROADMAP — the file-not-found
+// retry loop. The guard (slugLooksLikeTeamSuffixProjection) rejects
+// team-suffix-looking slugs for bare ids in the primary pass; the suffixed
+// projection stays available only as a fallback when the primary pass finds
+// nothing (#1195, guarded by the second test below).
+
+test("bare milestone id prefers the real title dir over a newer team-suffix projection (cursor 3523932401)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-bare-teamsuffix-")));
+  try {
+    const phasesDir = join(root, ".gsd", "phases");
+    // Intended flat-phase dir for the bare id: 01-<title-slug>/ with the ROADMAP.
+    const intendedDir = join(phasesDir, "01-clean-continuation");
+    mkdirSync(intendedDir, { recursive: true });
+    writeFileSync(join(intendedDir, "01-ROADMAP.md"), "# roadmap\n");
+
+    // Leftover team-mode projection: 01-<6char>-.../ with NO ROADMAP, made
+    // NEWER so an mtime tiebreak would wrongly prefer it without the guard.
+    const staleDir = join(phasesDir, "01-re4q3k-old-team-projection");
+    mkdirSync(staleDir, { recursive: true });
+    const newer = new Date(Date.now() + 60_000);
+    const older = new Date(Date.now() - 60_000);
+    utimesSync(staleDir, newer, newer);
+    utimesSync(intendedDir, older, older);
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("plan-milestone", "M001", root);
+    assert.equal(
+      resolved,
+      join(intendedDir, "01-ROADMAP.md"),
+      "bare id must resolve to the real title dir, not the newer team-suffix projection",
+    );
+    assert.notEqual(
+      resolved,
+      join(staleDir, "01-ROADMAP.md"),
+      "must NOT resolve into the team-suffix projection dir that has no ROADMAP",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("bare milestone id still falls back to a lone team-suffix projection (#1195)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-bare-teamsuffix-only-")));
+  try {
+    const phasesDir = join(root, ".gsd", "phases");
+    // The only on-disk dir for the bare id is a team-mode projection. With no
+    // non-suffixed candidate, the fallback pass must still resolve to it.
+    const onlyDir = join(phasesDir, "01-re4q3k-clean-continuation");
+    mkdirSync(onlyDir, { recursive: true });
+    writeFileSync(join(onlyDir, "01-ROADMAP.md"), "# roadmap\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("plan-milestone", "M001", root);
+    assert.equal(
+      resolved,
+      join(onlyDir, "01-ROADMAP.md"),
+      "with no non-suffixed dir, the team-suffix projection is the correct fallback",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ── #1208: flat-phase execute-task summaries resolve at the phase root ────────
+//
+// In flat-phase layout task summaries are written beside the plan files
+// (phases/<phase>/T##-SUMMARY.md), NOT under a tasks/ subdir. A tasks/ dir may
+// still exist to hold auxiliary task-scoped gate artifacts (e.g. T01-VERIFY.json).
+// Before the fix, the mere existence of that tasks/ dir redirected summary
+// verification into tasks/T##-SUMMARY.md — which never exists — trapping auto-mode
+// in a false verification retry that eventually paused after a successful task.
+
+test("flat-phase execute-task summary resolves at phase root when no tasks/ dir exists (#1208)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-flat-task-summary-")));
+  try {
+    const gsd = join(root, ".gsd");
+    const phaseDir = join(gsd, "phases", "49-end-to-end-mandates");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "49-03-PLAN.md"), "# plan\n- [x] T02\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    assert.equal(
+      resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root),
+      join(phaseDir, "T02-SUMMARY.md"),
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("flat-phase execute-task summary resolves at phase root even when tasks/ dir holds gate artifacts (#1208)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-flat-task-tasksdir-")));
+  try {
+    const gsd = join(root, ".gsd");
+    const phaseDir = join(gsd, "phases", "49-end-to-end-mandates");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "49-03-PLAN.md"), "# plan\n- [x] T02\n");
+    // Auxiliary task-scoped gate artifact — creates the tasks/ dir but must not
+    // redirect the T02 summary into tasks/.
+    const tasksDir = join(phaseDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(tasksDir, "T01-VERIFY.json"), '{"ok":true}');
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const resolved = resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root);
+    assert.equal(
+      resolved,
+      join(phaseDir, "T02-SUMMARY.md"),
+      "flat-phase task summary must resolve at the phase root, not tasks/",
+    );
+    assert.notEqual(
+      resolved,
+      join(tasksDir, "T02-SUMMARY.md"),
+      "a tasks/ dir with gate artifacts must NOT redirect summary resolution into tasks/",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("legacy execute-task summary still resolves under slices/<SID>/tasks/ (#1208 regression guard)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-legacy-task-summary-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# plan\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    assert.equal(
+      resolveExpectedArtifactPath("execute-task", "M001/S01/T02", root),
+      join(tasksDir, "T02-SUMMARY.md"),
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 // ── resolveSliceResearchLocation / resolveExistingSliceResearchPath ───────────
 //
 // Added in the code-quality consolidation PR as the shared dual-path resolver

package/src/resources/extensions/gsd/tests/auto-loop-no-copy-artifacts.test.ts

@@ -14,7 +14,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { createAutoWorktree, teardownAutoWorktree } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 function git(args: string[], cwd: string): void {
   execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });

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

@@ -797,9 +797,11 @@ test("stuck-loop: empty ring on a freshly constructed orchestrator advances norm
   assert.equal(result.kind, "advanced");
 });
 
-test("stuck-loop: partial fill of mixed units does not block", async (t) => {
+test("stuck-loop: distinct units making forward progress do not block", async (t) => {
+  // Healthy forward progress visits new units every advance — no key repeats,
+  // so no oscillation/repeat rule fires even once the window is full.
   let i = 0;
-  const sequence = ["M001/S01/A", "M001/S01/B", "M001/S01/A", "M001/S01/B", "M001/S01/A", "M001/S01/B"];
+  const sequence = ["M001/S01/A", "M001/S01/B", "M001/S01/C", "M001/S01/D", "M001/S01/E", "M001/S01/F"];
   const f = makeFixture({
     dispatch: () => ({ action: "dispatch", unitType: "execute-task", unitId: sequence[i++ % sequence.length], prompt: "p" }),
   });
@@ -811,6 +813,43 @@ test("stuck-loop: partial fill of mixed units does not block", async (t) => {
   }
 });
 
+test("stuck-loop #1225: two-unit oscillation blocks once the window saturates", async (t) => {
+  // Reproduces the execute-task ↔ complete-slice loop: a slice gate keeps
+  // reopening the same task, so two keys alternate forever. Neither key ever
+  // saturates the window on its own, so the old matchingCount>=SIZE gate never
+  // consulted detect-stuck and the loop ran until an external kill. The window
+  // still fills, so detect-stuck's oscillation/repeat rules must now fire.
+  let i = 0;
+  const sequence: Array<{ unitType: string; unitId: string }> = [
+    { unitType: "execute-task", unitId: "M001/S01/T01" },
+    { unitType: "complete-slice", unitId: "M001/S01" },
+  ];
+  const f = makeFixture({
+    dispatch: () => {
+      const next = sequence[i++ % sequence.length];
+      return { action: "dispatch", unitType: next.unitType, unitId: next.unitId, prompt: "p" };
+    },
+  });
+  t.after(() => f.cleanup());
+
+  let blocked: Awaited<ReturnType<typeof f.orchestrator.advance>> | undefined;
+  for (let round = 0; round < STUCK_WINDOW_SIZE; round++) {
+    const result = await f.orchestrator.advance();
+    if (result.kind === "blocked") {
+      blocked = result;
+      break;
+    }
+  }
+
+  assert.ok(blocked, "oscillation must be detected once the window saturates");
+  if (!blocked || blocked.kind !== "blocked") return;
+  assert.equal(blocked.action, "stop");
+  assert.ok(
+    blocked.reason.startsWith("stuck-loop:"),
+    `expected stuck-loop verdict, got: ${blocked.reason}`,
+  );
+});
+
 test("stuck-loop: ring saturated with same unit blocks with action 'stop' and stuck-loop reason", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());

package/src/resources/extensions/gsd/tests/auto-post-unit-artifact-diagnostic.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
@@ -8,6 +8,7 @@ import {
   maybeWriteParallelResearchCostSpikeBlocker,
 } from "../auto-post-unit.ts";
 import { resolveExpectedArtifactPath } from "../auto-recovery.ts";
+import { _clearGsdRootCache, clearPathCache } from "../paths.ts";
 
 test("missing execute-task artifact includes completion contract and completion-tool hint", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-artifact-diag-"));
@@ -56,3 +57,49 @@ test("parallel research cost spike writes durable PARALLEL-BLOCKER", () => {
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+// ── #1238: symlinked project root must not produce a ../ path walk ────────────
+//
+// On WSL (and any layout where the project root is reached through a symlink),
+// artifact resolution canonicalizes through gsdRoot (realpathSync), so the
+// resolved artifact path lives under the REAL root while `basePath` is still the
+// symlink. Before the fix, relative(symlinkBase, realArtifactPath) walked up out
+// of the symlink (../../…/home/…) and the diagnostic reported that broken path as
+// "not found on disk". Normalizing basePath to its real path first keeps the
+// displayed path anchored at the real .gsd root.
+
+test("symlinked project root yields a clean .gsd-relative artifact path, not a ../ walk (#1238)", () => {
+  const realRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-symlink-real-")));
+  const linkParent = realpathSync(mkdtempSync(join(tmpdir(), "gsd-symlink-link-")));
+  const linkRoot = join(linkParent, "project");
+  try {
+    // Content-bearing legacy milestone dir so plan-milestone resolves the
+    // canonical (realpath) ROADMAP path under realRoot/.gsd/milestones/M001/.
+    const milestoneDir = join(realRoot, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+    // The ROADMAP intentionally does not exist — this hits the "not found on
+    // disk" branch, the exact symptom in #1238.
+    symlinkSync(realRoot, linkRoot);
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const msg = _describeArtifactVerificationFailureForTest("plan-milestone", "M001", linkRoot);
+
+    assert.match(msg, /was not found on disk after unit execution/);
+    // The displayed path must be anchored at the real .gsd root, not a broken
+    // parent-walk out of the symlinked base.
+    assert.doesNotMatch(msg, /\.\.[/\\]/, "must not contain a ../ walk out of the symlinked base");
+    assert.match(
+      msg,
+      /\.gsd[/\\]milestones[/\\]M001[/\\]M001-ROADMAP\.md/,
+      "must show the clean .gsd-relative ROADMAP path",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(linkParent, { recursive: true, force: true });
+    rmSync(realRoot, { recursive: true, force: true });
+  }
+});

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

@@ -299,6 +299,63 @@ test("refreshRecoveryDbForArtifact treats missing execute-task DB rows as fatal
   });
 });
 
+test("refreshRecoveryDbForArtifact promotes an open execute-task DB row when artifacts are verified on disk (#1204)", () => {
+  const dir = makeTmpProject();
+  insertTask({
+    milestoneId: "M001",
+    sliceId: "S01",
+    id: "T01",
+    title: "Stuck Task",
+    status: "pending",
+  });
+  const sliceDir = join(dir, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+    "# S01 Plan",
+    "",
+    "- [ ] **T01: Implement feature** `est:1h`",
+    "",
+  ].join("\n"));
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01", dir);
+
+  assert.deepEqual(result, { ok: true });
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+  const planContent = readFileSync(join(sliceDir, "S01-PLAN.md"), "utf-8");
+  assert.ok(planContent.includes("[x] **T01:"), "plan checkbox should be re-rendered to [x]");
+  const events = readEvents(join(dir, ".gsd", "event-log.jsonl"));
+  assert.ok(
+    events.some((e) => e.cmd === "complete-task" && e.trigger_reason === "stuck-artifact-recovery"),
+    "a complete-task recovery event should be appended",
+  );
+});
+
+test("refreshRecoveryDbForArtifact still appends the recovery event when the plan checkbox sync throws after DB promotion (#1221)", () => {
+  const dir = makeTmpProject();
+  insertTask({
+    milestoneId: "M001",
+    sliceId: "S01",
+    id: "T01",
+    title: "Stuck Task",
+    status: "pending",
+  });
+  const sliceDir = join(dir, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  // Make the expected plan path a directory so the best-effort checkbox
+  // rewrite (readFileSync) throws EISDIR after the DB row is already promoted.
+  mkdirSync(join(sliceDir, "S01-PLAN.md"), { recursive: true });
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01", dir);
+
+  assert.deepEqual(result, { ok: true });
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+  const events = readEvents(join(dir, ".gsd", "event-log.jsonl"));
+  assert.ok(
+    events.some((e) => e.cmd === "complete-task" && e.trigger_reason === "stuck-artifact-recovery"),
+    "recovery event must still be appended even when the plan checkbox sync fails",
+  );
+});
+
 test("refreshRecoveryDbForArtifact closes complete-milestone DB row when artifacts exist but DB is stale (#5568)", async () => {
   const base = mkdtempSync(join(tmpdir(), "auto-recovery-complete-ms-"));
   mkdirSync(join(base, ".gsd"), { recursive: true });

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-start-project-milestone-reconcile.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { closeDatabase, getAllMilestones, getMilestone, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
+import { _getAdapter, closeDatabase, getAllMilestones, getMilestone, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
 import { reconcileMergedMilestonesFromJournal, reconcileProjectMilestonesFromDisk } from "../auto-start.ts";
 import { emitWorktreeMerged } from "../worktree-telemetry.ts";
 
@@ -69,3 +69,31 @@ test("#5389: bootstrap reconciles PROJECT.md milestones that are missing from DB
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("#1236: bootstrap merged-milestone reconciliation degrades to a warning instead of aborting when the DB is degraded", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-merged-reconcile-degraded-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Merged Milestone", status: "active" });
+
+    emitWorktreeMerged(base, "M001", { reason: "milestone-complete", conflict: false });
+
+    // Simulate a degraded DB: the connection stays "available" (isDbAvailable()
+    // remains true because the handle is non-null), but the milestones table is
+    // gone, so the reconciler's DB access throws partway through bootstrap.
+    _getAdapter()!.exec("DROP TABLE milestones");
+    assert.equal(isDbAvailable(), true);
+
+    // Regression (#1236): this reconciler was previously unguarded, so a
+    // degraded-DB failure threw and aborted the rest of `/gsd auto` bootstrap.
+    // It must now catch, warn, and return 0, matching its sibling
+    // reconcileProjectMilestonesFromDisk. Reaching the assertion proves it did
+    // not throw.
+    const closed = reconcileMergedMilestonesFromJournal(base);
+    assert.equal(closed, 0);
+  } finally {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-timeout-recovery-supervisor-inflight-guard.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Idle/hard timeout recovery honors the in-flight-tool guard (#1229 follow-up).
+ *
+ * `recoverTimedOutUnit` steers a still-running unit with `deliverAs: "steer"`
+ * and, before that, may swap the session model via
+ * `applySupervisorModelIfConfigured`. Swapping the model and triggering a turn
+ * while non-interactive tool calls are still open skips tool results and trips
+ * provider errors (#3512) — the same failure the soft wrap-up and continue-here
+ * timers guard against. This test pins that the idle and hard steering branches
+ * gate both the model swap and `triggerTurn` on `getInFlightToolCount() === 0`.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { clearGSDPreferencesCache } from "../preferences.ts";
+import {
+  markToolStart,
+  markToolEnd,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
+
+const SUPERVISOR_PREFS = [
+  "auto_supervisor:",
+  "  soft_timeout_minutes: 1",
+  "  idle_timeout_minutes: 100",
+  "  hard_timeout_minutes: 100",
+  "  model:",
+  "    model: supervisor-primary",
+  "    fallbacks: [supervisor-fb]",
+];
+
+interface Harness {
+  home: string;
+  base: string;
+  ctx: any;
+  pi: any;
+  rctx: RecoveryContext;
+  setModelCalls: unknown[][];
+  sendMessageCalls: unknown[][];
+}
+
+function makeHarness(): Harness {
+  const home = mkdtempSync(join(tmpdir(), "gsd-recovery-guard-home-"));
+  const base = mkdtempSync(join(tmpdir(), "gsd-recovery-guard-base-"));
+  process.env.GSD_HOME = home;
+  writeFileSync(join(home, "preferences.md"), ["---", ...SUPERVISOR_PREFS, "---", ""].join("\n"));
+  clearGSDPreferencesCache();
+
+  const setModelCalls: unknown[][] = [];
+  const sendMessageCalls: unknown[][] = [];
+
+  const ctx = {
+    ui: { notify: () => {} },
+    model: { provider: "anthropic" },
+    modelRegistry: {
+      getAvailable: () => [
+        { id: "supervisor-primary", provider: "anthropic" },
+        { id: "supervisor-fb", provider: "anthropic" },
+      ],
+    },
+  } as any;
+
+  const pi = {
+    sendMessage: (...args: unknown[]) => {
+      sendMessageCalls.push(args);
+    },
+    setModel: async (...args: unknown[]) => {
+      setModelCalls.push(args);
+      return true;
+    },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
+  } as any;
+
+  const rctx: RecoveryContext = {
+    basePath: base,
+    verbose: false,
+    currentUnitStartedAt: 1234,
+    unitRecoveryCount: new Map(),
+  };
+
+  return { home, base, ctx, pi, rctx, setModelCalls, sendMessageCalls };
+}
+
+function cleanup(h: Harness): void {
+  clearInFlightTools();
+  clearGSDPreferencesCache();
+  delete process.env.GSD_HOME;
+  rmSync(h.home, { recursive: true, force: true });
+  rmSync(h.base, { recursive: true, force: true });
+}
+
+// "discuss-project" resolves to a PROJECT.md that never exists in the temp base,
+// so recovery skips the "already on disk" shortcut and reaches the steering
+// branch with recoveryAttempts (0) < maxRecoveryAttempts.
+for (const reason of ["idle", "hard"] as const) {
+  test(`${reason} recovery skips the supervisor model swap while a tool is in flight`, async () => {
+    const h = makeHarness();
+    try {
+      markToolStart("call-1", true, "some_tool");
+
+      const outcome = await recoverTimedOutUnit(
+        h.ctx,
+        h.pi,
+        "discuss-project",
+        "P01",
+        reason,
+        h.rctx,
+      );
+
+      assert.equal(outcome, "recovered");
+      assert.equal(
+        h.setModelCalls.length,
+        0,
+        "model must NOT swap while a tool is in flight",
+      );
+      assert.equal(h.sendMessageCalls.length, 1, "steer message still sent (queued)");
+      const opts = h.sendMessageCalls[0][1] as { triggerTurn?: boolean; deliverAs?: string };
+      assert.equal(opts.triggerTurn, false, "turn is not triggered mid-tool-call");
+      assert.equal(opts.deliverAs, "steer");
+
+      markToolEnd("call-1");
+    } finally {
+      cleanup(h);
+    }
+  });
+
+  test(`${reason} recovery applies the supervisor model swap when no tools are in flight`, async () => {
+    const h = makeHarness();
+    try {
+      const outcome = await recoverTimedOutUnit(
+        h.ctx,
+        h.pi,
+        "discuss-project",
+        "P01",
+        reason,
+        h.rctx,
+      );
+
+      assert.equal(outcome, "recovered");
+      assert.equal(h.setModelCalls.length, 1, "model swaps to the supervisor model");
+      assert.deepEqual(
+        h.setModelCalls[0][0],
+        { id: "supervisor-primary", provider: "anthropic" },
+        "swaps to the configured supervisor primary",
+      );
+      assert.equal(h.sendMessageCalls.length, 1);
+      const opts = h.sendMessageCalls[0][1] as { triggerTurn?: boolean };
+      assert.equal(opts.triggerTurn, true, "turn is triggered when no tools are open");
+    } finally {
+      cleanup(h);
+    }
+  });
+}

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

@@ -28,7 +28,8 @@ 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,

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 ───────────────────────────────────────────────────