gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.0aaa4fc17

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

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
+
+test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = "/tmp/project";
+  autoSession.orchestration = {
+    async start() { return { kind: "advanced" as const }; },
+    async advance() { return { kind: "advanced" as const }; },
+    async resume() { return { kind: "advanced" as const }; },
+    async stop() { return { kind: "stopped" as const }; },
+    getStatus() {
+      return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
+    },
+  };
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.active, true);
+  assert.equal(snap.basePath, "/tmp/project");
+  assert.equal(snap.orchestrationPhase, "running");
+  assert.equal(snap.orchestrationTransitionCount, 3);
+  assert.equal(snap.orchestrationLastTransitionAt, 123);
+
+  autoSession.reset();
+});
+
+test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
+  autoSession.reset();
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.orchestrationPhase, undefined);
+  assert.equal(snap.orchestrationTransitionCount, undefined);
+  assert.equal(snap.orchestrationLastTransitionAt, undefined);
+});

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

@@ -201,6 +201,9 @@ test("AutoSession.toJSON() includes key diagnostic properties", () => {
     "basePath",
     "currentMilestoneId",
     "currentUnit",
+    "orchestrationPhase",
+    "orchestrationTransitionCount",
+    "orchestrationLastTransitionAt",
   ];
 
   const missing = requiredDiagnostics.filter(prop => !toJSONBody.includes(prop));

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -131,7 +131,7 @@ test("postflightPopStash — restores stashed changes and emits info notificatio
     run('git commit -m "simulate merge"', repo);
 
     const postNotifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M004", (msg, level) => {
+    postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
       postNotifications.push({ msg, level });
     });
 
@@ -171,7 +171,7 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     run('git commit -m "feat: add feature"', repo);
 
     // Postflight: pop stash
-    postflightPopStash(repo, "M005", () => {});
+    postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
 
     // README.md must still have our local content
     const restored = readFileSync(join(repo, "README.md"), "utf-8");
@@ -184,3 +184,89 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash conflict warning names the exact stash ref", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local work\n");
+    const preflight = preflightCleanRoot(repo, "M005C", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed");
+
+    writeFileSync(join(repo, "README.md"), "# merged work\n");
+    run("git add README.md", repo);
+    run('git commit -m "simulate conflicting merge"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
+    assert.match(warning, /git stash pop stash@\{\d+\}/);
+    assert.match(warning, /git stash apply stash@\{\d+\}/);
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash restores the matching GSD stash, not stash@{0}", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# target stash\n");
+    const preflight = preflightCleanRoot(repo, "M006", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed target change");
+
+    writeFileSync(join(repo, "other.txt"), "other stash\n");
+    run('git stash push --include-untracked -m "unrelated newer stash"', repo);
+
+    postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(stashList.includes("unrelated newer stash"), "unrelated newer stash must remain");
+    assert.ok(!stashList.includes("gsd-preflight-stash [gsd-preflight-stash:M006"), "target stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash restores the exact preflight marker when another same-milestone stash exists", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# target stash\n");
+    const preflight = preflightCleanRoot(repo, "M007", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed target change");
+    assert.ok(preflight.stashMarker, "preflight must expose exact stash marker");
+
+    writeFileSync(join(repo, "same-milestone.txt"), "newer same milestone stash\n");
+    run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M007:other]"', repo);
+
+    postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(stashList.includes("gsd-preflight-stash:M007:other"), "newer same-milestone stash must remain");
+    assert.ok(!stashList.includes(preflight.stashMarker), "exact target stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash falls back to milestone marker prefix when exact marker is unavailable", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# fallback stash\n");
+    run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M008:fallback]"', repo);
+
+    postflightPopStash(repo, "M008", undefined, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# fallback stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes("gsd-preflight-stash:M008:fallback"), "fallback stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

package/src/resources/extensions/gsd/tests/commands-eval-review.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -462,7 +462,7 @@ describe("findEvalReviewFile", () => {
     const target = join(basePath, ".gsd", "milestones", "M001", "slices", "S07", "S07-EVAL-REVIEW.md");
     writeFileSync(target, "---\nschema: eval-review/v1\n---\n", "utf-8");
     const found = findEvalReviewFile(basePath, "M001", "S07");
-    assert.equal(found, target);
+    assert.equal(found, realpathSync(target));
   });
 });
 

package/src/resources/extensions/gsd/tests/commands-extract-learnings.test.ts

@@ -1,3 +1,4 @@
+// GSD2 commands-extract-learnings tests
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
@@ -484,6 +485,14 @@ describe("buildExtractionStepsBlock", () => {
     assert.ok(/skip/i.test(block));
   });
 
+  it("limits duplicate checks to one milestone-scoped memory query", () => {
+    const block = buildExtractionStepsBlock(ctx);
+    const memoryQueryMatches = block.match(/memory_query/g) ?? [];
+    assert.equal(memoryQueryMatches.length, 1);
+    assert.ok(block.includes("Do not re-read milestone artefacts or repeat memory queries category-by-category"));
+    assert.ok(!block.includes("Before each `capture_thought` call, optionally call `memory_query`"));
+  });
+
   it("instructs capture_thought as the sole persistence path for Patterns, Lessons, and Decisions (ADR-013 step 6 cutover)", () => {
     const block = buildExtractionStepsBlock(ctx);
     // Each of the three persistence steps must call capture_thought.

package/src/resources/extensions/gsd/tests/commands-ship-eval-warn.test.ts

@@ -12,7 +12,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -129,7 +129,8 @@ describe("checkSliceEvalReview", () => {
     // points to a missing file — exactly the race a prior existsSync +
     // readFileSync sequence panicked on.
     const resolved = resolveSliceFile(basePath, "M001", "S07", "EVAL-REVIEW");
-    assert.equal(resolved, path);
+    assert.ok(resolved);
+    assert.equal(realpathSync(resolved), realpathSync(path));
     unlinkSync(path);
     const result = await checkSliceEvalReview(basePath, "M001", "S07");
     assert.equal(result.kind, "absent");

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -0,0 +1,47 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the complete milestone prompt renders required completion and verification guardrails.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("complete milestone prompt renders compact verification and completion guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-complete-milestone-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("complete-milestone", {
+    workingDirectory: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
+    milestoneId: "M001",
+    milestoneTitle: "Baseline And Safety",
+    roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+    milestoneSummaryPath: ".gsd/milestones/M001/M001-SUMMARY.md",
+    inlinedContext: "## Milestone Summary\n\n## Horizontal Checklist\n\n## Decision Re-evaluation",
+    extractLearningsSteps: "Write M001-LEARNINGS.md and call capture_thought.",
+  });
+
+  assert.match(prompt, /Complete Milestone M001/);
+  assert.match(prompt, /Verification Gate/);
+  assert.match(prompt, /Do NOT call `gsd_complete_milestone`/);
+  assert.match(prompt, /verification FAILED/);
+  assert.match(prompt, /gsd_requirement_update/);
+  assert.match(prompt, /gsd_complete_milestone/);
+  assert.match(prompt, /verificationPassed/);
+  assert.match(prompt, /gsd_milestone_status/);
+  assert.match(prompt, /Do NOT query.*\.gsd\/gsd\.db/i);
+  assert.match(prompt, /Horizontal Checklist/);
+  assert.match(prompt, /Decision Re-evaluation/);
+  assert.match(prompt, /self-diff/i);
+  assert.match(prompt, /GSD-(?:Task|Unit)/);
+  assert.match(prompt, /Milestone M001 complete/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tests
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
@@ -432,10 +433,9 @@ describe("complete-milestone", () => {
     }
   });
 
-  test("handleCompleteMilestone does not overwrite existing SUMMARY.md on re-dispatch (#4598)", async () => {
+  test("handleCompleteMilestone treats already-complete milestone as idempotent re-dispatch (#4598)", async () => {
     // This test verifies that when SUMMARY.md already exists (from a prior completion),
     // re-calling handleCompleteMilestone does not overwrite it.
-    // Before the fix this test FAILS because the handler unconditionally writes SUMMARY.md.
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();
     const mid = "M001";
@@ -443,7 +443,7 @@ describe("complete-milestone", () => {
     try {
       // Set up DB with milestone and a complete slice + task
       openDatabase(dbPath);
-      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertMilestone({ id: mid, title: "Test Milestone", status: "complete" });
       insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
 
@@ -472,15 +472,29 @@ describe("complete-milestone", () => {
       };
 
       const result = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in result), `already-complete re-dispatch should succeed: ${JSON.stringify(result)}`);
+      assert.equal(result.alreadyComplete, true);
 
-      // The call may return an error (milestone already complete) or success
-      // but in either case the SUMMARY.md must NOT be overwritten.
       const actualContent = readFileSync(summaryPath, "utf-8");
       assert.strictEqual(
         actualContent,
         originalContent,
         "existing SUMMARY.md must not be overwritten on re-dispatch (#4598)",
       );
+
+      // Repeated re-dispatch should also be idempotent.
+      const repeatResult = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in repeatResult), "repeated re-dispatch should also succeed");
+      assert.strictEqual(repeatResult.alreadyComplete, true, "repeated re-dispatch is identified as already-complete");
+      assert.ok(
+        repeatResult.summaryPath.endsWith(join(".gsd", "milestones", mid, `${mid}-SUMMARY.md`)),
+        "repeated re-dispatch returns the existing summary path",
+      );
+      assert.strictEqual(
+        readFileSync(summaryPath, "utf-8"),
+        originalContent,
+        "repeated re-dispatch must not overwrite SUMMARY.md",
+      );
     } finally {
       try { closeDatabase(); } catch { /* */ }
       clearPathCache();

package/src/resources/extensions/gsd/tests/component-loader.test.ts

@@ -1,12 +1,5 @@
-/**
- * Component Loader — Unit Tests
- *
- * Tests for multi-format component loading:
- * - New format (component.yaml)
- * - Legacy skill format (SKILL.md with frontmatter)
- * - Legacy agent format (.md with frontmatter)
- * - Directory scanning
- */
+// Project/App: GSD-2
+// File Purpose: Verifies component loading across modern and legacy formats.
 
 import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/crash-handler-secondary.test.ts

@@ -232,4 +232,59 @@ describe('emitCrashRecoveredUnitEnd (#3348)', () => {
       rmSync(base, { recursive: true, force: true });
     }
   });
+
+  test('emitOpenUnitEndForUnit closes the latest open start with error context', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitOpenUnitEndForUnit } = await import('../crash-recovery.ts');
+
+      const firstFlowId = randomUUID();
+      const secondFlowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 1,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 2,
+        eventType: 'unit-end',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02', status: 'completed' },
+        causedBy: { flowId: firstFlowId, seq: 1 },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: secondFlowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+
+      const emitted = emitOpenUnitEndForUnit(
+        base,
+        'execute-task',
+        'M008/S04/T02',
+        'cancelled',
+        { message: 'runUnitPhase exploded', category: 'unit-exception', isTransient: false },
+      );
+
+      assert.equal(emitted, true, 'open unit should be closed');
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 2, 'should preserve existing end and add one new end');
+      const newEnd = ends.find((e) => e.causedBy?.flowId === secondFlowId);
+      assert.ok(newEnd, 'new end should close the latest open start');
+      assert.equal(newEnd!.data?.status, 'cancelled');
+      assert.deepEqual(newEnd!.data?.errorContext, {
+        message: 'runUnitPhase exploded',
+        category: 'unit-exception',
+        isTransient: false,
+      });
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -30,6 +30,7 @@ import {
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
@@ -102,6 +103,27 @@ test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches
   assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
 });
 
+test("readCrashLock falls back to latest in-flight runtime record when dispatch claim is missing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  writeUnitRuntimeRecord(base, "execute-task", "M008/S04/T02", 1778069087937, {
+    phase: "dispatched",
+    lastProgressAt: 1778069087937,
+    lastProgressKind: "dispatch",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M008/S04/T02");
+  assert.equal(lock!.unitStartedAt, new Date(1778069087937).toISOString());
+});
+
 test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -372,6 +372,150 @@ describe("Custom engine loop integration", () => {
     assert.ok(stopEntry?.includes("Workflow complete"), "Should stop with 'Workflow complete'");
   });
 
+  it("finalizes custom-engine complete turns and clears current turn state", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a", status: "complete" }),
+    ], "already-done");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "already-done");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+    });
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          deps.callLog.push(`turnResult:${result.status}`);
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.deepEqual(turnResults, [{ status: "completed", failureClass: "none", error: undefined }]);
+    assert.ok(
+      deps.callLog.indexOf("turnResult:completed") < deps.callLog.indexOf("stopAuto:Workflow complete"),
+      `turn should finalize before stopAuto; log=${deps.callLog.join(",")}`,
+    );
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "complete workflow should not dispatch work");
+  });
+
+  it("stops blocked custom workflows and clears current turn state", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a", dependsOn: ["step-b"] }),
+      makeStep({ id: "step-b", dependsOn: ["step-a"] }),
+    ], "blocked-workflow");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "blocked-workflow");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+    });
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.equal(turnResults.length, 1);
+    assert.equal(turnResults[0].status, "stopped");
+    assert.equal(turnResults[0].failureClass, "manual-attention");
+    assert.match(turnResults[0].error ?? "", /custom-engine-dispatch-stop/);
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "blocked workflow should not dispatch a custom step");
+    assert.match(
+      deps.callLog.find((e: string) => e.startsWith("stopAuto:")) ?? "",
+      /Workflow blocked: no pending steps are ready/,
+    );
+  });
+
+  it("finalizes the active turn when the session lock is lost", async () => {
+    _resetPendingResolve();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession();
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      validateSessionLock: () => ({
+        valid: false,
+        failureReason: "pid-mismatch",
+        expectedPid: 111,
+        existingPid: 222,
+      } as SessionLockStatus),
+      handleLostSessionLock: () => {
+        deps.callLog.push("handleLostSessionLock");
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.deepEqual(turnResults, [{
+      status: "stopped",
+      failureClass: "manual-attention",
+      error: "session-lock-lost",
+    }]);
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "lost session lock must not dispatch work");
+    assert.ok(deps.callLog.includes("handleLostSessionLock"));
+  });
+
   it("does not call runPreDispatch or runFinalize on the custom path", async () => {
     _resetPendingResolve();