@ai-dossier/sched 0.59.0 → 0.60.0

package/dist/batch-dispatch.d.ts

@@ -380,6 +380,15 @@ interface AnchorTickContext {
  */
 /** @internal exported for tests. */
 export declare function memberDispatchModeFor(state: SchedState, batch: BatchEntry, config: SchedConfig): MemberDispatchMode;
+/**
+ * #815: how many consecutive ticks a parallel member's landing may fail on a
+ * PUSH (`member-push-failed` / `landing-push-failed`) before the batch blocks.
+ * A network blip should not cost an operator round-trip; the landing is
+ * idempotent (the rebase is a no-op once done, the lease pins the same tip,
+ * `merge --ff-only` succeeds when already merged), so the next tick simply
+ * runs it again.
+ */
+export declare const MAX_LAND_PUSH_RETRIES = 3;
 /**
  * One batch reconcile+refill pass. Called from `engine.ts`'s `tick()` after
  * the issue-level pass — this pass never claims a slot the issue pass already

package/dist/batch-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}

package/dist/batch-dispatch.js

@@ -96,7 +96,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_BATCH_AGENT_RESPAWNS = exports.tailMembersRefusal = void 0;
+exports.MAX_LAND_PUSH_RETRIES = exports.MAX_BATCH_AGENT_RESPAWNS = exports.tailMembersRefusal = void 0;
 exports.memberBranchFor = memberBranchFor;
 exports.evictMemberAndContinue = evictMemberAndContinue;
 exports.resumeBlockedGate = resumeBlockedGate;
@@ -176,9 +176,7 @@ function agentAlive(deps, slot) {
  * which escalates to SIGKILL (#844).
  */
 function killLiveAgent(deps, slot) {
-    if (agentAlive(deps, slot)) {
-        deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
-    }
+    (0, dispatch_1.killSlotAgent)(deps.spawnDeps, slot);
 }
 /**
  * Read a dead batch dispatch's own log and classify it (#629 AC3) — tail,
@@ -393,7 +391,7 @@ function applyDissolveOutcome(deps, batchId, outcome, now, membersBeforeRecovery
         stopAndReleaseBlocked(deps, batchId, now);
         return;
     }
-    teardownBatch(deps, batchId);
+    teardownBatch(deps, batchId, now);
 }
 /** Stop every live agent of a batch that just blocked, and release all its slots (#810). */
 function stopAndReleaseBlocked(deps, batchId, now) {
@@ -676,6 +674,30 @@ function usablePoolClaim(deps, w) {
         path.resolve(w) === w &&
         (deps.fsExists ?? ((p) => fs.existsSync(p)))(w));
 }
+/**
+ * The path of a worktree, other than the repo's own or the batch's, that has
+ * `branch` checked out — an earlier prep's pool claim orphaned by an engine
+ * exit before its run was recorded (#815). `null` when there is none. Member
+ * branch names are unique per batch/index/issue, so a match can only be this
+ * member's own leftover.
+ */
+function orphanedMemberClaim(deps, root, batch, branch) {
+    const listing = deps.exec('git', ['worktree', 'list', '--porcelain'], deps.repoDir);
+    if (listing === null)
+        return null;
+    let current = null;
+    for (const line of listing.split('\n')) {
+        if (line.startsWith('worktree '))
+            current = line.slice('worktree '.length).trim();
+        else if (line.trim() === `branch refs/heads/${branch}` && current !== null) {
+            const candidate = current;
+            if (candidate === root || candidate === batch.worktree)
+                return null;
+            return usablePoolClaim(deps, candidate) ? candidate : null;
+        }
+    }
+    return null;
+}
 function prepareMemberWorktree(deps, batch, memberIndex, issue, now) {
     if (batch.branch === null)
         return { ok: false, reason: 'no-integration-branch' };
@@ -720,7 +742,22 @@ function prepareMemberWorktree(deps, batch, memberIndex, issue, now) {
             poolClaimed: batch.member_pool_claimed,
         };
     }
-    const claimed = deps.exec(teardown_1.POOL_BIN, [...teardown_1.POOL_ARGS_PREFIX, 'claim', '--issue', String(issue), '--branch', branch], deps.repoDir);
+    // #815: a prior prep that died between its pool claim and the run record
+    // left the claim checked out on THIS member's branch at a pool path that is
+    // not re-derivable (the pool renames the claim to the branch slug). Claiming
+    // again would take a SECOND tree, and `checkout -B` would then fail because
+    // the branch is checked out in the orphan — an eviction over a blip. No run
+    // was recorded, so no agent ever started in it: take the orphan over and
+    // re-point it exactly like a fresh claim.
+    const orphan = orphanedMemberClaim(deps, root, batch, branch);
+    const claimed = orphan ??
+        deps.exec(teardown_1.POOL_BIN, [...teardown_1.POOL_ARGS_PREFIX, 'claim', '--issue', String(issue), '--branch', branch], deps.repoDir);
+    if (orphan !== null) {
+        deps.journal.append((0, journal_1.unitEvent)('member-claim-reused', unit(batch.id), {
+            issue,
+            detail: `${orphan} — a pool claim on ${branch} that no run recorded (engine exit mid-prep)`,
+        }), now);
+    }
     const claimedWorktree = claimed?.trim();
     if (claimedWorktree && usablePoolClaim(deps, claimedWorktree)) {
         // Re-point the warm spare at the member branch off the integration
@@ -796,26 +833,45 @@ function landMemberBranch(deps, batchId, now) {
         });
         return { ok: false, reason: 'invalid-branch-name' };
     }
-    if (deps.exec('git', ['merge', '--ff-only', batch.member_branch], batch.worktree) === null) {
-        journalEvent(deps, 'landing-failed', unit(batchId), {
-            issue: memberIssue,
-            reason: 'landing-merge-failed',
-            detail: `git merge --ff-only ${batch.member_branch} into ${batch.branch} failed — serial-landing invariant broken; blocking for an operator`,
+    return fastForwardOntoIntegration(deps, {
+        batchId,
+        issue: memberIssue,
+        memberBranch: batch.member_branch,
+        integrationBranch: batch.branch,
+        worktree: batch.worktree,
+        now,
+        mergeFailedDetail: 'serial-landing invariant broken; blocking for an operator',
+        landedDetail: `${batch.member_branch} fast-forwarded onto ${batch.branch}`,
+    });
+}
+/**
+ * The tail every landing shares (#815 — serial `landMemberBranch` and
+ * parallel `landParallelRun` once each carried a copy): `git merge --ff-only
+ * <member branch>` in the shared batch worktree (which holds the integration
+ * branch), push the integration branch, journal `member-landed`. Both steps
+ * are idempotent, so re-running it after a partial failure (merged locally,
+ * push failed) is safe. A failure journals `landing-failed` with its reason
+ * and returns it; the caller decides whether that blocks or retries.
+ */
+function fastForwardOntoIntegration(deps, land) {
+    const failed = (reason, detail) => {
+        journalEvent(deps, 'landing-failed', unit(land.batchId), {
+            issue: land.issue,
+            reason,
+            detail,
         });
-        return { ok: false, reason: 'landing-merge-failed' };
+        return { ok: false, reason };
+    };
+    if (deps.exec('git', ['merge', '--ff-only', land.memberBranch], land.worktree) === null) {
+        return failed('landing-merge-failed', `git merge --ff-only ${land.memberBranch} into ${land.integrationBranch} failed — ${land.mergeFailedDetail}`);
     }
-    if (deps.exec('git', ['push', 'origin', '--', batch.branch], batch.worktree) === null) {
-        journalEvent(deps, 'landing-failed', unit(batchId), {
-            issue: memberIssue,
-            reason: 'landing-push-failed',
-            detail: `landed ${batch.member_branch} on ${batch.branch} locally but the push failed — blocking so origin stays the durable copy`,
-        });
-        return { ok: false, reason: 'landing-push-failed' };
+    if (deps.exec('git', ['push', 'origin', '--', land.integrationBranch], land.worktree) === null) {
+        return failed('landing-push-failed', `landed ${land.memberBranch} on ${land.integrationBranch} locally but the push failed — blocking so origin stays the durable copy`);
     }
-    deps.journal.append((0, journal_1.unitEvent)('member-landed', unit(batchId), {
-        issue: memberIssue,
-        detail: `${batch.member_branch} fast-forwarded onto ${batch.branch}`,
-    }), now);
+    deps.journal.append((0, journal_1.unitEvent)('member-landed', unit(land.batchId), {
+        issue: land.issue,
+        detail: land.landedDetail,
+    }), land.now);
     return { ok: true };
 }
 /**
@@ -1225,26 +1281,10 @@ function claimAndSetup(deps, config, dispatch, batchId, now, result) {
         // Parallel members each claim their OWN slot (`batch:<id>#<issue>`), so
         // the setup slot is released here and the members' worktrees are prepared
         // by `spawnParallelMembers` (outside the lock, per member).
-        deps.store.withLock((s) => {
-            const b = (0, state_1.findBatch)(s, batchId);
-            if (!b || b.status !== 'ready') {
-                journalEvent(deps, 'unit-failed', unit(batchId), {
-                    reason: 'batch-left-ready-during-setup',
-                    detail: `worktree ${setup.worktree} created but batch is now '${b?.status ?? 'gone'}' — orphaned, manual cleanup required`,
-                });
-                return { state: releaseSlot(s, batchId, now), result: undefined };
-            }
-            let next = (0, state_1.patchBatch)(s, batchId, {
-                branch: setup.branch,
-                worktree: setup.worktree,
-                run_id: setup.runId,
-                pool_claimed: setup.poolClaimed,
-                member_dispatch: 'parallel',
-                member_runs: [],
-            }, now);
-            next = (0, state_1.transitionBatch)(next, batchId, 'executing', { executing_member: 0 }, now);
-            return { state: releaseSlot(next, batchId, now), result: undefined };
-        });
+        deps.store.withLock((s) => ({
+            state: landSetup(deps, s, batchId, setup, now, { member_dispatch: 'parallel', member_runs: [] }, 0, (next) => releaseSlot(next, batchId, now)),
+            result: undefined,
+        }));
         spawnParallelMembers(deps, config, dispatch, batchId, now, result);
         return;
     }
@@ -1287,34 +1327,44 @@ function claimAndSetup(deps, config, dispatch, batchId, now, result) {
         abortSetup(`member-worktree-prep-failed:${memberPrep.reason}`, `member worktree prep failed: ${memberPrep.reason} (member 1 #${firstIssue}, branch ${memberBranchFor(batchId, 1, firstIssue)})`);
         return;
     }
-    deps.store.withLock((s) => {
-        const b = (0, state_1.findBatch)(s, batchId);
-        if (!b || b.status !== 'ready') {
-            // The batch moved (dissolved/abandoned) between the claim and here — a
-            // real worktree now exists that nothing else knows about, and the slot
-            // this claim took is still `assigned` with no agent in it. Release the
-            // slot rather than leaking capacity; the worktree is orphaned (named in
-            // the journal for manual cleanup — it is not this rare-race path's job
-            // to guess whether reusing or removing it is safe).
-            journalEvent(deps, 'unit-failed', unit(batchId), {
-                reason: 'batch-left-ready-during-setup',
-                detail: `worktree ${setup.worktree} created but batch is now '${b?.status ?? 'gone'}' — orphaned, manual cleanup required`,
-            });
-            return { state: releaseSlot(s, batchId, now), result: undefined };
-        }
-        let next = (0, state_1.patchBatch)(s, batchId, {
-            branch: setup.branch,
-            worktree: setup.worktree,
-            run_id: setup.runId,
-            pool_claimed: setup.poolClaimed,
-            member_dispatch: 'serial',
-        }, now);
-        next = (0, state_1.transitionBatch)(next, batchId, 'executing', { executing_member: 1 }, now);
-        const slot = slotFor(next, batchId);
-        if (slot)
-            next = spawnMember(deps, dispatch, next, slot, batchId, now, result, memberPrep);
-        return { state: next, result: undefined };
-    });
+    deps.store.withLock((s) => ({
+        state: landSetup(deps, s, batchId, setup, now, { member_dispatch: 'serial' }, 1, (next) => {
+            const slot = slotFor(next, batchId);
+            return slot
+                ? spawnMember(deps, dispatch, next, slot, batchId, now, result, memberPrep)
+                : next;
+        }),
+        result: undefined,
+    }));
+}
+/**
+ * Land a completed `runBatchSetup` on the batch entry (inside the caller's
+ * lock): patch branch/worktree/run id, move `ready → executing`, then hand the
+ * result to `after` (serial: spawn member 1; parallel: release the setup slot).
+ * A batch that left `ready` between the claim and here (dissolved/abandoned)
+ * leaves a real worktree nothing else knows about and a slot still `assigned`
+ * with no agent in it — release the slot rather than leak capacity; the
+ * worktree is orphaned (named in the journal for manual cleanup — it is not
+ * this rare-race path's job to guess whether reusing or removing it is safe).
+ * Shared by both dispatch modes so the two landings cannot drift (#815).
+ */
+function landSetup(deps, s, batchId, setup, now, modePatch, executingMember, after) {
+    const b = (0, state_1.findBatch)(s, batchId);
+    if (!b || b.status !== 'ready') {
+        journalEvent(deps, 'unit-failed', unit(batchId), {
+            reason: 'batch-left-ready-during-setup',
+            detail: `worktree ${setup.worktree} created but batch is now '${b?.status ?? 'gone'}' — orphaned, manual cleanup required`,
+        });
+        return releaseSlot(s, batchId, now);
+    }
+    const next = (0, state_1.transitionBatch)((0, state_1.patchBatch)(s, batchId, {
+        branch: setup.branch,
+        worktree: setup.worktree,
+        run_id: setup.runId,
+        pool_claimed: setup.poolClaimed,
+        ...modePatch,
+    }, now), batchId, 'executing', { executing_member: executingMember }, now);
+    return after(next);
 }
 // --- Continuation: claim a fresh slot for the next live step ---
 /**
@@ -1643,18 +1693,8 @@ function runValidate(deps, config, dispatch, batchId, now, result) {
         }
         deps.journal.append((0, journal_1.unitEvent)('verify-complete', unit(batchId), { detail: suite.detail ?? 'suite green' }), now);
         const admitted = deps.store.withLock((s) => {
-            const b = (0, state_1.findBatch)(s, batchId);
-            if (!b || b.status !== 'validating')
-                return { state: s, result: false };
-            if (b.executing_member < b.members.length) {
-                return {
-                    state: (0, state_1.transitionBatch)(s, batchId, 'executing', 
-                    // #809: a parallel batch spawns every run-less member itself.
-                    isParallelBatch(b) ? {} : { executing_member: b.executing_member + 1 }, now),
-                    result: true,
-                };
-            }
-            return { state: (0, state_1.transitionBatch)(s, batchId, 'reviewing', {}, now), result: undefined };
+            const out = readmitAfterValidation(s, batchId, now);
+            return { state: out.state, result: out.admitted };
         });
         if (admitted) {
             const b = (0, state_1.findBatch)(deps.store.load(), batchId);
@@ -1766,19 +1806,32 @@ function evictOffender(deps, config, batchId, offender, attribution, now, result
         return;
     }
     if (outcome.suite?.ok) {
-        deps.store.withLock((s) => {
-            const b = (0, state_1.findBatch)(s, batchId);
-            if (!b || b.status !== 'validating')
-                return { state: s, result: undefined };
-            if (b.executing_member < b.members.length) {
-                return {
-                    state: (0, state_1.transitionBatch)(s, batchId, 'executing', isParallelBatch(b) ? {} : { executing_member: b.executing_member + 1 }, now),
-                    result: undefined,
-                };
-            }
-            return { state: (0, state_1.transitionBatch)(s, batchId, 'reviewing', {}, now), result: undefined };
-        });
+        deps.store.withLock((s) => ({
+            state: readmitAfterValidation(s, batchId, now).state,
+            result: undefined,
+        }));
+    }
+}
+/**
+ * The green-gate exit of `validating` (#815 — one step for `runValidate` and
+ * `evictOffender`): a member admitted while the suite ran sends the batch back
+ * to `executing` (the suite must run again before final review); otherwise it
+ * moves on to `reviewing`. A batch no longer `validating` is left untouched
+ * (`admitted: false`, so the caller falls through to the tail spawn).
+ */
+function readmitAfterValidation(s, batchId, now) {
+    const b = (0, state_1.findBatch)(s, batchId);
+    if (!b || b.status !== 'validating')
+        return { state: s, admitted: false };
+    if (b.executing_member < b.members.length) {
+        return {
+            state: (0, state_1.transitionBatch)(s, batchId, 'executing', 
+            // #809: a parallel batch spawns every run-less member itself.
+            isParallelBatch(b) ? {} : { executing_member: b.executing_member + 1 }, now),
+            admitted: true,
+        };
     }
+    return { state: (0, state_1.transitionBatch)(s, batchId, 'reviewing', {}, now), admitted: false };
 }
 /**
  * The one-shot claim on resolving `currentMember` (#613). Transitions the batch only while
@@ -3104,7 +3157,7 @@ function closeWithoutReport(deps, batchId, why, now, result) {
         detail: `${why} — batch closed without its report (the PR is merged); post the batch report by hand if one is wanted`,
     });
     result.failed.push(unit(batchId));
-    teardownBatch(deps, batchId);
+    teardownBatch(deps, batchId, now);
 }
 function reconcileTailSlot(deps, config, batchId, slot, now, result) {
     const state = deps.store.load();
@@ -3213,7 +3266,7 @@ _config, batchId, slot, now, result) {
             return { state: n, result: undefined };
         });
         result.completed.push(unit(batchId));
-        teardownBatch(deps, batchId);
+        teardownBatch(deps, batchId, now);
         return;
     }
     if (dead) {
@@ -3823,7 +3876,7 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
         });
         result.mergeAccepted.push(unit(batch.id));
         if (finishInline && !keepWorktree) {
-            teardownBatch(deps, batch.id);
+            teardownBatch(deps, batch.id, now);
         }
     }
 }
@@ -4132,11 +4185,11 @@ function recordAnchorCloseFailed(deps, batch, outcome, shipped, now) {
  * eviction-threshold dissolve): a dissolved batch's worktree is otherwise
  * left on disk forever, since nothing else ever calls this for it.
  */
-function teardownBatch(deps, batchId) {
+function teardownBatch(deps, batchId, now) {
     // #855: a kept batch's trees are the operator's — every teardown path reads
     // the same persisted decision. Only its live agents are stopped.
     if ((0, state_1.findBatch)(deps.store.load(), batchId)?.worktree_kept === true) {
-        teardownParallelRuns(deps, batchId, null);
+        teardownParallelRuns(deps, batchId, null, now);
         return;
     }
     // #677: the current member's worktree goes first — it is batch-owned
@@ -4149,8 +4202,8 @@ function teardownBatch(deps, batchId) {
     const terminal = (0, state_1.findBatch)(deps.store.load(), batchId);
     const lastMemberLanded = terminal?.ranges.some((r) => r.issue === terminal.members[terminal.executing_member - 1]) ===
         true;
-    const serial = teardownMemberWorktree(deps, batchId, deps.now(), lastMemberLanded);
-    teardownParallelRuns(deps, batchId, serial);
+    const serial = teardownMemberWorktree(deps, batchId, now, lastMemberLanded);
+    teardownParallelRuns(deps, batchId, serial, now);
     deleteMemberBranches(deps, batchId);
     const state = deps.store.load();
     const batch = (0, state_1.findBatch)(state, batchId);
@@ -4619,17 +4672,60 @@ function landParallelRun(deps, batch, run, now) {
     ], run.worktree) === null) {
         return fail('member-push-failed', `rebased ${run.branch} onto ${batch.branch} but could not push it (origin moved since ${remoteTip.slice(0, 12) || 'absent'}, or the push failed) — blocking so nothing pushed after verification is overwritten`);
     }
-    if (deps.exec('git', ['merge', '--ff-only', run.branch], batch.worktree) === null) {
-        return fail('landing-merge-failed', `git merge --ff-only ${run.branch} into ${batch.branch} failed right after a clean rebase — blocking for an operator`);
-    }
-    if (deps.exec('git', ['push', 'origin', '--', batch.branch], batch.worktree) === null) {
-        return fail('landing-push-failed', `landed ${run.branch} on ${batch.branch} locally but the push failed — blocking so origin stays the durable copy`);
-    }
-    deps.journal.append((0, journal_1.unitEvent)('member-landed', unit(batch.id), {
+    const ff = fastForwardOntoIntegration(deps, {
+        batchId: batch.id,
+        issue: run.issue,
+        memberBranch: run.branch,
+        integrationBranch: batch.branch,
+        worktree: batch.worktree,
+        now,
+        mergeFailedDetail: 'right after a clean rebase — blocking for an operator',
+        landedDetail: `${run.branch} rebased onto and fast-forwarded into ${batch.branch} (member ${run.index}, parallel)`,
+    });
+    return ff.ok ? { kind: 'landed' } : { kind: 'failed', reason: ff.reason };
+}
+/**
+ * #815: how many consecutive ticks a parallel member's landing may fail on a
+ * PUSH (`member-push-failed` / `landing-push-failed`) before the batch blocks.
+ * A network blip should not cost an operator round-trip; the landing is
+ * idempotent (the rebase is a no-op once done, the lease pins the same tip,
+ * `merge --ff-only` succeeds when already merged), so the next tick simply
+ * runs it again.
+ */
+exports.MAX_LAND_PUSH_RETRIES = 3;
+/** Reasons that mean "the push failed", as opposed to a broken invariant that retrying cannot fix. */
+const TRANSIENT_LAND_REASONS = new Set([
+    'member-push-failed',
+    'landing-push-failed',
+]);
+/**
+ * Consecutive push-failure ticks per parallel member, keyed by state dir +
+ * batch + issue. In-memory on purpose: a restart merely grants a fresh budget
+ * (still bounded), and it keeps the persisted schema untouched.
+ */
+const landPushRetries = new Map();
+function landRetryKey(deps, batchId, issue) {
+    return `${deps.store.dir}\0${batchId}\0${issue}`;
+}
+/**
+ * Whether a failed parallel landing should be retried next tick instead of
+ * blocking the batch: only push failures, at most `MAX_LAND_PUSH_RETRIES`
+ * times in a row. Journals `landing-retry` with the position in the budget.
+ */
+function deferTransientPushFailure(deps, batchId, run, reason, now) {
+    if (!TRANSIENT_LAND_REASONS.has(reason))
+        return false;
+    const key = landRetryKey(deps, batchId, run.issue);
+    const attempt = (landPushRetries.get(key) ?? 0) + 1;
+    if (attempt > exports.MAX_LAND_PUSH_RETRIES)
+        return false;
+    landPushRetries.set(key, attempt);
+    deps.journal.append((0, journal_1.unitEvent)('landing-retry', unit(batchId), {
         issue: run.issue,
-        detail: `${run.branch} rebased onto and fast-forwarded into ${batch.branch} (member ${run.index}, parallel)`,
+        reason,
+        detail: `${reason} for member ${run.index} (#${run.issue}) — retrying next tick (${attempt}/${exports.MAX_LAND_PUSH_RETRIES}) before blocking`,
     }), now);
-    return { kind: 'landed' };
+    return true;
 }
 /**
  * Walk members IN ORDER: skip every resolved one (landed, evicted, or no longer
@@ -4678,10 +4774,14 @@ function advanceParallelBatch(deps, config, dispatch, batchId, now, result) {
             continue;
         }
         if (landed.kind === 'failed') {
+            if (deferTransientPushFailure(deps, batchId, run, landed.reason, now))
+                return;
+            landPushRetries.delete(landRetryKey(deps, batchId, run.issue));
             stopRunningMembers(deps, batchId, now);
             blockBatchForOperator(deps, config, batchId, { reason: landed.reason }, now, result);
             return;
         }
+        landPushRetries.delete(landRetryKey(deps, batchId, run.issue));
         // `git log` outside the lock (same invariant as `completeMemberGate`).
         const ranges = (0, attribution_1.memberRanges)(boundaryCommits(deps, batch));
         deps.store.withLock((s) => {
@@ -4807,11 +4907,10 @@ function reconcileParallelBatch(deps, config, dispatch, batchId, now, result, pa
  * `kept-worktree` warning names them. A run whose earlier teardown failed
  * (`teardown_failed_at`) is not re-attempted either.
  */
-function teardownParallelRuns(deps, batchId, serial) {
+function teardownParallelRuns(deps, batchId, serial, now) {
     const batch = (0, state_1.findBatch)(deps.store.load(), batchId);
     if (!batch)
         return;
-    const now = deps.now();
     for (const run of batch.member_runs) {
         if (run.torn_down)
             continue;
@@ -5047,7 +5146,7 @@ function runBatchTick(deps, config, dispatch) {
             // and it stops any agent that is somehow still running in a kept tree.
             if (batch.member_runs.some((r) => !r.torn_down)) {
                 try {
-                    teardownParallelRuns(deps, batch.id, null);
+                    teardownParallelRuns(deps, batch.id, null, now);
                 }
                 catch (err) {
                     journalEvent(deps, 'teardown-failed', unit(batch.id), {