tickmarkr 2.2.0 → 2.3.0

package/dist/gates/verdict-cause.js

@@ -54,10 +54,14 @@ export function hasVerdictParticipationWitness(raw, nonce, discriminator) {
     const discriminatorPattern = new RegExp(String.raw `"${discriminator}"\s*:\s*${valuePattern}\s*[,}]`);
     return objectPrefixes(raw).some((prefix) => noncePattern.test(prefix) && discriminatorPattern.test(prefix));
 }
-export function classifyVerdictCause(raw, nonce, discriminator) {
+export function classifyVerdictCause(raw, nonce, discriminator, process = {}) {
+    if (process.timedOut)
+        return "timeout";
     if (raw.trim().length === 0)
         return "empty-output";
-    return hasVerdictParticipationWitness(raw, nonce, discriminator)
-        ? "malformed-verdict"
-        : "no-verdict";
+    if (hasVerdictParticipationWitness(raw, nonce, discriminator))
+        return "malformed-verdict";
+    if (process.exitCode !== undefined && process.exitCode !== 0)
+        return "startup-failure";
+    return "no-verdict";
 }

package/dist/run/consult.d.ts

@@ -9,6 +9,9 @@ export interface ConsultVerdict {
     reason?: string;
     guidance?: string;
     excludeAdapter?: string;
+    adapter?: string;
+    model?: string;
+    vendor?: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -36,5 +39,9 @@ export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: Work
     runId?: string;
     channels?: Array<{
         adapter: string;
+        model?: string;
+        vendor?: string;
+        channel?: "sub" | "api";
+        tier?: string;
     }>;
 }): Promise<ConsultVerdict>;

package/dist/run/consult.js

@@ -147,6 +147,10 @@ opts = {}) {
             out = r.stdout + r.stderr;
         }
         else {
+            // Preserve the adapter contract for CLIs that cannot seed their TUI: supported adapters use
+            // the interactive form, while a declared null keeps the existing visible print fallback.
+            const command = adapter.interactiveCommand(promptFile, seatModel)
+                ?? adapter.headlessCommand(promptFile, seatModel);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,
@@ -158,7 +162,7 @@ opts = {}) {
             writeFileSync(scriptPath, [
                 "export BASH_SILENCE_DEPRECATION_WARNING=1",
                 bannerShell(),
-                adapter.headlessCommand(promptFile, seatModel),
+                command,
                 gateExitTrailer(nonce),
             ].join("\n"));
             try {
@@ -205,6 +209,17 @@ opts = {}) {
     // the same rule as every prefer entry — and disallowedBy carries the full deny grammar (adapter,
     // model, or adapter:model), so a model-scoped deny cannot slip past an adapter-id-only read.
     const allowedSeats = seats.filter((s) => disallowedBy(s, cfg.routing, "consult") === null);
+    const seatIdentity = (seat) => {
+        let vendor = opts.channels?.find((candidate) => candidate.adapter === seat.adapter && candidate.model === seat.model)?.vendor;
+        if (!vendor) {
+            try {
+                const adapter = getAdapter(seat.adapter, adapters);
+                vendor = adapter.channels(cfg).find((channel) => channel.model === seat.model)?.vendor ?? adapter.vendor;
+            }
+            catch { /* an unknown adapter still gets explicit unknown provenance */ }
+        }
+        return { adapter: seat.adapter, model: seat.model, vendor: vendor ?? "unknown" };
+    };
     if (!allowedSeats.length) {
         const d = disallowedBy(seats[seats.length - 1], cfg.routing, "consult");
         return {
@@ -216,11 +231,14 @@ opts = {}) {
         try {
             const parsed = await invokeSeat(seat.adapter, seat.model, i);
             if (parsed.verdict)
-                return parsed.verdict;
+                return { ...parsed.verdict, ...seatIdentity(seat) };
         }
         catch {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
         }
     }
-    return { action: "human", notes: "consult verdict unparseable — failing safe to human" };
+    return {
+        action: "human",
+        notes: "consult verdict unparseable — failing safe to human",
+    };
 }

package/dist/run/daemon.d.ts

@@ -1,5 +1,6 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
+import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
@@ -13,6 +14,7 @@ export interface RunOptions {
     retryFailed?: boolean;
     concurrency?: number;
     driver?: ExecutorDriver;
+    driverOverride?: DriverChoice;
     adapters?: WorkerAdapter[];
     globalDir?: string;
     mode?: RoutingMode;
@@ -100,6 +102,8 @@ export declare const gateSatisfied: (g: GateResult) => boolean;
  * A round is the gate-result span opened by each `gates` phase-start, per task.
  */
 export declare function decisiveReviewRounds(events: JournalEvent[]): JournalEvent[];
+export declare const SUITE_POLL_MS = 250;
+export declare const APPROVAL_POLL_MS = 250;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -139,6 +143,16 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     lastMergedTask?: string;
     baseline?: Baseline;
 }): Promise<boolean>;
+type SuitePidProbe = (pid: number) => number | undefined;
+/** 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 declare function countLiveSuites(snapshot: string, repoRoot: string, daemonPid?: number, cwdForPid?: (pid: number) => string | undefined, suiteParentForPid?: SuitePidProbe): number;
+export declare const setLiveSuiteCountForTests: (probe: (repoRoot: string) => Promise<number>) => void;
+export declare const resetLiveSuiteCountForTests: () => void;
+/** 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 declare function liveSuiteCount(repoRoot: string): Promise<number>;
 /** Test seam — exercise the production observer's total read bound with a small real tree. */
 export declare function setObserveBudgetBytesForTests(bytes: number): void;
 export declare function resetObserveBudgetBytesForTests(): void;

package/dist/run/daemon.js

@@ -12,6 +12,7 @@ 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 { DeliveryReadinessError } from "../drivers/herdr.js";
+import { driverEvidence } from "../drivers/index.js";
 import { herdrSealShellPrefix, SubprocessDriver } from "../drivers/subprocess.js";
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
@@ -19,11 +20,12 @@ import { runGates } from "../gates/run-gates.js";
 import { filesGlob } from "../graph/files-glob.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 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";
@@ -67,12 +69,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 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.
@@ -95,9 +98,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();
@@ -163,6 +170,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
@@ -268,6 +288,8 @@ 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;
+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
@@ -556,6 +578,106 @@ 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);
+    const candidates = rows.filter((row) => !ancestors.has(row.pid) && SUITE_COMMAND_RE.test(row.command));
+    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;
@@ -1255,11 +1377,25 @@ export async function runDaemon(repoRoot, opts = {}) {
                 baseRef = await gitHead(repoRoot);
                 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")));
                 // 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, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, environment, ...(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
+                journal.append("run-start", undefined, {
+                    pid: process.pid, baseRef, commands, channels: channels.map(channelKey),
+                    channelsByRole: {
+                        worker: pools.worker.map(channelKey),
+                        judge: pools.judge.map(channelKey),
+                        review: pools.review.map(channelKey),
+                        consult: pools.consult.map(channelKey),
+                    },
+                    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 } : {}),
+                }); // 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
                 // names a successor that has no journal. Append-only — the prior journal is never rewritten.
@@ -1370,6 +1506,41 @@ 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;
+                    for (;;) {
+                        const count = await liveSuiteCount(repoRoot);
+                        if (count === 0)
+                            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) => {
@@ -1786,6 +1957,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const applyVerdict = async (v, attempts, trigger) => {
                     journal.append("consult-verdict", t.id, {
                         action: v.action, notes: v.notes,
+                        adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
                         ...(v.reason ? { reason: v.reason } : {}),
                         ...(v.guidance ? { guidance: v.guidance } : {}),
                         ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
@@ -1836,21 +2008,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);
@@ -1902,7 +2077,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
@@ -1926,7 +2104,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;
@@ -1984,10 +2165,10 @@ 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 } : {}),
                         };
                         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) ?? [],
@@ -2009,7 +2190,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                                     return;
                                 }
+                                if (e.phase === "note") {
+                                    journal.append(e.name, t.id, e.payload);
+                                    return;
+                                }
                                 const g = e.result;
+                                classifySignalOnlyTest(g);
                                 inParallelOrder(g.gate, () => {
                                     journalGateResult(g);
                                     noteReviewRetry(g);
@@ -2019,7 +2205,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);
@@ -2354,7 +2548,14 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const adapter = getAdapter(assignment.adapter, adapters);
                     // 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)
@@ -3452,7 +3653,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                             journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                             return;
                         }
+                        if (e.phase === "note") {
+                            journal.append(e.name, t.id, e.payload);
+                            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
@@ -3485,7 +3691,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const gated = await gitHead(wt);
                         gateSubject = { commit: await gateCommitSubject(taskBase, gated, wt), attempt };
                         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) ?? [],
@@ -3508,7 +3714,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 : undefined,
                             excludeReviewers: badReviewers,
                             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))
@@ -3605,6 +3812,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
@@ -3654,7 +3862,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 continue;
                             return;
                         }
-                        journal.append("consult-verdict", t.id, { action: v.action, notes: v.notes, capAdvisory: true });
+                        journal.append("consult-verdict", t.id, {
+                            action: v.action, notes: v.notes,
+                            adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
+                            capAdvisory: true,
+                        });
                     }
                     // v1.85 T3: a narrow battery over fully carried commits earns a REPAIR (decided above) — the
                     // next dispatch carries the findings verbatim and the diff content instead of re-onboarding a
@@ -3670,13 +3882,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"
@@ -3685,7 +3901,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" });
                     }
@@ -3740,7 +3956,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
@@ -3765,7 +3987,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;

package/dist/run/git.d.ts

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
 export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export declare const SUITE_PARENT_ENV = "TICKMARKR_SUITE_PARENT";
 export declare const DEFAULT_FORK_CAP = "6";
 /**
  * OBS-618: how many PROCESSES one vitest fork can hold at its peak — the fork, a daemon it spawns,