@opengsd/gsd-pi 1.2.0-dev.9ad8ae33 → 1.2.0-dev.a6376d75

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

@@ -3,6 +3,7 @@
 
 import test, { mock } from "node:test";
 import assert from "node:assert/strict";
+import { execSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -24,7 +25,9 @@ import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
 import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
 import { autoLoop as rawAutoLoop } from "../auto/loop.js";
-import { runPreDispatch, runDispatch, runUnitPhase } from "../auto/phases.js";
+import { runPreDispatch } from "../auto/pre-dispatch.js";
+import { runDispatch } from "../auto/dispatch.js";
+import { runUnitPhase, resetSessionTimeoutState } from "../auto/unit-phase.js";
 import { detectStuck } from "../auto/detect-stuck.js";
 import type { UnitResult, AgentEndEvent, LoopState } from "../auto/types.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
@@ -531,7 +534,7 @@ test("runUnit failsafe defers cancellation while timeout recovery is making fres
     const ctx = makeMockCtx();
     const pi = makeMockPi();
     const s = makeMockSession();
-    s.basePath = mkdtempSync(join(tmpdir(), "gsd-rununit-recovery-"));
+    s.basePath = makeLoopTestBase("gsd-rununit-recovery-");
     s.currentUnit = { type: "task", id: "T01", startedAt: 1234 };
 
     const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
@@ -1366,12 +1369,19 @@ function makeMockDeps(
  * runUnit mock (dispatch counters, milestone state, etc.).
  */
 function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-auto-loop-"));
+  // Plan 001 enforces worktree safety for all isolation modes. Loop-mechanics
+  // tests run with getIsolationMode: () => "none", so the project root itself
+  // must be a valid git working tree for source-writing Units to dispatch.
+  execSync("git init --initial-branch=main", { cwd: basePath, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: basePath, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: basePath, stdio: "ignore" });
   return {
     active: true,
     verbose: false,
     stepMode: false,
     paused: false,
-    basePath: mkdtempSync(join(tmpdir(), "gsd-auto-loop-")),
+    basePath,
     originalBasePath: "",
     currentMilestoneId: "M001",
     currentUnit: null,
@@ -1419,6 +1429,15 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
   } as any;
 }
 
+/** Create a temp project root suitable for loop-mechanics tests. */
+function makeLoopTestBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  execSync("git init --initial-branch=main", { cwd: base, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: base, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: base, stdio: "ignore" });
+  return base;
+}
+
 test("autoLoop exits when s.active is set to false", async (t) => {
   _resetPendingResolve();
 
@@ -1506,7 +1525,7 @@ test("autoLoop preserves stuck recovery counter when dispatch recovery continues
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
-  const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-stuck-counter-reset-")));
+  const basePath = realpathSync(makeLoopTestBase("gsd-stuck-counter-reset-"));
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
   mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
   writeFileSync(
@@ -1581,7 +1600,7 @@ test("autoLoop skips provider dispatch when execute-task is already complete in
   ctx.ui.setStatus = () => {};
   ctx.ui.setWidget = () => {};
   const pi = makeMockPi();
-  const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-already-complete-dispatch-")));
+  const basePath = realpathSync(makeLoopTestBase("gsd-already-complete-dispatch-"));
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
 
   try {
@@ -3992,7 +4011,7 @@ test("resolveAgentEndCancelled with errorContext passes it through to resolved p
 test("runUnitPhase pauses transient aborted cancellations instead of hard-stopping", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-aborted-cancel-"));
+  const basePath = makeLoopTestBase("gsd-aborted-cancel-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -4064,10 +4083,157 @@ test("runUnitPhase pauses transient aborted cancellations instead of hard-stoppi
   assert.equal(deps.callLog.includes("stopAuto"), false);
 });
 
+test("resetSessionTimeoutState gives a new auto session a fresh session-creation timeout budget", async (t) => {
+  _resetPendingResolve();
+
+  // runUnitPhase schedules an auto-resume setTimeout on transient session
+  // timeouts. Capture and clear those timers so the test process can exit
+  // promptly while still exercising the real production path.
+  const originalSetTimeout = globalThis.setTimeout;
+  const timerHandles: ReturnType<typeof originalSetTimeout>[] = [];
+  globalThis.setTimeout = ((callback: any, delay?: number, ...args: any[]) => {
+    const handle = originalSetTimeout(callback, delay ?? 0, ...args);
+    timerHandles.push(handle);
+    return handle;
+  }) as any;
+
+  const basePath = makeLoopTestBase("gsd-session-timeout-reset-");
+  execSync("git init", { cwd: basePath });
+  execSync('git -c user.email=test@test.com -c user.name=Test commit --allow-empty -m init', { cwd: basePath });
+
+  t.after(() => {
+    for (const handle of timerHandles) clearTimeout(handle);
+    globalThis.setTimeout = originalSetTimeout;
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const notifications: Array<{ message: string; level?: string }> = [];
+  ctx.ui.notify = (message: string, level?: string) => {
+    notifications.push({ message, level });
+  };
+  const pi = makeMockPi();
+  const s = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+  });
+  const deps = makeMockDeps();
+
+  async function runTimeoutUnit(iteration: number): Promise<string | undefined> {
+    notifications.length = 0;
+    const callsBefore = pi.calls.length;
+    let seq = 0;
+    const phasePromise = runUnitPhase(
+      { ctx, pi, s, deps, prefs: undefined, iteration, flowId: `flow-${iteration}`, nextSeq: () => ++seq },
+      {
+        unitType: "plan-slice",
+        unitId: "M001/S01",
+        prompt: "plan the slice",
+        finalPrompt: "plan the slice",
+        pauseAfterUatDispatch: false,
+        state: {
+          phase: "planning",
+          activeMilestone: { id: "M001", title: "Milestone" },
+          activeSlice: { id: "S01", title: "Slice" },
+          activeTask: null,
+          registry: [{ id: "M001", title: "Milestone", status: "active" }],
+          recentDecisions: [],
+          blockers: [],
+          nextAction: "",
+          progress: { milestones: { done: 0, total: 1 } },
+          requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+        } as any,
+        mid: "M001",
+        midTitle: "Milestone",
+        isRetry: false,
+        previousTier: undefined,
+      },
+      makeLoopState(),
+    );
+
+    // Wait until runUnit has dispatched the prompt, then resolve the unit
+    // as a session-creation timeout. This avoids the 120s real timeout and
+    // the mock-timer interaction that runUnitPhase's pre-flight setup makes
+    // fragile.
+    await new Promise<void>((resolve) => {
+      const check = () => {
+        if (pi.calls.length > callsBefore) return resolve();
+        setTimeout(check, 5);
+      };
+      check();
+    });
+    resolveAgentEndCancelled({
+      message: "Session creation timed out",
+      category: "timeout",
+      isTransient: true,
+    });
+
+    const result = await phasePromise;
+    return (result as any).reason;
+  }
+
+  // Start from a known state in case a previous test left the counter raised.
+  resetSessionTimeoutState();
+
+  // Exhaust the per-process timeout budget in the first "session".
+  for (let i = 1; i <= 4; i++) {
+    const reason = await runTimeoutUnit(i);
+    assert.equal(reason, "session-timeout");
+  }
+  const lastBudgetNotification = notifications.find((n) =>
+    n.message.includes("Session creation timed out")
+  );
+  assert.ok(lastBudgetNotification, "expected a session-creation timeout notification");
+  assert.match(
+    lastBudgetNotification.message,
+    /Pausing for manual review/,
+    "fourth consecutive timeout should exhaust the auto-resume budget",
+  );
+
+  // Simulate a new auto-mode session starting. autoLoop() must reset the
+  // module-level counter so the next timeout is treated as the first in the
+  // new session rather than inheriting the exhausted budget.
+  const freshSession = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+    active: false,
+  });
+  freshSession.orchestration = createLoopTestOrchestration(ctx, pi, freshSession, deps);
+  await rawAutoLoop(ctx, pi, freshSession, deps);
+
+  const reasonAfterReset = await runTimeoutUnit(5);
+  assert.equal(reasonAfterReset, "session-timeout");
+  const notificationAfterReset = notifications.find((n) =>
+    n.message.includes("Auto-resuming")
+  );
+  assert.ok(notificationAfterReset, "expected an auto-resume notification after reset");
+  assert.match(
+    notificationAfterReset.message,
+    /Auto-resuming/,
+    "after autoLoop entry the timeout budget should be fresh so the first timeout auto-resumes",
+  );
+});
+
 test("runUnitPhase treats setup-race cancellations as pause-induced when session is already paused", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-paused-setup-race-"));
+  const basePath = makeLoopTestBase("gsd-paused-setup-race-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -4142,7 +4308,7 @@ test("runUnitPhase treats setup-race cancellations as pause-induced when session
 test("runUnitPhase remembers aborted milestone closeout for same-unit resume", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-aborted-closeout-"));
+  const basePath = makeLoopTestBase("gsd-aborted-closeout-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -4222,7 +4388,7 @@ test("runUnitPhase remembers aborted milestone closeout for same-unit resume", a
 test("runUnitPhase schedules default auto-resume for transient provider cancellations", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-provider-resume-"));
+  const basePath = makeLoopTestBase("gsd-provider-resume-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4319,7 +4485,7 @@ test("runUnitPhase schedules default auto-resume for transient provider cancella
 test("runUnitPhase pauses ghost completions before closeout and finalize side effects", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-ghost-completion-"));
+  const basePath = makeLoopTestBase("gsd-ghost-completion-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4421,7 +4587,7 @@ test("runUnitPhase pauses ghost completions before closeout and finalize side ef
 test("runUnitPhase records failed routing outcome when expected artifact is missing", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-routing-artifact-missing-"));
+  const basePath = makeLoopTestBase("gsd-routing-artifact-missing-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4504,7 +4670,7 @@ test("runUnitPhase records failed routing outcome when expected artifact is miss
 test("runUnitPhase execute-task retry prompt instructs gsd_task_complete instead of manual summary writes", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-execute-task-retry-prompt-"));
+  const basePath = makeLoopTestBase("gsd-execute-task-retry-prompt-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4585,7 +4751,7 @@ test("runUnitPhase execute-task retry prompt instructs gsd_task_complete instead
 test("runUnitPhase non-execute-task retry prompt keeps generic required-file guidance", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-non-execute-retry-prompt-"));
+  const basePath = makeLoopTestBase("gsd-non-execute-retry-prompt-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4933,7 +5099,7 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
 test("runUnitPhase retries 0-tool units with ordinary network-related assistant text", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-network-text-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-network-text-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -5028,7 +5194,7 @@ test("runUnitPhase retries 0-tool units with ordinary network-related assistant
 test("runUnitPhase pauses auto-mode when zero-tool-call retry is exhausted", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-exhausted-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-exhausted-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -5313,7 +5479,7 @@ test("autoLoop rejects complete-slice with 0 tool calls as context-exhausted (#2
 test("autoLoop pauses on zero-tool-call rate-limit assistant messages instead of immediate retry", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-rate-limit-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-rate-limit-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -5529,6 +5695,15 @@ test("dispatch Worktree Safety honors degraded branch fallback instead of demand
   // branch in the project root. The safety gate must validate against that
   // effective branch mode, not the configured worktree mode.
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-degraded-"));
+  execSync("git init --initial-branch=main", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: projectRoot, stdio: "ignore" });
+  // The lifecycle fallback checks out the milestone branch in the project
+  // root, so the safety gate's branch verification expects that branch here
+  // too. expectedBranch comes from deps.autoWorktreeBranch (mocked to
+  // "auto/M001"), so the fixture repo must be on that same branch.
+  execSync("git commit --allow-empty -m init", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git checkout -b auto/M001", { cwd: projectRoot, stdio: "ignore" });
   t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
 
   const s = makeLoopSession({
@@ -5591,6 +5766,15 @@ test("dispatch Worktree Safety honors stranded branch recovery instead of demand
   // NOT degraded — the adoption is intentional. The safety gate must validate
   // against the effective branch mode, not the configured worktree mode.
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-stranded-"));
+  execSync("git init --initial-branch=main", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: projectRoot, stdio: "ignore" });
+  // Stranded recovery adopts the milestone branch in the project root, so the
+  // safety gate's branch verification expects that branch here too.
+  // expectedBranch comes from deps.autoWorktreeBranch (mocked to "auto/M001"),
+  // so the fixture repo must be on that same branch.
+  execSync("git commit --allow-empty -m init", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git checkout -b auto/M001", { cwd: projectRoot, stdio: "ignore" });
   t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
 
   const s = makeLoopSession({
@@ -5648,7 +5832,7 @@ test("runDispatch runs stuck detection while artifact verification retry is pend
   const notifications: string[] = [];
   ctx.ui.notify = (msg: string) => { notifications.push(msg); };
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-5719-retry-stuck-"));
+  const basePath = makeLoopTestBase("gsd-5719-retry-stuck-");
   t.after(() => rmSync(basePath, { recursive: true, force: true }));
 
   const s = makeLoopSession({
@@ -5716,7 +5900,7 @@ test("runDispatch falls back to main when dispatch guard cannot read main branch
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-5530-main-branch-fallback-"));
+  const basePath = makeLoopTestBase("gsd-5530-main-branch-fallback-");
   t.after(() => rmSync(basePath, { recursive: true, force: true }));
 
   let guardBranch: string | null = null;
@@ -6243,7 +6427,7 @@ test("pre-dispatch replace resolves final unit before dispatch health and stuck
   );
 });
 
-test("autoLoop warns but proceeds for greenfield project (no project files) (#1833)", async () => {
+test("autoLoop warns but proceeds for greenfield project (no project files) (#1833)", async (t) => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -6252,7 +6436,9 @@ test("autoLoop warns but proceeds for greenfield project (no project files) (#18
   const pi = makeMockPi();
 
   const notifications: string[] = [];
-  const s = makeLoopSession({ basePath: "/tmp/empty-worktree" });
+  const basePath = makeLoopTestBase("gsd-greenfield-");
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const s = makeLoopSession({ basePath });
 
   ctx.ui.notify = (msg: string) => {
     notifications.push(msg);
@@ -6275,8 +6461,6 @@ test("autoLoop warns but proceeds for greenfield project (no project files) (#18
         blockers: [],
       } as any;
     },
-    // Has .git but no package.json or src/
-    existsSync: (p: string) => p.endsWith(".git"),
   });
 
   await autoLoop(ctx, pi, s, deps);

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

@@ -42,7 +42,7 @@ import {
 } from "../gsd-db.js";
 import { AutoSession } from "../auto/session.js";
 import { registerAutoWorker } from "../db/auto-workers.js";
-import { claimMilestoneLease } from "../db/milestone-leases.js";
+import { claimMilestoneLease, getMilestoneLease, releaseMilestoneLease } from "../db/milestone-leases.js";
 import { recordDispatchClaim, markFailed } from "../db/unit-dispatches.js";
 import { normalizeRealPath } from "../paths.js";
 import { acquireSessionLock, releaseSessionLock } from "../session-lock.js";
@@ -308,6 +308,71 @@ test("advance() sets active unit and is reflected in status", async (t) => {
   });
 });
 
+test("advance() reclaims a released milestone lease before isolated source dispatch", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  writeFileSync(
+    join(f.base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: branch\n---\n",
+  );
+  execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: f.base, stdio: "ignore" });
+
+  const priorWorkerId = registerAutoWorker({ projectRootRealpath: f.base });
+  const priorLease = claimMilestoneLease(priorWorkerId, "M001");
+  assert.equal(priorLease.ok, true);
+  if (!priorLease.ok) return;
+  assert.equal(releaseMilestoneLease(priorWorkerId, "M001", priorLease.token), true);
+
+  const resumedWorkerId = registerAutoWorker({ projectRootRealpath: f.base });
+  f.session.workerId = resumedWorkerId;
+  f.session.currentMilestoneId = null;
+  f.session.milestoneLeaseToken = null;
+
+  const result = await f.orchestrator.advance();
+
+  assert.equal(result.kind, "advanced", JSON.stringify(result));
+  assert.equal(f.session.currentMilestoneId, "M001");
+  assert.equal(f.session.milestoneLeaseToken, priorLease.token + 1);
+  const lease = getMilestoneLease("M001");
+  assert.equal(lease?.worker_id, resumedWorkerId);
+  assert.equal(lease?.status, "held");
+  assert.ok(f.journalNames().includes("advance"));
+  assert.ok(!f.journalNames().includes("advance-blocked"));
+});
+
+test("advance() claims the active milestone lease even when session still holds a prior milestone token", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  writeFileSync(
+    join(f.base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: branch\n---\n",
+  );
+  execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: f.base, stdio: "ignore" });
+
+  insertMilestone({ id: "M000", title: "Prior", status: "complete" });
+  const workerId = registerAutoWorker({ projectRootRealpath: f.base });
+  const staleLease = claimMilestoneLease(workerId, "M000");
+  assert.equal(staleLease.ok, true);
+  if (!staleLease.ok) return;
+
+  f.session.workerId = workerId;
+  f.session.currentMilestoneId = "M000";
+  f.session.milestoneLeaseToken = staleLease.token;
+
+  const result = await f.orchestrator.advance();
+
+  assert.equal(result.kind, "advanced", JSON.stringify(result));
+  assert.equal(f.session.currentMilestoneId, "M001");
+  const activeLease = getMilestoneLease("M001");
+  assert.equal(activeLease?.worker_id, workerId);
+  assert.equal(activeLease?.status, "held");
+  assert.equal(f.session.milestoneLeaseToken, activeLease?.fencing_token);
+  assert.ok(f.journalNames().includes("advance"));
+  assert.ok(!f.journalNames().includes("advance-blocked"));
+});
+
 test("advance() blocks source dispatch when an earlier slice is incomplete", async (t) => {
   const f = makeFixture({
     dispatch: () => ({
@@ -425,7 +490,7 @@ test("advance() reports completion when complete state has no next unit", async
   assert.equal(f.orchestrator.getStatus().phase, "stopped");
 });
 
-test("advance() blocks all-complete stop when completed milestone is still unmerged in a worktree", async (t) => {
+test("advance() merges a completed milestone worktree before all-complete stop", async (t) => {
   const f = makeFixture({ complete: true, noTask: true });
   t.after(() => f.cleanup());
 
@@ -466,17 +531,16 @@ test("advance() blocks all-complete stop when completed milestone is still unmer
 
   const result = await f.orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
-  if (result.kind !== "blocked") return;
-  assert.equal(result.action, "pause");
-  assert.equal(result.terminalOutcome?.code, "settlement-blocked");
-  assert.match(result.reason, /worktree branch has not been merged to main/);
-  assert.doesNotMatch(result.reason, /quality gate Q3 is still pending/);
-  assert.equal(f.orchestrator.getStatus().phase, "paused");
-  assert.equal(f.session.milestoneSettlement?.ok, false);
+  assert.equal(result.kind, "stopped");
+  if (result.kind !== "stopped") return;
+  assert.equal(result.reason, "All milestones complete");
+  assert.equal(result.terminalOutcome?.code, "all-complete");
+  assert.equal(f.orchestrator.getStatus().phase, "stopped");
+  assert.equal(f.session.milestoneMergedInPhases, true);
+  assert.deepEqual(f.session.milestoneSettlement, { ok: true, reason: "settled" });
   const names = f.journalNames();
-  assert.ok(names.includes("advance-blocked"));
-  assert.ok(!names.includes("advance-stopped"));
+  assert.ok(names.includes("advance-stopped"));
+  assert.ok(!names.includes("advance-blocked"));
 });
 
 test("advance() stopped clears previous activeUnit and resets idempotent lock", async (t) => {

package/src/resources/extensions/gsd/tests/auto-pause-double-entry-guard.test.ts

@@ -13,7 +13,7 @@ import { join } from "node:path";
 import { capturePauseAutoUnitIdentity, pauseAuto, isAutoActive } from "../auto.ts";
 import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.ts";
 import { autoSession } from "../auto-runtime-state.ts";
-import { _isPauseOriginCancelledResult } from "../auto/phases.ts";
+import { _isPauseOriginCancelledResult } from "../auto/phase-helpers.ts";
 
 test("pauseAuto sets s.active = false synchronously before first await (blocks concurrent re-entry)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-double-pause-guard-"));

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -7,10 +7,17 @@ import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "nod
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { cleanupAfterLoopExit, pauseAuto, rerootCommandSession, stopAuto } from "../auto.ts";
+import {
+  anchorProcessCwdForAutoResume,
+  cleanupAfterLoopExit,
+  pauseAuto,
+  rerootCommandSession,
+  stopAuto,
+} from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { readPausedSessionMetadata } from "../interrupted-session.ts";
 import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
 
@@ -107,6 +114,25 @@ test("cleanupAfterLoopExit preserves paused worktree session and visible failure
   }
 });
 
+test("anchorProcessCwdForAutoResume recovers when current cwd was deleted", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-resume-cwd-anchor-"));
+  const deletedCwd = join(base, ".gsd-worktrees", "M002");
+  const previousCwd = process.cwd();
+
+  mkdirSync(deletedCwd, { recursive: true });
+
+  try {
+    process.chdir(deletedCwd);
+    rmSync(deletedCwd, { recursive: true, force: true });
+
+    assert.equal(anchorProcessCwdForAutoResume(base), true);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit clears status and progress widget without replacing outcome surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
@@ -276,6 +302,56 @@ test("pauseAuto marks active worker as stopping and clears workerId", async () =
   }
 });
 
+test("pauseAuto preserves worker lease across transient provider auto-resume pauses", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pause-provider-lease-"));
+  const previousCwd = process.cwd();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.originalBasePath = base;
+  autoSession.currentMilestoneId = "M001";
+
+  try {
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active" });
+    const workerId = registerAutoWorker({ projectRootRealpath: base });
+    const lease = claimMilestoneLease(workerId, "M001");
+    assert.equal(lease.ok, true);
+    if (!lease.ok) return;
+
+    autoSession.workerId = workerId;
+    autoSession.milestoneLeaseToken = lease.token;
+    process.chdir(base);
+
+    await pauseAuto(undefined, undefined, {
+      message: "Provider error: socket closed",
+      category: "provider",
+      isTransient: true,
+    });
+
+    assert.equal(autoSession.paused, true);
+    assert.equal(autoSession.workerId, workerId);
+    assert.equal(autoSession.milestoneLeaseToken, lease.token);
+    assert.equal(getAutoWorker(workerId)?.status, "active");
+    const row = getMilestoneLease("M001");
+    assert.equal(row?.worker_id, workerId);
+    assert.equal(row?.status, "held");
+    assert.equal(row?.fencing_token, lease.token);
+  } finally {
+    autoSession.reset();
+    try {
+      closeDatabase();
+    } catch {
+      /* noop */
+    }
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("pauseAuto records the expected worktree path when paused from project root", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-pause-worktree-path-"));
   const previousCwd = process.cwd();

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

@@ -7,7 +7,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { resolveDispatchRecoveryAttempts, runFinalize } from "../auto/phases.ts";
+import { resolveDispatchRecoveryAttempts } from "../auto/unit-phase.ts";
+import { runFinalize } from "../auto/finalize.ts";
 import { AutoSession } from "../auto/session.ts";
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "../unit-runtime.ts";
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";