gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -1,213 +1,71 @@
 // GSD Extension — Interactive Routing Bypass Tests
-// Verifies that dynamic routing is skipped for interactive (guided-flow) dispatches
-// and that model downgrade notifications always fire (#3962).
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import test, { describe } 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));
-
-// ─── Source-level structural tests ──────────────────────────────────────────
-
-const modelSelectionSrc = readFileSync(
-  join(__dirname, "..", "auto-model-selection.ts"),
-  "utf-8",
-);
-
-const guidedFlowSrc = readFileSync(
-  join(__dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-const autoStartSrc = readFileSync(
-  join(__dirname, "..", "auto-start.ts"),
-  "utf-8",
-);
-
-describe("interactive routing bypass (#3962)", () => {
-  test("selectAndApplyModel accepts isAutoMode parameter", () => {
-    // The function signature should include isAutoMode with a default of true
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode"),
-      "selectAndApplyModel should have isAutoMode parameter",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode = true"),
-      "isAutoMode should default to true (auto-mode behavior preserved)",
-    );
-  });
-
-  test("routing is disabled when isAutoMode is false", () => {
-    // The code should disable routing when not in auto-mode
-    assert.ok(
-      modelSelectionSrc.includes("if (!isAutoMode)"),
-      "should check isAutoMode flag to disable routing",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("routingConfig.enabled = false"),
-      "should set routingConfig.enabled = false for interactive mode",
-    );
-  });
-
-  test("resolvePreferredModelConfig skips routing synthesis when isAutoMode is false", () => {
-    // resolvePreferredModelConfig should accept isAutoMode and bail early
-    // before synthesizing a routing ceiling from tier_models (#3962 codex review)
-    assert.ok(
-      modelSelectionSrc.includes("function resolvePreferredModelConfig"),
-      "resolvePreferredModelConfig should exist",
-    );
-    // The function should check isAutoMode before routing synthesis
-    const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
-    assert.ok(
-      fnBody.includes("isAutoMode"),
-      "resolvePreferredModelConfig should accept isAutoMode parameter",
-    );
-    assert.ok(
-      fnBody.includes("if (!isAutoMode) return undefined"),
-      "should return undefined (skip routing synthesis) when not in auto-mode",
-    );
-  });
-
-  test("selectAndApplyModel threads isAutoMode to resolvePreferredModelConfig", () => {
-    // The call to resolvePreferredModelConfig inside selectAndApplyModel
-    // should pass isAutoMode as the third argument
-    const callSite = "resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode)";
-    assert.ok(
-      modelSelectionSrc.includes(callSite),
-      "selectAndApplyModel should pass isAutoMode to resolvePreferredModelConfig",
-    );
-  });
-
-  test("guided-flow passes isAutoMode=false", () => {
-    // guided-flow.ts should explicitly pass isAutoMode as false
-    assert.ok(
-      guidedFlowSrc.includes("/* isAutoMode */ false"),
-      "guided-flow should pass isAutoMode=false to selectAndApplyModel",
-    );
-  });
-
-  test("auto/phases.ts does NOT pass isAutoMode=false", () => {
-    // auto/phases.ts should use the default (true) — it's auto-mode
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolvePreferredModelConfig } from "../auto-model-selection.ts";
+
+function withRoutingPrefs<T>(fn: () => T): T {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: gpt-4o-mini",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
       "utf-8",
     );
-    assert.ok(
-      !phasesSrc.includes("isAutoMode"),
-      "auto/phases.ts should use default isAutoMode=true (not pass it explicitly)",
-    );
-  });
-});
-
-describe("model downgrade notifications always visible (#3962)", () => {
-  test("downgrade notification is not gated by verbose flag", () => {
-    // The downgrade notification block should NOT be wrapped in `if (verbose)`
-    // Find the downgrade block and verify it's not behind a verbose check
-    const downgradeBlock = "if (routingResult.wasDowngraded)";
-    const downgradeIdx = modelSelectionSrc.indexOf(downgradeBlock);
-    assert.ok(downgradeIdx > 0, "downgrade block should exist");
-
-    // Extract the code between wasDowngraded check and the next routing label assignment
-    const afterDowngrade = modelSelectionSrc.slice(
-      downgradeIdx,
-      modelSelectionSrc.indexOf("routingTierLabel =", downgradeIdx),
-    );
-
-    // The notification calls should NOT be wrapped in `if (verbose)`
-    assert.ok(
-      !afterDowngrade.includes("if (verbose)"),
-      "downgrade notifications should not be gated by verbose flag",
-    );
-
-    // But the notification calls should exist
-    assert.ok(
-      afterDowngrade.includes('ctx.ui.notify('),
-      "downgrade notifications should still fire",
-    );
-  });
-
-  test("tier escalation notification is not gated by verbose flag", () => {
-    // Extract the escalation block: from "if (escalated)" to its closing
-    // and verify the notification is present but `if (verbose)` is not.
-    const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
-    assert.ok(escalatedIdx > 0, "escalation block should exist");
-
-    // 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",
-    );
-    assert.ok(
-      !block.includes("if (verbose)"),
-      "escalation block should not gate notification behind verbose flag",
-    );
-  });
-});
-
-describe("auto-mode start routing banner (#3962)", () => {
-  test("auto-start shows dynamic routing status on startup", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing:"),
-      "auto-start should display routing status banner",
-    );
-    assert.ok(
-      autoStartSrc.includes("resolveDynamicRoutingConfig"),
-      "auto-start should import resolveDynamicRoutingConfig",
-    );
-  });
-
-  test("banner shows different messages for enabled vs disabled routing", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: enabled"),
-      "should show message when routing is enabled",
-    );
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: disabled"),
-      "should show message when routing is disabled",
-    );
-  });
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+    return fn();
+  } 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("banner shows the ceiling model", () => {
-    assert.ok(
-      autoStartSrc.includes("startModelLabel"),
-      "banner should reference the start/ceiling model",
-    );
-  });
-
-  test("banner accounts for flat-rate provider suppression", () => {
-    // The banner should check isFlatRateProvider to accurately reflect
-    // whether routing will actually be active at dispatch time (#3962 codex review)
-    assert.ok(
-      autoStartSrc.includes("isFlatRateProvider"),
-      "banner should check flat-rate provider status",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectivelyEnabled"),
-      "banner should compute effective routing state, not just raw config",
-    );
+describe("interactive routing bypass (#3962)", () => {
+  test("interactive dispatch does not synthesize dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        false,
+      );
+
+      assert.equal(result, undefined);
+    });
   });
 
-  test("banner uses effective ceiling from tier_models.heavy when configured", () => {
-    // The actual ceiling may come from tier_models.heavy, not the start model
-    assert.ok(
-      autoStartSrc.includes("tier_models?.heavy"),
-      "banner should check tier_models.heavy for the effective ceiling",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectiveCeiling"),
-      "banner should compute the effective ceiling model",
-    );
+  test("auto-mode dispatch still synthesizes dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        true,
+      );
+
+      assert.ok(result);
+      assert.equal(result!.primary, "claude-opus-4-6");
+      assert.equal(result!.source, "synthesized");
+    });
   });
 });

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

@@ -1,62 +1,19 @@
-/**
- * Regression test for #3675 — isolation:none stale branch guard
- *
- * When switching from isolation:branch/worktree to isolation:none, HEAD
- * could remain on a milestone/<MID> branch. The fix in auto-start.ts
- * detects this and auto-checks out to the integration branch.
- *
- * This structural test verifies the milestone/ branch check exists
- * in auto-start.ts.
- */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { resolveIsolationNoneBranchCheckout } from "../auto-start.ts";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'auto-start.ts'), 'utf-8');
-
-describe('isolation:none stale branch guard (#3675)', () => {
-  test('checks for milestone/ branch prefix', () => {
-    assert.match(source, /startsWith\(["']milestone\//,
-      'auto-start should check for milestone/ branch prefix');
-  });
-
-  test('imports nativeGetCurrentBranch', () => {
-    assert.match(source, /nativeGetCurrentBranch/,
-      'auto-start should import nativeGetCurrentBranch');
-  });
-
-  test('imports nativeDetectMainBranch', () => {
-    assert.match(source, /nativeDetectMainBranch/,
-      'auto-start should import nativeDetectMainBranch');
-  });
-
-  test('imports nativeCheckoutBranch', () => {
-    assert.match(source, /nativeCheckoutBranch/,
-      'auto-start should import nativeCheckoutBranch');
-  });
-
-  test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
-      'guard should only activate when isolation mode is "none"');
-  });
-
-  test('calls nativeCheckoutBranch to return to integration branch', () => {
-    assert.match(source, /nativeCheckoutBranch\(base,\s*integrationBranch\)/,
-      'should checkout to the integration branch');
+describe("isolation:none stale branch guard (#3675)", () => {
+  test("returns integration branch for stale milestone branch in isolation:none", () => {
+    assert.equal(
+      resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", true),
+      "main",
+    );
   });
 
-  test('guard is wrapped in try-catch (non-fatal)', () => {
-    // Find the milestone/ check and verify it is inside a try block
-    const milestoneIdx = source.indexOf('startsWith("milestone/")');
-    assert.ok(milestoneIdx > 0, 'milestone/ check should exist');
-    const before = source.slice(Math.max(0, milestoneIdx - 500), milestoneIdx);
-    assert.match(before, /try\s*\{/,
-      'milestone branch guard should be inside a try block');
+  test("does nothing outside milestone branches, repos, or isolation:none", () => {
+    assert.equal(resolveIsolationNoneBranchCheckout("feature", "main", "none", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "worktree", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", false), null);
   });
 });

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

@@ -17,6 +17,7 @@ import { join } from "node:path";
 
 import type { JournalEntry } from "../journal.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { IterationContext, LoopState, PreDispatchData, IterationData } from "../auto/types.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
@@ -65,7 +66,6 @@ function makeMockDeps(
     }) as any,
     loadEffectiveGSDPreferences: () => ({ preferences: {} }),
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
-    syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
     validateSessionLock: () => ({ valid: true }) as SessionLockStatus,
     updateSessionLock: () => {},
@@ -85,7 +85,11 @@ function makeMockDeps(
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -120,14 +124,14 @@ function makeMockDeps(
     readFileSync: () => "",
     atomicWriteSync: () => {},
     GitServiceImpl: class {} as any,
-    resolver: {
-      get workPath() { return "/tmp/project"; },
-      get projectRoot() { return "/tmp/project"; },
-      get lockPath() { return "/tmp/project"; },
-      enterMilestone: () => {},
-      exitMilestone: () => {},
-      mergeAndExit: () => {},
-      mergeAndEnterNext: () => {},
+    worktreeProjection: new WorktreeStateProjection(),
+    lifecycle: {
+      enterMilestone: () => ({ ok: true, mode: "worktree", path: "/tmp/project" }),
+      exitMilestone: (_mid: string, opts: { merge: boolean }) => ({
+        ok: true,
+        merged: opts.merge,
+        codeFilesChanged: false,
+      }),
     } as any,
     postUnitPreVerification: async () => "continue" as const,
     runPostUnitVerification: async () => "continue" as const,
@@ -399,6 +403,240 @@ test("runDispatch pauses when complete-milestone summary exists on disk but the
   assert.equal(stopCalls, 0, "mismatch pause should not hard-stop the loop");
 });
 
+test("runDispatch pauses when execute-task artifacts exist but DB status is still open", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:1h`",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing → execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
+  assert.equal(pauseCalls, 1, "execute-task disk/db mismatch should pause auto-mode");
+  assert.equal(stopCalls, 0, "execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(invalidateCalls, 0, "mismatch should not clear caches and continue toward redispatch");
+  assert.equal(loopState.recentUnits.length, 3, "mismatch should keep the stuck window intact");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "mismatch should not reset the recovery counter");
+});
+
+test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB status is still open", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-l2-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01\n\n## Tasks\n\n- [x] **T01: First task** `est:1h`\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 1,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
+  assert.equal(pauseCalls, 1, "Level 2 execute-task disk/db mismatch should pause auto-mode");
+  assert.equal(stopCalls, 0, "Level 2 execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "Level 2 should invalidate caches before the final artifact recheck");
+  assert.equal(loopState.recentUnits.length, 3, "Level 2 mismatch should keep the stuck window intact");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 mismatch should not reset the recovery counter");
+});
+
+test("runDispatch clears execute-task stuck state when artifacts and DB status are complete", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-complete-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "complete" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01\n\n## Tasks\n\n- [x] **T01: First task** `est:1h`\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "closed DB task should not pause auto-mode");
+  assert.equal(stopCalls, 0, "closed DB task should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "closed DB task recovery should invalidate caches once");
+  assert.deepEqual(loopState.recentUnits, [], "closed DB task recovery should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "closed DB task recovery should reset the recovery counter");
+});
+
 test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
   const capture = createEventCapture();
   let invalidateCalls = 0;