@ai-dossier/sched 0.46.1 → 0.48.0

package/dist/state.js

@@ -9,8 +9,41 @@
  * decision-pending | failed(escalation-cap)" — encoded generically for every
  * non-terminal issue status rather than repeated per row.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRANSITIONS = exports.CLEARED_SLOT_FIELDS = exports.CLEARED_PR_WATCH_FIELDS = exports.CLEARED_ANCHOR_CLOSE_FAILED_FIELDS = exports.CLEARED_ENTRY_DEDUP_MARKERS = exports.ISSUE_UNIVERSAL_FAILURE_EDGES = void 0;
+exports.TRANSITIONS = exports.PARKED_MEMBER_STATUSES = exports.CLEARED_SLOT_FIELDS = exports.CLEARED_PR_WATCH_FIELDS = exports.CLEARED_ANCHOR_CLOSE_FAILED_FIELDS = exports.CLEARED_ENTRY_DEDUP_MARKERS = exports.ISSUE_UNIVERSAL_FAILURE_EDGES = void 0;
 exports.allowedBatchTransitions = allowedBatchTransitions;
 exports.createEmptyState = createEmptyState;
 exports.createBatch = createBatch;
@@ -27,11 +60,23 @@ exports.appendEvictions = appendEvictions;
 exports.distinctEvictions = distinctEvictions;
 exports.duplicateEvictionDetail = duplicateEvictionDetail;
 exports.requeueMember = requeueMember;
+exports.memberExitEvidence = memberExitEvidence;
+exports.recordedMemberBranch = recordedMemberBranch;
+exports.validatedMembersOf = validatedMembersOf;
+exports.memberDispatchProfile = memberDispatchProfile;
+exports.parkMember = parkMember;
 exports.findEntry = findEntry;
 exports.findBatch = findBatch;
 exports.batchUnit = batchUnit;
 exports.slotForBatch = slotForBatch;
+exports.batchMemberUnit = batchMemberUnit;
+exports.slotForBatchMember = slotForBatchMember;
+exports.slotsForBatch = slotsForBatch;
+exports.releaseBatchMemberSlot = releaseBatchMemberSlot;
+exports.releaseAllBatchSlots = releaseAllBatchSlots;
 exports.releaseBatchSlot = releaseBatchSlot;
+const path = __importStar(require("node:path"));
+const attribution_1 = require("./attribution");
 const dispatch_1 = require("./dispatch");
 const journal_1 = require("./journal");
 const types_1 = require("./types");
@@ -63,21 +108,29 @@ const ISSUE_BASE_TRANSITIONS = {
     // #468: dispatched → parked is the detached-ship exit — the agent parked
     // its PR on auto-merge and exited; parked → shipped accepts the MERGE
     // (never the park — RFC-0001 §E.4 "scheduler gates on merge").
-    // Both also carry `evicted`: a batch dissolve (#472) requeues every unshipped
-    // member whatever state it reached, and an unmodelled edge there would throw
-    // mid-eviction, after the reverts already landed.
+    // Both also carry `evicted`: a batch dissolve (#472) parks or requeues every
+    // unshipped member whatever state it reached, and an unmodelled edge there
+    // would throw mid-eviction, after the reverts already landed.
     dispatched: ['shipped', 'parked', 'evicted'],
     parked: ['shipped', 'evicted'],
     shipped: ['done'],
     // batched/waiting/validated also carry `evicted`: RFC-0001 §D.2 dissolving
-    // requeues members at ANY batch stage, not just mid-member (F.8).
-    batched: ['waiting', 'evicted'],
-    waiting: ['in-work', 'evicted'],
-    'in-work': ['committed', 'evicted'],
-    committed: ['validated', 'evicted'],
+    // removes members at ANY batch stage, not just mid-member (F.8).
+    // #810: `handed-back` is the member's own explicit hand-back (a `blocked` /
+    // `review partial` milestone it posted) — a pre-landing exit, so it exists
+    // on the rows a member can still be working in, never from `validated`.
+    batched: ['waiting', 'evicted', 'handed-back'],
+    waiting: ['in-work', 'evicted', 'handed-back'],
+    'in-work': ['committed', 'evicted', 'handed-back'],
+    committed: ['validated', 'evicted', 'handed-back'],
     validated: ['shipped-in-batch', 'evicted'],
     'shipped-in-batch': ['done'],
+    // #810: `evicted` and `handed-back` are PARKED — terminal for their batch,
+    // never auto-dispatched. The only way on is an operator's decision:
+    // `sched requeue` (→ `requeued`, full-cycle from the member branch with
+    // the batch's dispatch profile) or `sched abandon`/`stop` (universal edges).
     evicted: ['requeued'],
+    'handed-back': ['requeued'],
     // `batched` is the half-batch rail: a member requeued into a fresh batch by a
     // halved dissolve (#472 AC4) re-enters §D.1's slot line, not the full-cycle
     // one. Without it those members are stranded — `requeued` + `mode: 'slot'` is
@@ -273,12 +326,16 @@ function createBatch(id, members, now, opts = {}) {
         pr_watch_failed_ticks: 0,
         anchor_closed_at: null,
         ...exports.CLEARED_ANCHOR_CLOSE_FAILED_FIELDS,
+        member_dispatch: null,
+        member_runs: [],
         created_at: timestamp,
         updated_at: timestamp,
     };
 }
 const ISSUE_STATUSES = new Set(Object.keys(ISSUE_BASE_TRANSITIONS));
 const BATCH_STATUSES = new Set(Object.keys(BATCH_TRANSITIONS));
+/** #809: the closed vocabulary `validateState` accepts for `MemberRun.status`. */
+const MEMBER_RUN_STATUS_SET = new Set(types_1.MEMBER_RUN_STATUSES);
 const SLOT_STATUSES = new Set(Object.keys(SLOT_BASE_TRANSITIONS));
 const CYCLE_MODES = new Set(['full', 'slot']);
 const MODEL_TIERS = new Set(['mechanical', 'mid', 'strong']);
@@ -387,6 +444,12 @@ function validateQueueEntry(data, where) {
             ev.reverted_commits.some((c) => typeof c !== 'string')) {
             throw new Error(`${label}: failure_evidence.reverted_commits must be an array of strings`);
         }
+        // #810: `reason` and `branch` reach an agent's prompt and git argv on a
+        // requeue — a malformed value is refused at load, never interpolated.
+        if (typeof ev.reason !== 'string') {
+            throw new Error(`${label}: failure_evidence.reason must be a string`);
+        }
+        validateMemberBranch(ev.branch, `${label}: failure_evidence.branch`);
     }
     validateDedupMarker(entry, label, 'ground_truth_unreachable_since', 'ground_truth_unreachable_ticks');
     validateDedupMarker(entry, label, 'pr_watch_waiting_since', 'pr_watch_waiting_ticks');
@@ -394,6 +457,14 @@ function validateQueueEntry(data, where) {
         throw new Error(`${label}: enqueued_at/updated_at must be ISO date strings`);
     }
 }
+/** #810: a recorded member branch is absent, null, or a plain git ref. */
+function validateMemberBranch(branch, label) {
+    if (branch === undefined || branch === null)
+        return;
+    if (typeof branch !== 'string' || !attribution_1.SAFE_REF_RE.test(branch)) {
+        throw new Error(`${label} must be null or a plain git ref`);
+    }
+}
 /**
  * The #472 recovery fields of one batch. Absent fields are legacy (pre-1.3.0)
  * and backfilled by the migration below; present ones must be well-shaped —
@@ -462,6 +533,15 @@ function validateBatchRecovery(batch, id) {
                 issue <= 0) {
                 throw new Error(`Batch ${id}: each ${key} record must carry a positive issue number`);
             }
+            // #810: an unrecognized `kind` would silently change what the dissolve
+            // threshold counts — refuse it rather than guess.
+            if (key === 'evictions') {
+                const { kind, branch } = record;
+                if (kind !== undefined && !types_1.MEMBER_EXIT_KINDS.includes(kind)) {
+                    throw new Error(`Batch ${id}: evictions[].kind must be one of ${types_1.MEMBER_EXIT_KINDS.join('|')}`);
+                }
+                validateMemberBranch(branch, `Batch ${id}: evictions[].branch`);
+            }
         }
     }
     if (batch.pr !== null &&
@@ -606,6 +686,49 @@ function validateState(data) {
                 !dispatch_1.DISPATCH_PROFILE_RE.test(batch.dispatch_profile))) {
             throw new Error(`Batch ${batch.id}: dispatch_profile must match ${dispatch_1.DISPATCH_PROFILE_RE} or be null, got ${String(batch.dispatch_profile)}`);
         }
+        // #809: absent (pre-1.23.0) and null are both "not decided yet".
+        if (batch.member_dispatch !== undefined &&
+            batch.member_dispatch !== null &&
+            batch.member_dispatch !== 'serial' &&
+            batch.member_dispatch !== 'parallel') {
+            throw new Error(`Batch ${batch.id}: member_dispatch must be "serial", "parallel", or null, got ${String(batch.member_dispatch)}`);
+        }
+        if (batch.member_runs !== undefined) {
+            if (!Array.isArray(batch.member_runs)) {
+                throw new Error(`Batch ${batch.id}: member_runs must be an array`);
+            }
+            for (const run of batch.member_runs) {
+                const r = run;
+                // These values become git argv, spawn cwds and teardown targets —
+                // hold persisted state to the same shape the code that wrote it
+                // enforced (SAFE_REF_RE branch, absolute resolved path, a member of
+                // this batch), so a corrupt or hand-edited state.json cannot point a
+                // rebase/force-push/teardown somewhere else.
+                const worktree = r.worktree;
+                if (typeof run !== 'object' ||
+                    run === null ||
+                    !Number.isInteger(r.issue) ||
+                    r.issue <= 0 ||
+                    !batch.members.includes(r.issue) ||
+                    !Number.isInteger(r.index) ||
+                    r.index <= 0 ||
+                    typeof r.branch !== 'string' ||
+                    !attribution_1.SAFE_REF_RE.test(r.branch) ||
+                    typeof worktree !== 'string' ||
+                    !path.isAbsolute(worktree) ||
+                    path.resolve(worktree) !== worktree ||
+                    worktree.includes('\0') ||
+                    worktree.includes('\n') ||
+                    (r.pool_claimed !== undefined && typeof r.pool_claimed !== 'boolean') ||
+                    (r.torn_down !== undefined && typeof r.torn_down !== 'boolean') ||
+                    (r.gate_inconclusive !== undefined &&
+                        r.gate_inconclusive !== null &&
+                        typeof r.gate_inconclusive !== 'string') ||
+                    !MEMBER_RUN_STATUS_SET.has(String(r.status))) {
+                    throw new Error(`Batch ${batch.id}: malformed member_runs entry ${JSON.stringify(run)}`);
+                }
+            }
+        }
         if (!Number.isInteger(batch.executing_member) || batch.executing_member < 0) {
             throw new Error(`Batch ${batch.id}: executing_member must be a non-negative integer`);
         }
@@ -920,6 +1043,21 @@ function validateState(data) {
         anchor_close_failed_reason: batch.anchor_close_failed_reason ?? null,
         anchor_close_failed_since: batch.anchor_close_failed_since ?? null,
         anchor_close_failed_ticks: batch.anchor_close_failed_ticks ?? 0,
+        // 1.22.0 → 1.23.0 (#809): every batch written before parallel member
+        // dispatch ran serially. `null` (not `'serial'`) keeps a still-`ready`
+        // batch free to choose its mode at the claim; past `ready`, a null mode
+        // reads as serial (`isParallelBatch`), so an in-flight batch never flips.
+        member_dispatch: batch.member_dispatch ?? null,
+        member_runs: (batch.member_runs ?? []).map((run) => ({
+            ...run,
+            pool_claimed: run.pool_claimed ?? false,
+            gate_inconclusive: run.gate_inconclusive ?? null,
+            torn_down: run.torn_down ?? false,
+        })),
+        // 1.23.0 → 1.24.0 (#810): no backfill — `evictions[].kind`/`branch` and
+        // `failure_evidence.branch` are optional (absent = a pre-#810 `evicted`
+        // record with no recorded branch), and `handed-back` is a new status no
+        // older state can contain.
     }));
     return {
         ...data,
@@ -1201,15 +1339,19 @@ function partitionByIssue(seen, records) {
  * (RFC-0001 §D.1 "in-work/committed → evicted(reason) → requeued", §F.8
  * "nothing green is discarded").
  *
- * The single requeue path for `abandonBatch` (operator dissolve), eviction and
- * automatic dissolve (#472), so the "which edge applies from here?" question is
- * answered once:
+ * The single requeue path — `abandonBatch` (operator dissolve), an operator's
+ * `sched requeue` of a parked member (`requeueParkedMember`, #810), the
+ * aggregate-suite eviction (`evictMembers`), and a dissolve's unstarted
+ * members / half-batch split (#472) — so the "which edge applies from here?"
+ * question is answered once. (Per-member evictions and hand-backs on the
+ * executing rail PARK through `parkMember` instead, #810.)
  *
  * - already terminal or shipped → left alone, `requeued: false`
  * - never reached the batch rail (`queued`/`classified`), or already on the
  *   requeue rail (`requeued`) → metadata retag only; there is no status edge to
  *   take, and re-transitioning `requeued → requeued` would throw
- * - `evicted` → the one remaining edge, `evicted → requeued`
+ * - parked (`evicted` / `handed-back`) → the one remaining edge, `→ requeued`
+ *   — keeping the dispatch profile stamped at park time (#810)
  * - anything else active → the full failure rail, `→ evicted → requeued`
  *
  * `target` is where the member goes next: full-cycle (`{ mode: 'full', batch:
@@ -1238,9 +1380,22 @@ extra = {}) {
     const reviewPatch = target.mode === 'full' && entry.review === 'full'
         ? { tier: (0, dispatch_1.memberDispatchTier)(entry), review: 'light' }
         : {};
+    // #810 (the #713 class, on the requeue rail): a member leaving its batch for
+    // a full cycle keeps the batch's dispatch profile. A slot member's own
+    // `dispatch_profile` is normally null — the BATCH carries it — so without
+    // this every requeue silently re-ran the member on the config default
+    // (observed: an `openai` batch's members requeued `dispatch_profile: null`).
+    // A PARKED entry already carries the profile stamped at park time — which
+    // may be a deliberate `null` (a `dispatch-profile-missing` dissolve parks on
+    // the config default); re-deriving it from the batch would bring the broken
+    // profile back.
+    const profilePatch = target.mode === 'full' && !exports.PARKED_MEMBER_STATUSES.has(entry.status)
+        ? { dispatch_profile: memberDispatchProfile(state, entry) }
+        : {};
     const patch = {
         ...target,
         ...reviewPatch,
+        ...profilePatch,
         reason,
         ...exports.CLEARED_ENTRY_DEDUP_MARKERS,
         ...extra,
@@ -1249,12 +1404,118 @@ extra = {}) {
         return { state: patchEntry(state, issue, patch, now), requeued: true };
     }
     let next = state;
-    if (entry.status !== 'evicted') {
+    if (!exports.PARKED_MEMBER_STATUSES.has(entry.status)) {
         next = transitionIssue(next, issue, 'evicted', { reason }, now);
     }
     next = transitionIssue(next, issue, 'requeued', patch, now);
     return { state: next, requeued: true };
 }
+/**
+ * #810: the statuses a batch member is PARKED in — out of its batch, its work
+ * (if any) on its member branch, and never auto-dispatched until an operator
+ * decides (`sched requeue` / `sched abandon`).
+ */
+exports.PARKED_MEMBER_STATUSES = new Set(types_1.MEMBER_EXIT_KINDS);
+/**
+ * The `failure_evidence` a pre-landing member exit records (#810): no failing
+ * tests, no attribution, nothing reverted — just why, and where its work is.
+ */
+function memberExitEvidence(batchId, reason, branch, now) {
+    return {
+        batch: batchId,
+        reason,
+        failing_tests: [],
+        attribution: 'none',
+        reverted_commits: [],
+        branch,
+        at: now.toISOString(),
+    };
+}
+/**
+ * The member branch holding `issue`'s un-landed work in `batch` (#810): its
+ * parallel run's branch, else the serial current-member branch when `issue`
+ * is the member in work. `null` when the batch has none recorded. (Contrast
+ * `memberBranchFor` in batch-dispatch.ts, which BUILDS the name for a spawn.)
+ */
+function recordedMemberBranch(batch, issue) {
+    const run = batch.member_runs.find((r) => r.issue === issue);
+    if (run !== undefined)
+        return run.branch;
+    if (batch.members[batch.executing_member - 1] === issue)
+        return batch.member_branch;
+    return null;
+}
+/**
+ * #810: the members of `batch` whose work is validated and landed on its
+ * integration branch — the work a dissolve must never throw away. The one
+ * definition shared by the executing rail's dissolve suppression, the
+ * `full` dissolve's block, and `sched status`.
+ */
+function validatedMembersOf(state, batch) {
+    const exited = new Set(batch.evictions.map((e) => e.issue));
+    return batch.members.filter((issue) => {
+        if (exited.has(issue))
+            return false;
+        const entry = findEntry(state, issue);
+        return (entry !== undefined &&
+            entry.mode === 'slot' &&
+            entry.batch === batch.id &&
+            entry.status === 'validated');
+    });
+}
+/**
+ * The dispatch profile a member runs on (#810): its own when it has one, else
+ * its batch's. The one answer for "which provider does this member's work
+ * belong to?" — a requeue and a park both carry it onto the entry.
+ */
+function memberDispatchProfile(state, entry) {
+    if (entry.dispatch_profile !== null && entry.dispatch_profile !== undefined) {
+        return entry.dispatch_profile;
+    }
+    if (entry.batch === null)
+        return null;
+    return findBatch(state, entry.batch)?.dispatch_profile ?? null;
+}
+/**
+ * Park one batch member (#810): move it to `evicted` (an engine-decided
+ * failure) or `handed-back` (the member's own explicit hand-back), keeping
+ * `mode: 'slot'` + `batch` so the ledger still says which batch it left, and
+ * stamping the evidence (reason, member branch) and the batch's dispatch
+ * profile onto the entry. Nothing is requeued: an operator's `sched requeue`
+ * is the only way on, and it then continues from `failure_evidence.branch`
+ * on the recorded profile.
+ *
+ * Replaces the pre-#810 automatic `requeueMember(..., { mode: 'full' })` on
+ * the eviction rail, which restarted the member from the base branch on the
+ * config-default provider — discarding its commits and its profile.
+ *
+ * Already terminal / shipped / parked → left alone (`parked: false`).
+ */
+function parkMember(state, issue, kind, reason, now = new Date(), extra = {}) {
+    const entry = state.entries.find((e) => e.issue === issue);
+    if (!entry || isPreservedMember(entry) || exports.PARKED_MEMBER_STATUSES.has(entry.status)) {
+        return { state, parked: false };
+    }
+    const patch = {
+        reason,
+        dispatch_profile: memberDispatchProfile(state, entry),
+        ...exports.CLEARED_ENTRY_DEDUP_MARKERS,
+        ...extra,
+    };
+    // A `classified` member (evicted before its first spawn, e.g. a failed
+    // worktree prep) walks the `batched` waypoint first — the same waypoint
+    // `advanceMemberToInWork` walks. `queued`/`requeued` have no batch-rail
+    // edge at all and are left where they are, reported as not parked.
+    let next = state;
+    if (entry.status === 'classified') {
+        next = transitionIssue(next, issue, 'batched', {}, now);
+    }
+    const from = findEntry(next, issue)?.status;
+    if (from === undefined || !allowedIssueTransitions(from).includes(kind)) {
+        return { state, parked: false };
+    }
+    return { state: transitionIssue(next, issue, kind, patch, now), parked: true };
+}
 // --- Lookups ---
 function findEntry(state, issue) {
     return state.entries.find((e) => e.issue === issue);
@@ -1270,6 +1531,57 @@ function batchUnit(batchId) {
 function slotForBatch(state, batchId) {
     return state.slots.find((s) => s.unit === batchUnit(batchId));
 }
+/**
+ * The `unit` string a PARALLEL batch member's own slot carries (#809):
+ * `batch:<id>#<issue>`. Distinct from {@link batchUnit} so the batch-level
+ * lookups (`slotForBatch`) keep meaning "the batch's setup/tail/report/fix
+ * agent" and never pick up a member's slot. `#` can never occur in a batch id
+ * (enqueue's `BATCH_ID_RE`), so the two shapes cannot collide.
+ */
+function batchMemberUnit(batchId, issue) {
+    return `${batchUnit(batchId)}#${issue}`;
+}
+/** The slot currently holding a parallel member's unit, if any (#809). */
+function slotForBatchMember(state, batchId, issue) {
+    return state.slots.find((s) => s.unit === batchMemberUnit(batchId, issue));
+}
+/**
+ * Every non-idle slot a batch holds (#809) — its own `batch:<id>` slot plus
+ * any parallel member slots `batch:<id>#<issue>`. For the whole-batch exits
+ * (stop, abandon, a terminal batch's leak repair, reconcile-error
+ * containment), which must release all of them, not only the batch slot.
+ */
+function slotsForBatch(state, batchId) {
+    const own = batchUnit(batchId);
+    return state.slots.filter((s) => s.status !== 'idle' && s.unit !== null && (s.unit === own || s.unit.startsWith(`${own}#`)));
+}
+/** Walk one slot to idle (see {@link NEXT_TOWARD_IDLE}). */
+function walkSlotIdToIdle(state, slotId, now) {
+    let next = state;
+    let slot = next.slots.find((s) => s.id === slotId);
+    // Bounded: the longest real walk (recovering → failed → idle, or
+    // running → exited → verifying → complete → idle) is 4 hops.
+    for (let i = 0; i < 8 && slot && slot.status !== 'idle'; i++) {
+        const to = NEXT_TOWARD_IDLE[slot.status];
+        if (to === null)
+            break;
+        next = transitionSlot(next, slot.id, to, {}, now);
+        slot = next.slots.find((s) => s.id === slotId);
+    }
+    return next;
+}
+/** Release one parallel member's slot to idle (#809); a no-op when it holds none. */
+function releaseBatchMemberSlot(state, batchId, issue, now) {
+    const slot = slotForBatchMember(state, batchId, issue);
+    return slot ? walkSlotIdToIdle(state, slot.id, now) : state;
+}
+/** Release EVERY slot a batch holds — batch slot and member slots (#809). */
+function releaseAllBatchSlots(state, batchId, now) {
+    let next = state;
+    for (const slot of slotsForBatch(state, batchId))
+        next = walkSlotIdToIdle(next, slot.id, now);
+    return next;
+}
 /** Slot statuses, in the order a walk toward `idle` passes through them. */
 const NEXT_TOWARD_IDLE = {
     idle: null,
@@ -1293,20 +1605,14 @@ const NEXT_TOWARD_IDLE = {
  * leaked for the life of the state file, with no CLI lever to recover it. One
  * operator `abandon --batch` per leaked slot, against a `max_slots` typically
  * of 3, and the scheduler starves showing nothing but a dead pid.
+ *
+ * #809: releases the batch's OWN slot only — never a parallel member's
+ * (`batch:<id>#<issue>`); the whole-batch exits (`abandonBatch`, `stopBatch`)
+ * now call {@link releaseAllBatchSlots}.
  */
 function releaseBatchSlot(state, batchId, now) {
-    let next = state;
-    let slot = slotForBatch(next, batchId);
-    // Bounded: the longest real walk (recovering → failed → idle, or
-    // running → exited → verifying → complete → idle) is 4 hops.
-    for (let i = 0; i < 8 && slot && slot.status !== 'idle'; i++) {
-        const to = NEXT_TOWARD_IDLE[slot.status];
-        if (to === null)
-            break;
-        next = transitionSlot(next, slot.id, to, {}, now);
-        slot = slotForBatch(next, batchId);
-    }
-    return next;
+    const slot = slotForBatch(state, batchId);
+    return slot ? walkSlotIdToIdle(state, slot.id, now) : state;
 }
 /**
  * All transition tables, exposed as public API — future consumers (#464's