tickmarkr 2.2.1 → 2.4.0

package/dist/run/daemon.js

@@ -4,6 +4,7 @@ import { shq } from "../adapters/types.js";
 import { appendFileSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, readSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { stringify } from "yaml";
 import { classifyDeadChannel, NO_TRAILER_SUMMARY, trailerPattern, UNPARSEABLE_TRAILER_SUMMARY, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../adapters/registry.js";
@@ -23,9 +24,9 @@ import { GATE_NAMES } from "../graph/schema.js";
 import { distFingerprint } from "../cli/commands/version.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { runEnvironment } from "./environment.js";
-import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, sameCapacity, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, sameCapacity, sh, shGit, SUITE_PARENT_ENV, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
-import { activeRetryBan, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingConsultGuidance, outstandingReviewFindings, pendingRepairFindings, phaseForGate, readPriorRunEvidence, recordedTaskFailureKind, renderStructuredReviewFinding, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, structuredFindings, upheldFeedbackByTask } from "./journal.js";
+import { 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 } from "../gates/review.js";
 import { acquireApprovalSerialization, acquireRunLock, isPidLive, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
@@ -69,12 +70,13 @@ export function resolveRunMode(repoRoot, opts = {}) {
     return { cfg: resolved.cfg, mode: resolved.mode, source, ...(conflict ? { conflict } : {}) };
 }
 // T14: the events that prove an approval was ENACTED — narrowly causal, never merely subsequent.
-// An ordinary approval (no release, attempt-cap, recheck, review-upheld) all buy a WORKER, so the
-// proof is a dispatch. Generic terminal events are deliberately NOT proof: an approved human-gate
+// Ordinary, attempt-cap and review-upheld approvals buy a WORKER, so their proof is a dispatch;
+// recheck has its own battery enactment below. Generic terminal events are deliberately NOT proof: an approved human-gate
 // task can fail in routing before task-dispatch, and the catch appends task-failed — treating that
 // as enactment reports "complete" over an approval that never ran (the exact silent-completion this
 // task exists to kill).
-const DISPATCH_ENACTMENT = new Set(["task-dispatch", "repair-dispatch"]);
+const DISPATCH_ENACTMENT = new Set(["task-dispatch", "repair-dispatch", "resume-restore"]);
+const RECHECK_ENACTMENT = "recheck-battery";
 // The ONE approval that enacts without buying a worker: GATE_SATISFIED_RELEASE resumes from the
 // persisted task branch after the approved gate (execTask's satisfiedGate branch), whose first act
 // for the task is worktree-recreation. That event is causal for this path, not incidental.
@@ -97,9 +99,13 @@ export function outstandingApprovals(events) {
         newest.set(e.taskId, i); });
     return [...newest]
         .filter(([taskId, i]) => {
-        const noWorker = events[i].data.release === GATE_SATISFIED_RELEASE;
+        const release = events[i].data.release;
+        const noWorker = release === GATE_SATISFIED_RELEASE;
+        const recheck = release === RECHECK_RELEASE;
         return !events.slice(i + 1).some((e) => e.taskId === taskId
-            && (DISPATCH_ENACTMENT.has(e.event) || (noWorker && e.event === GATE_SATISFIED_ENACTMENT)));
+            && (DISPATCH_ENACTMENT.has(e.event)
+                || (noWorker && e.event === GATE_SATISFIED_ENACTMENT)
+                || (recheck && e.event === RECHECK_ENACTMENT)));
     })
         .map(([taskId]) => taskId)
         .sort();
@@ -132,7 +138,8 @@ export function formatSummary(s) {
  *  run id (cli/commands/status.ts positionalRunId), so naming it here is what stops the board from
  *  following the newest journal in a repo that already carries a second, newer run — a board showing
  *  the wrong run is a recorded incident (skills/tickmarkr-overseer/SKILL.md). */
-export const watchCommand = (runId) => `tickmarkr status --watch ${runId}`;
+export const daemonEntrypoint = fileURLToPath(new URL("../cli/index.js", import.meta.url));
+export const watchCommand = (runId) => `${shq(process.execPath)} ${shq(daemonEntrypoint)} status --watch ${shq(runId)}`;
 const MAX_ATTEMPTS = 10; // ponytail: hard cap so a pathological ladder can never loop forever
 // v1.85 T3 (retry economics): two repairs per engagement, then the fresh ladder. A repair re-uses the
 // findings and the landed diff instead of re-buying onboarding; when two of them have not closed the
@@ -165,6 +172,19 @@ const isOracleFailure = (g) => g.details.startsWith("oracle failed:");
  */
 export const gateSatisfied = (g) => (g.pass || g.meta?.skipped === true) && g.meta?.infra !== true;
 const gateFailed = (g) => !gateSatisfied(g);
+const SIGNAL_EXIT_RE = /\b(?:SIGTERM|SIGKILL|signal\s+(?:9|15)|exit(?:s|ed|\s+code)?\s+(?:137|143))\b/i;
+const FAILURE_IDENTITY_RE = /\b(?:AssertionError|FAIL\s+\S|Tests?\s+\d+\s+failed|expected\s+.+\s+to\s+)\b/i;
+/** A signalled test runner with no failure identity produced no verdict about HEAD. Baseline owns the
+ * ordinary infra vocabulary; this daemon-only rider handles the signal-shaped non-verdict before its
+ * journal row and repair accounting are written. */
+function classifySignalOnlyTest(g) {
+    if (g.gate !== "test" || g.pass || g.meta?.infra === true || !SIGNAL_EXIT_RE.test(g.details))
+        return;
+    const named = Array.isArray(g.meta?.failingTests) && g.meta.failingTests.length > 0;
+    if (named || FAILURE_IDENTITY_RE.test(g.details))
+        return;
+    g.meta = { ...g.meta, classification: "infra", infra: true, retryable: false, kind: "signal-exit" };
+}
 // v1.85 T3: the gates whose failure IS a deterministic measurement — a machine re-ran a command over a
 // tree and printed the same bytes. Those are the failures the fingerprint cap governs (the ruling names
 // it a "deterministic-gate" cap): a third identical answer to a question already answered twice is the
@@ -195,7 +215,7 @@ function narrowRepairBattery(failing) {
 }
 // v2.0 T2 (OBS-554): the measurement keys run-gates stamps on a GateResult, lifted verbatim onto the
 // gate row. One list, one lift — both onGate sites record through the same helper.
-const GATE_TELEMETRY_KEYS = ["durationMs", "load1Start", "load1End", "selectedDurationMs", "fullDurationMs", "invocations"];
+const GATE_TELEMETRY_KEYS = ["durationMs", "load1Start", "load1End", "load1Max", "load1Mean", "selectedDurationMs", "fullDurationMs", "invocations"];
 const gateMeasurement = (meta = {}) => Object.fromEntries(GATE_TELEMETRY_KEYS.filter((k) => meta[k] !== undefined).map((k) => [k, meta[k]]));
 /**
  * T4 (OBS-265): the journal with the review objections a round did NOT hinge on removed. Judge and
@@ -270,6 +290,13 @@ function approvedReviewRoundCeiling(events, taskId) {
     return undefined;
 }
 const BLOCKED_POLL_MS = 30_000; // between trailer-wait slices, check whether the pane is blocked on a prompt
+export const SUITE_POLL_MS = 250;
+// ponytail: one fixed ceiling on the live-suite wait; the baseline's test ceilingMs is the upgrade path
+export const SUITE_WAIT_CEILING_MS = 600_000;
+let suiteWaitCeilingMs = SUITE_WAIT_CEILING_MS;
+export const setSuiteWaitCeilingForTests = (ms) => { suiteWaitCeilingMs = ms; };
+export const resetSuiteWaitCeilingForTests = () => { suiteWaitCeilingMs = SUITE_WAIT_CEILING_MS; };
+export const APPROVAL_POLL_MS = 250;
 const PROVIDER_DEATH_REQUEUE_CAP = 2; // v1.46 T1: requeue same assignment twice, then fall through to the normal ladder
 const PROVIDER_DEATH_BACKOFF_MS = 500; // short backoff before provider-death requeue
 const NO_TRAILER_DEMOTION_STREAK = 2; // OBS-57: consecutive no-trailer windows demote a channel for the rest of the run
@@ -319,6 +346,7 @@ export function resetNudgeTimingForTests() {
 // diff merely quotes "rate limit" keeps working undisturbed).
 const QUOTA_BANNER_SILENT_MS = 3 * 60_000;
 let quotaBannerSilentMs = QUOTA_BANNER_SILENT_MS;
+const WORKER_STARTUP_FAILURE_RE = /(?:not logged in|authentication(?:[ _-](?:required|failed|error))|401 unauthorized|model[_ -]?not[_ -]?found|(?:model|deployment)[^\n]{0,80}(?:not found|does not exist|is unavailable)|(?:404|not[_ -]?found)[^\n]{0,80}(?:model|deployment))/i;
 /** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */
 export function setQuotaBannerSilentMsForTests(ms) {
     quotaBannerSilentMs = ms;
@@ -558,6 +586,110 @@ async function observeWorkerProcessTree(marker, cwd) {
     }
     return tree.size === 0 ? "empty" : "running";
 }
+const SUITE_COMMAND_RE = /(?:^|[\s/])(vitest(?:\.mjs)?|jest|mocha)(?:[\s/]|$)|\bnpm(?:\s+run)?\s+test\b/i;
+function processCwd(pid) {
+    try {
+        return realpathSync(readlinkSync(`/proc/${pid}/cwd`));
+    }
+    catch { /* Darwin has no /proc */ }
+    try {
+        const out = execFileSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
+        });
+        const path = out.split("\n").find((line) => line.startsWith("n"))?.slice(1);
+        return path ? realpathSync(path) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processSuiteParent(pid) {
+    try {
+        const env = readFileSync(`/proc/${pid}/environ`, "utf8").split("\0");
+        const value = env.find((entry) => entry.startsWith(`${SUITE_PARENT_ENV}=`))?.slice(SUITE_PARENT_ENV.length + 1);
+        return value && /^\d+$/.test(value) ? Number(value) : undefined;
+    }
+    catch { /* Darwin has no /proc process environments */ }
+    try {
+        const out = execFileSync("ps", ["eww", "-p", String(pid), "-o", "command="], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000,
+        });
+        const value = new RegExp(`(?:^|\\s)${SUITE_PARENT_ENV}=(\\d+)(?:\\s|$)`).exec(out)?.[1];
+        return value ? Number(value) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const pathAtOrBelow = (root, candidate) => {
+    const rel = relative(root, candidate);
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+};
+/** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership
+ * rules remain testable on hosts that forbid process inspection; production supplies cwd and the
+ * inherited TICKMARKR_SUITE_PARENT marker from the process itself. */
+export function countLiveSuites(snapshot, repoRoot, daemonPid = process.pid, cwdForPid = processCwd, suiteParentForPid = processSuiteParent) {
+    const rows = [];
+    for (const line of snapshot.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+        if (match && !match[3].startsWith("Z")) {
+            rows.push({ pid: Number(match[1]), ppid: Number(match[2]), command: match[4] });
+        }
+    }
+    const byPid = new Map(rows.map((row) => [row.pid, row]));
+    const ancestors = new Set();
+    for (let pid = daemonPid; pid && !ancestors.has(pid); pid = byPid.get(pid)?.ppid ?? 0)
+        ancestors.add(pid);
+    const descendants = new Set([daemonPid]);
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const row of rows)
+            if (!descendants.has(row.pid) && descendants.has(row.ppid)) {
+                descendants.add(row.pid);
+                grew = true;
+            }
+    }
+    const root = realpathSync(repoRoot);
+    // OBS-889 (run 3372): a bare-codex worker carries its whole prompt in argv and the prompt names the
+    // runner ("…as a vitest test whose…"), so a finished interactive worker counted as a live suite and
+    // held a task's gates for 9 min 46 s. A runner is named in a command's HEAD — `node <bin>`,
+    // `npm test`, `npx vitest`, `sh -c npm test` — never 140 KB into it: read the first four tokens only.
+    const candidates = rows.filter((row) => !ancestors.has(row.pid) && SUITE_COMMAND_RE.test(row.command.split(/\s+/, 4).join(" ")));
+    const attributable = new Set(candidates.filter((row) => {
+        if (descendants.has(row.pid))
+            return true;
+        const cwd = cwdForPid(row.pid);
+        if (cwd !== undefined && pathAtOrBelow(root, cwd))
+            return true;
+        const suiteParent = suiteParentForPid(row.pid);
+        if (suiteParent === daemonPid)
+            return true;
+        const parentCwd = suiteParent === undefined ? undefined : cwdForPid(suiteParent);
+        return parentCwd !== undefined && pathAtOrBelow(root, parentCwd);
+    }).map((row) => row.pid));
+    // npm/npx + vitest + pool workers are one suite. Count only attributable suite processes with no
+    // attributable suite ancestor, while still following ordinary non-suite parents between them.
+    return [...attributable].filter((pid) => {
+        for (let parent = byPid.get(pid)?.ppid; parent; parent = byPid.get(parent)?.ppid) {
+            if (attributable.has(parent))
+                return false;
+        }
+        return true;
+    }).length;
+}
+let liveSuiteCountForTests;
+export const setLiveSuiteCountForTests = (probe) => {
+    liveSuiteCountForTests = probe;
+};
+export const resetLiveSuiteCountForTests = () => { liveSuiteCountForTests = undefined; };
+/** Live full-suite roots attributable to this repository or this daemon. Ancestors are excluded so
+ * a daemon invoked by vitest does not wait on its own test harness forever. */
+export async function liveSuiteCount(repoRoot) {
+    if (liveSuiteCountForTests)
+        return liveSuiteCountForTests(repoRoot);
+    const snapshot = await shGit("ps -Aww -o pid=,ppid=,state=,command=", repoRoot, 15_000);
+    return snapshot.code === 0 ? countLiveSuites(snapshot.stdout, repoRoot) : 0;
+}
 const OBSERVE_CHUNK_BYTES = 64 * 1024;
 const OBSERVE_BUDGET_BYTES = 256 * 1024 * 1024;
 let observeBudgetBytes = OBSERVE_BUDGET_BYTES;
@@ -1099,6 +1231,8 @@ export async function runDaemon(repoRoot, opts = {}) {
             const trackedDriver = {
                 id: driver.id,
                 interactive: driver.interactive,
+                ...(driver.readSource ? { readSource: driver.readSource } : {}),
+                ...(driver.describe ? { describe: driver.describe.bind(driver) } : {}),
                 slot: async (cwd, name, o) => { const s = await driver.slot(cwd, name, o); liveSlots.add(s); return s; },
                 run: (s, cmd) => driver.run(s, cmd),
                 waitOutput: (s, p, ms, o) => driver.waitOutput(s, p, ms, o),
@@ -1107,10 +1241,25 @@ export async function runDaemon(repoRoot, opts = {}) {
                 read: (s, n) => driver.read(s, n),
                 ...(driver.sendKey ? { sendKey: driver.sendKey.bind(driver) } : {}),
                 ...(driver.nudge ? { nudge: driver.nudge.bind(driver) } : {}),
+                ...(driver.narrator ? { narrator: async (cwd, command, id) => {
+                        const s = await driver.narrator(cwd, command, id);
+                        liveSlots.add(s);
+                        return s;
+                    } } : {}),
+                ...(driver.project ? { project: driver.project.bind(driver) } : {}),
+                ...(driver.reconcile ? { reconcile: driver.reconcile.bind(driver) } : {}),
                 notify: (m, o) => driver.notify(m, o),
                 close: closeSlot,
                 worktree: (r, b, base) => driver.worktree(r, b, base),
             };
+            const absentCapabilities = new Set();
+            const noteCapabilityAbsent = (capability) => {
+                if (absentCapabilities.has(capability)
+                    || journal.read().some((event) => event.event === "driver-capability-absent" && event.data.capability === capability))
+                    return;
+                absentCapabilities.add(capability);
+                journal.append("driver-capability-absent", undefined, { driver: driver.id, capability });
+            };
             // Termination (SIGINT/SIGTERM): record the daemon-controlled exit before closing every live slot,
             // reconcile owned panes against an EMPTY
             // desired set (herdr panes not in memory; panesToClose spares foreign names, watch panes, and
@@ -1135,6 +1284,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                         catch (error) {
                             console.error(`tickmarkr ${runId}: deliberate exit cause could not be journalled (${error instanceof Error ? error.message : String(error)})`);
                         }
+                        // Stop the scheduler before the first awaited retirement. Otherwise a freed slot can fund a
+                        // new attempt while this reaper is still closing the old ones.
+                        abortRun(new Error(`terminated by ${sig}`));
                         if (cfg.visibility.keepPanes !== "forever") {
                             for (const s of liveSlots) { // closeSlot only deletes the element being visited — safe during Set iteration
                                 try {
@@ -1149,13 +1301,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         releaseRunLock(repoRoot); // the process dies at exit() below — the finally never runs on this path
                     }
-                    abortRun(new Error(`terminated by ${sig}`));
                     exit(sig === "SIGINT" ? 130 : 143);
                 })();
             };
             process.on("SIGINT", onTermination);
             process.on("SIGTERM", onTermination);
             journal = opts.resume ? Journal.open(repoRoot, runId, opts.narrate) : Journal.create(repoRoot, runId, opts.narrate);
+            const reviewHistory = journal.read()
+                .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
+                .map((event) => event.data.reviewer);
             // Capture this before this observer appends run-resume. A prior run-end belongs to a completed
             // lifecycle and must use the ordinary resume/redispatch rules; only an interrupted live attempt
             // owns reusable measurements or unclean-death residue.
@@ -1185,6 +1339,20 @@ export async function runDaemon(repoRoot, opts = {}) {
             const approved = new Set(approvalStartupEvents.filter((e) => e.event === "task-approved" && e.taskId).map((e) => e.taskId));
             let approvalSweepCursor = approvalStartupEvents.length;
             const commands = detectGateCommands(repoRoot, cfg);
+            const watchName = formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId });
+            let watchSlot;
+            const openBoard = async () => {
+                if (!trackedDriver.narrator) {
+                    noteCapabilityAbsent("narrator");
+                    return;
+                }
+                try {
+                    watchSlot = await trackedDriver.narrator(repoRoot, watchCommand(runId), runId);
+                }
+                catch (error) {
+                    journal.append("watch-placement-failed", undefined, { error: error instanceof Error ? error.message : String(error) });
+                }
+            };
             let baseRef;
             let baseline;
             // Phase 46 (RES-01/RES-02): the resume-state map is built ONCE here so execTask closes over it.
@@ -1252,9 +1420,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                     ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
                     ...(opts.retryFailed ? { retryFailed: true } : {}),
                 });
+                await openBoard();
             }
             else {
                 baseRef = await gitHead(repoRoot);
+                journal.append("baseline-start", undefined, { baseRef, commands });
+                await openBoard();
                 baseline = await captureBaseline(repoRoot, commands);
                 writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
                 writeFileSync(join(journal.dir, "graph.json"), readFileSync(join(tickmarkrDir(repoRoot), "graph.json")));
@@ -1300,21 +1471,6 @@ export async function runDaemon(repoRoot, opts = {}) {
             const collateral = pinnedCollateral ?? collateralHits(graph.tasks, repoRoot);
             if (!pinnedCollateral)
                 writeFileSync(collateralPath, JSON.stringify(Object.fromEntries(collateral), null, 2));
-            // T6: open the narrator AFTER run-start/run-resume is journaled so the watch surface has a run to
-            // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
-            // a failed-to-open or later-dead watch pane never affects the run.
-            // OBS-103: hold the returned slot — narrator() returns the run's board under its canonical owned
-            // name whichever way it got there (the herdr driver retires a survivor it finds and re-splits, so
-            // the live command is run-bound), and the run-end sweep below retires it by that name regardless
-            // of which daemon instance split the pane.
-            const watchName = formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId });
-            let watchSlot;
-            try {
-                watchSlot = await driver.narrator?.(repoRoot, watchCommand(runId), runId);
-            }
-            catch (error) {
-                journal.append("watch-placement-failed", undefined, { error: error instanceof Error ? error.message : String(error) });
-            }
             const intWt = await ensureIntegration(repoRoot, branch, baseRef);
             // v1.1 visibility: role-named slots; panes persist per keepPanes (attempt = v1 close-after-harvest)
             const keepOpen = cfg.visibility.keepPanes !== "attempt";
@@ -1353,7 +1509,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     if (watchSlot && watchSlot.name === watchName && !desired.has(watchName)) {
                         const w = watchSlot;
                         watchSlot = undefined;
-                        await driver.close(w);
+                        await trackedDriver.close(w);
                     }
                 }
                 catch {
@@ -1386,6 +1542,48 @@ export async function runDaemon(repoRoot, opts = {}) {
                 mergeChain = next.catch(() => undefined);
                 return next;
             };
+            // OBS-829/OBS-854: one full-suite verdict round at a time in this run, and do not begin beside an
+            // externally live suite attributable to this repository. The process scan catches nested scratch
+            // suites through daemon parentage even after cwd stops naming a worktree.
+            let suiteChain = Promise.resolve();
+            let suitePending = 0;
+            const withSuiteWindow = async (taskId, enabled, run) => {
+                if (!enabled)
+                    return run();
+                const previous = suiteChain;
+                let release;
+                suiteChain = new Promise((resolve) => { release = resolve; });
+                const queued = suitePending++ > 0;
+                if (queued) {
+                    const count = Math.max(1, await liveSuiteCount(repoRoot));
+                    journal.append("suite-wait", taskId, { count });
+                }
+                await previous;
+                try {
+                    let lastCount = -1;
+                    const startedAt = Date.now();
+                    for (;;) {
+                        const count = await liveSuiteCount(repoRoot);
+                        if (count === 0)
+                            break;
+                        // OBS-889: a census that never reaches zero held T5's gates with no row and no end. Proceed at
+                        // the ceiling, flagged: the verdict that follows was produced beside whatever is still counted.
+                        if (Date.now() - startedAt >= suiteWaitCeilingMs) {
+                            journal.append("suite-wait-ceiling", taskId, { count, waitedMs: Date.now() - startedAt });
+                            break;
+                        }
+                        if (count !== lastCount)
+                            journal.append("suite-wait", taskId, { count });
+                        lastCount = count;
+                        await new Promise((wake) => setTimeout(wake, SUITE_POLL_MS));
+                    }
+                    return await run();
+                }
+                finally {
+                    suitePending--;
+                    release();
+                }
+            };
             // gateFails/consults are execTask-scoped counters passed in so a park row is a rich verified-failure
             // observation (e.g. ladder-exhausted + gateFails:4); every task-human row has a closed kind, never prose alone.
             const gateFailApprovalReason = (taskId, identity, includeUphold = false) => {
@@ -1644,6 +1842,14 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // `test` row whose scope no consumer could recover.
                         ...(Array.isArray(g.meta?.selectedTests) ? { selectedTests: g.meta.selectedTests } : {}),
                         ...(g.meta?.fullSuite === true ? { fullSuite: true } : {}),
+                        ...(g.meta?.reapedGroup === true ? { reapedGroup: true } : {}),
+                        ...(g.gate === "review" && typeof g.meta?.reviewer === "string" ? {
+                            reviewer: g.meta.reviewer,
+                            ...(typeof g.meta.vendor === "string" ? { vendor: g.meta.vendor } : {}),
+                            ...(typeof g.meta.provider === "string" ? { provider: g.meta.provider } : {}),
+                            ...(typeof g.meta.rotationSeat === "number" ? { rotationSeat: g.meta.rotationSeat } : {}),
+                            ...(typeof g.meta.timeoutMs === "number" ? { timeoutMs: g.meta.timeoutMs } : {}),
+                        } : {}),
                         // A finding's path is its own evidence path. Do not pass task scope here: a declaration says
                         // where work is allowed, not where this verdict found the defect.
                         ...(blocking ? {
@@ -1665,9 +1871,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // T7: the capacity the gate's own command child ran under, lifted verbatim from the result
                         // the battery produced — read where the shell built that child's environment, never
                         // re-derived from the run's own budget, which would answer a different number than the
-                        // operator's export did. It is this row's only COMPARABLE identity: the two load samples
-                        // beside it are endpoint reads of a gate whose interior neither of them saw, so no reader
-                        // compares them, and matching capacity never claims the machine was calm. A gate that ran
+                        // operator's export did. It is this row's only COMPARABLE identity: the load samples describe
+                        // contention while capacity describes how the command divided the machine, and matching
+                        // capacity never claims the machine was calm. A gate that ran
                         // no command carries nothing — it divided nothing.
                         //
                         // `dirtiedBy` is the one hole in that lift: run-gates REPLACES a green battery verdict with
@@ -1853,21 +2059,24 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // contiguous green prefix whose recorded commit is still the task branch tip.
                 const satisfiedGate = satisfiedGates.get(t.id);
                 const replayedGates = replayedGateResults.get(t.id);
-                resumeGateReplay: if (satisfiedGate || replayedGates) {
+                const recheck = pendingRechecks(journal.read()).has(t.id);
+                resumeGateReplay: if (satisfiedGate || replayedGates || recheck) {
                     const taskBase = await integrationHead(intWt);
                     const taskBranch = `${branch}--${t.id}`;
                     const priorWt = worktreePath(repoRoot, taskBranch);
                     if (!existsSync(priorWt)) {
-                        if (satisfiedGate)
-                            throw new Error(`approved gate ${satisfiedGate} cannot resume: task worktree is missing`);
+                        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
                         // commit to compare and no landed work to gate, so fall through to the ordinary worker path.
                         replayedGateResults.delete(t.id);
                         break resumeGateReplay;
                     }
-                    const resumeReason = satisfiedGate
-                        ? `approved gate ${satisfiedGate}`
-                        : `recorded gates on ${replayedGates.commit.slice(0, 10)}`;
+                    const resumeReason = recheck
+                        ? "operator recheck"
+                        : 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);
@@ -1919,7 +2128,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                             : [],
                         raw: "",
                     };
-                    const gateAuthor = rs?.lastAssignment ?? assignment;
+                    const parkedAuthor = recheck
+                        ? [...journal.read()].reverse().find((e) => e.event === "task-dispatch" && e.taskId === t.id)?.data.assignment
+                        : undefined;
+                    const gateAuthor = parkedAuthor ?? rs?.lastAssignment ?? assignment;
                     const satisfiedIndex = satisfiedGate ? GATE_NAMES.indexOf(satisfiedGate) : -1;
                     // The serial pipeline could have at most one blocking result, so "everything after the
                     // approved gate" was enough. v1.85 can record both verdict siblings red in one round, and a
@@ -1943,7 +2155,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                         priorResults.set(e.data.gate, e);
                     }
                     let remainingGates;
-                    if (satisfiedGate) {
+                    if (recheck) {
+                        remainingGates = GATE_NAMES.filter((gate) => t.gates.includes(gate));
+                    }
+                    else if (satisfiedGate) {
                         remainingGates = t.gates.filter((gate) => {
                             if (gate === satisfiedGate)
                                 return false;
@@ -2001,10 +2216,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                             // This suffix is re-measured to decide whether resume may advance, but the interrupted
                             // attempt already paid for its red result. The next worker-backed round remains the next
                             // deterministic-fingerprint occurrence/review round for budget accounting.
-                            ...(!satisfiedGate ? { replayMeasurement: true } : {}),
+                            ...(!satisfiedGate && !recheck ? { replayMeasurement: true } : {}),
                         };
+                        await trackedDriver.project?.(t.id, "in-review");
                         journal.phaseStart(t.id, "gates");
-                        const { results } = await runGates(resumedTask, {
+                        const { results } = await withSuiteWindow(t.id, resumedTask.gates.includes("test") && commands.test !== undefined, () => runGates(resumedTask, {
                             worktree: wt, baseRef: taskBase, result: priorResult, author: gateAuthor,
                             commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
                             collateral: collateral.get(t.id) ?? [],
@@ -2020,6 +2236,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 }
                                 : undefined,
                             excludeReviewers: badReviewers,
+                            reviewHistory,
                             onGate: async (e) => {
                                 if (e.phase === "start") {
                                     notePhaseStart(e);
@@ -2031,6 +2248,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     return;
                                 }
                                 const g = e.result;
+                                classifySignalOnlyTest(g);
                                 inParallelOrder(g.gate, () => {
                                     journalGateResult(g);
                                     noteReviewRetry(g);
@@ -2040,7 +2258,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     }
                                 });
                             },
-                        });
+                        }));
+                        results.forEach(classifySignalOnlyTest);
+                        if (pendingRechecks(journal.read()).has(t.id)) {
+                            journal.append("recheck-battery", t.id, {
+                                commit: gateSubject.commit,
+                                gates: resumedTask.gates,
+                                pass: results.every(gateSatisfied),
+                            });
+                        }
                         const approvedCommits = await commitsAheadOf(taskBase, wt);
                         graph = addEvidence(graph, t.id, { commits: approvedCommits, gateResults: results });
                         saveGraph(repoRoot, graph);
@@ -2087,6 +2313,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             attempts: rs?.attempts ?? 0, assignment: gateAuthor, taskContentDigest: contentDigest,
                         });
                         journal.append("merge", t.id, { branch: taskBranch, commit: await integrationHead(intWt) });
+                        await trackedDriver.project?.(t.id, "completed");
                         journal.telemetry({
                             taskId: t.id, shape: t.shape, adapter: gateAuthor.adapter, model: gateAuthor.model,
                             channel: gateAuthor.channel, attempts: rs?.attempts ?? 0, outcome: "done",
@@ -2257,11 +2484,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                     lastContextTokens = undefined;
                     graph = setStatus(graph, t.id, "running");
                     saveGraph(repoRoot, graph);
+                    await trackedDriver.project?.(t.id, "in-progress");
                     // T6: a dispatch that carries an outstanding finding says so, and names it. Without this the
                     // ledger cannot tell a carried dispatch from an amnesiac one — the exact question a run that
                     // spends two frontier attempts re-deriving a known defect has to be able to answer afterwards.
                     journal.append("task-dispatch", t.id, {
                         assignment, attempt, provenance: dispatchProvenance(r.provenance), retryMode,
+                        excludedChannels: [...demotedChannels].sort(),
                         ...(outstandingFindings.length > 0 ? { carriedFindings: outstandingFindings } : {}),
                         ...(carriedConsultGuidance ? { carriedConsultGuidance } : {}),
                     });
@@ -2373,9 +2602,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // itself before gates regardless of what the worker does with it.
                     writeFileSync(promptFile, `${WORKTREE_LAYOUT_CONTRACT}\n\n${workerContract}\n\n${readFileSync(promptFile, "utf8")}`);
                     const adapter = getAdapter(assignment.adapter, adapters);
+                    if (adapter.trustDialog && !trackedDriver.sendKey)
+                        noteCapabilityAbsent("sendKey");
                     // VIS-04: workers share one role tab. T2: `owned` names the pane canonically (ownership contract);
                     // the legacy name stays the fallback for drivers without owned handling (subprocess spies).
-                    const slot = await trackedDriver.slot(wt, `${t.id}-worker-${assignment.adapter}-a${attempt}-${runTag}`, { group: "workers", owned: { role: "worker", taskId: t.id, attempt, runId } });
+                    const workerSlotOpts = {
+                        group: "workers",
+                        owned: { role: "worker", taskId: t.id, attempt, runId },
+                    };
+                    // Keep the established enumerable slot-options shape consumed by legacy drivers while making
+                    // the adapter hook available as an own request field to execution surfaces such as Orca.
+                    Object.defineProperty(workerSlotOpts, "agent", { value: assignment.adapter });
+                    const slot = await trackedDriver.slot(wt, `${t.id}-worker-${assignment.adapter}-a${attempt}-${runTag}`, workerSlotOpts);
                     const sessionId = retryMode === "resume" ? priorSession.id : slot.name;
                     const icmd = retryMode === "resume"
                         ? adapter.resumeCommand(sessionId, promptFile, assignment.model)
@@ -2419,7 +2657,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // between task-dispatch and this line — worktree recreation, setup, prompt write, slot allocation,
                     // the launch itself — can still die with no worker having seen the brief, and `--retry-failed`
                     // must then re-send that same brief rather than a fresh prompt on a possibly banned channel.
-                    const noteLaunched = () => journal.append("worker-launch", t.id, { attempt, retryMode });
+                    const noteLaunched = async () => journal.append("worker-launch", t.id, {
+                        attempt,
+                        retryMode,
+                        ...(trackedDriver.describe ? await trackedDriver.describe(slot) : {}),
+                    });
+                    const noteWorkerLiveness = (event, data) => journal.append(event, t.id, { ...data, source: trackedDriver.readSource ?? "driver.read" });
                     let cpuFlat;
                     let cpuAccountant;
                     let cpuGapCount = 0;
@@ -2551,6 +2794,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // subprocess tree that REACHED its exit marker, not about what the worker claimed.
                     let processExited = false;
                     let earlyLaunchDead = false;
+                    let startupFailure = false;
                     let deadWorkerPark;
                     let settleParsed;
                     let seedResult;
@@ -2633,7 +2877,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         continue attempts;
                                     return;
                                 }
-                                noteLaunched();
+                                await noteLaunched();
                                 output = seedResult.output;
                             }
                             else {
@@ -2647,14 +2891,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         continue attempts;
                                     return;
                                 }
-                                noteLaunched();
+                                await noteLaunched();
                                 output = await driver.read(slot, PANE_READ_ROWS);
                             }
                             // The returning paths report the same fact on the result; both callbacks land on the one
                             // latch, and the second is a no-op. A seed that answered is never re-answered by the loop.
                             if (seedResult?.trustAnswered)
                                 noteSeedTrustAnswered();
-                            if (seedResult?.seedFailed) {
+                            startupFailure = WORKER_STARTUP_FAILURE_RE.test(stallSnapshotBannerRows(output));
+                            if (seedResult?.seedFailed || startupFailure) {
                                 finished = false;
                             }
                             else {
@@ -2742,7 +2987,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             throw error;
                                         if (!paneReadHeld) {
                                             paneReadHeld = true;
-                                            journal.append("worker-dead-held", t.id, {
+                                            noteWorkerLiveness("worker-dead-held", {
                                                 slot: slot.name, attempt, reason: "pane-read-unreadable",
                                                 error: error instanceof Error ? error.message : String(error),
                                             });
@@ -2755,6 +3000,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     }
                                     if (paneText.length > 0)
                                         everHadOutput = true;
+                                    if (WORKER_STARTUP_FAILURE_RE.test(stallSnapshotBannerRows(paneText))) {
+                                        startupFailure = true;
+                                        output = paneText;
+                                        break;
+                                    }
                                     // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
                                     if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
                                         earlyLaunchDead = true;
@@ -2828,7 +3078,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     catch (error) {
                                         if (!paneStatusHeld) {
                                             paneStatusHeld = true;
-                                            journal.append("worker-dead-held", t.id, {
+                                            noteWorkerLiveness("worker-dead-held", {
                                                 slot: slot.name, attempt, reason: "pane-status-unreadable",
                                                 error: error instanceof Error ? error.message : String(error),
                                             });
@@ -2905,7 +3155,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             paneAbsent = false;
                                             if (!paneReadHeld) {
                                                 paneReadHeld = true;
-                                                journal.append("worker-dead-held", t.id, {
+                                                noteWorkerLiveness("worker-dead-held", {
                                                     slot: slot.name, attempt, reason: "pane-read-unreadable",
                                                     error: error instanceof Error ? error.message : String(error),
                                                 });
@@ -2929,7 +3179,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             paneAbsent = false;
                                             if (!paneReadHeld) {
                                                 paneReadHeld = true;
-                                                journal.append("worker-dead-held", t.id, {
+                                                noteWorkerLiveness("worker-dead-held", {
                                                     slot: slot.name, attempt, reason: "pane-read-unreadable",
                                                     error: error instanceof Error ? error.message : String(error),
                                                 });
@@ -2953,7 +3203,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     if (deathCertain) {
                                         const preservation = await preserveDeadWorker(wt, taskBase);
                                         if (!preservation.ref) {
-                                            journal.append("worker-dead-held", t.id, {
+                                            noteWorkerLiveness("worker-dead-held", {
                                                 slot: slot.name, attempt, reason: `worktree-${preservation.state}`,
                                             });
                                             continue;
@@ -2962,7 +3212,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         const reason = `worker is unambiguously dead: pane absent, process tree empty, and worktree unchanged; preserved at ${ref}`;
                                         deadWorkerPark = { ref, reason };
                                         journal.append("worktree-preserved", t.id, { ref });
-                                        journal.append("worker-dead-held", t.id, {
+                                        noteWorkerLiveness("worker-dead-held", {
                                             slot: slot.name, attempt, reason: "unambiguous-worker-death", ref,
                                         });
                                         break;
@@ -2978,8 +3228,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // 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.
-                                    const fastKillEligible = !stallProgress.rowSignalSaturated
-                                        && !nudgePending && !nudgeFailed
+                                    const fastKillEligible = !nudgePending && !nudgeFailed
                                         && sliceNow - lastOutputGrowthAt >= deadChannelFastKillMs
                                         && worktreeSinceLaunch === "unchanged";
                                     const harvestCpuEligible = !nudgePending && !nudgeFailed
@@ -3020,14 +3269,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // (an elapsed "9s"→"10s" lengthens the read and would hide a frozen pane). But the
                                     // tracker SHARES the read window's ceiling: its row signal saturates once a sample
                                     // FILLS a PANE_READ_ROWS read on raw lines (blanks/chrome included — see stall.ts),
-                                    // and past that point a flat tracker means "unmeasurable", not "dead". For unmetered
-                                    // adapters (codex, cursor-agent, grok, opencode — no contextUsage, so the token signal
-                                    // never fires) rows are the ONLY
-                                    // signal, and those are exactly the non-nudgeable adapters this kill governs — a live
-                                    // worker past the ceiling would be concluded dead mid-work. So the kill STANDS DOWN on
-                                    // a saturated row signal (journaled once per attempt); the rolling window still owns
-                                    // that pane, exactly as pre-T1. Token growth counts as life either way, so a metered
-                                    // worker thinking through a long tool run survives.
+                                    // and past that point a flat tracker means "unmeasurable", not "dead". Journal that
+                                    // unreadability once, then let the independent CPU and worktree legs decide: accruing or
+                                    // unreadable CPU preserves the worker; flat CPU beside an unchanged tree may conclude.
+                                    // A saturated row alone is never a death verdict.
                                     // The triad has NO status exemption: a pane that herdr reports as blocked, idle, working
                                     // or unknown dies alike once it holds no trailer, an unchanged tree and no growth — waiting the
                                     // rolling window out on a status reading is exactly the blindness T1 removes. A matched
@@ -3041,7 +3286,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // filesystem/git observation answer that clause.
                                     if (stallProgress.rowSignalSaturated && !rowSaturationHeld) {
                                         rowSaturationHeld = true;
-                                        journal.append("worker-dead-held", t.id, { slot: slot.name, attempt, reason: "row-signal-saturated" });
+                                        journal.append("contact-unreadable", t.id, {
+                                            slot: slot.name, attempt, source: "pane-rows", reason: "row-signal-saturated", concludes: false,
+                                        });
                                     }
                                     // OBS-548: the FOURTH leg, and the one the daemon already measured. The three legs above
                                     // are all channel-side: they say a pane stopped talking. The tree's CPU says whether
@@ -3058,12 +3305,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             journal.append("worker-dead", t.id, {
                                                 slot: slot.name, attempt, silentMs: sliceNow - lastOutputGrowthAt,
                                                 cpuMs: leg.cpu.ms, cpuResolutionMs: leg.cpu.resolutionMs,
+                                                source: trackedDriver.readSource ?? "driver.read",
                                             });
                                             break;
                                         }
                                         if (!cpuHeld) {
                                             cpuHeld = true;
-                                            journal.append("worker-dead-held", t.id, {
+                                            noteWorkerLiveness("worker-dead-held", {
                                                 slot: slot.name, attempt, reason: leg.state === "accruing" ? "cpu-accruing" : "cpu-unmeasurable",
                                             });
                                         }
@@ -3191,11 +3439,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     continue attempts;
                                 return;
                             }
-                            noteLaunched();
+                            await noteLaunched();
                             // OBS-54: headless workers have the same output-inactivity budget as visible panes.
                             // v1.76: same monotonic-progress measure as the interactive site; harvest stays raw.
                             const stallWindowMs = taskTimeoutMinutes * 60_000;
                             const initialPane = await driver.read(slot, 500);
+                            startupFailure = WORKER_STARTUP_FAILURE_RE.test(stallSnapshotBannerRows(initialPane));
                             let everHadOutput = initialPane.length > 0;
                             const stallProgress = new StallProgressTracker();
                             stallProgress.observe({ paneText: initialPane, seedSubmitted: true, contextTokens });
@@ -3208,7 +3457,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             // worker-result-harvested row. The interactive site has always kept them apart (`finished`
                             // 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 (Date.now() - lastProgressAt < stallWindowMs) {
+                            while (!startupFailure && Date.now() - lastProgressAt < stallWindowMs) {
                                 const remaining = stallWindowMs - (Date.now() - lastProgressAt);
                                 let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                                 if (!everHadOutput) {
@@ -3225,6 +3474,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 const paneText = await driver.read(slot, 500);
                                 if (paneText.length > 0)
                                     everHadOutput = true;
+                                if (WORKER_STARTUP_FAILURE_RE.test(stallSnapshotBannerRows(paneText))) {
+                                    startupFailure = true;
+                                    break;
+                                }
                                 if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
                                     earlyLaunchDead = true;
                                     break;
@@ -3286,7 +3539,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                     }
                     let result = settleParsed ?? adapter.parse(output, nonce);
                     const workerFinished = finished;
-                    const workerCause = classifyWorkerResultCause({ output, ok: result.ok, finished, exitCode, summary: result.summary, timedOut, deadChannel: deadChannelKilled });
+                    const workerCause = startupFailure
+                        ? "startup-failure"
+                        : classifyWorkerResultCause({ output, ok: result.ok, finished, exitCode, summary: result.summary, timedOut, deadChannel: deadChannelKilled });
                     journal.append("worker-result", t.id, {
                         ok: result.ok, summary: result.summary, deviations: result.deviations, finished: workerFinished, exitCode,
                         mode: interactive ? "interactive" : "print", ...(workerCause ? { cause: workerCause } : {}),
@@ -3403,7 +3658,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // T2 review: classify the PRE-HARVEST parse — classifyDeadChannel bails on any ok:true
                     // result, so reading the synthesized harvest result would swallow auth-required /
                     // setup-required / provider-outage for every committed-but-walled attempt (in both modes).
-                    const dead = classifyDeadChannel(preHarvestResult) ?? (earlyLaunchDead ? "setup-required" : undefined);
+                    const dead = classifyDeadChannel(preHarvestResult) ?? (earlyLaunchDead || startupFailure ? "setup-required" : undefined);
                     if (dead) {
                         const from = channelKey(assignment);
                         demotedChannels.add(from); // excluded for later attempts AND later tasks in this run
@@ -3478,6 +3733,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             return;
                         }
                         const g = e.result;
+                        classifySignalOnlyTest(g);
                         inParallelOrder(g.gate, () => {
                             // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
                             // which channel flaked, which channel retried — so `tickmarkr journal`/report can distinguish "judge
@@ -3509,8 +3765,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                     gateLoop: while (true) {
                         const gated = await gitHead(wt);
                         gateSubject = { commit: await gateCommitSubject(taskBase, gated, wt), attempt };
+                        await trackedDriver.project?.(t.id, "in-review");
                         journal.phaseStart(t.id, "gates");
-                        ({ results, commits } = await runGates(t, {
+                        ({ results, commits } = await withSuiteWindow(t.id, t.gates.includes("test") && commands.test !== undefined, () => runGates(t, {
                             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) ?? [],
@@ -3532,8 +3789,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 }
                                 : undefined,
                             excludeReviewers: badReviewers,
+                            reviewHistory,
                             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))
@@ -3569,6 +3828,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 attempts: attempt + 1, assignment, taskContentDigest: contentDigest,
                             });
                             journal.append("merge", t.id, { branch: taskBranch, commit: await integrationHead(intWt) });
+                            await trackedDriver.project?.(t.id, "completed");
                             // firstAttemptOk/gateFails/consults are recorded FACTS, not policy — a parkKind:"stall" row is
                             // recorded but NOT quality-negative in v1.6; Phase 12 owns reward policy, so flipping it later needs zero data migration.
                             journal.telemetry({ taskId: t.id, shape: t.shape, adapter: assignment.adapter, model: assignment.model, channel: assignment.channel, attempts: attempt + 1, outcome: "done", durationMs: Date.now() - startMs, firstAttemptOk: attempt === 0, gateFails, consults, tokens, meteredAttempts: tokens ? metered : undefined, retryMode });
@@ -3630,6 +3890,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // failing gate, and `feedback` still carries every one of them to the next attempt.
                     const repairBattery = failing.some((g) => g.gate !== "review") ? failing.filter((g) => g.gate !== "review") : failing;
                     const repairable = narrowRepairBattery(repairBattery) && lostCommits.length === 0 && landed.length > 0;
+                    const repairHistory = repairReachSinceApproval(journal.read(), t.id);
                     const repairsDrawn = repairsSinceApproval(journal.read(), t.id);
                     const repair = repairable && repairsDrawn < MAX_REPAIRS;
                     // v1.85 T3: the fingerprint cap. Two normalized-identical failures of one DETERMINISTIC gate on
@@ -3699,13 +3960,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const repairExhausted = repairable && !repair;
                     if (repair && !capStep) {
                         journal.append("repair-attempt", t.id, {
-                            repair: repairsDrawn + 1, of: MAX_REPAIRS, gates: failing.map((g) => g.gate),
+                            repair: repairHistory.length + 1, charge: repairsDrawn + 1, of: MAX_REPAIRS,
+                            gates: failing.map((g) => g.gate),
                             commits: landed.length,
                             findings: feedback, // the failure bytes this repair must carry, replayable across a resume
                         });
                     }
                     else if (repairExhausted && !capStep) {
-                        journal.append("repair-exhausted", t.id, { repairs: repairsDrawn, of: MAX_REPAIRS, gates: failing.map((g) => g.gate) });
+                        journal.append("repair-exhausted", t.id, {
+                            repairs: repairsDrawn, of: MAX_REPAIRS, gates: failing.map((g) => g.gate),
+                            reached: repairHistory,
+                        });
                     }
                     const step = capStep ?? (repair || (reviewFixRetry && !repairExhausted)
                         ? "retry"
@@ -3714,7 +3979,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         journal.append("escalation", t.id, {
                             step, attempt: attempt + 1,
                             ...(reviewFixRetry && !repairExhausted ? { reviewFix: true } : {}),
-                            ...(repair ? { repair: repairsDrawn + 1 } : {}),
+                            ...(repair ? { repair: repairHistory.length + 1, repairCharge: repairsDrawn + 1 } : {}),
                         });
                         await driver.notify(`tickmarkr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
                     }
@@ -3769,7 +4034,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 }
                 if (inflight.size === 0)
                     break;
-                await Promise.race([...inflight.values(), aborted]); // aborted rejects on termination — unwinds the run
+                const waiters = [...inflight.values(), aborted];
+                // A free slot is itself a scheduling boundary: poll the append-only approval stream instead of
+                // sleeping until an unrelated long-running task settles.
+                if (inflight.size < concurrency) {
+                    waiters.push(new Promise((wake) => setTimeout(wake, APPROVAL_POLL_MS)));
+                }
+                await Promise.race(waiters); // aborted rejects on termination — unwinds the run
             }
             // D-07: the sweep now closes only what's LEFT in keptSlots — done-closed worker slots were removed
             // (no double-close) and self-cleaned LLM/consult panes were never added under keepLlm:false. This
@@ -3794,7 +4065,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             // OBS-34: post-merge integration-tip verify — strict exit codes, no baseline forgiveness.
             const lastMergedTask = [...journal.read()].reverse().find((e) => e.event === "merge" && e.taskId)?.taskId;
             if (summary.done.length > 0 && Object.keys(commands).length > 0) {
-                const tipFailed = await verifyIntegrationTipCached(intWt, commands, journal, { lastMergedTask, baseline });
+                const tipFailed = await withSuiteWindow(undefined, commands.test !== undefined, () => verifyIntegrationTipCached(intWt, commands, journal, { lastMergedTask, baseline }));
                 summary.tipVerify = tipFailed ? "failed" : "passed";
                 if (tipFailed && lastMergedTask)
                     summary.lastMergedTask = lastMergedTask;