gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.c5f2443b3

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

@@ -0,0 +1,353 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createAutoOrchestrator } from "../auto/orchestrator.js";
+import type { AutoOrchestratorDeps } from "../auto/contracts.js";
+
+function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOrchestratorDeps; calls: string[] } {
+  const calls: string[] = [];
+
+  const deps: AutoOrchestratorDeps = {
+    dispatch: {
+      async decideNextUnit() {
+        calls.push("dispatch.decide");
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+    recovery: {
+      async classifyAndRecover() {
+        calls.push("recovery.classify");
+        return { action: "stop", reason: "fatal" };
+      },
+    },
+    worktree: {
+      async prepareForUnit() { calls.push("worktree.prepare"); },
+      async syncAfterUnit() { calls.push("worktree.sync"); },
+      async cleanupOnStop() { calls.push("worktree.cleanup"); },
+    },
+    health: {
+      async preAdvanceGate() {
+        calls.push("health.pre");
+        return { allow: true };
+      },
+      async postAdvanceRecord() { calls.push("health.post"); },
+    },
+    runtime: {
+      async ensureLockOwnership() { calls.push("runtime.lock"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    notifications: {
+      async notifyLifecycle(event) { calls.push(`notify:${event.name}`); },
+    },
+  };
+
+  return { deps: { ...deps, ...overrides }, calls };
+}
+
+test("start() advances and records active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(result.kind, "advanced");
+  const status = orchestrator.getStatus();
+  assert.equal(status.phase, "running");
+  assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
+  assert.ok(calls.includes("journal:start"));
+  assert.ok(calls.includes("journal:advance"));
+});
+
+test("advance() returns blocked when health gate denies", async () => {
+  const { deps } = makeDeps({
+    health: {
+      async preAdvanceGate() { return { allow: false, reason: "doctor-block" }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  assert.equal(result.reason, "doctor-block");
+});
+
+test("advance() stops when dispatch has no next unit", async () => {
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() { return null; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+});
+
+test("advance() uses recovery on error", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("lock lost"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "error");
+  assert.equal(result.reason, "needs manual");
+  assert.equal(orchestrator.getStatus().phase, "error");
+  assert.ok(calls.includes("journal:advance-error"));
+});
+
+test("advance() is idempotent for the same active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(second.kind, "blocked");
+  assert.equal(second.reason, "idempotent advance: unit already active");
+
+  const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
+  assert.equal(prepareCalls, 1);
+});
+
+test("resume() re-enters running flow via advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "advanced");
+  assert.equal(orchestrator.getStatus().phase, "running");
+});
+
+test("resume() clears idempotent lock and allows re-advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const resumed = await orchestrator.resume();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(resumed.kind, "advanced");
+});
+
+test("transitionCount increases across lifecycle transitions", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const before = orchestrator.getStatus().transitionCount;
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  const afterStart = orchestrator.getStatus().transitionCount;
+  await orchestrator.stop("done");
+  const afterStop = orchestrator.getStatus().transitionCount;
+
+  assert.ok(afterStart > before);
+  assert.ok(afterStop > afterStart);
+});
+
+test("stop() clears idempotent unit lock so advance can run again", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const stopped = await orchestrator.stop("reset");
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(second.kind, "advanced");
+});
+
+test("advance() stopped clears previous activeUnit", async () => {
+  let first = true;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        if (first) {
+          first = false;
+          return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+        }
+        return null;
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+});
+
+test("recovery stop clears activeUnit", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "stop", reason: "fatal" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+  assert.ok(calls.includes("journal:advance-stopped"));
+  assert.ok(calls.includes("notify:stopped"));
+  assert.ok(!calls.includes("notify:error"));
+});
+
+test("recovery retry maps to paused result", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "retry", reason: "transient" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "paused");
+  assert.equal(result.reason, "transient");
+  assert.equal(orchestrator.getStatus().phase, "paused");
+  assert.ok(calls.includes("journal:advance-paused"));
+  assert.ok(calls.includes("notify:pause"));
+});
+
+test("getStatus() returns defensive copy of activeUnit", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const snap1 = orchestrator.getStatus();
+  if (snap1.activeUnit) snap1.activeUnit.unitId = "MUTATED";
+  const snap2 = orchestrator.getStatus();
+
+  assert.equal(snap2.activeUnit?.unitId, "T01");
+});
+
+test("start() clears prior idempotent lock", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(restarted.kind, "advanced");
+});
+
+test("error path emits error notification", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("notify:error"));
+});
+
+test("blocked path journals advance-blocked", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("journal:advance-blocked"));
+});
+
+test("health post hook runs on blocked result", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("health.post"));
+});
+
+test("start() emits start notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.ok(calls.includes("notify:start"));
+});
+
+test("resume() emits resume notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.resume();
+
+  assert.ok(calls.includes("notify:resume"));
+});
+
+test("stopped with no remaining units clears idempotent lock for next advance", async () => {
+  let callCount = 0;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        callCount += 1;
+        if (callCount === 2) return null;
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+  const after = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(after.kind, "advanced");
+});
+
+test("stop() cleans up worktree and transitions to stopped", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.stop("user-request");
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+  assert.ok(calls.includes("worktree.cleanup"));
+  assert.ok(calls.includes("journal:stop"));
+  assert.ok(calls.includes("notify:stop"));
+});

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

@@ -34,6 +34,25 @@ test("#2302 bug 1: auto_pr condition should not require pushed flag", () => {
   );
 });
 
+test("auto_pr skips milestone branch push when configured remote is absent", () => {
+  const autoPrIdx = autoWorktreeSrc.indexOf("prefs.auto_pr === true");
+  assert.ok(autoPrIdx !== -1, "auto_pr block exists in auto-worktree.ts");
+
+  const autoPrBlock = autoWorktreeSrc.slice(
+    autoPrIdx,
+    autoWorktreeSrc.indexOf("// 11. Guard removed", autoPrIdx),
+  );
+  const remoteExistsIdx = autoPrBlock.indexOf("gitRemoteExists(originalBasePath_, remote)");
+  const pushIdx = autoPrBlock.indexOf('execFileSync("git", ["push", remote, milestoneBranch]');
+
+  assert.ok(remoteExistsIdx !== -1, "auto_pr must check that the configured remote exists");
+  assert.ok(pushIdx !== -1, "auto_pr still pushes the milestone branch before creating the PR");
+  assert.ok(
+    remoteExistsIdx < pushIdx,
+    "auto_pr must check remote existence before pushing the milestone branch",
+  );
+});
+
 // ─── Bug 2: phases.ts should not duplicate PR creation ──────────────────────
 
 const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");

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/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-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/custom-engine-loop-integration.test.ts

@@ -372,6 +372,44 @@ describe("Custom engine loop integration", () => {
     assert.ok(stopEntry?.includes("Workflow complete"), "Should stop with 'Workflow complete'");
   });
 
+  it("finishes custom-engine skip turns 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 }> = [];
+    const deps = makeMockDeps({
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          turnResults.push({ status: result.status });
+          s.active = false;
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.deepEqual(turnResults, [{ status: "skipped" }]);
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "skip should not dispatch a custom step");
+  });
+
   it("does not call runPreDispatch or runFinalize on the custom path", async () => {
     _resetPendingResolve();