@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.8e6112e9

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

@@ -22,8 +22,8 @@ import {
   createAutoOrchestrator,
   decideOrchestratorDispatch,
   resolveLiveOrchestratorBasePath,
-  STUCK_WINDOW_SIZE,
 } from "../auto/orchestrator.js";
+import { STUCK_WINDOW_SIZE } from "../auto/dispatch-history.js";
 import type { OrchestratorContext } from "../auto/orchestrator.js";
 import type { AutoOrchestrationModule, AutoSessionContext } from "../auto/contracts.js";
 import type { GSDState } from "../types.js";
@@ -41,6 +41,10 @@ import {
   openDatabase,
 } from "../gsd-db.js";
 import { AutoSession } from "../auto/session.js";
+import { registerAutoWorker } from "../db/auto-workers.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";
 import { queryJournal } from "../journal.js";
 import { invalidateAllCaches } from "../cache.js";
@@ -304,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: () => ({
@@ -421,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());
 
@@ -462,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) => {
@@ -518,13 +586,12 @@ test("advance() is idempotent for the same active unit", async (t) => {
   if (first.kind === "advanced") {
     assert.deepEqual(first.unit, { unitType: "execute-task", unitId: "M001/S01/T01" });
   }
-  assert.equal(second.kind, "blocked");
-  if (second.kind !== "blocked") return;
+  assert.equal(second.kind, "skipped");
+  if (second.kind !== "skipped") return;
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "pause");
 });
 
-test("idempotency block fires with its own reason before saturation", async (t) => {
+test("idempotency skip fires with its own reason before saturation", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
 
@@ -532,10 +599,9 @@ test("idempotency block fires with its own reason before saturation", async (t)
   const second = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(second.kind, "blocked");
-  if (second.kind !== "blocked") return;
+  assert.equal(second.kind, "skipped");
+  if (second.kind !== "skipped") return;
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "pause");
 });
 
 test("completeActiveUnit clears in-flight idempotency and stops stale same-unit advance", async (t) => {
@@ -671,12 +737,12 @@ test("resume() clears idempotent lock and allows re-advance", async (t) => {
   t.after(() => f.cleanup());
 
   const first = await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const resumed = await f.orchestrator.resume();
   const next = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(resumed.kind, "resumed");
   assert.equal(next.kind, "advanced");
 });
@@ -686,11 +752,11 @@ test("start() clears prior idempotent lock", async (t) => {
   t.after(() => f.cleanup());
 
   await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const restarted = await f.orchestrator.start(SESSION_CONTEXT);
   const next = await f.orchestrator.advance();
 
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(restarted.kind, "started");
   assert.equal(next.kind, "advanced");
 });
@@ -700,32 +766,28 @@ test("stop() clears idempotent unit lock so advance can run again", async (t) =>
   t.after(() => f.cleanup());
 
   const first = await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const stopped = await f.orchestrator.stop("reset");
   const second = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(stopped.kind, "stopped");
   assert.equal(second.kind, "advanced");
 });
 
-test("blocked path journals advance-blocked and records a health snapshot", async (t) => {
+test("idempotent path journals advance-skipped and records a health snapshot", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
 
   await f.orchestrator.advance();
   await f.orchestrator.advance();
 
-  assert.ok(f.journalNames().includes("advance-blocked"));
+  assert.ok(f.journalNames().includes("advance-skipped"));
 });
 
 // ─── Stuck-loop ring buffer (issue #5787) ──────────────────────────────────
 
-test("STUCK_WINDOW_SIZE matches the legacy auto/phases.ts constant", () => {
-  assert.equal(STUCK_WINDOW_SIZE, 6);
-});
-
 test("stuck-loop: empty ring on a freshly constructed orchestrator advances normally", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
@@ -761,21 +823,24 @@ test("stuck-loop: ring saturated with same unit blocks with action 'stop' and st
   // First call advances.
   assert.equal(results[0].kind, "advanced");
 
-  // Intermediate calls are blocked by idempotency (not stuck-loop yet).
+  // Intermediate calls are skipped by idempotency (not stuck-loop yet).
   for (let i = 1; i < STUCK_WINDOW_SIZE - 1; i++) {
     const r = results[i];
-    assert.equal(r.kind, "blocked", `round ${i} should be blocked`);
-    if (r.kind !== "blocked") return;
+    assert.equal(r.kind, "skipped", `round ${i} should be skipped`);
+    if (r.kind !== "skipped") return;
     assert.equal(r.reason, "idempotent advance: unit already active");
-    assert.equal(r.action, "pause");
   }
 
-  // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop.
+  // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop
+  // with the detect-stuck rule verdict in the reason.
   const last = results[STUCK_WINDOW_SIZE - 1];
   assert.equal(last.kind, "blocked");
   if (last.kind !== "blocked") return;
   assert.equal(last.action, "stop");
-  assert.equal(last.reason, `stuck-loop: execute-task:M001/S01/T01 picked ${STUCK_WINDOW_SIZE} times`);
+  assert.ok(
+    last.reason.startsWith("stuck-loop: execute-task:M001/S01/T01 derived"),
+    `expected detect-stuck verdict reason, got: ${last.reason}`,
+  );
 });
 
 test("stuck-loop: start() resets the ring so a fresh saturation cycle is required", async (t) => {
@@ -855,6 +920,80 @@ test("stuck-loop: stop('user-request') resets the ring (hard stop)", async (t) =
   assert.equal(next.kind, "advanced");
 });
 
+test("stuck-loop #482 regression: start() rehydrates the window from the dispatch ledger so cross-session re-dispatch loops are detected", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  // Simulate a PRIOR session: the dispatch ledger recorded the same unit
+  // being re-dispatched repeatedly without progress. The orchestrator under test is a
+  // fresh instance (as it would be after a session restart) — before the
+  // Dispatch History module, start() reset the window to [] and the loop
+  // would silently re-dispatch the unit forever (#482: 146 re-dispatches).
+  const worker = registerAutoWorker({ projectRootRealpath: normalizeRealPath(f.base) });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `prior-session-${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "" });
+  }
+
+  const started = await f.orchestrator.start(SESSION_CONTEXT);
+  assert.equal(started.kind, "started");
+
+  // The very next decision for the same unit must trip the stuck verdict
+  // instead of advancing.
+  const result = await f.orchestrator.advance();
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.action, "stop");
+  assert.ok(result.reason.startsWith("stuck-loop:"), `expected stuck-loop reason, got: ${result.reason}`);
+});
+
+test("stuck-loop #482: resume() with an empty window rehydrates from the dispatch ledger", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  const worker = registerAutoWorker({ projectRootRealpath: normalizeRealPath(f.base) });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `prior-session-resume-${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "" });
+  }
+
+  // Fresh orchestrator resuming a prior session: window starts empty, so
+  // resume() must rehydrate (while in-process resume keeps the live window —
+  // see the #572 preservation tests above).
+  const resumed = await f.orchestrator.resume();
+  assert.equal(resumed.kind, "resumed");
+
+  const result = await f.orchestrator.advance();
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.action, "stop");
+  assert.ok(result.reason.startsWith("stuck-loop:"), `expected stuck-loop reason, got: ${result.reason}`);
+});
+
 test("stuck-loop: journal records the stuck-loop reason on advance-blocked", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
@@ -1148,6 +1287,103 @@ test("decideOrchestratorDispatch forwards constructor session when advance input
   }
 });
 
+test("decideOrchestratorDispatch evaluates deep pre-planning rules without an active milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+});
+
+test("decideOrchestratorDispatch does not replay milestone-scoped verification retry when no milestone is active", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-retry-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const stalePendingRetry = {
+    unitType: "execute-task",
+    unitId: "M027.S1.T1",
+    prompt: "stale retry prompt",
+    pauseAfterUatDispatch: false,
+    state: stateSnapshot,
+    mid: "M027",
+    midTitle: "Parked",
+  };
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+    pendingVerificationRetryDispatch: stalePendingRetry,
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+  // The stale retry must be preserved for a future tick, not consumed by this
+  // no-active-milestone path (mirrors pre-#712-fix behavior where !active
+  // returned null before touching the retry).
+  const sess = session as unknown as { pendingVerificationRetryDispatch: unknown };
+  assert.equal(sess.pendingVerificationRetryDispatch, stalePendingRetry);
+});
+
 test("decideOrchestratorDispatch adopts next active milestone after the session milestone is closed", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-milestone-adopt-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

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";

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

@@ -1,12 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkRemoteAutoSession } from "../auto.ts";
+import { checkRemoteAutoSession, forceStopAutoRemote } from "../auto.ts";
 import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { normalizeRealPath } from "../paths.ts";
 import { readCrashLock } from "../crash-recovery.ts";
 
@@ -35,6 +36,29 @@ function setWorkerPid(workerId: string, pid: number): void {
   ).run({ ":pid": pid, ":worker_id": workerId });
 }
 
+function insertMilestone(id: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO milestones (id, title, status, created_at)
+     VALUES (:id, :title, 'active', :created_at)`,
+  ).run({
+    ":id": id,
+    ":title": id,
+    ":created_at": new Date().toISOString(),
+  });
+}
+
+function writeLegacyLock(base: string, pid: number): void {
+  const now = new Date().toISOString();
+  writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify({
+    pid,
+    startedAt: now,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: now,
+  }));
+}
+
 function findDeadPidCandidate(): number {
   const candidates = [99_999, 199_999, 299_999, 399_999];
   for (const pid of candidates) {
@@ -62,3 +86,41 @@ test("checkRemoteAutoSession clears stale lock state when lock PID is dead", (t)
   assert.deepEqual(remote, { running: false });
   assert.equal(readCrashLock(base), null, "stale lock should be cleared by remote session check");
 });
+
+test("forceStopAutoRemote escalates a live remote PID and releases worker state", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 424_242;
+  setWorkerPid(workerId, pid);
+  insertMilestone("M001");
+  writeLegacyLock(base, pid);
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true, "precondition: worker holds a milestone lease");
+
+  const signals: Array<NodeJS.Signals | 0> = [];
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    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 should escalate when the PID is still alive");
+  assert.equal(getAutoWorker(workerId)?.status, "stopping");
+  assert.equal(
+    getMilestoneLease("M001")?.status,
+    "released",
+    "force stop should release held milestone leases",
+  );
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});