@ai-dossier/sched 0.50.0 → 0.52.0

package/dist/batch-dispatch.js

@@ -96,6 +96,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BATCH_AGENT_RESPAWNS = exports.tailMembersRefusal = void 0;
 exports.memberBranchFor = memberBranchFor;
 exports.evictMemberAndContinue = evictMemberAndContinue;
 exports.resumeBlockedGate = resumeBlockedGate;
@@ -117,6 +118,7 @@ const recovery_1 = require("./recovery");
 const run_log_1 = require("./run-log");
 const scheduler_1 = require("./scheduler");
 const state_1 = require("./state");
+Object.defineProperty(exports, "tailMembersRefusal", { enumerable: true, get: function () { return state_1.tailMembersRefusal; } });
 const teardown_1 = require("./teardown");
 const types_1 = require("./types");
 function emptyResult() {
@@ -160,6 +162,12 @@ function sanitizeUntrustedText(value) {
 function journalEvent(deps, event, unitId, extra = {}) {
     deps.journal.append((0, journal_1.unitEvent)(event, unitId, extra), deps.now());
 }
+/** Stop the slot's agent if it is still alive (pid-start-safe: a reused pid is never signalled). */
+function killLiveAgent(deps, slot) {
+    if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
+        deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
+    }
+}
 /**
  * Read a dead batch dispatch's own log and classify it (#629 AC3) — tail,
  * member, fix and report all reach a `dead` agent the same way (`pid` no
@@ -1014,7 +1022,11 @@ function spawnMemberAgent(deps, dispatch, state, slot, batchId, now, result, tar
     // #677: the prompt carries THIS member's own worktree and the integration
     // branch it was cut from — `member-cycle`'s `worktree`/`integration_branch`
     // inputs. The shared batch worktree is no longer a member surface at all.
-    const prompt = (0, dispatch_1.buildMemberPrompt)(dispatch.memberPrompt, memberIssue, batchId, target.member.worktree, batch.branch, review);
+    const prompt = (0, dispatch_1.buildMemberPrompt)(dispatch.memberPrompt, memberIssue, batchId, target.member.worktree, batch.branch, review) +
+        // #822: a member respawned after running the wrong procedure.
+        (batch.reprompted_members.some((r) => r.issue === memberIssue)
+            ? (0, dispatch_1.wrongProcedureDirective)(memberIssue, batchId)
+            : '');
     const logFile = (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, target.index, memberIssue);
     // #629: captured BEFORE spawning, mirroring `engine.ts`'s own
     // `spawnAndRecord` — the log is per-role and append-mode, so the size at
@@ -1309,6 +1321,20 @@ function spawnMemberContinuation(deps, config, dispatch, batchId, now, result) {
     }
     claimAndSpawn(deps, config, batchId, 'member', now, (nextState, slot) => spawnMember(deps, dispatch, nextState, slot, batchId, now, result, member));
 }
+/**
+ * #832: the one pre-dispatch verdict for a tail — checked before a slot is
+ * claimed and again under the claim's lock. A tail whose respawns are spent
+ * (a crash landed between counting the exit that spent them and blocking the
+ * batch) is refused, as is a members mismatch. Only a batch in a tail phase
+ * is judged; anything else is not the tail's to refuse.
+ */
+function tailDispatchRefusal(state, batch) {
+    if (batch.status !== 'reviewing' && batch.status !== 'shipping')
+        return null;
+    if (agentRespawnsSpent(batch, 'tail'))
+        return 'respawn-cap:tail';
+    return (0, state_1.tailMembersRefusal)(batch, (0, state_1.validatedMembersOf)(state, batch));
+}
 /**
  * Tail/report/fix dispatches (this function, `spawnReportAgent`,
  * `reconcileFixSlot`) are NOT recorded live to `runs.jsonl` — only member
@@ -1317,11 +1343,27 @@ function spawnMemberContinuation(deps, config, dispatch, batchId, now, result) {
  * the only way to see their cost today, reconstructed from the raw log
  * after the fact. Wiring in live recording for these later means repeating
  * `spawnMember`'s own #564 fix first: none of these three spawn functions'
- * patches stamp `SlotEntry.spawned_at` either, so a `recordXRunLog` guarded
+ * patches stamped `SlotEntry.spawned_at` either, so a `recordXRunLog` guarded
  * on `spawned_at !== null` (mirroring `recordMemberRunLog`) would silently
- * no-op forever, exactly like the original bug.
+ * no-op forever, exactly like the original bug. #832 made the tail and report
+ * spawns stamp it (their hand-back fence needs it); the fix agent still does
+ * not.
  */
 function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
+    // #832: the tail runs over the LANDED members only — never `batch.members`,
+    // which still lists a member that was stopped, handed back, evicted or
+    // parked. A refusal blocks the batch before any agent is spawned (and
+    // before a slot is claimed — `blockBatchForOperator` posts a milestone, an
+    // exec that must not run under the store lock).
+    const before = deps.store.load();
+    const pending = (0, state_1.findBatch)(before, batchId);
+    if (pending) {
+        const refusal = tailDispatchRefusal(before, pending);
+        if (refusal !== null) {
+            blockBatchForOperator(deps, config, batchId, { reason: refusal, milestonePhase: 'batch-review' }, now, result);
+            return;
+        }
+    }
     claimAndSpawn(deps, config, batchId, 'reviewing', now, (state, slot) => {
         const batch = (0, state_1.findBatch)(state, batchId);
         if (!batch || batch.worktree === null || batch.anchor === null) {
@@ -1331,9 +1373,20 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
             });
             return releaseSlot(state, batchId, now);
         }
+        const landed = (0, state_1.validatedMembersOf)(state, batch);
+        const lateRefusal = tailDispatchRefusal(state, batch);
+        if (lateRefusal !== null) {
+            // The state changed between the pre-check and the lock (a concurrent
+            // stop/park) — release, and the next tick's pre-check (reading the same
+            // persisted state) blocks the batch with this reason.
+            journalEvent(deps, 'slot-released', unit(batchId), {
+                detail: `tail not dispatched: ${lateRefusal} (state changed before the claim; the next tick blocks the batch)`,
+            });
+            return releaseSlot(state, batchId, now);
+        }
         const spawnSpec = (0, dispatch_1.resolveTierSpawn)(dispatch, 'strong', batch.anchor);
         const cmd = spawnSpec.cmd;
-        const prompt = (0, dispatch_1.buildBatchTailPrompt)(dispatch.batchTailPrompt, batchId, batch.anchor, batch.members, batch.worktree);
+        const prompt = (0, dispatch_1.buildBatchTailPrompt)(dispatch.batchTailPrompt, batchId, batch.anchor, landed, batch.worktree);
         const logFile = (0, dispatch_1.batchTailLogPath)(deps.store.runsDir, batchId);
         // #629: fences `handleDeadDispatchApiError`'s classification to this
         // dispatch's slice — see `spawnMember`'s identical comment.
@@ -1356,6 +1409,14 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
             phase: 'reviewing',
             last_progress_at: now.toISOString(),
             log_offset_at_spawn: logOffset,
+            // #832: the fence `reconcileTailSlot` reads — without it a
+            // `batch-review blocked` left on the anchor by an EARLIER dispatch
+            // (or a previous batch on the same anchor, #605) would block this one.
+            // The fence tolerates `DISPATCH_FENCE_TOLERANCE_MS` (60s) of clock skew,
+            // so a blocked milestone posted less than a minute before this spawn
+            // still counts — only a resume that re-dispatches the tail that fast
+            // could trip it.
+            spawned_at: now.toISOString(),
         };
         const next = slot.status === 'assigned' ? (0, state_1.transitionSlot)(state, slot.id, 'running', patch, now) : state;
         deps.journal.append((0, journal_1.unitEvent)('spawned', unit(batchId), {
@@ -1370,6 +1431,13 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
     });
 }
 function spawnReportAgent(deps, config, dispatch, batchId, now, result) {
+    // #832: respawns already spent (a crash landed between counting the exit
+    // that spent them and closing the batch) — close it now, never spawn.
+    const pending = (0, state_1.findBatch)(deps.store.load(), batchId);
+    if (pending && pending.status === 'deployed' && agentRespawnsSpent(pending, 'report')) {
+        closeWithoutReport(deps, batchId, 'respawn-cap:report', now, result);
+        return;
+    }
     claimAndSpawn(deps, config, batchId, 'report', now, (state, slot) => {
         const batch = (0, state_1.findBatch)(state, batchId);
         if (!batch || batch.anchor === null) {
@@ -1406,6 +1474,8 @@ function spawnReportAgent(deps, config, dispatch, batchId, now, result) {
             phase: 'report',
             last_progress_at: now.toISOString(),
             log_offset_at_spawn: logOffset,
+            // #832: the fence `reconcileReportSlot`'s hand-back check reads.
+            spawned_at: now.toISOString(),
         };
         const next = slot.status === 'assigned'
             ? (0, state_1.transitionSlot)(state, slot.id, 'running', patchState, now)
@@ -2001,7 +2071,7 @@ function resumeBlockedGate(deps, config, dispatch, batchId, now) {
         // `suite-unreadable`) — name the actual reason and the operator path
         // instead of a bare illegal-transition error that reads like a bug.
         if (batch.status === 'blocked') {
-            throw new types_1.SchedNotFoundError(`Batch ${batchId} is blocked on '${batch.blocked_reason ?? '?'}', which has no gate recheck: inspect the batch worktree/state named in its journal, then \`sched abandon --batch ${batchId}\` if it is a dead end`);
+            throw new types_1.SchedNotFoundError(`Batch ${batchId} is blocked on '${batch.blocked_reason ?? '?'}', which has no gate recheck (a batch blocked over landed work — dissolve-refused / tail-blocked / members-mismatch / respawn-cap:tail — resumes via \`sched resume --batch\`, #822): inspect the batch worktree/state named in its journal, then \`sched abandon --batch ${batchId}\` if it is a dead end`);
         }
         throw new types_1.IllegalTransitionError('batch', batch.status, 'executing');
     }
@@ -2277,8 +2347,113 @@ function readMemberDispatch(deps, batchId, memberIssue, slot, now) {
         milestone,
         dead,
         blockedNow: (0, groundtruth_1.isMemberBlocked)(milestone, slot.spawned_at),
+        wrongProcedure: (0, groundtruth_1.isWrongProcedureMilestone)(milestone, slot.spawned_at),
+    };
+}
+/**
+ * #822: whether a wrong-procedure read counts against THIS dispatch of
+ * `memberIssue`. After a re-prompt, only a milestone posted strictly after
+ * the re-prompt does: the killed first dispatch's milestones still sit
+ * inside the respawn's 60s fence tolerance and would otherwise evict the
+ * member the moment it respawns. No tolerance here — the engine and the
+ * member's CLI stamp times on the same host.
+ */
+function wrongProcedureCounts(batch, memberIssue, read) {
+    if (!read.wrongProcedure || read.milestone === null)
+        return false;
+    const prior = batch.reprompted_members.find((r) => r.issue === memberIssue);
+    if (prior === undefined)
+        return true;
+    const at = Date.parse(read.milestone.at);
+    const repromptedAt = Date.parse(prior.reprompted_at);
+    return Number.isNaN(at) || Number.isNaN(repromptedAt) ? false : at > repromptedAt;
+}
+/**
+ * #822 (#810 proposal 3): the member's dispatch ran the wrong procedure (a
+ * full-cycle-shaped trail — imboard #4174 ran full-cycle as a batch member).
+ * That is a dispatch mistake, not the member's work failing, so the first
+ * time it is RE-PROMPTED: a live agent is stopped (a full-cycle run left going
+ * would open its own PR), the slot is released, and the member is recorded in
+ * `reprompted_members` — the wedge arm (serial) or `spawnParallelMembers`
+ * (parallel) respawns it in place, in the same worktree, with
+ * `wrongProcedureDirective` appended. Returns `'evict'` when the member was
+ * already re-prompted once: the caller evicts it `wrong-procedure`.
+ */
+function repromptWrongProcedure(deps, batchId, memberIssue, milestoneAt, slot, release, now) {
+    // Never respawn into (or release) a worktree the old agent is still in: a
+    // dying full-cycle run could still push, post, or open a PR. Signal it and
+    // decide on a later tick, once it is gone — and so the re-prompt's
+    // `reprompted_at` fence postdates everything it could still post.
+    if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
+        deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
+        return 'waiting';
+    }
+    const outcome = deps.store.withLock((s) => {
+        const released = release(s);
+        const b = (0, state_1.findBatch)(released, batchId);
+        if (!b || b.reprompted_members.some((r) => r.issue === memberIssue)) {
+            return { state: released, result: 'evict' };
+        }
+        return {
+            state: (0, state_1.patchBatch)(released, batchId, {
+                reprompted_members: [
+                    ...b.reprompted_members,
+                    { issue: memberIssue, milestone_at: milestoneAt, reprompted_at: now.toISOString() },
+                ],
+            }, now),
+            result: 'reprompted',
+        };
+    });
+    if (outcome === 'reprompted') {
+        journalEvent(deps, 'member-reprompted', unit(batchId), {
+            issue: memberIssue,
+            reason: 'wrong-procedure',
+            milestone_at: milestoneAt,
+            detail: `${WRONG_PROCEDURE_SHAPE} — respawning it once in place with a member-cycle directive`,
+        });
+    }
+    return outcome;
+}
+/** #822: the evidence line every wrong-procedure journal/eviction names. */
+const WRONG_PROCEDURE_SHAPE = 'member posted a full-cycle-shaped milestone (no batch=/mode=slot key)';
+/** #822: the eviction a member earns for running the wrong procedure after its one re-prompt. */
+function wrongProcedureFailure(lastTool, shippedPr = null) {
+    return {
+        reason: shippedPr === null ? 'wrong-procedure' : 'wrong-procedure-shipped',
+        detail: shippedPr === null
+            ? `${WRONG_PROCEDURE_SHAPE} again after its one re-prompt`
+            : `${WRONG_PROCEDURE_SHAPE} and its full-cycle run already reached ship (PR ${shippedPr === 'unknown' ? 'not named' : `#${shippedPr}`}) — evicted without a re-prompt; close or reconcile that PR by hand`,
+        kind: 'evicted',
+        extraKv: {
+            ...(lastTool ? { last_tool: lastTool } : {}),
+            ...(typeof shippedPr === 'number' ? { stray_pr: String(shippedPr) } : {}),
+        },
     };
 }
+/**
+ * #822: the one wrong-procedure decision shared by both member rails —
+ * `'waiting'` (the old agent is still dying), `'reprompted'`, or the
+ * eviction failure to apply. A run that already shipped is evicted without
+ * a re-prompt.
+ */
+function decideWrongProcedure(deps, batchId, memberIssue, milestone, slot, release, lastTool, now) {
+    const shipped = (0, groundtruth_1.wrongProcedureShippedPr)(milestone);
+    if (shipped !== null) {
+        if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
+            deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
+            return 'waiting';
+        }
+        const tool = lastTool();
+        deps.store.withLock((s) => ({ state: release(s), result: undefined }));
+        return wrongProcedureFailure(tool, shipped);
+    }
+    const verdict = repromptWrongProcedure(deps, batchId, memberIssue, milestone.at, slot, release, now);
+    if (verdict === 'waiting')
+        return verdict;
+    // The finished dispatch's run-log entry, exactly once (never while waiting).
+    const tool = lastTool();
+    return verdict === 'reprompted' ? verdict : wrongProcedureFailure(tool);
+}
 /**
  * The eviction a blocked-or-dead member dispatch earns (shared by both rails).
  * #605: only a milestone THIS dispatch posted may name the reason. A dead
@@ -2348,6 +2523,16 @@ function reconcileMemberSlot(deps, config, dispatch, batchId, slot, now, result)
         completeMemberGate(deps, config, dispatch, batchId, batch, memberIssue, now, result);
         return;
     }
+    // #822: a wrong-procedure trail is re-prompted once, then evicted — decided
+    // before the dead/blocked rail, which would otherwise evict it as an
+    // unverified exit at the first sight.
+    if (wrongProcedureCounts(batch, memberIssue, read) && read.milestone !== null) {
+        const decision = decideWrongProcedure(deps, batchId, memberIssue, read.milestone, slot, (s) => releaseSlot(s, batchId, now), () => recordMemberRunLog(deps, dispatch, state0, batchId, batch.executing_member, memberIssue, slot, now), now);
+        if (typeof decision === 'object') {
+            evictMemberAndContinue(deps, config, dispatch, batchId, batch, memberIssue, decision, now, result);
+        }
+        return;
+    }
     if (read.dead &&
         !read.blockedNow &&
         handleDeadDispatchApiError(deps, batchId, (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, batch.executing_member, memberIssue), slot.log_offset_at_spawn ?? 0, now)) {
@@ -2565,7 +2750,98 @@ function reconcileFixSlot(deps, config, batchId, slot, now, result) {
     }
     evictOffender(deps, config, batchId, offenderRecord.issue, 'overlap', now, result);
 }
-function reconcileTailSlot(deps, batchId, slot, now, result) {
+/**
+ * #832: how many times one tail-work phase's agent (`tail` or `report`) is
+ * RESPAWNED after exiting unverified — the first dispatch plus this many
+ * respawns; the next unverified exit ends the phase instead. The #629 class:
+ * the tick loop's "same wedge" arm respawns a dead tail/report agent on its
+ * own, so without a cap an agent that exits without a verdict is
+ * redispatched forever (b-20260924-04: the strong-tier tail four times,
+ * ~375k tokens, stopped only by hand).
+ */
+exports.MAX_BATCH_AGENT_RESPAWNS = 2;
+/** #832: whether `batch` has already spent its respawns for `phase`. */
+function agentRespawnsSpent(batch, phase) {
+    return (batch.agent_exits !== null &&
+        batch.agent_exits.phase === phase &&
+        batch.agent_exits.count > exports.MAX_BATCH_AGENT_RESPAWNS);
+}
+/**
+ * #832: count one unverified exit of `phase`'s agent, release its slot, and
+ * journal the exit with its position against the cap — one lock, so the count
+ * and the release cannot come apart. Returns `'capped'` when this exit spent
+ * the phase's last respawn (the caller ends the phase), else `'respawn'`.
+ * The count is per phase — another phase's exits start it over — and verified
+ * progress clears it (`clearAgentExits`).
+ */
+function releaseAndCountAgentExit(deps, batchId, phase, failed, now) {
+    const count = deps.store.withLock((s) => {
+        const b = (0, state_1.findBatch)(s, batchId);
+        const prior = b?.agent_exits;
+        const next = prior && prior.phase === phase ? prior.count + 1 : 1;
+        let n = releaseSlot(s, batchId, now);
+        if (b)
+            n = (0, state_1.patchBatch)(n, batchId, { agent_exits: { phase, count: next } }, now);
+        return { state: n, result: next };
+    });
+    journalEvent(deps, failed.event, unit(batchId), {
+        ...failed.extra,
+        detail: `${String(failed.extra.detail ?? 'unverified exit')} ${count}/${exports.MAX_BATCH_AGENT_RESPAWNS + 1} (log: ${failed.log})`,
+    });
+    return count > exports.MAX_BATCH_AGENT_RESPAWNS ? 'capped' : 'respawn';
+}
+/** #832: verified progress in a tail-work phase — the respawn count starts over. */
+function clearAgentExits(s, batchId, now) {
+    const b = (0, state_1.findBatch)(s, batchId);
+    return b && b.agent_exits !== null ? (0, state_1.patchBatch)(s, batchId, { agent_exits: null }, now) : s;
+}
+/**
+ * #832: the tail posted its own `batch-review`/`batch-ship blocked` — release
+ * its slot and block the batch with that reason in ONE lock (no milestone to
+ * post: the agent's is already the anchor's record, so no exec runs under the
+ * lock), so a crash can never leave the slot released with the batch still
+ * `reviewing` for the wedge arm to respawn. The agent decided; respawning it
+ * would only get the same answer again.
+ */
+function blockOnTailHandBack(deps, config, batch, reason, now, result) {
+    const rDeps = recoveryDeps(deps, config, batch, now);
+    deps.store.withLock((s) => {
+        const released = releaseSlot(s, batch.id, now);
+        const b = (0, state_1.findBatch)(released, batch.id);
+        if (!b || types_1.TERMINAL_BATCH_STATUSES.has(b.status) || b.status === 'blocked') {
+            return { state: released, result: undefined };
+        }
+        const blocked = (0, recovery_1.blockBatch)(released, batch.id, { reason, milestonePhase: 'batch-review', milestoneAlreadyPosted: true }, rDeps);
+        return { state: blocked.state, result: undefined };
+    });
+    result.failed.push(unit(batch.id));
+}
+/**
+ * #832: close a MERGED batch whose report agent spent its respawns, without
+ * its report. The report is the batch's summary, not its work — the PR is
+ * merged and deployed — so the batch goes `deployed → reported → done` and
+ * is torn down like any finished batch. Blocking it instead would not stop
+ * anything: `reconcileStaleBlockedBatches` walks a blocked batch with a
+ * merged PR straight back to `deployed`, and the report agent would respawn.
+ */
+function closeWithoutReport(deps, batchId, why, now, result) {
+    const closed = deps.store.withLock((s) => {
+        const b = (0, state_1.findBatch)(s, batchId);
+        if (!b || b.status !== 'deployed')
+            return { state: s, result: false };
+        let n = (0, state_1.transitionBatch)(s, batchId, 'reported', { agent_exits: null }, now);
+        n = (0, state_1.transitionBatch)(n, batchId, 'done', {}, now);
+        return { state: n, result: true };
+    });
+    if (!closed)
+        return;
+    journalEvent(deps, 'report-failed', unit(batchId), {
+        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);
+}
+function reconcileTailSlot(deps, config, batchId, slot, now, result) {
     const state = deps.store.load();
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch || batch.anchor === null)
@@ -2580,10 +2856,28 @@ function reconcileTailSlot(deps, batchId, slot, now, result) {
             const b = (0, state_1.findBatch)(s, batchId);
             if (!b || b.status !== 'reviewing')
                 return { state: s, result: undefined };
-            return { state: (0, state_1.transitionBatch)(s, batchId, 'shipping', {}, now), result: undefined };
+            const n = clearAgentExits(s, batchId, now);
+            return { state: (0, state_1.transitionBatch)(n, batchId, 'shipping', {}, now), result: undefined };
         });
         return;
     }
+    // #832: the tail handed back (`batch-review`/`batch-ship blocked`, e.g.
+    // `members-mismatch`) — block the batch with its reason, never respawn.
+    // Checked before liveness: the agent is done deciding whether or not its
+    // process has exited yet, and the block releases its slot. Only for a slot
+    // that recorded its dispatch time: a tail spawned before #832 stamped
+    // `spawned_at` has no fence, and an unfenced read would let an older
+    // `blocked` milestone on the anchor block this dispatch — that exit falls
+    // through to the (capped) unverified path instead.
+    const handedBack = slot.spawned_at === null
+        ? null
+        : (0, groundtruth_1.batchPhaseBlockedReason)(milestone, ['batch-review', 'batch-ship'], slot.spawned_at);
+    if (handedBack !== null) {
+        if (!dead)
+            killLiveAgent(deps, slot);
+        blockOnTailHandBack(deps, config, batch, `tail-blocked:${handedBack}`, now, result);
+        return;
+    }
     if ((0, groundtruth_1.isBatchTailParked)(milestone)) {
         const pr = (0, groundtruth_1.prOfMilestone)(milestone);
         journalEvent(deps, 'pr-parked', unit(batchId), { pr: pr ?? undefined });
@@ -2595,6 +2889,7 @@ function reconcileTailSlot(deps, batchId, slot, now, result) {
             const b = (0, state_1.findBatch)(n, batchId);
             if (!b)
                 return { state: n, result: undefined };
+            n = clearAgentExits(n, batchId, now);
             n = b.status === 'reviewing' ? (0, state_1.transitionBatch)(n, batchId, 'shipping', {}, now) : n;
             n = (0, state_1.transitionBatch)(n, batchId, 'awaiting-merge', { pr }, now);
             return { state: n, result: undefined };
@@ -2610,12 +2905,20 @@ function reconcileTailSlot(deps, batchId, slot, now, result) {
         if (handleDeadDispatchApiError(deps, batchId, (0, dispatch_1.batchTailLogPath)(deps.store.runsDir, batchId), slot.log_offset_at_spawn ?? 0, now)) {
             return;
         }
-        deps.journal.append((0, journal_1.unitEvent)('unit-failed', unit(batchId), { reason: 'tail-agent-exited-unverified' }), now);
-        deps.store.withLock((s) => ({ state: releaseSlot(s, batchId, now), result: undefined }));
+        // #832: counted — once the respawns are spent the batch blocks instead.
+        const outcome = releaseAndCountAgentExit(deps, batchId, 'tail', {
+            event: 'unit-failed',
+            extra: { reason: 'tail-agent-exited-unverified' },
+            log: (0, dispatch_1.batchTailLogPath)(deps.store.runsDir, batchId),
+        }, now);
+        if (outcome === 'capped') {
+            blockBatchForOperator(deps, config, batchId, { reason: 'respawn-cap:tail', milestonePhase: 'batch-review' }, now, result);
+            return;
+        }
         result.failed.push(unit(batchId));
     }
 }
-function reconcileReportSlot(deps, batchId, slot, now, result) {
+function reconcileReportSlot(deps, config, batchId, slot, now, result) {
     const state = deps.store.load();
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch || batch.anchor === null)
@@ -2630,7 +2933,7 @@ function reconcileReportSlot(deps, batchId, slot, now, result) {
             // #629: a verified report completion is proof dispatch is healthy —
             // reset the confirmed-failure streak, mirroring the per-issue path's
             // own verified-complete branch.
-            let n = (0, dispatch_health_1.resetDispatchApiErrorStreak)(releaseSlot(s, batchId, now));
+            let n = clearAgentExits((0, dispatch_health_1.resetDispatchApiErrorStreak)(releaseSlot(s, batchId, now)), batchId, now);
             const b = (0, state_1.findBatch)(n, batchId);
             if (!b || b.status !== 'deployed')
                 return { state: n, result: undefined };
@@ -2650,8 +2953,15 @@ function reconcileReportSlot(deps, batchId, slot, now, result) {
         if (handleDeadDispatchApiError(deps, batchId, (0, dispatch_1.batchReportLogPath)(deps.store.runsDir, batchId), slot.log_offset_at_spawn ?? 0, now)) {
             return;
         }
-        deps.journal.append((0, journal_1.unitEvent)('report-failed', unit(batchId), { detail: 'unverified exit' }), now);
-        deps.store.withLock((s) => ({ state: releaseSlot(s, batchId, now), result: undefined }));
+        // #832: counted — once the respawns are spent the merged batch closes
+        // without its report (see `closeWithoutReport` for why not a block).
+        const outcome = releaseAndCountAgentExit(deps, batchId, 'report', {
+            event: 'report-failed',
+            extra: { detail: 'unverified exit' },
+            log: (0, dispatch_1.batchReportLogPath)(deps.store.runsDir, batchId),
+        }, now);
+        if (outcome === 'capped')
+            closeWithoutReport(deps, batchId, 'respawn-cap:report', now, result);
     }
 }
 // --- PR watch for `awaiting-merge` batches (mirrors `pollParkedPrs`/`reconcileParked`) ---
@@ -3689,9 +3999,7 @@ function reconcileParallelMemberSlot(deps, config, dispatch, batchId, run, slot,
         // into that tree with its pid no longer tracked anywhere (so neither a
         // dissolve nor `sched stop --batch` could stop it). Its work is done —
         // stop it first.
-        if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
-            deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
-        }
+        killLiveAgent(deps, slot);
         journalEvent(deps, 'external-advance', unit(batchId), {
             issue: run.issue,
             detail: 'member review done',
@@ -3714,6 +4022,17 @@ function reconcileParallelMemberSlot(deps, config, dispatch, batchId, run, slot,
         result.completed.push(memberUnit);
         return;
     }
+    // #822: re-prompt once, then evict — see the serial rail.
+    const parallelBatch = (0, state_1.findBatch)(state0, batchId);
+    if (parallelBatch &&
+        wrongProcedureCounts(parallelBatch, run.issue, read) &&
+        read.milestone !== null) {
+        const decision = decideWrongProcedure(deps, batchId, run.issue, read.milestone, slot, release, () => recordMemberRunLog(deps, dispatch, state0, batchId, run.index, run.issue, slot, now), now);
+        if (typeof decision === 'object') {
+            evictParallelMember(deps, config, batchId, run, decision, now, result);
+        }
+        return;
+    }
     if (read.dead &&
         !read.blockedNow &&
         handleDeadDispatchApiError(deps, batchId, (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, run.index, run.issue), slot.log_offset_at_spawn ?? 0, now, { releaseWith: release })) {
@@ -4024,9 +4343,7 @@ function stopMemberAgent(deps, batchId, issue, now) {
     const slot = (0, state_1.slotForBatchMember)(deps.store.load(), batchId, issue);
     if (slot === undefined)
         return;
-    if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
-        deps.spawnDeps.kill(slot.pid, slot.pid_start ?? undefined);
-    }
+    killLiveAgent(deps, slot);
     deps.store.withLock((s) => ({
         state: (0, state_1.releaseBatchMemberSlot)(s, batchId, issue, now),
         result: undefined,
@@ -4158,7 +4475,7 @@ function runBatchTick(deps, config, dispatch) {
             if (!fresh || types_1.TERMINAL_BATCH_STATUSES.has(fresh.status) || fresh.status === 'blocked') {
                 return { state, result: undefined };
             }
-            const blocked = (0, state_1.transitionBatch)(state, batchId, 'blocked', { blocked_reason: 'reconcile-error' }, now);
+            const blocked = (0, state_1.transitionBatch)(state, batchId, 'blocked', { blocked_reason: 'reconcile-error', agent_exits: null }, now);
             return { state: (0, state_1.releaseAllBatchSlots)(blocked, batchId, now), result: undefined };
         });
         journalEvent(deps, 'unit-failed', unit(batchId), { reason: 'reconcile-error', detail });
@@ -4272,10 +4589,10 @@ function runBatchTick(deps, config, dispatch) {
                     reconcileFixSlot(deps, config, batch.id, slot, now, result);
                 }
                 else if (batch.status === 'reviewing' || batch.status === 'shipping') {
-                    reconcileTailSlot(deps, batch.id, slot, now, result);
+                    reconcileTailSlot(deps, config, batch.id, slot, now, result);
                 }
                 else if (batch.status === 'deployed') {
-                    reconcileReportSlot(deps, batch.id, slot, now, result);
+                    reconcileReportSlot(deps, config, batch.id, slot, now, result);
                 }
                 continue;
             }