@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

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";
@@ -165,7 +165,7 @@ function makeFixture(opts: FixtureOptions = {}): Fixture {
   session.resourceVersionOnStart = null;
 
   const ctx: OrchestratorContext = {
-    ctx: { model: {}, modelRegistry: { getAll: () => [] }, ui: { notify() {} } } as never,
+    ctx: { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] }, ui: { notify() {} } } as never,
     pi: { getActiveTools: () => [] } as never,
     dispatchBasePath: base,
     runtimeBasePath: base,
@@ -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) => {
@@ -1045,6 +1109,7 @@ test("decideOrchestratorDispatch forwards session-derived dispatch inputs identi
   try {
     const fakeModelRegistry = {
       getAll: () => [],
+      getAvailable: () => [],
       getProviderAuthMode: (_provider: string) => "apiKey" as const,
     };
     const ctx = {
@@ -1144,10 +1209,12 @@ test("decideOrchestratorDispatch prefers caller-supplied dispatch inputs over ct
   try {
     const ctxModelRegistry = {
       getAll: () => [],
+      getAvailable: () => [],
       getProviderAuthMode: (_provider: string) => "apiKey" as const,
     };
     const overrideModelRegistry = {
       getAll: () => [],
+      getAvailable: () => [],
       getProviderAuthMode: (_provider: string) => "oauth" as const,
     };
     const ctx = {
@@ -1204,7 +1271,7 @@ test("decideOrchestratorDispatch forwards constructor session when advance input
   setRegistry(new RuleRegistry([captureRule]));
 
   try {
-    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+    const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
     const pi = { getActiveTools: () => [] } as never;
     const session = {
       basePath: "/tmp/worktree-fixture",
@@ -1249,7 +1316,7 @@ test("decideOrchestratorDispatch evaluates deep pre-planning rules without an ac
     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 ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
   const pi = { getActiveTools: () => [] } as never;
   const session = {
     basePath: base,
@@ -1290,7 +1357,7 @@ test("decideOrchestratorDispatch does not replay milestone-scoped verification r
     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 ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
   const pi = { getActiveTools: () => [] } as never;
   const stalePendingRetry = {
     unitType: "execute-task",
@@ -1351,7 +1418,7 @@ test("decideOrchestratorDispatch adopts next active milestone after the session
   setRegistry(new RuleRegistry([captureRule]));
 
   try {
-    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+    const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
     const pi = { getActiveTools: () => [] } as never;
     const session = {
       basePath: base,
@@ -1385,7 +1452,7 @@ test("decideOrchestratorDispatch keeps blocking stale milestone worktree scope",
   };
   const worktreePath = join(base, ".gsd", "worktrees", "M001");
   mkdirSync(worktreePath, { recursive: true });
-  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
   const pi = { getActiveTools: () => [] } as never;
   const session = {
     basePath: worktreePath,
@@ -1406,7 +1473,7 @@ test("decideOrchestratorDispatch keeps blocking stale milestone worktree scope",
 
 test("decideOrchestratorDispatch replays pending verification retry dispatch", async () => {
   const stateSnapshot = makeState();
-  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
   const pi = { getActiveTools: () => [] } as never;
   const session = {
     basePath: "/tmp/worktree-fixture",
@@ -1463,7 +1530,7 @@ test("decideOrchestratorDispatch clears verification retry state when skipping a
     };
     setRegistry(new RuleRegistry([retryRule]));
 
-    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+    const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
     const pi = { getActiveTools: () => [] } as never;
     const session = {
       basePath: base,
@@ -1507,7 +1574,7 @@ test("decideOrchestratorDispatch preserves stop reason as a blocked decision", a
   setRegistry(new RuleRegistry([stopRule]));
 
   try {
-    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+    const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
     const pi = { getActiveTools: () => [] } as never;
 
     const result = await decideOrchestratorDispatch(ctx, pi, "/tmp/parity-fixture", undefined, { stateSnapshot });
@@ -1537,7 +1604,7 @@ test("decideOrchestratorDispatch preserves dispatch skip instead of collapsing i
   setRegistry(new RuleRegistry([skipRule]));
 
   try {
-    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+    const ctx = { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] } } as never;
     const pi = { getActiveTools: () => [] } as never;
 
     const result = await decideOrchestratorDispatch(ctx, pi, "/tmp/parity-fixture", undefined, { stateSnapshot });

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

@@ -5,12 +5,19 @@ import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { cleanupAfterLoopExit, pauseAuto, rerootCommandSession, stopAuto } from "../auto.ts";
+import { join, dirname } from "node:path";
+
+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,42 @@ 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("anchorProcessCwdForAutoResume falls back when primary basePath is missing", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-resume-cwd-anchor-fallback-"));
+  const missingWorktree = join(base, ".gsd-worktrees", "M002");
+  const previousCwd = process.cwd();
+
+  mkdirSync(base, { recursive: true });
+  mkdirSync(dirname(missingWorktree), { recursive: true });
+
+  try {
+    assert.equal(anchorProcessCwdForAutoResume(missingWorktree, [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 +319,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();
@@ -769,7 +862,7 @@ test("stopAuto completion closeout emits a headless terminal notification withou
       "headless completion closeout must emit the terminal stop notification headless waits for",
     );
     assert.equal(
-      typeof widgetCalls.filter(([key]) => key === "gsd-progress").at(-1)?.[1],
+      typeof widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1],
       "function",
       "headless completion closeout must still leave the final roll-up widget installed",
     );

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-start-orphan-bootstrap.test.ts

@@ -118,6 +118,51 @@ function makeRepoWithMultipleStrandedMilestones(): string {
   return base;
 }
 
+function makeRepoWithOnlySiblingStrandedAndLockedActive(): string {
+  // Locked milestone (M002) is the active row but has NO stranded
+  // milestone branch. A sibling milestone (M001) has a stranded branch.
+  // A parallel worker locked to M002 must skip the sibling's stranded
+  // action entirely — neither block on it nor adopt it.
+  const base = mkdtempSync(join(tmpdir(), "gsd-locked-no-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  // M002 has CONTEXT so bootstrap's pre-planning gate doesn't route to
+  // showSmartEntry and the test reaches the post-lock session-init path.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M002", "M002-CONTEXT.md"),
+    "# M002 context\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"none\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  // Sibling M001 has stranded work on milestone/M001.
+  runGit(base, ["checkout", "-b", "milestone/M001"]);
+  writeFileSync(join(base, "m001.txt"), "sibling stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M001 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  // M002 has no stranded branch at all.
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  // Both milestones are open so the stranded audit produces a blocking
+  // action for the sibling (M001). M002 is the lock target and active
+  // row; getActiveMilestoneId honors the lock regardless of M001 order.
+  insertMilestone({ id: "M001", title: "Sibling milestone", status: "pending" });
+  insertMilestone({ id: "M002", title: "Locked milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
 function makeRepoWithActiveMismatchAndStrandedTarget(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-targeted-stranded-bootstrap-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
@@ -455,6 +500,197 @@ test("bootstrap blocks active stranded recovery when another open milestone also
   }
 });
 
+test("parallel worker recovers its locked stranded milestone despite stranded siblings", async () => {
+  const base = makeRepoWithMultipleStrandedMilestones();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "branch" }]);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.match(messages, /Resuming saved milestone work for M002/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M002/);
+    assert.doesNotMatch(messages, /\/gsd auto M001/);
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("locked worker with no own stranded action does not adopt sibling stranded action", async () => {
+  const base = makeRepoWithOnlySiblingStrandedAndLockedActive();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const enterCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: (mid: string) => {
+            enterCalls.push(mid);
+            return { ok: true, mode: "none", path: base };
+          },
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    // Must not adopt M001 (the sibling stranded action) — the locked
+    // worker has no stranded action of its own, so adoption should not
+    // run at all. enterMilestone for M002 is also gated off by
+    // isolation=none with no stranded recoveryMode (#742 regression).
+    assert.deepEqual(adoptCalls, []);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.doesNotMatch(messages, /Resuming saved milestone work for M001/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M002/);
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("bootstrap honors explicit solo milestone lock when recovering stranded target worktree", async () => {
   const base = makeRepoWithActiveMismatchAndStrandedTarget();
   const previousCwd = process.cwd();