akm-cli 0.9.31 → 0.10.261001-beta

package/dist/workflows/exec/native-executor.js

@@ -20,8 +20,6 @@
  *    gate loops journal under `~r<n>` / `~l<n>`.
  *  - `onError: "fail"` fails on any unit failure, `"continue"` lets the gate
  *    decide; `retry: { max, on }` re-dispatches listed failure reasons.
- *  - `isolation: worktree` runs each attempt of an agent/sdk unit in a fresh
- *    detached worktree (removed when clean, kept when dirty); llm units reject it.
  *  - Run `budget` ceilings are consumed per actual dispatch and abort the step
  *    when crossed, regardless of `on_error`.
  */
@@ -52,9 +50,7 @@ import { scheduleUnits } from "./scheduler.js";
 // path. This module dispatches; step-work.ts owns the pure decisions.
 import { clip, computeStepWorkList, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
 import { dispatchWorkflowExecution, } from "./unit-dispatch.js";
-import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "../../tasks/frozen-script.js";
 import { enqueueUnitWrite } from "./unit-writer.js";
-import { assertGitWorkTree, cleanupUnitWorktree, createUnitWorktree } from "./worktree.js";
 /**
  * Per-step dispatch budget against the run's `budget` ceilings, seeded from
  * the journal and consumed per actual dispatch (never by a reused row).
@@ -171,7 +167,7 @@ function openDispatchBudget(ctx, dispatched) {
 }
 /** Resolve the live-at-dispatch prerequisites once, after durable-row reuse is known. */
 async function prepareStepDispatchPrerequisites(input) {
-    const { plan, template, workUnits, ctx, willDispatch, dispatched } = input;
+    const { plan, workUnits, willDispatch, dispatched } = input;
     let env;
     let sensitiveValues;
     const frozenEnvironment = workUnits[0]?.environment;
@@ -195,35 +191,10 @@ async function prepareStepDispatchPrerequisites(input) {
             };
         }
     }
-    let worktreeBase;
-    if (willDispatch && template.isolation === "worktree") {
-        if (template.frozenTarget.kind === "command" && template.frozenTarget.runner.kind === "llm") {
-            return {
-                ok: false,
-                result: failedStep(dispatched, `Step "${plan.stepId}" declares isolation: worktree on an llm unit — the llm runner has no ` +
-                    `working directory to isolate. Use the agent or sdk runner for worktree-isolated units.`),
-            };
-        }
-        const target = workUnits[0]?.frozenTarget;
-        const frozenCwd = target && "cwdIdentity" in target ? target.cwdIdentity : undefined;
-        if (frozenCwd)
-            assertFrozenDirectoryContained(frozenCwd);
-        const base = frozenCwd?.realRoot ?? ctx.workDir ?? process.cwd();
-        const preflightWorktree = ctx.preflightWorktree ?? assertGitWorkTree;
-        const gitError = preflightWorktree(base);
-        if (gitError !== undefined) {
-            return {
-                ok: false,
-                result: failedStep(dispatched, `Step "${plan.stepId}" cannot use isolation: worktree: ${gitError}`),
-            };
-        }
-        worktreeBase = base;
-    }
     return {
         ok: true,
         ...(env ? { env } : {}),
         ...(sensitiveValues ? { sensitiveValues } : {}),
-        ...(worktreeBase !== undefined ? { worktreeBase } : {}),
     };
 }
 async function executeStepPlanInConnection(plan, ctx) {
@@ -251,32 +222,25 @@ async function executeStepPlanInConnection(plan, ctx) {
     const dispatcher = ctx.dispatcher ?? defaultUnitDispatcher;
     // Load journaled rows first: a completed unit is reused, never re-dispatched.
     const completedRows = indexCompletedRows(await withWorkflowRunsRepo((repo) => repo.getUnitsForStep(ctx.runId, plan.stepId)));
-    // Env resolution and worktree preflight run only when some unit will
-    // dispatch, so a fully-journaled step resumes even if an env asset or git is
-    // gone. Every unit is classified once; the preflight and dispatch share it.
+    // Env resolution runs only when some unit will dispatch, so a fully-journaled
+    // step resumes even if an env asset is gone. Every unit is classified once;
+    // the preflight and dispatch share it.
     const reuseDecisions = workUnits.map((unit) => classifyUnitReuse(unit, completedRows));
     const willDispatch = reuseDecisions.some((decision) => decision.kind === "dispatch");
     const prerequisites = await prepareStepDispatchPrerequisites({
         plan,
-        template,
         workUnits,
-        ctx,
         willDispatch,
         dispatched,
     });
     if (!prerequisites.ok)
         return prerequisites.result;
-    const { env, sensitiveValues, worktreeBase } = prerequisites;
+    const { env, sensitiveValues } = prerequisites;
     // Budget ceilings + lifetime-cap accounting, and the budget-chained abort
     // signal they trip. Extracted verbatim (behavior-identical) — see
     // {@link openDispatchBudget}.
     const { signal, budget, unchainSignal } = openDispatchBudget(ctx, dispatched);
     let outcomes;
-    // Worktree removals started by finished units and awaited below, before this
-    // step reports anything. Cleanup is best-effort, but "the step resolved" must
-    // still mean "its clean worktrees are gone" — only the WAIT moves off the
-    // unit's scheduler slot, not the guarantee.
-    const pendingWorktreeCleanups = [];
     const frozenTargetConcurrency = template.frozenTarget.kind === "command" ? template.frozenTarget.concurrency : undefined;
     try {
         outcomes = await scheduleUnits(workUnits, (workUnit, index) => runUnit({
@@ -284,12 +248,10 @@ async function executeStepPlanInConnection(plan, ctx) {
             workUnit,
             env,
             sensitiveValues,
-            ...(worktreeBase !== undefined ? { worktreeBase } : {}),
             ctx,
             signal,
             dispatcher,
             reuse: reuseDecisions[index],
-            pendingWorktreeCleanups,
             budget,
         }), {
             concurrency: workList.list.concurrency,
@@ -300,9 +262,6 @@ async function executeStepPlanInConnection(plan, ctx) {
     }
     finally {
         unchainSignal?.();
-        // The barrier. `allSettled` because each task already swallowed its own
-        // failure into a warn — nothing here can fail the step.
-        await Promise.allSettled(pendingWorktreeCleanups);
     }
     // Capture live-only diagnostics BEFORE any hard reduction replaces the unit
     // list with a failed-step envelope. Budget/cap and journal-write failures
@@ -358,11 +317,9 @@ async function runUnit(input) {
         prompt,
         frozenTarget: workUnit.frozenTarget,
         ...(workUnit.execContext ? { execContext: workUnit.execContext } : {}),
-        // A NON-isolated exec unit spawns in the engine invocation's working
-        // directory. `dispatchJournaledAttempt` overwrites this with the unit's
-        // fresh worktree when `isolation: worktree` is in play. Only exec units get
-        // it: handing an agent unit a cwd it never had would change harness
-        // behavior, and the agent path already takes its cwd from its profile.
+        // An exec unit spawns in the engine invocation's working directory. Only
+        // exec units get it: handing an agent unit a cwd it never had would change
+        // harness behavior, and the agent path already takes its cwd from its profile.
         ...(workUnit.frozenTarget.kind !== "command" && ctx.workDir !== undefined ? { cwd: ctx.workDir } : {}),
         timeoutMs: workUnit.timeoutMs,
         ...(workUnit.schema ? { schema: workUnit.schema } : {}),
@@ -370,7 +327,7 @@ async function runUnit(input) {
         ...(sensitiveValues ? { sensitiveValues } : {}),
         ...(input.signal ? { signal: input.signal } : {}),
         // F-1: forwarded to exec-unit.ts's childEnv for a
-        // "script"/"shell" unit, and to dispatchWorkflowExecution's
+        // "shell" unit, and to dispatchWorkflowExecution's
         // runExecution eventSource option (unit-dispatch.ts)
         // for a "command" unit — both arms observe it.
         ...(ctx.eventSource !== undefined ? { eventSource: ctx.eventSource } : {}),
@@ -424,8 +381,6 @@ async function runUnit(input) {
             request: { ...request, unitId: attemptId },
             attemptId,
             inputHash,
-            ...(input.worktreeBase !== undefined ? { worktreeBase: input.worktreeBase } : {}),
-            pendingWorktreeCleanups: input.pendingWorktreeCleanups,
         });
         // Attempts use `~r<n>` journal suffixes while durable step evidence remains
         // attached to the content-derived base identity.
@@ -463,30 +418,7 @@ function journaledUnitResultJson(outcome) {
         return null;
     return JSON.stringify(clip(parts.join("\n--- unit output ---\n"), WORKFLOW_UNIT_DIAGNOSTIC_CLIP));
 }
-async function prepareAttemptWorktree(input) {
-    if (input.worktreeBase === undefined)
-        return { ok: true, request: input.request };
-    const created = await createUnitWorktree(input.worktreeBase, input.ctx.runId, input.attemptId, 
-    // A child-workflow target has no commit of its own (its prepared worktree goes unused).
-    input.workUnit.frozenTarget.kind === "child-workflow" ? undefined : input.workUnit.frozenTarget.gitCommitOid);
-    if (created.preservedLeftover !== undefined) {
-        warn(`Workflow unit ${input.attemptId}: a previous attempt left uncollected work in its isolation worktree; ` +
-            `preserved at ${created.preservedLeftover}`);
-    }
-    if (!created.ok) {
-        return {
-            ok: false,
-            outcome: {
-                unitId: input.request.unitId,
-                ok: false,
-                failureReason: "worktree_failed",
-                error: created.error,
-            },
-        };
-    }
-    return { ok: true, request: { ...input.request, cwd: created.path }, worktreePath: created.path };
-}
-async function reserveJournaledDispatch(input, worktreePath, startedAt) {
+async function reserveJournaledDispatch(input, startedAt) {
     const { plan, workUnit, ctx, attemptId, inputHash } = input;
     let durableAttempt;
     await enqueueUnitWrite(async () => {
@@ -503,7 +435,6 @@ async function reserveJournaledDispatch(input, worktreePath, startedAt) {
                 engine: target.kind === "command" ? target.request.engine.name : null,
                 model: target.kind === "command" ? (target.request.model?.resolved ?? null) : null,
                 inputHash,
-                worktreePath: worktreePath ?? null,
                 now: startedAt,
             }).attempt;
         });
@@ -538,37 +469,14 @@ async function finishJournaledDispatch(input) {
         }
     }));
 }
-function queueAttemptWorktreeCleanup(input, worktreePath) {
-    if (worktreePath === undefined || input.worktreeBase === undefined)
-        return;
-    const worktreeBase = input.worktreeBase;
-    input.pendingWorktreeCleanups.push((async () => {
-        try {
-            const cleanup = await cleanupUnitWorktree(worktreeBase, worktreePath);
-            if (cleanup.dirty) {
-                warn(`Workflow unit ${input.attemptId} left uncommitted changes in its isolation worktree; retained at ${worktreePath}`);
-            }
-            else if (!cleanup.removed) {
-                warn(`Workflow unit ${input.attemptId}: could not clean up isolation worktree ${worktreePath}: ${cleanup.error}`);
-            }
-        }
-        catch (err) {
-            warn(`Workflow unit ${input.attemptId}: could not clean up isolation worktree ${worktreePath}: ${message(err)}`);
-        }
-    })());
-}
 /** Journal one dispatch attempt: insert row, events, dispatch, finish row. */
 async function dispatchJournaledAttempt(input) {
     const { workUnit, ctx, dispatcher, attemptId } = input;
-    const prepared = await prepareAttemptWorktree(input);
-    if (!prepared.ok)
-        return prepared.outcome;
-    let { request } = prepared;
-    const { worktreePath } = prepared;
+    let { request } = input;
     const startedAt = new Date().toISOString();
     let durableAttempt;
     try {
-        durableAttempt = await reserveJournaledDispatch(input, worktreePath, startedAt);
+        durableAttempt = await reserveJournaledDispatch(input, startedAt);
     }
     catch (err) {
         // A failed dispatch-row insert means NOTHING dispatched (the row is the
@@ -576,8 +484,6 @@ async function dispatchJournaledAttempt(input) {
         // letting the throw escape into the scheduler, where a swallowed worker
         // error is indistinguishable from "never claimed" and used to be
         // misreported as an aborted, never-dispatched unit.
-        if (worktreePath !== undefined && input.worktreeBase !== undefined)
-            await cleanupUnitWorktree(input.worktreeBase, worktreePath);
         return {
             unitId: request.unitId,
             ok: false,
@@ -632,9 +538,6 @@ async function dispatchJournaledAttempt(input) {
     catch (err) {
         journalError = err;
     }
-    // A clean worktree is removed, a dirty one kept and logged. Cleanup starts
-    // here and is awaited at the step barrier, never holding this scheduler slot.
-    queueAttemptWorktreeCleanup(input, worktreePath);
     // A journal-write failure AFTER a successful dispatch is its own loud
     // failure class: the unit's work ran (and may have succeeded), but its
     // terminal state could not be recorded, so the row may be stuck `running`.
@@ -796,44 +699,6 @@ async function dispatchUnit(request, dispatcher) {
  */
 export const defaultUnitDispatcher = async (request, feedback) => {
     const frozenTarget = request.frozenTarget;
-    if (frozenTarget.kind === "script") {
-        assertFrozenDirectoryContained(frozenTarget.cwdIdentity);
-        const materialized = materializeFrozenScript({
-            sourceRef: frozenTarget.ref,
-            interpreter: frozenTarget.interpreter,
-            extension: frozenTarget.extension,
-            bytesBase64: frozenTarget.bytesBase64,
-            byteLength: frozenTarget.byteLength,
-            sha256: frozenTarget.contentHash,
-        });
-        try {
-            const command = frozenScriptCommand({
-                sourceRef: frozenTarget.ref,
-                interpreter: frozenTarget.interpreter,
-                extension: frozenTarget.extension,
-                bytesBase64: frozenTarget.bytesBase64,
-                byteLength: frozenTarget.byteLength,
-                sha256: frozenTarget.contentHash,
-            }, materialized.file);
-            return await runExecUnit({
-                unitId: request.unitId,
-                exec: {
-                    ...frozenTarget.exec,
-                    command: command,
-                },
-                baseDir: request.cwd ?? frozenTarget.cwdIdentity.realCwd,
-                ...(request.env ? { env: request.env } : {}),
-                ...(request.execContext ? { context: request.execContext } : {}),
-                ...(request.schema ? { hasOutputSchema: true } : {}),
-                timeoutMs: request.timeoutMs,
-                ...(request.signal ? { signal: request.signal } : {}),
-                ...(request.eventSource !== undefined ? { eventSource: request.eventSource } : {}),
-            });
-        }
-        finally {
-            cleanupFrozenScript(materialized);
-        }
-    }
     if (frozenTarget.kind === "shell") {
         if (frozenTarget.cwdIdentity)
             assertFrozenDirectoryContained(frozenTarget.cwdIdentity);

package/dist/workflows/exec/run-workflow.js

@@ -21,16 +21,15 @@ import { resolveStorageLocations } from "../../storage/locations.js";
 import { withWorkflowRunsConnection, withWorkflowRunsRepo } from "../../storage/repositories/workflow-runs-repository.js";
 import { computePlanHash } from "../ir/plan-hash.js";
 import { decodeWorkflowPlan, readRunPlan } from "../runtime/run-plan.js";
-import { abandonWorkflowRun, completeWorkflowStep, getNextWorkflowStep, resumeWorkflowRun, } from "../runtime/runs.js";
+import { abandonWorkflowRun, getNextWorkflowStep, resumeWorkflowRun } from "../runtime/runs.js";
 import { loadWorkflowAsset } from "../runtime/workflow-asset-loader.js";
 import { frozenSummaryJudge } from "./frozen-judge.js";
 import { mergeLoweringNotices } from "./lowering-notices.js";
 import { defaultUnitDispatcher, executeStepPlan, } from "./native-executor.js";
-// Shared step semantics — route evaluation + cascaded-skip bookkeeping,
-// gate-evaluation journaling, and the whole step-completion path
+// Shared step semantics — gate-evaluation journaling, and the whole step-completion path
 // (`finalizeExecutedStep`) live in step-work.ts as ONE implementation, so the
 // fresh-execution and resume paths cannot drift from each other.
-import { activeGateLoop, blockStepForJudgeFailure, cascadeSkippedRouter, effectiveGateMaxLoops, finalizeExecutedStep, recoverGateFeedback, referencedStepIds, seedJournaledRouteDecisions, } from "./step-work.js";
+import { activeGateLoop, blockStepForJudgeFailure, effectiveGateMaxLoops, finalizeExecutedStep, recoverGateFeedback, referencedStepIds, } from "./step-work.js";
 export async function runWorkflowSteps(options) {
     let target = options.target;
     let params = options.params;
@@ -72,8 +71,8 @@ export async function runWorkflowSteps(options) {
         }
         if (remainingSteps !== undefined) {
             // The step budget is DISTINCT PROCESSED STEPS, not `executed` entries:
-            // gate loops of one step and route-skips must not shrink a retry's
-            // remaining budget (they never counted against maxSteps either).
+            // gate loops of one step must not shrink a retry's remaining budget
+            // (they never counted against maxSteps either).
             remainingSteps -= result.stepsProcessed;
             if (remainingSteps <= 0)
                 return aggregate;
@@ -262,28 +261,6 @@ async function loadAuthoritativeRunPlan(options, next, stored) {
     }
     return stored;
 }
-/**
- * Complete a branch target no completed router selected as `skipped` — no
- * dispatch, no gate loop, and (per the `maxSteps` contract) no step consumed.
- * Returns the re-read spine state so the caller can continue its walk.
- */
-async function skipUnselectedRouteTarget(input) {
-    const { runId, stepId, stepPlan, skipInfo, routeUnselected, executed } = input;
-    // Cascade: a skipped step that is ITSELF a router
-    // never evaluates its route, so none of its declared targets were
-    // selected — mark them all skip-on-reach too (a target another
-    // completed router selects stays protected via routeSelected). Without
-    // this, every branch of the skipped router would run unconditionally.
-    if (stepPlan.route) {
-        cascadeSkippedRouter(stepPlan.route, stepId, routeUnselected);
-    }
-    const notes = skipInfo.selected === null
-        ? `Skipped by route: step "${skipInfo.router}" was itself skipped, so none of its branch targets run.`
-        : `Skipped by route: step "${skipInfo.router}" selected "${skipInfo.selected}".`;
-    executed.push({ stepId, ok: true, unitCount: 0, failedUnits: 0, summary: notes });
-    await completeWorkflowStep({ runId, stepId, status: "skipped", notes });
-    return getNextWorkflowStep(runId);
-}
 /**
  * Seed a step's starting gate loop and feedback from its journaled gate rows,
  * so a run interrupted after a rejection resumes at the next loop with the
@@ -307,41 +284,31 @@ async function recoverGateLoopState(runId, stepPlan) {
  */
 const STEP_FINISHED_KINDS = new Set(["advanced", "failed", "gate-exhausted"]);
 /**
- * One attempt at a step's work. Route-only steps (YAML `route:` — no execution
- * subgraph) dispatch no units; they only decide the spine's path in
- * `finalizeExecutedStep`. Everything else executes its subgraph through the
- * native executor.
+ * One attempt at a step's work: execute its subgraph through the native
+ * executor.
  */
 async function executeStepSubgraph(ctx, loop) {
-    const { options, next, plan, stepPlan, step, evidence } = ctx;
+    const { options, next, plan, stepPlan, evidence } = ctx;
     const { gateLoop, gateFeedback, unitsDispatched, tokensUsed } = loop;
-    return !stepPlan.root && stepPlan.route
-        ? {
-            ok: true,
-            units: [],
-            evidence: {},
-            summary: `Step "${step.id}" is a route step — no units dispatched.`,
-            unitsDispatched,
-        }
-        : await executeStepPlan(stepPlan, {
-            runId: next.run.id,
-            workflowRef: next.run.workflowRef,
-            params: next.run.params ?? {},
-            evidence,
-            unitsDispatched,
-            tokensUsed,
-            // Budget ceilings ride the FROZEN plan: a mid-run
-            // asset edit can never loosen or tighten a run's budget.
-            ...(plan.budget ? { budget: plan.budget } : {}),
-            gateLoop,
-            ...(gateFeedback ? { gateFeedback } : {}),
-            // F-1: threaded to an exec unit's child env;
-            // undefined for every non-task caller (byte-identical, RunWorkflowOptions doc).
-            ...(options.eventSource !== undefined ? { eventSource: options.eventSource } : {}),
-            ...(options.signal ? { signal: options.signal } : {}),
-            ...(options.dispatcher ? { dispatcher: options.dispatcher } : {}),
-            maxConcurrency: Math.min(options.maxConcurrency ?? Number.POSITIVE_INFINITY, plan.execution?.maxConcurrency ?? 1),
-        });
+    return await executeStepPlan(stepPlan, {
+        runId: next.run.id,
+        workflowRef: next.run.workflowRef,
+        params: next.run.params ?? {},
+        evidence,
+        unitsDispatched,
+        tokensUsed,
+        // Budget ceilings ride the FROZEN plan: a mid-run
+        // asset edit can never loosen or tighten a run's budget.
+        ...(plan.budget ? { budget: plan.budget } : {}),
+        gateLoop,
+        ...(gateFeedback ? { gateFeedback } : {}),
+        // F-1: threaded to an exec unit's child env;
+        // undefined for every non-task caller (byte-identical, RunWorkflowOptions doc).
+        ...(options.eventSource !== undefined ? { eventSource: options.eventSource } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.dispatcher ? { dispatcher: options.dispatcher } : {}),
+        maxConcurrency: Math.min(options.maxConcurrency ?? Number.POSITIVE_INFINITY, plan.execution?.maxConcurrency ?? 1),
+    });
 }
 /**
  * Drive one step's bounded gate loop: a rejection with loops left re-executes
@@ -349,7 +316,7 @@ async function executeStepSubgraph(ctx, loop) {
  * decision and running budget totals; `ctx.executed` is appended in place.
  */
 async function runStepGateLoop(ctx, gate, totals) {
-    const { options, next, stepPlan, step, evidence, executed, routeSelected, routeUnselected } = ctx;
+    const { options, next, stepPlan, step, executed } = ctx;
     const { summaryJudge } = ctx;
     const { startLoop, maxLoops } = gate;
     let { unitsDispatched, tokensUsed } = totals;
@@ -376,7 +343,7 @@ async function runStepGateLoop(ctx, gate, totals) {
             summary: result.summary,
             ...(result.notices ? { notices: result.notices } : {}),
         });
-        // Route, gate, and advance: the shared completion path, live or resumed.
+        // Gate and advance: the shared completion path, live or resumed.
         let finalize;
         try {
             finalize = await finalizeExecutedStep({
@@ -388,10 +355,6 @@ async function runStepGateLoop(ctx, gate, totals) {
                 gateLoop,
                 loopsRemaining: gateLoop < maxLoops,
                 result,
-                priorEvidence: evidence,
-                params: next.run.params ?? {},
-                routeSelected,
-                routeUnselected,
                 summaryJudge,
                 signal: options.signal,
             });
@@ -413,10 +376,6 @@ async function runStepGateLoop(ctx, gate, totals) {
             // when some later reference can read it (`referencedStepIds`).
             if (ctx.liveEvidenceConsumers.has(step.id))
                 ctx.liveEvidence.set(step.id, result.evidence);
-            // A route-only step's summary IS its decision (finalize surfaces it).
-            if (finalize.summaryOverride !== undefined) {
-                executed[executed.length - 1] = { ...executed[executed.length - 1], summary: finalize.summaryOverride };
-            }
             return outcome({ kind: "advanced" });
         }
         if (finalize.kind === "judge-failed") {
@@ -451,11 +410,6 @@ async function runStepGateLoop(ctx, gate, totals) {
             });
         }
         if (finalize.kind === "failed") {
-            // A route-failure was pushed as ok:true (the units succeeded); reflect
-            // the deterministic route failure in the executed report.
-            if (finalize.routeFailure) {
-                executed[executed.length - 1] = { ...executed[executed.length - 1], ok: false, summary: finalize.summary };
-            }
             return outcome({ kind: "failed" });
         }
         // gate-exhausted: rejected with no loop budget left — stop with feedback.
@@ -486,9 +440,8 @@ liveEvidence) {
     let aborted = false;
     const maxSteps = options.maxSteps ?? Number.POSITIVE_INFINITY;
     // The `maxSteps` budget counts DISTINCT spine steps that finished processing
-    // — never `executed.length`, which grows once per gate-loop iteration and
-    // once per route-skip. A step's whole bounded gate loop consumes ONE step;
-    // a route-skipped step consumes NOTHING (no work was dispatched for it).
+    // — never `executed.length`, which grows once per gate-loop iteration. A
+    // step's whole bounded gate loop consumes ONE step.
     let stepsProcessed = 0;
     let { unitsDispatched, tokensUsed } = await seedRunAccountingFromJournal(next.run.id);
     const plan = await loadAuthoritativeRunPlan(options, next, storedPlan);
@@ -498,16 +451,6 @@ liveEvidence) {
     // and holding every step's for the whole invocation is pure ballast when
     // nothing downstream names it.
     const liveEvidenceConsumers = referencedStepIds(plan);
-    // Route bookkeeping: targets a completed router did NOT select are skipped
-    // when the spine reaches them; a target ANY router selected is protected
-    // (two routers may share a target).
-    const routeSelected = new Set();
-    const routeUnselected = new Map();
-    // Replay journaled route decisions before the spine advances, so a
-    // re-invoked run skips the unselected branches. A done run skips this.
-    if (!next.done) {
-        seedJournaledRouteDecisions(plan, next, routeSelected, routeUnselected);
-    }
     while (!next.done && next.step && next.run.status === "active" && stepsProcessed < maxSteps) {
         // A caller abort (options.signal) is a graceful break.
         if (options.signal?.aborted) {
@@ -520,19 +463,6 @@ liveEvidence) {
             throw new UsageError(`Step "${step.id}" of run ${next.run.id} is not present in its frozen workflow plan (${next.run.workflowRef}). ` +
                 "The run journal is inconsistent; abandon this run and start a new one.");
         }
-        // A branch target no completed router selected → auto-skip, no dispatch.
-        const skipInfo = routeUnselected.get(step.id);
-        if (skipInfo && !routeSelected.has(step.id)) {
-            next = await skipUnselectedRouteTarget({
-                runId: next.run.id,
-                stepId: step.id,
-                stepPlan,
-                skipInfo,
-                routeUnselected,
-                executed,
-            });
-            continue;
-        }
         const evidence = {};
         for (const s of next.workflow.steps)
             evidence[s.id] = liveEvidence.get(s.id) ?? s.evidence;
@@ -589,8 +519,6 @@ liveEvidence) {
             liveEvidence,
             liveEvidenceConsumers,
             executed,
-            routeSelected,
-            routeUnselected,
             summaryJudge,
         }, { startLoop, maxLoops, seededFeedback }, { unitsDispatched, tokensUsed });
         unitsDispatched = outcome.unitsDispatched;