tickmarkr 2.5.5 → 2.5.6

package/dist/run/daemon.js

@@ -1,4 +1,4 @@
-import { commandLeaseEnvironment, CommandLeases, currentCommandLeaseToken, isRunnerCommand, runWithCommandLease, withCommandLease } from "./lease.js";
+import { COMMAND_LEASE_TOKEN_ENV, commandLeaseEnvironment, CommandLeases, currentCommandLeaseToken, isRunnerCommand, runWithCommandLease, withCommandLease } from "./lease.js";
 import { execFileSync, spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { shq } from "../adapters/types.js";
@@ -13,7 +13,7 @@ import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../ada
 import { SettledTrailerTracker, addUsage, channelKey, matchesInputBox, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { collateralHits } from "../compile/collateral.js";
-import { DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
+import { ExecutionPolicySchema, DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
 import { DeliveryReadinessError } from "../drivers/herdr.js";
 import { driverEvidence } from "../drivers/index.js";
 import { herdrSealShellPrefix, MAX_BUF, SubprocessDriver } from "../drivers/subprocess.js";
@@ -25,8 +25,11 @@ import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHa
 import { GATE_NAMES } from "../graph/schema.js";
 import { distFingerprint } from "../cli/commands/version.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
+import { executionSignal, remainingExecutionMs, withExecutionBudget, withoutExecutionBudget, ExecutionBudgetExceeded } from "./execution-budget.js";
+import { repairSelectionDecision } from "./repair-selection.js";
+import { failureDisposition, reserveInfrastructureRetry } from "./recovery.js";
 import { runEnvironment } from "./environment.js";
-import { cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sh, shGit, SUITE_PARENT_ENV, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sameVerification, sh, shGit, SUITE_PARENT_ENV, verificationProtocol, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
 import { applyScopeAmendments, activeRetryBan, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingConsultGuidance, outstandingReviewFindings, pendingRechecks, pendingRepairFindings, phaseForGate, readPriorRunEvidence, recordedTaskFailureKind, RECHECK_RELEASE, renderStructuredReviewFinding, repairReachSinceApproval, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, structuredFindings, upheldFeedbackByTask } from "./journal.js";
 import { isDiffCapPark, pickReviewer } from "../gates/review.js";
@@ -35,7 +38,7 @@ import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verif
 import { climbChannel, marginalCostRank, nextChannel, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
 import { readTierLiveness, readWatchBoard, supervisionBeatPath } from "./supervision.js";
-import { harvestCpuFlatWindowMs, NUDGEABLE_ADAPTERS, PANE_READ_ROWS, StallProgressTracker, stallSnapshotBannerRows, WorkerTreeCpuAccountant, } from "./stall.js";
+import { harvestCpuFlatWindowMs, NUDGEABLE_ADAPTERS, PANE_READ_ROWS, StallProgressTracker, stallSnapshotBannerRows, WorkerTreeCpuAccountant, reapOwnedProcessGroup, readOwnedProcessGroup, } from "./stall.js";
 // The live set is also the ownership claim shared by task cleanup and termination.
 export async function closeLiveSlot(liveSlots, driver, slot) {
     if (!liveSlots.delete(slot))
@@ -48,6 +51,10 @@ export async function closeLiveSlot(liveSlots, driver, slot) {
         throw error;
     }
 }
+// A fixed attempt ceiling is independent of the rolling inactivity clock.
+let attemptHardTimeoutMs;
+export function setAttemptHardTimeoutMsForTests(ms) { attemptHardTimeoutMs = ms; }
+export function resetAttemptHardTimeoutMsForTests() { attemptHardTimeoutMs = undefined; }
 // Compatibility exports: gate dispatch can import stall.ts without importing the daemon.
 export { harvestCpuFlatWindowMs, resetHarvestCpuFlatMsForTests, setHarvestCpuFlatMsForTests, workerTreeCpuMs, } from "./stall.js";
 const MODE_RANK = { "staff-led": 0, "risk-based": 1, "partner-led": 2 };
@@ -261,6 +268,22 @@ export function decisiveReviewRounds(events) {
         close(taskId); // Map iteration tolerates deleting the current key
     return events.filter((e) => !spent.has(e));
 }
+/** OBS-1034: the files a byte cap drops from a repair diff — every file whose header starts at or past the cap, plus the one the cut lands inside.
+ * Offsets are UTF-8 BYTES (the cap's unit), never UTF-16 code units. `names` is the NUL-delimited `git diff --name-only` list in
+ * header order, so quoted headers (tabs, quotes, non-ASCII) still name their file. */
+function repairDiffFilesCut(diff, cap, names) {
+    const files = [];
+    const header = Buffer.from("\ndiff --git ");
+    const starts = diff.subarray(0, header.length - 1).equals(header.subarray(1)) ? [0] : [];
+    for (let at = diff.indexOf(header); at !== -1; at = diff.indexOf(header, at + 1))
+        starts.push(at + 1);
+    starts.forEach((start, i) => {
+        const end = starts[i + 1] === undefined ? diff.length : starts[i + 1] - 1;
+        if (start >= cap || end > cap)
+            files.push(names[i] ?? "(unnamed)");
+    });
+    return files;
+}
 /** The fix-only contract: the findings verbatim, then the diff content of the work already landed. */
 function repairBrief(findings, diff, baseRef) {
     const repair = { findings, diff };
@@ -781,6 +804,12 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
     }
     return tipFailed;
 }
+async function commitsAheadOfRef(base, head, cwd) {
+    if (head === base)
+        return [];
+    const r = await shGit(`git log --reverse --format=%H ${shq(base)}..${shq(head)}`, cwd);
+    return r.code === 0 ? r.stdout.trim().split("\n").filter(Boolean) : [];
+}
 async function commitsAheadOf(base, wt) {
     const head = await gitHead(wt);
     if (head === base)
@@ -1376,6 +1405,12 @@ function endedRunIdsForReconcile(repoRoot) {
     return ended;
 }
 export async function runDaemon(repoRoot, opts = {}) {
+    // OBS-1045: a daemon launched from inside a leased command (a nested runner, an operator's test
+    // shell) inherits its ancestor's lease token through the environment, and every gate it ran would
+    // ride that lease instead of taking its own. Clear it at run-start so the first gate leases itself.
+    if (process.env[COMMAND_LEASE_TOKEN_ENV]) {
+        delete process.env[COMMAND_LEASE_TOKEN_ENV];
+    }
     // v1.51 T2 / OBS-89 (v1.60): retired --quality env seam. Mode resolution owns premium routing;
     // route() no longer reads the retired env at all, so the old entrypoint scrub is gone with it.
     const adapters = opts.adapters ?? allAdapters();
@@ -1442,6 +1477,21 @@ export async function runDaemon(repoRoot, opts = {}) {
         // > repo > global > default. The resolved cfg carries mode-compiled floors; route() never sees the mode.
         const rm = resolveRunMode(repoRoot, { flag: opts.mode, spec: graph.mode, globalDir: opts.globalDir });
         const cfg = rm.cfg;
+        if (opts.resume) {
+            const start = Journal.open(repoRoot, runId).read().find((e) => e.event === "run-start");
+            const snapshot = start?.data.effectivePolicy;
+            if (snapshot !== undefined && (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)
+                || !("config" in snapshot) || !snapshot.config || typeof snapshot.config !== "object" || Array.isArray(snapshot.config))) {
+                throw new Error("cannot restore malformed recorded execution policy");
+            }
+            const recorded = snapshot;
+            // Historical runs did not opt in; current settings cannot grant them a new allowance.
+            cfg.executionPolicy = recorded?.config?.executionPolicy === undefined
+                ? undefined : ExecutionPolicySchema.parse(recorded.config.executionPolicy);
+        }
+        if (cfg.executionPolicy && driver.id !== "subprocess") {
+            throw new Error("experimental executionPolicy currently requires the subprocess driver");
+        }
         // Resolve both budgets once: worker fan-out divides by dispatch concurrency; verification
         // divides by one runner command holding a lease. Explicit operator caps still win.
         const concurrency = opts.concurrency ?? cfg.concurrency;
@@ -1472,14 +1522,58 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // opens/closes keep the ledger exact. Termination then closes exactly what is still live — and a
                 // slot closed once (task-done, quota reroute, gate self-clean) can never be closed twice.
                 const liveSlots = new Set();
-                const closeSlot = (s) => closeLiveSlot(liveSlots, driver, s);
+                // A driver handle identifies the physical slot even if a retry returns a new Slot object.
+                const trustAnsweredSlots = new Set();
+                const workerOwners = new Map();
+                const reapReports = new Map();
+                const reapWorker = async (slot) => {
+                    const owner = workerOwners.get(slot);
+                    if (owner) {
+                        const processGroup = readOwnedProcessGroup(owner.groupFile);
+                        let survivors;
+                        try {
+                            const shared = processGroup !== undefined && [...workerOwners].some(([other, otherOwner]) => other !== slot && liveSlots.has(other) && readOwnedProcessGroup(otherOwner.groupFile) === processGroup);
+                            if (shared)
+                                throw new Error(`worker group ${processGroup} is shared with another live attempt`);
+                            survivors = await reapOwnedProcessGroup(processGroup, slot.cwd);
+                        }
+                        catch (error) {
+                            journal.append("worker-process-reaped", owner.taskId, { slot: slot.name, attempt: owner.attempt,
+                                processGroup: processGroup ?? null, survivors: null, error: String(error) });
+                            throw error;
+                        }
+                        reapReports.set(slot, { processGroup: processGroup ?? null, survivors });
+                        journal.append("worker-process-reaped", owner.taskId, {
+                            slot: slot.name, attempt: owner.attempt, processGroup: processGroup ?? null, survivors,
+                        });
+                        if (survivors && survivors.length > 0)
+                            throw new Error(`worker group ${processGroup} survivors: ${survivors.join(", ")}`);
+                    }
+                };
+                const closeSlot = (s) => closeLiveSlot(liveSlots, { close: async (slot) => {
+                        await reapWorker(slot);
+                        await driver.close(slot);
+                    } }, s);
+                const budgetSlots = new Map();
                 const trackedDriver = {
                     id: driver.id,
                     interactive: driver.interactive,
                     ...(driver.readSource ? { readSource: driver.readSource } : {}),
                     ...(driver.describe ? { describe: driver.describe.bind(driver) } : {}),
                     ...(driver.focus ? { focus: driver.focus.bind(driver) } : {}),
-                    slot: async (cwd, name, o) => { const s = await driver.slot(cwd, name, o); liveSlots.add(s); return s; },
+                    slot: async (cwd, name, o) => {
+                        const signal = executionSignal();
+                        signal?.throwIfAborted();
+                        const s = await driver.slot(cwd, name, o);
+                        liveSlots.add(s);
+                        if (signal)
+                            budgetSlots.get(signal)?.add(s);
+                        if (signal?.aborted) {
+                            await withoutExecutionBudget(() => closeSlot(s));
+                            signal.throwIfAborted();
+                        }
+                        return s;
+                    },
                     run: (s, cmd) => driver.run(s, cmd),
                     waitOutput: (s, p, ms, o) => driver.waitOutput(s, p, ms, o),
                     waitAgentStatus: (s, st, ms) => driver.waitAgentStatus(s, st, ms),
@@ -1540,6 +1634,14 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 activeTipVerify.controller.abort(termination);
                                 await activeTipVerify.settled;
                             }
+                            if (cfg.visibility.keepPanes === "forever") {
+                                for (const s of Array.from(liveSlots)) {
+                                    try {
+                                        await reapWorker(s);
+                                    }
+                                    catch { /* survivor evidence is retained by the reaper */ }
+                                }
+                            }
                             if (cfg.visibility.keepPanes !== "forever") {
                                 for (const s of Array.from(liveSlots)) { // snapshot: failed closes restore membership for the next sweep
                                     try {
@@ -1563,6 +1665,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const demotedReviewers = new Set(journal.read()
                     .filter((event) => event.event === "review-pool-demotion" && typeof event.data.reviewer === "string")
                     .map((event) => event.data.reviewer));
+                // OBS-1010: a demotion the JOURNAL carries into this session left the rotation for the run — a
+                // resumed daemon excludes that seat from every review pick (reviewer role only; the worker channel
+                // is untouched — channel-demotion is the worker fold, replayExcludedChannels). In-session demotions
+                // keep their soft ordering above so a still-live seat can be re-tried at the end of the rotation.
+                const replayedReviewerExclusions = opts.resume ? [...demotedReviewers] : [];
+                // OBS-1025 add.2 / OBS-1052 (Leg-2): the run-scoped no-verdict tally run-gates retires a seat from at two
+                // strikes. execTask's badReviewers already excludes a seat after ONE strike within a task, so this map
+                // is what bounds a seat that flakes once per task (or once per session) across the run. Seeded from the
+                // journal's review-no-verdict rows — the same notes noteReviewEvent appends — so a resumed daemon keeps
+                // the count; run-gates appends to it in place, exactly as it does demotedReviewers.
+                const reviewNoVerdicts = new Map();
+                for (const event of journal.read()) {
+                    if (event.event !== "review-no-verdict" || event.data.noVerdict !== true || typeof event.data.reviewer !== "string")
+                        continue;
+                    reviewNoVerdicts.set(event.data.reviewer, [...(reviewNoVerdicts.get(event.data.reviewer) ?? []), String(event.data.cause)]);
+                }
                 const reviewHistory = journal.read()
                     .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
                     .map((event) => event.data.reviewer);
@@ -1702,11 +1820,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                 };
                 // Context carries attribution through gates and remote inference; only shell commands acquire.
                 const commandLeases = new CommandLeases();
-                const withCommandContext = (taskId, run, signal) => runWithCommandLease((_command, execute) => commandLeases.run(async () => {
+                const withCommandContext = (taskId, run, signal = executionSignal()) => runWithCommandLease((_command, execute) => commandLeases.run(async () => {
                     let lastCount = -1;
                     const startedAt = Date.now();
                     for (;;) {
                         signal?.throwIfAborted();
+                        executionSignal()?.throwIfAborted();
                         const count = await liveSuiteCount(repoRoot);
                         if (count === 0)
                             break;
@@ -1730,7 +1849,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const waitForBaseline = async (taskId) => {
                     if (baselinePending)
                         journal.append("baseline-wait", taskId, { baseRef });
-                    await baselineCapture;
+                    const signal = executionSignal();
+                    if (!signal) {
+                        await baselineCapture;
+                        return;
+                    }
+                    signal.throwIfAborted();
+                    // Capture is run-owned; stop this task waiting without cancelling another task's baseline.
+                    await new Promise((resolve, reject) => {
+                        const abort = () => reject(signal.reason);
+                        signal.addEventListener("abort", abort, { once: true });
+                        baselineCapture.then(() => { signal.removeEventListener("abort", abort); resolve(); }, (error) => { signal.removeEventListener("abort", abort); reject(error); });
+                    });
                 };
                 // Phase 46 (RES-01/RES-02): the resume-state map is built ONCE here so execTask closes over it.
                 // Empty Map on fresh runs — every seed below conditions on resume.get(t.id), never on opts.resume (the
@@ -1745,7 +1875,23 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // every shell this run spawns will divide the machine by. Recorded evidence from another session
                 // is only reusable against this.
                 const sessionCapacity = resolvedCapacity();
+                // R41: run-start/run-resume provenance — the protocol + effective lifecycle policy measured at
+                // the repository root when this session began. Gate-result rows do NOT carry this value: each row
+                // carries what run-gates measured for the task worktree the gate ran in (meta.verification), and
+                // the replay guard below compares against a fresh measurement for the recreated worktree.
+                const sessionVerification = verificationProtocol(process.env, repoRoot);
                 const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
+                // Stamp each daemon session, including resumes with changed configuration or CLI overrides.
+                // Keep the loaded-config hash's existing meaning; resolved execution inputs are explicit beside it.
+                // Journal.append applies the normal credential redaction to the readable policy snapshot.
+                const sessionMetadata = {
+                    environment: runEnvironment(cfg, channels, health),
+                    distFingerprint: distFingerprint(),
+                    verification: sessionVerification,
+                    effectivePolicy: { config: cfg, concurrency, driver: driver.id, commands },
+                    mode: rm.mode.mode,
+                    modeSource: rm.source,
+                };
                 if (opts.resume) {
                     // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
                     // two-concurrent-runs hazard supersession exists to prevent. Fail closed, naming the successor.
@@ -1794,6 +1940,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         graph = setStatus(graph, id, st);
                     }
                     journal.append("run-resume", undefined, {
+                        ...sessionMetadata,
                         pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
                         ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
                         ...(opts.retryFailed ? { retryFailed: true } : {}),
@@ -1820,11 +1967,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // Attach a rejection handler immediately; gate and run-close awaits still propagate the error.
                     void baselineCapture.catch(() => { baselineFailed = true; });
                     writeFileSync(join(journal.dir, "graph.json"), readFileSync(join(tickmarkrDir(repoRoot), "graph.json")));
-                    // v1.70 T2: environment identity beside the graph/branch identity — running tickmarkr version,
-                    // loaded-config hash, and the probed CLI version of each adapter holding a channel in the run,
-                    // gathered through the existing probe/config-load paths (no second mechanism).
-                    const environment = runEnvironment(cfg, channels, health);
                     journal.append("run-start", undefined, {
+                        ...sessionMetadata,
                         pid: process.pid, baseRef, commands, channels: channels.map(channelKey),
                         channelsByRole: {
                             worker: pools.worker.map(channelKey),
@@ -1834,9 +1978,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                         },
                         driver: driver.id,
                         driverEvidence: driverEvidence(cfg, driver, opts.driverOverride),
-                        distFingerprint: distFingerprint(),
-                        branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source,
-                        environment, ...(prior ? { supersedes: prior.runId } : {}),
+                        branch, graphDefinitionHash: graphDefinitionHash(graph),
+                        ...(prior ? { supersedes: prior.runId } : {}),
                     }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
                     runStarted = true;
                     // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
@@ -1923,6 +2066,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let mergeChain = Promise.resolve();
                 const mergeSerial = (taskBranch, t, gated) => {
                     const next = mergeChain.then(() => {
+                        executionSignal()?.throwIfAborted();
                         journal.phaseStart(t.id, "merge");
                         return mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated);
                     });
@@ -1939,10 +2083,24 @@ export async function runDaemon(repoRoot, opts = {}) {
                     ];
                     return `${identity} — release with ${commands.map((command) => `\`${command}\``).join(" or ")}`;
                 };
-                const namedPaths = (text) => [...text.matchAll(/(?:^|[\s`'"(])((?:[A-Za-z0-9_@.()[\]-]+\/)+[A-Za-z0-9_@.[\]-]+|[A-Za-z0-9_@-]+(?:\.[A-Za-z0-9_-]+)+)(?=$|[\s`'"),:;.!?])/g)]
+                // `present`: OBS-1007 add.4/5 — a gate DIAGNOSTIC may name only paths that exist in the tree or the
+                // diff (`f.filepath`, `scripted.sh`, `gates.diffCap` lifted from review prose are not paths). A
+                // worker's own scope refusal keeps the lexical rule: the file it needs may not exist yet.
+                const namedPaths = (text, present) => [...text.matchAll(/(?:^|[\s`'"(])((?:[A-Za-z0-9_@.()[\]-]+\/)+[A-Za-z0-9_@.[\]-]+|[A-Za-z0-9_@-]+(?:\.[A-Za-z0-9_-]+)+)(?=$|[\s`'"),:;.!?])/g)]
                     .map((match) => match[1].replace(/^\.\//, "").replace(/\.$/, ""))
                     .filter((path) => !path.split("/").includes("..")
-                    && (/\.[A-Za-z][A-Za-z0-9_-]*$/.test(basename(path)) || existsSync(join(repoRoot, path))));
+                    && (present
+                        ? present.has(path)
+                        : (/\.[A-Za-z][A-Za-z0-9_-]*$/.test(basename(path)) || existsSync(join(repoRoot, path)))));
+                const diffPaths = async (base, wt) => {
+                    const out = await shGit(`git diff --name-only -z ${shq(base)}..HEAD`, wt);
+                    return new Set(out.code === 0 ? out.stdout.split("\0").filter(Boolean) : []);
+                };
+                /** The paths a gate diagnostic may name: the gated worktree's tracked tree plus its diff — never the main checkout. */
+                const treeOrDiffPaths = async (base, wt) => {
+                    const tree = await shGit("git ls-files -z", wt);
+                    return new Set([...(tree.code === 0 ? tree.stdout.split("\0").filter(Boolean) : []), ...await diffPaths(base, wt)]);
+                };
                 const park = async (t, reason, kind, assignment, attempts, startMs, gateFails = 0, consults = 0, tokens, metered = 0, retryMode = "fresh", details = {}) => {
                     // OBS-979: a worker refusal can identify the missing authoring scope even when gates
                     // subsequently supply the park's disposition. Keep that actionable path on the park itself.
@@ -1979,7 +2137,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // count. The two callers arrive at it differently (the attempt loop's index already excludes the
                 // dispatch in flight; a gate replay's rs.attempts already includes it), and the ordinal journaled
                 // below is derived from it here so both paths number the same dispatch identically.
-                const dispositionScopeRed = async (t, results, assignment, attempts, startMs, gateFails, consults, tokens, metered, retryMode) => {
+                const dispositionScopeRed = async (t, results, assignment, attempts, startMs, gateFails, consults, tokens, metered, retryMode, changed = new Set()) => {
                     const scopeRed = results.find((g) => g.gate === "scope" && gateFailed(g));
                     const verdict = scopeRed?.meta?.collateral;
                     if (!verdict && t.files.length > 0) {
@@ -1992,7 +2150,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // A scope verdict already attributes actual out-of-scope EDITS using the collateral map.
                         // Path-only diagnostics from the other gates name code that needs fixing, not an edit the
                         // worker made. Do not replace the scope gate's stronger attribution with that inference.
-                        const paths = reds.filter((g) => g.gate !== "scope" || !g.meta?.collateral).flatMap((g) => namedPaths(g.details));
+                        const paths = reds.filter((g) => g.gate !== "scope" || !g.meta?.collateral).flatMap((g) => namedPaths(g.details, changed));
                         if (refusal.length || (paths.length > 0 && paths.every((path) => !allowed(path)))) {
                             const classification = {
                                 gate: refusal.length ? "worker" : reds[0]?.gate,
@@ -2075,6 +2233,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                 };
                 const execTask = async (t) => {
                     const startMs = Date.now();
+                    let stallSeat;
+                    let stallReaps = 0;
+                    let reapedWorktreeRef;
                     const taskTimeoutMinutes = t.timeoutMinutes ?? cfg.taskTimeoutMinutes;
                     if (t.humanGate && !approved.has(t.id)) {
                         // GATE-08: the condition is the APPROVAL, never the code path. `!opts.resume` (or any run-phase
@@ -2151,10 +2312,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                         && !demotedChannels.has(channelKey(rs.lastAssignment))) {
                         assignment = rs.lastAssignment; // restore the consult-chosen assignment (bypasses route()'s static re-pick)
                     }
-                    else if (!hintsChanged && rs && rs.tried.length) {
+                    else if (!hintsChanged && rs && rs.tried.length && !t.routingHints?.pin) {
                         // trailing-reroute edge (kill between verdict and dispatch), a stale fleet, OR a fresh-budget
                         // release (attempts 0 + non-empty tried): pick a failover over the replayed exclusions via the
                         // EXISTING nextChannel `tried` parameter — zero router changes (D-03).
+                        // OBS-1034: a PIN is exempt — route() already returned it, and a review-upheld repair of the diff
+                        // the pin produced belongs on the pin, not on the next seat its own tried[] entry would pick.
                         const next = nextChannel(assignment, t, cfg, channels, rs.tried, profile, demotedChannels);
                         if (next)
                             assignment = next;
@@ -2180,7 +2343,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // stays unblocked); inert to replayStatuses (unknown events ignored, pinned at journal.test.ts:70-80).
                     if (rs)
                         journal.append("resume-restore", t.id, { attempts: rs.attempts, tried: [...tried], assignment });
-                    const badReviewers = []; // v1.1: reviewer channels that produced unparseable output for this task
+                    // Keep one live list: recovery retries must see exclusions added by onGate during the round.
+                    const badReviewers = [...replayedReviewerExclusions];
                     const noteReviewEvent = (e) => {
                         journal.append(e.name, t.id, e.payload);
                         if (e.name === "review-no-verdict" && typeof e.payload.reviewer === "string") {
@@ -2190,7 +2354,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                     };
                     // Keep the measured siblings, including a red judge, while replacing only a missing review.
                     // Every dispatched seat is excluded for this task, so the loop is bounded by the eligible pool.
-                    const runReviewRecovery = async (task, ctx) => {
+                    const runReviewRecovery = async (task, ctx, allowSelection = true) => {
+                        ctx.authorizeInfraRetry = cfg.executionPolicy?.boundedInfrastructure
+                            ? (subject, cause) => reserveInfrastructureRetry(journal.read(), task.id, subject, journal.append.bind(journal), cause) : undefined;
+                        if (cfg.executionPolicy?.repairSelection && allowSelection) {
+                            const decision = repairSelectionDecision(journal.read(), task.id, true);
+                            ctx.selectTests = decision.selectTests;
+                            ctx.requiredRepairTests = decision.requiredFiles;
+                            ctx.selectionReason = decision.reason;
+                        }
                         const round = await runGates(task, ctx);
                         let review = round.results.find((g) => g.gate === "review");
                         while (review?.meta?.noVerdict === true) {
@@ -2263,6 +2435,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const unverdicted = (g.meta?.skipped === true && !g.pass) || noVerdictReview;
                         journal.append("gate-result", t.id, {
                             gate: g.gate, ...(unverdicted ? {} : { pass: g.pass }), details: g.details,
+                            // R41: the protocol + effective lifecycle policy the gate MEASURED under, stamped by run-gates
+                            // for the worktree it ran in; absent only for a row that never went through the battery.
+                            ...(g.meta?.verification !== undefined ? { verification: g.meta.verification } : {}),
                             ...(gateSubject ? { commit: gateSubject.commit, attempt: gateSubject.attempt } : {}),
                             ...(gateSubject?.replayMeasurement ? { replayMeasurement: true } : {}),
                             ...(gateSubject?.replayedFromAttempt !== undefined ? { replayedFromAttempt: gateSubject.replayedFromAttempt } : {}),
@@ -2271,6 +2446,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                             // be able to tell "the suite found a defect" from "the runner never ran", and the merge
                             // predicate's reason for refusing has to be legible in the ledger it refused from.
                             ...(g.meta?.infra === true ? { infra: true } : {}),
+                            // OBS-1030: a dirty-tree refusal names its litter, its culprit command and the recovery ref ON
+                            // THE ROW — the ledger is where an operator looks for the ref before a recheck, not the prose.
+                            ...(g.meta?.dirtyWorktree === true ? {
+                                dirtyWorktree: true, dirtyPaths: g.meta.paths,
+                                ...(typeof g.meta.culprit === "string" ? { culprit: g.meta.culprit } : {}),
+                                ...(typeof g.meta.preservedRef === "string" ? { preservedRef: g.meta.preservedRef } : {}),
+                            } : {}),
+                            ...(cfg.executionPolicy && !g.pass ? { disposition: failureDisposition(g) } : {}),
+                            ...Object.fromEntries(["runnerInfraRerun", "hostStarvedRerun", "recoveryBlocked", "failingFiles", "selectionDecision"]
+                                .filter((key) => g.meta?.[key] !== undefined).map((key) => [key, g.meta[key]])),
                             // OBS-540: preserve terminal-vs-retryable infra exactly. normalizeGateOutcome deliberately
                             // defaults a legacy infra row to retryable, so dropping an explicit false here reverses the
                             // oracle's recorded verdict when any journal-backed reader reconstructs it.
@@ -2440,7 +2625,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // FROM THE JOURNAL, not from process memory: a park, a `resume`, or a daemon restart must not
                     // hand the selector a clean slate it did not earn, and the journal is the only state that
                     // survives all three (same read as upheldFeedbackByTask above).
-                    let testGateFailed = journal.read().some((e) => e.event === "gate-result" && e.taskId === t.id && e.data.gate === "test" && e.data.pass === false);
+                    let testGateFailed = journal.read().some((e) => e.event === "gate-result" && e.taskId === t.id && e.data.gate === "test" && e.data.pass === false
+                        && !(cfg.executionPolicy?.boundedInfrastructure && e.data.disposition === "infrastructure"));
                     let retryMode = "fresh";
                     let lastContextTokens; // v1.23 reset signal, including stalled/quota attempts
                     // v1.29: only a gate-failed attempt can seed same-session retry. The next attempt consumes this
@@ -2550,7 +2736,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const taskBase = await integrationHead(intWt);
                         const taskBranch = `${branch}--${t.id}`;
                         const priorWt = worktreePath(repoRoot, taskBranch);
-                        if (!existsSync(priorWt)) {
+                        // OBS-1022: the ref `approve --recheck` validated (commits ahead of the base) is the tree the
+                        // battery gates — read from the pending approval row, never re-selected here, so the tree
+                        // approve counted and the tree the daemon gates are one and the same, checkout present or not.
+                        const preservedRef = recheck
+                            ? [...journal.read()].reverse().find((e) => e.taskId === t.id && e.event === "task-approved" && e.data.release === RECHECK_RELEASE)?.data.recheckedRef
+                            : undefined;
+                        if (!existsSync(priorWt) && !preservedRef) {
                             if (satisfiedGate || recheck)
                                 throw new Error(`${recheck ? "recheck" : `approved gate ${satisfiedGate}`} cannot resume: task worktree is missing`);
                             // Observed passes are an optimization, never authority: without the task worktree there is no
@@ -2563,9 +2755,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                             : satisfiedGate
                                 ? `approved gate ${satisfiedGate}`
                                 : `recorded gates on ${replayedGates.commit.slice(0, 10)}`;
-                        const priorTaskTip = await gitHead(priorWt);
-                        const priorTaskSubject = await gateCommitSubject(taskBase, priorTaskTip, priorWt);
-                        const commitsToCarry = await commitsAheadOf(taskBase, priorWt);
+                        const priorTaskTip = preservedRef ? (await shGit(`git rev-parse ${shq(preservedRef)}`, repoRoot)).stdout.trim() : await gitHead(priorWt);
+                        const priorTaskSubject = await gateCommitSubject(taskBase, priorTaskTip, preservedRef ? repoRoot : priorWt);
+                        const commitsToCarry = preservedRef ? await commitsAheadOfRef(taskBase, priorTaskTip, repoRoot) : await commitsAheadOf(taskBase, priorWt);
                         const wt = await recreateTaskWorktree(taskBranch, taskBase, priorWt);
                         const carriedCommits = await cherryPickCommits(wt, commitsToCarry);
                         // Reuse is about the tree the gates will actually inspect. The integration tip may have moved
@@ -2604,16 +2796,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         const workerEvent = [...journal.read()].reverse()
                             .find((e) => e.event === "worker-result" && e.taskId === t.id);
-                        if (!workerEvent)
+                        // OBS-1022: a task that FAILED before its harvest has no worker-result; a recheck judges the
+                        // committed tree on its own evidence, so the missing claim is recorded as exactly that.
+                        if (!workerEvent && !recheck)
                             throw new Error(`${resumeReason} cannot resume: worker result is missing`);
-                        const priorResult = {
+                        const priorResult = workerEvent ? {
                             ok: workerEvent.data.ok === true,
                             summary: typeof workerEvent.data.summary === "string" ? workerEvent.data.summary : "",
                             deviations: Array.isArray(workerEvent.data.deviations)
                                 ? workerEvent.data.deviations.filter((d) => typeof d === "string")
                                 : [],
                             raw: "",
-                        };
+                        } : { ok: false, summary: "no worker result recorded (task failed before harvest); recheck gates the committed tree", deviations: [], raw: "" };
                         const parkedAuthor = recheck
                             ? [...journal.read()].reverse().find((e) => e.event === "task-dispatch" && e.taskId === t.id)?.data.assignment
                             : undefined;
@@ -2679,7 +2873,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     commit: replayedGates.commit, recorded: replayedCapacities, resolved: sessionCapacity,
                                 });
                             }
-                            let reusable = sameWorld && (exactCurrentCommit || canonicalCurrentCommit || recreatedLegacyCommit);
+                            // R41: the same rule for the verification protocol, measured for the RECREATED worktree
+                            // the re-run would gate in (its project npmrc included) — but a row with NO stamp is an OLDER
+                            // row from a different (pre-stamp) implementation, never "unchanged": it is re-run.
+                            const replayVerification = verificationProtocol(process.env, wt);
+                            const replayedVerifications = priorEvents
+                                .filter((e) => e.event === "gate-result" && e.taskId === t.id && e.data.commit === replayedGates.commit)
+                                .map((e) => e.data.verification);
+                            const sameProtocol = replayedVerifications.every((recorded) => sameVerification(recorded, replayVerification));
+                            if (!sameProtocol) {
+                                journal.append("gate-replay-verification-changed", t.id, {
+                                    commit: replayedGates.commit, recorded: replayedVerifications, resolved: replayVerification,
+                                });
+                            }
+                            let reusable = sameWorld && sameProtocol && (exactCurrentCommit || canonicalCurrentCommit || recreatedLegacyCommit);
                             const reused = [];
                             const declaredGates = GATE_NAMES.filter((gate) => t.gates.includes(gate));
                             for (const gate of declaredGates) {
@@ -2695,6 +2902,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         const resumedTask = { ...t, gates: remainingGates };
                         gateLoop: while (true) {
+                            executionSignal()?.throwIfAborted();
                             const gated = await gitHead(wt);
                             gateSubject = {
                                 commit: await gateCommitSubject(taskBase, gated, wt),
@@ -2713,7 +2921,6 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
                                 collateral: collateral.get(t.id) ?? [],
                                 // a recheck re-verifies a human's release: it never selects tests down, it runs the suite.
-                                pipeline: "v185",
                                 via: cfg.visibility.llm === "pane"
                                     ? {
                                         driver: trackedDriver,
@@ -2725,6 +2932,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     : undefined,
                                 excludeReviewers: badReviewers,
                                 reviewHistory, demotedReviewers, priorReviewers: taskReviewers(t.id),
+                                // Leg-2 (OBS-1052): the run-scoped two-strike tally — without it retirement is inert and a
+                                // flaking seat is re-asked on every task. (carriedAuthors is held back: see SURGEON-LEG2-REPORT.)
+                                reviewNoVerdicts,
                                 onGate: async (e) => {
                                     if (e.phase === "start") {
                                         notePhaseStart(e);
@@ -2746,7 +2956,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         }
                                     });
                                 },
-                            }));
+                            }, false));
                             results.forEach(classifySignalOnlyTest);
                             if (pendingRechecks(journal.read()).has(t.id)) {
                                 journal.append("recheck-battery", t.id, {
@@ -2764,6 +2974,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     await park(t, `${infra.gate}: ${infra.details}`, "infra", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
                                     return;
                                 }
+                                const capTrip = results.find(isDiffCapPark);
+                                if (capTrip) {
+                                    await park(t, `${capTrip.gate}: ${capTrip.details}`, "diff-cap", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                                    return;
+                                }
                                 // OBS-547: disposition FIRST, and through the same helper the ordinary attempt path uses. A
                                 // crash between a journaled scope red and its classification must not turn a predicted red
                                 // into a charged one just because a resume is what observed it.
@@ -2776,7 +2991,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // restored. Ask the journal which state this is, and take the classified dispatch's own
                                 // assignment back with it.
                                 const classified = journal.classifiedDispatch(t.id);
-                                if (await dispositionScopeRed(t, results, classified?.assignment ?? gateAuthor, classified ? (rs?.attempts ?? 0) : Math.max(0, (rs?.attempts ?? 0) - 1), startMs, gateFails, consults, tokens, metered, retryMode))
+                                if (await dispositionScopeRed(t, results, classified?.assignment ?? gateAuthor, classified ? (rs?.attempts ?? 0) : Math.max(0, (rs?.attempts ?? 0) - 1), startMs, gateFails, consults, tokens, metered, retryMode, await treeOrDiffPaths(taskBase, wt)))
                                     return;
                                 gateFails++;
                                 // Observed green gates are only measurements. If the resumed suffix is red, preserve that
@@ -2827,6 +3042,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // the same worktree. The next loop iteration retires it before reading/recreating the tree.
                     let supersededWorkerSlot;
                     attempts: for (let attempt = rs?.attempts ?? 0;; attempt++) {
+                        executionSignal()?.throwIfAborted();
                         if (attempt !== providerDeathAttempt) {
                             providerDeathRequeues = 0;
                             providerDeathAttempt = attempt;
@@ -3021,7 +3237,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const taskBranch = `${branch}--${t.id}`; // "--": a ref can't nest under the existing integration branch (locked decision 10)
                         const priorWt = worktreePath(repoRoot, taskBranch);
                         const recreating = existsSync(priorWt);
+                        // Carry the interrupted worker's snapshot, never incidental files created by later gates.
+                        const preserved = recreating ? reapedWorktreeRef : undefined;
+                        reapedWorktreeRef = undefined;
                         const commitsToCarry = recreating ? await commitsAheadOf(taskBase, priorWt) : [];
+                        if (preserved)
+                            commitsToCarry.push(preserved);
                         const wt = await recreateTaskWorktree(taskBranch, taskBase, priorWt);
                         // OBS-58: quota-failover and every retry recreate the task worktree from the integration tip —
                         // cherry-pick prior attempts' landed commits forward so a failover dispatch cannot silently
@@ -3090,14 +3311,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                         if (repairFindings) {
                             const raw = await shGit(`git diff ${shq(taskBase)}..HEAD`, wt);
                             const cap = cfg.gates.diffCap ?? DEFAULT_DIFF_CAP; // same fallback the measuring gates use
-                            const diff = raw.stdout.length > cap
-                                ? `${raw.stdout.slice(0, cap)}\n… diff truncated at gates.diffCap (${cap} bytes)`
+                            // OBS-1034: a capped brief says WHAT it cut — the files whose hunks start at or past the cap
+                            // (the file the cut lands inside is partial too) — on the row and in the worker's prompt.
+                            const rawBytes = Buffer.from(raw.stdout, "utf8"); // the cap is BYTES: measure and cut in UTF-8, not code units
+                            const capped = rawBytes.length > cap;
+                            const droppedFiles = capped ? repairDiffFilesCut(rawBytes, cap, [...await diffPaths(taskBase, wt)]) : [];
+                            const diff = capped
+                                ? `${new TextDecoder().decode(rawBytes.subarray(0, cap))}\n… diff truncated at gates.diffCap (${cap} bytes)`
+                                    + `\nPARTIAL DIFF: the diff above is incomplete; files cut by the cap: ${droppedFiles.join(", ") || "(unknown)"}`
                                 : raw.stdout;
                             const brief = repairBrief(repairFindings, diff, taskBase);
                             // anything the live brief holds beyond the journaled findings (a consult's guidance) is kept:
                             // a repair adds the diff and the fix-only contract, it never subtracts what was already known.
                             feedback = feedback && !brief.includes(feedback) ? `${brief}\n\n${feedback}` : brief;
-                            journal.append("repair-dispatch", t.id, { diffBytes: diff.length, capped: raw.stdout.length > cap });
+                            journal.append("repair-dispatch", t.id, { diffBytes: Buffer.byteLength(diff, "utf8"), capped, ...(capped ? { droppedFiles } : {}) });
                         }
                         if (feedback || priorNamed.length > 0) {
                             feedback = augmentRetryBrief(feedback, { attempted: commitsToCarry, carried: carriedCommits, present: presentCommits });
@@ -3159,7 +3386,14 @@ export async function runDaemon(repoRoot, opts = {}) {
                             ? (hasSeed ? ":" : icmd)
                             : adapter.invoke(t, wt, assignment, { promptFile }).command;
                         const dispatchScript = promptFile.replace(/\.md$/, ".sh");
+                        // Approval can reset the attempt counter while the old pane remains retained.
+                        // Its ownership claim must survive a new engagement reusing the script path.
+                        const groupFile = `${dispatchScript}.${nonce}.pgid`;
+                        workerOwners.set(slot, { taskId: t.id, attempt, groupFile });
                         writeFileSync(dispatchScript, [
+                            // A driver may launch inside the daemon's group. That group is never worker-owned.
+                            `worker_pgid=$(ps -o pgid= -p $$ 2>/dev/null); daemon_pgid=$(ps -o pgid= -p ${process.pid} 2>/dev/null)`,
+                            `if [ -n "$worker_pgid" ] && [ -n "$daemon_pgid" ] && [ "$worker_pgid" != "$daemon_pgid" ]; then printf '%s\\n' "$worker_pgid" > ${shq(groupFile)}; fi`,
                             "export BASH_SILENCE_DEPRECATION_WARNING=1",
                             bannerShell(),
                             workerCmd,
@@ -3226,7 +3460,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             }
                             if (hasSeed || cpuAccountant !== undefined)
                                 return;
-                            cpuAccountant = new WorkerTreeCpuAccountant(dispatchScript, wt);
+                            cpuAccountant = new WorkerTreeCpuAccountant(dispatchScript, wt, () => readOwnedProcessGroup(groupFile));
                             await cpuAccountant.start();
                         };
                         const readCpuLeg = () => {
@@ -3320,6 +3554,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // window that could not have killed anything and briefed the next worker to fix a stall that
                         // never happened. Fourth conflation in the taxonomy OBS-53 opened.
                         let deadChannelKilled = false;
+                        let hardTimedOut = false;
+                        let quotaBannerKilled = false;
+                        let driverProbeFailed = false;
+                        let heldLegs = [];
+                        const noteDriverUnreadable = (error) => {
+                            driverProbeFailed = true;
+                            heldLegs = ["quota:driver-unreadable", "stall:driver-unreadable"];
+                            journal.append("contact-unreadable", t.id, { slot: slot.name, attempt, source: "driver", concludes: false,
+                                error: error instanceof Error ? error.message : String(error) });
+                        };
                         // T2 review: print mode's "the exit marker appeared". Kept apart from `finished` (the
                         // trailer) but still needed by the keepPanes decision below, whose contract is about a
                         // subprocess tree that REACHED its exit marker, not about what the worker claimed.
@@ -3337,7 +3581,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const trailerFrames = interactive && adapter.busyFrameMarkers
                             ? new SettledTrailerTracker(adapter.busyFrameMarkers) : undefined;
                         const sampleTrailer = (frame) => {
-                            const trailer = new RegExp(trailerPattern(nonce)).test(frame);
+                            const parsed = adapter.parse(frame, nonce);
+                            const trailer = new RegExp(trailerPattern(nonce)).test(frame)
+                                && parsed.summary !== NO_TRAILER_SUMMARY && parsed.summary !== UNPARSEABLE_TRAILER_SUMMARY;
                             return trailerFrames ? trailerFrames.sample(frame, trailer) : trailer;
                         };
                         let seedResult;
@@ -3351,11 +3597,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // DeliveryReadinessError, and that catch continues or returns with no result to read, so a
                         // latch built from one would start false with the key already sent, and the next modal on
                         // this slot would get the free Enter this contract exists to prevent.
-                        let trustAnswered = false;
+                        let trustAnswered = trustAnsweredSlots.has(slot.id);
                         const noteSeedTrustAnswered = () => {
                             if (trustAnswered)
                                 return;
                             trustAnswered = true;
+                            trustAnsweredSlots.add(slot.id);
                             // Same audit line the loop below writes, so a live run shows the answer wherever it happened.
                             journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id, phase: "seed" });
                         };
@@ -3409,7 +3656,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // failure rather than allowed to race the trailer wait.
                                     try {
                                         seedResult = await runInteractiveSeed({
-                                            driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes,
+                                            driver: trustAnswered ? {
+                                                run: driver.run.bind(driver), waitOutput: driver.waitOutput.bind(driver), read: driver.read.bind(driver),
+                                            } : driver,
+                                            slot, adapter, assignment, promptFile, taskTimeoutMinutes,
                                             onTrustAnswered: noteSeedTrustAnswered,
                                         });
                                     }
@@ -3456,6 +3706,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // pageRepeatMs elapses, so an operator who missed the first one is paged again.
                                     let lastPagedStatus;
                                     let lastPagedAt = 0;
+                                    let pagesSuppressed = 0; // OBS-1006: pageable slices swallowed by the cadence since the last row
                                     // T1 review: worker-status is journaled on CHANGE, not per slice — every journal append
                                     // is narrated to the run's live surface (cli/commands/run.ts) and feeds activity.ts's
                                     // `now:` cell, so a per-slice append wrote a status line per worker per ~30s slice and
@@ -3481,9 +3732,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     let cpuHeld = false; // likewise for the CPU leg's stand-down (OBS-548)
                                     let paneReadHeld = false;
                                     let paneStatusHeld = false;
-                                    while (Date.now() - lastProgressAt < stallWindowMs) {
+                                    const hardDeadline = attemptStart + (attemptHardTimeoutMs ?? stallWindowMs * 4);
+                                    await armCpuLeg(true);
+                                    while (Date.now() < hardDeadline) {
+                                        if (termSignal)
+                                            throw new Error(`terminated by ${termSignal}`);
+                                        executionSignal()?.throwIfAborted();
+                                        driverProbeFailed = false;
                                         const sliceStart = Date.now();
-                                        const remaining = stallWindowMs - (sliceStart - lastProgressAt);
+                                        const remaining = Math.max(100, Math.min(stallWindowMs - (sliceStart - lastProgressAt), hardDeadline - sliceStart));
                                         let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                                         const startupLeft = workerLaunchedAt === undefined
                                             ? 0
@@ -3500,11 +3757,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // otherwise cost a minute per pair of CPU samples. At the shipped 5m gate this leaves
                                         // every slice before the gate exactly as long as it already was.
                                         slice = Math.min(slice, harvestSliceMs(sliceStart - lastProgressAt));
-                                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
+                                        slice = Math.min(slice, remainingExecutionMs() ?? slice);
+                                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true }).catch((error) => { noteDriverUnreadable(error); return false; })) {
                                             // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
                                             // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
                                             // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
-                                            output = await driver.read(slot, PANE_READ_ROWS); // TUI transcripts carry chrome — read deeper than print's 500
+                                            output = await driver.read(slot, PANE_READ_ROWS).catch((error) => { noteDriverUnreadable(error); return output; }); // TUI transcripts carry chrome — read deeper than print's 500
                                             finished = sampleTrailer(output);
                                             const exit = exitRe.exec(output);
                                             if (finished || (exit && !(trailerFrames && new RegExp(trailerPattern(nonce)).test(output)))) {
@@ -3513,6 +3771,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                 await sampleContext(); // final poll-seam sample before leaving the wait
                                                 break;
                                             }
+                                            if (adapter.parse(output, nonce).summary === UNPARSEABLE_TRAILER_SUMMARY)
+                                                break;
                                             if (trailerFrames && new RegExp(trailerPattern(nonce)).test(output)) {
                                                 // A matching busy frame is still a live turn. Preserve the rolling progress budget.
                                                 await sampleContext();
@@ -3529,19 +3789,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             paneText = await driver.read(slot, PANE_READ_ROWS);
                                         }
                                         catch (error) {
-                                            // Preserve the pre-existing exception path when the independent status probe still
-                                            // sees a pane. The outer attempt finally owns accountant cleanup on that path. Only
-                                            // an undetectable status makes the read failure relevant to the death detector, and
-                                            // that genuinely unmeasurable pair fails open to the rolling timeout.
-                                            let paneUndetectable = true;
-                                            try {
-                                                paneUndetectable = await driver.status(slot) === "unknown";
-                                            }
-                                            catch {
-                                                // Two unreadable pane probes are still unmeasurable, never proof of death.
-                                            }
-                                            if (!paneUndetectable)
-                                                throw error;
+                                            noteDriverUnreadable(error);
                                             if (!paneReadHeld) {
                                                 paneReadHeld = true;
                                                 noteWorkerLiveness("worker-dead-held", {
@@ -3549,14 +3797,14 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                     error: error instanceof Error ? error.message : String(error),
                                                 });
                                             }
-                                            await armCpuLeg(false);
+                                            await armCpuLeg(true);
                                             const spent = Date.now() - sliceStart;
                                             if (spent < slice)
                                                 await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
                                             continue;
                                         }
                                         // waitOutput is only a wake hint; a driver may miss a trailer already painted.
-                                        if (trailerFrames && sampleTrailer(paneText)) {
+                                        if (sampleTrailer(paneText)) {
                                             output = paneText;
                                             finished = true;
                                             const exit = exitRe.exec(output);
@@ -3565,6 +3813,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             await sampleContext();
                                             break;
                                         }
+                                        if (adapter.parse(paneText, nonce).summary === UNPARSEABLE_TRAILER_SUMMARY) {
+                                            output = paneText;
+                                            break;
+                                        }
+                                        if (driverProbeFailed) {
+                                            const spent = Date.now() - sliceStart;
+                                            if (spent < slice)
+                                                await new Promise((resolve) => setTimeout(resolve, Math.min(slice - spent, 1_000)));
+                                            continue;
+                                        }
                                         if (paneText.length > 0)
                                             everHadOutput = true;
                                         if (startupFailureInWindow(paneText, workerLaunchedAt)) {
@@ -3623,14 +3881,19 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // filtered by identity, never by novelty — a banner already on screen at launch
                                         // classifies exactly like one printed mid-attempt (T1 review: a novelty baseline
                                         // exculpated the launch-throttle case forever).
-                                        if (QUOTA_RE.test(stallSnapshotBannerRows(paneText)))
+                                        const bannerMatch = QUOTA_RE.exec(stallSnapshotBannerRows(paneText));
+                                        if (bannerMatch)
                                             quotaStreak++;
                                         else
                                             quotaStreak = 0;
-                                        if (quotaStreak >= 2 && sliceNow - lastProgressAt >= quotaBannerSilentMs) {
+                                        if (bannerMatch && !stallProgress.rowSignalSaturated && !nudgeFailed
+                                            && !(driver.nudge && NUDGEABLE_ADAPTERS.has(adapter.id) && (!nudged || nudgeDeadline !== undefined))
+                                            && readCpuLeg().state === "flat"
+                                            && quotaStreak >= 2 && sliceNow - lastProgressAt >= quotaBannerSilentMs) {
                                             // no `output =` here: the post-loop no-trailer tail re-reads the pane anyway, so an
                                             // assignment would only split the classification read from the verdict read.
-                                            journal.append("quota-banner", t.id, { slot: slot.name, attempt, silentMs: sliceNow - lastProgressAt });
+                                            quotaBannerKilled = true;
+                                            journal.append("quota-banner", t.id, { slot: slot.name, attempt, silentMs: sliceNow - lastProgressAt, matched: bannerMatch[0], excerpt: bannerMatch.input, regex: QUOTA_RE.source });
                                             break;
                                         }
                                         // T1 (OBS-262): the `paged` latch is deleted — status is sampled EVERY slice (and
@@ -3643,6 +3906,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             st = await driver.status(slot);
                                         }
                                         catch (error) {
+                                            noteDriverUnreadable(error);
                                             if (!paneStatusHeld) {
                                                 paneStatusHeld = true;
                                                 noteWorkerLiveness("worker-dead-held", {
@@ -3650,7 +3914,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                     error: error instanceof Error ? error.message : String(error),
                                                 });
                                             }
-                                            await armCpuLeg(false);
+                                            await armCpuLeg(true);
                                             const spent = Date.now() - sliceStart;
                                             if (spent < slice)
                                                 await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
@@ -3668,6 +3932,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                     const paneText = await driver.read(slot, 80);
                                                     if (matchesTrustDialog(paneText, adapter.trustDialog)) {
                                                         trustAnswered = true;
+                                                        trustAnsweredSlots.add(slot.id);
                                                         // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
                                                         // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
                                                         journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
@@ -3793,20 +4058,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // lastProgressAt. Either one advancing is output growth.
                                         const lastOutputGrowthAt = Math.max(stallProgress.lastRowGrowthAt ?? 0, lastProgressAt);
                                         // Everything the fast-kill can decide from the CHANNEL, evaluated before the CPU leg is
-                                        // asked for anything: the kill's own probe costs a `ps` every 100ms, so an ineligible
-                                        // slice must not pay for it. The CPU reading is consulted at the kill itself, below.
+                                        // asked for a conclusion. The shared CPU reading is consulted at the kill below.
                                         const fastKillEligible = !nudgePending && !nudgeFailed
                                             && sliceNow - lastOutputGrowthAt >= deadChannelFastKillMs
                                             && worktreeSinceLaunch === "unchanged";
-                                        const harvestCpuEligible = !nudgePending && !nudgeFailed
-                                            && sliceNow - lastProgressAt >= harvestSilentMs;
-                                        // OBS-548: ONE accountant serves both readers, so its lifecycle is decided once per
-                                        // slice from BOTH windows. Arming per-reader let the harvest's own "not silent enough
-                                        // yet" branch stop the sampler the fast-kill had just started, and a restarted
-                                        // accountant re-bases its monotonic total — the leg could then never read flat. The
-                                        // accountant also carries the readers' nudge holds: when neither reader may conclude,
-                                        // there is no reason to fork its 10 Hz process snapshots through the remaining window.
-                                        await armCpuLeg(harvestCpuEligible || fastKillEligible);
+                                        // All silent conclusions share the attempt's continuous CPU ledger. A nudge
+                                        // hold or a saturated pane must not reset its history before the stall boundary.
+                                        await armCpuLeg(true);
                                         // T2 (OBS-264): the liveness triad CONCLUDES the wait on finished work — commits ahead
                                         // of the task base (this attempt's own AND any carried forward — see the eligibility
                                         // comment at the dispatch site), a flat worker-tree CPU delta, and >= harvestSilentMs
@@ -3864,7 +4122,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // concluded here". A live CPU delta is a live worker, by construction; an UNMEASURABLE
                                         // reading keeps the fail-open contract the probe already states (undefined is never
                                         // evidence a worker stopped), so on a host whose `ps` cannot be read the fast-kill stands
-                                        // down and the rolling window owns the pane, exactly as pre-T1.
+                                        // down and the fixed attempt ceiling bounds the hold.
                                         if (fastKillEligible) {
                                             const leg = readCpuLeg();
                                             if (leg.state === "flat") {
@@ -3883,6 +4141,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                 });
                                             }
                                         }
+                                        const stallCpu = readCpuLeg();
+                                        heldLegs = [
+                                            ...(stallProgress.rowSignalSaturated ? ["quota:row-signal-saturated", "stall:row-signal-saturated"] : []),
+                                            ...(stallCpu.state !== "flat" ? [`stall:cpu-${stallCpu.state}`] : []),
+                                            ...(nudgeFailed || nudgePending ? ["quota:nudge", "stall:nudge"] : []),
+                                            ...(worktreeSincePriorRead === "unreadable" ? ["stall:worktree-unreadable"] : []),
+                                        ];
+                                        if (sliceNow - lastProgressAt >= stallWindowMs && heldLegs.length === 0) {
+                                            timedOut = true;
+                                            break;
+                                        }
                                         if (nudgeable && !nudged && sliceNow - lastProgressAt >= nudgeAfterSilentMs) {
                                             nudged = true;
                                             // T1 review: a false return is a driver-delivery outcome (missing pin, readiness
@@ -3890,16 +4159,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             // one failure is a flake class, retried once in-slice after a short settle. Only a
                                             // failed RETRY condemns the channel. Both failures happen inside this slice, so the
                                             // latch stays immediate and exactly one failure is journaled per attempt.
-                                            let delivered = await driver.nudge(slot, WORKER_NUDGE_MESSAGE);
+                                            let delivered = await driver.nudge(slot, WORKER_NUDGE_MESSAGE).catch((error) => { noteDriverUnreadable(error); return false; });
                                             if (!delivered) {
                                                 await new Promise((r) => setTimeout(r, NUDGE_REDELIVER_MS));
-                                                delivered = await driver.nudge(slot, WORKER_NUDGE_MESSAGE);
+                                                delivered = await driver.nudge(slot, WORKER_NUDGE_MESSAGE).catch((error) => { noteDriverUnreadable(error); return false; });
                                             }
                                             if (delivered) {
                                                 // absorb the nudge's own echo BEFORE arming the grace timer — post-nudge progress
                                                 // is measured against this baseline, not against the echo.
-                                                const echo = await driver.read(slot, PANE_READ_ROWS);
-                                                stallProgress.observe({ paneText: echo, contextTokens });
+                                                const echo = await driver.read(slot, PANE_READ_ROWS).catch((error) => { noteDriverUnreadable(error); return undefined; });
+                                                if (echo !== undefined)
+                                                    stallProgress.observe({ paneText: echo, contextTokens });
                                                 nudgeDeadline = Date.now() + workerNudgeGraceMs;
                                                 journal.append("worker-nudge", t.id, { slot: slot.name, attempt });
                                             }
@@ -3907,15 +4177,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                 // Delivery failure is journal evidence about the daemon's contact attempt only.
                                                 // The fast-kill's worktree clause remains wholly filesystem/git-derived above.
                                                 nudgeFailed = true;
-                                                journal.append("worker-nudge-failed", t.id, { slot: slot.name, attempt });
+                                                journal.append("worker-nudge-failed", t.id, { slot: slot.name, attempt, cause: "delivery-refused-or-unconfirmed" });
                                             }
                                         }
-                                        if (nudged && nudgeDeadline !== undefined && sliceNow >= nudgeDeadline && sliceNow - lastProgressAt >= workerNudgeGraceMs) {
+                                        if (!stallProgress.rowSignalSaturated && readCpuLeg().state === "flat" && nudged && nudgeDeadline !== undefined && sliceNow >= nudgeDeadline && sliceNow - lastProgressAt >= workerNudgeGraceMs) {
                                             // grace spent, still no post-nudge progress: re-harvest once (the trailer may have
                                             // landed between polls), then conclude the wait as a stall NOW — the consult sees the
                                             // un-answered nudge instead of the remainder of the window.
+                                            const finalPane = await driver.read(slot, PANE_READ_ROWS).catch((error) => { noteDriverUnreadable(error); return undefined; });
+                                            if (finalPane === undefined)
+                                                continue;
                                             nudgeDeadline = undefined;
-                                            output = await driver.read(slot, PANE_READ_ROWS);
+                                            output = finalPane;
                                             finished = sampleTrailer(output);
                                             const exit = exitRe.exec(output);
                                             if (finished || (exit && !(trailerFrames && new RegExp(trailerPattern(nonce)).test(output)))) {
@@ -3925,8 +4198,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                                 break;
                                             }
                                             journal.append("worker-nudge-expired", t.id, { slot: slot.name, attempt, graceMs: workerNudgeGraceMs });
-                                            lastProgressAt = Date.now() - stallWindowMs; // the existing harvest/classify tail runs unmodified
-                                            continue; // conclude via the loop condition — never page over an acted-on nudge
+                                            timedOut = true;
+                                            break;
                                         }
                                         // Unlatched page (T1): the page DECISION fires and is journaled every slice the
                                         // operator is the right actor — i.e. the nudge path doesn't own it (non-allowlisted
@@ -3939,23 +4212,32 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // once pageRepeatMs elapses, so a missed first page is not the last one.
                                         const pageable = (st === "blocked" || st === "idle")
                                             && (!nudgePending || nudgeFailed);
+                                        // OBS-1006: the row is appended INSIDE the delivery guard — one row per page delivered, never
+                                        // one per slice — and it carries how many pageable slices were suppressed since the last one.
                                         if (pageable) {
-                                            journal.append("operator-page", t.id, { slot: slot.name, attempt, status: st });
                                             if (st !== lastPagedStatus || sliceNow - lastPagedAt >= pageRepeatMs) {
+                                                journal.append("operator-page", t.id, { slot: slot.name, attempt, status: st, suppressed: pagesSuppressed });
+                                                pagesSuppressed = 0;
                                                 lastPagedStatus = st;
                                                 lastPagedAt = sliceNow;
                                                 const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
                                                 await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
                                             }
+                                            else {
+                                                pagesSuppressed++;
+                                            }
                                         }
                                         // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
                                         const spent = Date.now() - sliceStart;
                                         if (spent < slice)
                                             await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
                                     }
-                                    if (!finished && exitCode === null) {
+                                    if (!finished && exitCode === null && adapter.parse(output, nonce).summary !== UNPARSEABLE_TRAILER_SUMMARY) {
                                         // timed out (or only ever saw false positives): harvest whatever the pane holds now
-                                        timedOut = Date.now() - lastProgressAt >= stallWindowMs;
+                                        hardTimedOut = Date.now() >= hardDeadline;
+                                        timedOut ||= hardTimedOut;
+                                        if (hardTimedOut)
+                                            journal.append("worker-hard-timeout", t.id, { slot: slot.name, attempt, heldLegs });
                                         try {
                                             output = await driver.read(slot, PANE_READ_ROWS);
                                         }
@@ -3963,14 +4245,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             // The poll loop already recorded the unreadable pane. Retain the last readable bytes
                                             // so this ambiguous path still reaches the ordinary timeout/consult backstop.
                                         }
-                                        finished = trailerFrames ? trailerFrames.settled : new RegExp(trailerPattern(nonce)).test(output);
+                                        finished = sampleTrailer(output);
                                         const exit = exitRe.exec(output);
                                         exitCode = exit ? Number(exit[1]) : null;
                                         processExited = exit !== null;
                                     }
                                     if (finished && !trailerFrames) {
-                                        await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
-                                        output = await driver.read(slot, PANE_READ_ROWS);
+                                        await driver.waitAgentStatus(slot, "idle", 5_000).catch(noteDriverUnreadable);
+                                        const settled = await driver.read(slot, PANE_READ_ROWS).catch((error) => { noteDriverUnreadable(error); return output; });
+                                        if (sampleTrailer(settled))
+                                            output = settled;
                                     }
                                     // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
                                     // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
@@ -4028,6 +4312,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // there is the trailer regex; the exit marker only sets exitCode), and the cause taxonomy
                                 // already names this shape "clean-exit-no-trailer" — unreachable in print mode until now.
                                 while (!startupFailure && Date.now() - lastProgressAt < stallWindowMs) {
+                                    executionSignal()?.throwIfAborted();
                                     const remaining = stallWindowMs - (Date.now() - lastProgressAt);
                                     let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                                     const startupLeft = workerLaunchedAt === undefined
@@ -4042,6 +4327,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     }
                                     // T2 (OBS-264): same probe cadence the interactive loop uses — see harvestSliceMs.
                                     slice = Math.min(slice, harvestSliceMs(Date.now() - lastProgressAt));
+                                    slice = Math.min(slice, remainingExecutionMs() ?? slice);
                                     if (await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                                         processExited = true;
                                         break;
@@ -4089,7 +4375,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // interactive attempts to the same exit marker before close and the post-hoc usage disk read
                         // so a writer never races the reader (real CLIs can flush usage asynchronously after the trailer).
                         if (interactive && finished && !exitRe.test(output)) {
-                            await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, 2_000, { regex: true });
+                            await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, 2_000, { regex: true }).catch(noteDriverUnreadable);
                         }
                         // Free availability reroutes deliberately reuse the charged-attempt ordinal. Stream artifacts
                         // cannot: every dispatch owns bytes that must remain independently recoverable, so derive the
@@ -4126,8 +4412,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                             try {
                                 await closeSlot(slot);
                                 if (!workerFinished) {
+                                    const ref = await preserveWorktree(wt);
+                                    if (ref) {
+                                        journal.append("worktree-preserved", t.id, { ref });
+                                        reapedWorktreeRef = ref;
+                                    }
                                     journal.append("worker-reaped-before-harvest", t.id, {
-                                        slot: slot.name, attempt, cause: workerCause ?? "stall-timeout",
+                                        slot: slot.name, attempt, cause: hardTimedOut ? "hard-timeout" : workerCause ?? "stall-timeout",
+                                        ...reapReports.get(slot),
+                                        ...(hardTimedOut ? { heldLegs } : {}),
                                         ...(startupEvidence ? { evidence: startupEvidence } : {}),
                                     });
                                 }
@@ -4175,6 +4468,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // commits survive via the existing commitsToCarry/cherryPickCommits carry-forward.
                         if (workerFinished && !result.ok && await dispositionScopeRed(t, [], assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode))
                             return;
+                        if (!workerFinished && !processExited && (timedOut || deadChannelKilled || quotaBannerKilled)) {
+                            const seat = channelKey(assignment);
+                            stallReaps = stallSeat === seat ? stallReaps + 1 : 1;
+                            stallSeat = seat;
+                            if (stallReaps >= 2) {
+                                const ref = await preserveWorktree(wt);
+                                if (ref)
+                                    journal.append("worktree-preserved", t.id, { ref });
+                                await park(t, `two consecutive stall reaps without a gate on seat ${seat}`, "stall", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode, { seat, stallReaps });
+                                return;
+                            }
+                        }
+                        else {
+                            stallReaps = 0;
+                            stallSeat = undefined;
+                        }
                         const preHarvestResult = result;
                         // T2 (OBS-264): recognize committed no-trailer work BEFORE any no-trailer streak, provider,
                         // quota or dead-channel routing. Gates never trusted the trailer, so this successful synthesis
@@ -4366,6 +4675,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         // Provisioning can mutate the shared dependency tree the pristine capture is still using.
                         await waitForBaseline(t.id);
+                        stallReaps = 0;
+                        stallSeat = undefined;
                         graph = setStatus(graph, t.id, "gated");
                         saveGraph(repoRoot, graph);
                         // OBS-47: re-assert the node_modules link BEFORE gates run on any attempt. A worker may have
@@ -4430,6 +4741,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         let results = [];
                         let commits = [];
                         gateLoop: while (true) {
+                            executionSignal()?.throwIfAborted();
                             const gated = await gitHead(wt);
                             gateSubject = { commit: await gateCommitSubject(taskBase, gated, wt), attempt };
                             await trackedDriver.project?.(t.id, "in-review");
@@ -4469,7 +4781,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     worktree: wt, baseRef: taskBase, result, author: assignment,
                                     commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
                                     collateral: collateral.get(t.id) ?? [],
-                                    pipeline: "v185", selectTests: !testGateFailed,
+                                    selectTests: !testGateFailed,
                                     via: cfg.visibility.llm === "pane"
                                         ? {
                                             driver: trackedDriver,
@@ -4488,13 +4800,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         : undefined,
                                     excludeReviewers: badReviewers,
                                     reviewHistory, demotedReviewers, priorReviewers: taskReviewers(t.id),
+                                    reviewNoVerdicts, // Leg-2 (OBS-1052): see the recheck site above
                                     onGate,
                                 })));
                             }
                             results.forEach(classifySignalOnlyTest);
                             graph = addEvidence(graph, t.id, { commits, gateResults: results, artifacts: [promptFile] });
                             saveGraph(repoRoot, graph);
-                            if (results.some((g) => g.gate === "test" && !g.pass))
+                            if (results.some((g) => g.gate === "test" && !g.pass
+                                && !(cfg.executionPolicy?.boundedInfrastructure && failureDisposition(g) === "infrastructure")))
                                 testGateFailed = true;
                             if (results.every(gateSatisfied)) {
                                 // T6: every gate — the review included — is satisfied on this commit, so the failure brief
@@ -4506,6 +4820,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // gate-fail brief is, so prior-RUN evidence (retired by its own rule, not by this reviewer)
                                 // survives and only this run's settled findings go.
                                 feedback = withCarriedEvidence("");
+                                executionSignal()?.throwIfAborted();
                                 const m = await mergeSerial(taskBranch, t, gated);
                                 if (m.tipMoved) {
                                     journal.append("tip-moved", t.id, m.tipMoved);
@@ -4555,12 +4870,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // flowing through the chargeable quality path below.
                         const infraFailure = results.find((g) => gateFailed(g) && g.meta?.infra === true);
                         if (infraFailure) {
-                            await park(t, `${infraFailure.gate}: ${infraFailure.details}`, "infra", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
+                            await park(t, `${infraFailure.gate}: ${infraFailure.details}${infraFailure.meta?.recoveryBlocked ? ` — ${infraFailure.meta.recoveryBlocked}` : ""}`, "infra", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
+                            return;
+                        }
+                        // OBS-1007: a cap trip is a typed park of its own — the diff cannot shrink by retrying and the
+                        // only honest verb is a recheck under a raised cap. Decided BEFORE the authoring classifier, which
+                        // used to lift `gates.diffCap` out of the cap prose as a files[] hint.
+                        const capTrip = results.find(isDiffCapPark);
+                        if (capTrip) {
+                            await park(t, `${capTrip.gate}: ${capTrip.details}`, "diff-cap", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
                             return;
                         }
                         // OBS-547: who pays for this red is decided by the run's collateral prediction (see
                         // dispositionScopeRed) — an authoring defect parks unchargeable before any accounting below.
-                        if (await dispositionScopeRed(t, results, assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode))
+                        if (await dispositionScopeRed(t, results, assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode, await treeOrDiffPaths(taskBase, wt)))
                             return;
                         gateFails++; // this attempt's gates failed — the one place quality degradation is verified (never inferred from attempts)
                         // v1.53 T3: prefer the CLI's own session id captured from this attempt's output (kimi's resume
@@ -4720,6 +5043,39 @@ export async function runDaemon(repoRoot, opts = {}) {
                         return;
                     }
                 };
+                const executeWithPolicy = async (t) => {
+                    const policy = cfg.executionPolicy;
+                    if (!policy || (t.humanGate && !approved.has(t.id)))
+                        return execTask(t);
+                    await withExecutionBudget({ limitMs: policy.taskExecutionLimitMs, taskId: t.id,
+                        readEvents: () => journal.read(), append: journal.append.bind(journal) }, async () => {
+                        const signal = executionSignal();
+                        const slots = new Set();
+                        budgetSlots.set(signal, slots);
+                        let closing;
+                        const closeOwned = () => withoutExecutionBudget(async () => {
+                            for (const slot of slots)
+                                await closeSlot(slot);
+                        });
+                        const stop = () => {
+                            closing = closeOwned();
+                            // Awaited again below; prevent an unhandled rejection while the worker unwinds.
+                            void closing.catch(() => { });
+                        };
+                        signal.addEventListener("abort", stop, { once: true });
+                        try {
+                            await execTask(t);
+                        }
+                        finally {
+                            signal.removeEventListener("abort", stop);
+                            if (signal.aborted) {
+                                await closing;
+                                await closeOwned();
+                            }
+                            budgetSlots.delete(signal);
+                        }
+                    });
+                };
                 taskLoopStarted = true;
                 const inflight = new Map();
                 // A settled worker can release a dependency or an approval in the same poll tick.
@@ -4752,8 +5108,33 @@ export async function runDaemon(repoRoot, opts = {}) {
                             .filter((t) => !inflight.has(t.id))
                             .slice(0, Math.max(0, concurrency - inflight.size));
                         for (const t of ready) {
-                            const p = execTask(t)
+                            const p = executeWithPolicy(t)
                                 .catch(async (err) => {
+                                const cleanupErrors = [];
+                                for (const [slot, owner] of workerOwners) {
+                                    if (owner.taskId !== t.id || !liveSlots.has(slot))
+                                        continue;
+                                    try {
+                                        await withoutExecutionBudget(() => closeSlot(slot));
+                                    }
+                                    catch (error) {
+                                        // Cleanup evidence must not replace the task's original failure or abort siblings.
+                                        cleanupErrors.push({ slot: slot.name, attempt: owner.attempt, error: String(error) });
+                                    }
+                                }
+                                const cleanupEvidence = cleanupErrors.length ? { cleanupErrors } : {};
+                                if (err instanceof ExecutionBudgetExceeded) {
+                                    const wt = worktreePath(repoRoot, `${branch}--${t.id}`);
+                                    const ref = await preserveWorktree(wt);
+                                    if (ref)
+                                        journal.append("worktree-preserved", t.id, { ref });
+                                    const dispatch = journal.read().reverse().find((e) => e.taskId === t.id && e.event === "task-dispatch");
+                                    await park(t, err.message, "infra", null, 0, Date.now(), 0, 0, undefined, 0, "fresh", { disposition: "execution-budget-exhausted", limitMs: cfg.executionPolicy.taskExecutionLimitMs,
+                                        ...cleanupEvidence,
+                                        ...(Number.isInteger(dispatch?.data.attempt) ? { attempt: dispatch.data.attempt } : {}),
+                                        ...(dispatch?.data.assignment ? { assignment: dispatch.data.assignment } : {}) });
+                                    return;
+                                }
                                 const taskEvents = journal.read().filter((e) => e.taskId === t.id);
                                 const dispatch = [...taskEvents].reverse().find((e) => e.event === "task-dispatch");
                                 // OBS-206: shared rule with `resume --retry-failed` — see classifyTaskFailure.
@@ -4761,7 +5142,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 const attempts = dispatch && Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0;
                                 graph = setStatus(graph, t.id, "failed");
                                 saveGraph(repoRoot, graph);
-                                journal.append("task-failed", t.id, { error: String(err), kind, attempts });
+                                journal.append("task-failed", t.id, { error: String(err), kind, attempts, ...cleanupEvidence });
                                 journal.telemetry({ taskId: t.id, shape: t.shape, adapter: "-", model: "-", channel: "-", attempts: 0, outcome: "failed", durationMs: 0 });
                                 await reconcile({ spareLiveLlm: true }); // task-failed is a terminal event
                             })