tickmarkr 2.6.4 → 2.6.5

package/dist/run/daemon.js

@@ -36,7 +36,7 @@ import { changeRepresented, cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gi
 import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyRepairDisposition, resolveScopeHints } from "./repair-disposition.js";
 import { applyScopeAmendments, activeRetryBan, interruptedAttempt, RESUME_HARVEST_SOURCE, resumeHarvestAuthor, approvalAction, APPROVAL_REFUSED, bindingToken, effectiveEvents, foldDecisions, physicalLine, staleApprovals, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingConsultGuidance, readableExcerpt, receiptOrigin, outstandingReviewFindings, pendingApprovalActions, pendingRechecks, pendingRepairFindings, phaseForGate, priorJudgments, readPriorRunEvidence, recordedTaskFailureKind, reraisedReviewChains, RECHECK_RELEASE, renderStructuredReviewFinding, repairReachSinceApproval, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, standingRulings, structuredFindings, upheldFeedbackByTask } from "./journal.js";
-import { gateReviewerFloor, isDiffCapPark, isGarbageReview, pickReviewer } from "../gates/review.js";
+import { carriedAuthorVendors, gateReviewerFloor, isDiffCapPark, isGarbageReview, pickReviewer } from "../gates/review.js";
 import { acquireApprovalSerialization, acquireRunLock, isPidLive, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, reusedTipEvidence, verifyIntegrationTip } from "./merge.js";
 import { channelExclusion, climbChannel, inTaskPool, marginalCostRank, nextChannel, poolExhaustion, route, taskPool } from "../route/router.js";
@@ -377,6 +377,49 @@ function classifyInfraResult(g) {
 const TIMEOUT_SHAPED_RE = /\b(?:Test|Hook) timed out in (?:\d+|#)\s*ms\b|\bexpected (?:\d+|#)(?:\.(?:\d+|#))? to be (?:less than|below)(?: or equal to)? (?:\d+|#)/i;
 const RUNNER_INFRA_DIAGNOSTIC_RE = /\bnever-started (?:[1-9]\d*|#)(?![\d#])|\[vitest-worker\]: Timeout calling\b/;
 const timeoutShaped = (details) => TIMEOUT_SHAPED_RE.test(readableExcerpt(details));
+/** C (E1): the one no-verdict that is the host's slowness, not the seat's — the same predicate run-gates
+ * applies to its run-scoped tally, read here for the live task strike and the resume reconstruction. */
+const proofTimeoutNote = (data) => data.cause === "seat-launch-failed" && data.launchCause === "checkout-proof-timeout";
+/** C: the gate-fresh-forced reason that bounds the out-of-scope re-execution, one per journaled subject. */
+const OUTSIDE_SCOPE_RED = "no-commit-out-of-scope-red";
+const NAMED_FAILURE_FILE_RE = /^\s*(\S+\.(?:test|spec)\.[cm]?[jt]sx?)\s+>/gm;
+/** D-854: the runner certificate the vitest manifest path appends to a red (test-manifest.ts). */
+const RUNNER_CERTIFICATE_RE = /runner-level diagnostic: never-started ([^;\s]+); reporter errors ([^;\s]+)/g;
+/** C: a journaled test red whose failing-file attribution is nonempty, trustworthy and complete (repair
+ * selection's own rule: a behavioral red on a real subject from a full suite or a screen that names
+ * every failure), POSITIVELY certified complete by its runner, uncontradicted by the files its own text
+ * names, and wholly outside a declared files[]. Empty files[] is unrestricted and never qualifies;
+ * every other shape keeps its replay. */
+function outsideScopeRed(t, taskId, data, commit) {
+    if (!t.files.length || data.gate !== "test" || data.pass !== false || data.skipped === true || data.commit !== commit
+        // a failed producer — an infra row, a dirty-tree refusal, a recovery the runner could not finish —
+        // never attributes anything, whatever files it lists
+        || data.infra === true || data.dirtyWorktree === true || data.recoveryBlocked !== undefined)
+        return false;
+    const attribution = repairSelectionDecision([{ event: "gate-result", taskId, data }], taskId, true);
+    if (attribution.reason !== "known-failing-files" || attribution.requiredFiles.length === 0)
+        return false;
+    const text = readableExcerpt(String(data.details ?? ""));
+    // D-854: validate, never filter. A collection failure has no module record, so failingFiles omits it
+    // and it lives only in the certificate's counts; any never-started file or reporter error, an unknown
+    // count, or no certificate at all leaves the attribution unproven.
+    // ponytail: a nonzero count never qualifies, even when each diagnostic names an outside file — the
+    // details interleave diagnostics with the stdout tail; map them only if outside-scope collection reds need it.
+    const certificates = [...text.matchAll(RUNNER_CERTIFICATE_RE)];
+    if (!certificates.length || certificates.some((m) => m[1] !== "0" || m[2] !== "0"))
+        return false;
+    const named = [...text.matchAll(ATTRIBUTED_FILE_RE), ...text.matchAll(NAMED_FAILURE_FILE_RE)].map((m) => m[1].replace(/^\.\//, ""));
+    if (named.some((file) => !attribution.requiredFiles.includes(file)))
+        return false; // contradictory
+    const inScope = filesGlob(t.files);
+    return attribution.requiredFiles.every((file) => !inScope(file));
+}
+/** C: every test red a round journaled on `commit` is an out-of-scope red (none means none). */
+const allOutsideScopeReds = (t, rows, commit) => {
+    const reds = rows.filter((e) => e.event === "gate-result" && e.data.gate === "test" && e.data.pass === false
+        && e.data.skipped !== true && e.data.commit === commit);
+    return reds.length > 0 && reds.every((e) => outsideScopeRed(t, e.taskId ?? t.id, e.data, commit));
+};
 const ATTRIBUTED_FILE_RE = /^\s*(?:FAIL|×|✗)\s+(?:\|[^|\n]*\|\s+)?(\S+\.(?:test|spec)\.[cm]?[jt]sx?)\b/gm;
 /** The failing files a red attributes to itself: the runner's own list, else its FAIL headlines. */
 const attributedFailingFiles = (g) => [...new Set(Array.isArray(g.meta?.failingFiles) && g.meta.failingFiles.length
@@ -2203,10 +2246,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // is what bounds a seat that flakes once per task (or once per session) across the run. Seeded from the
                 // journal's review-no-verdict rows — the same notes noteReviewEvent appends — so a resumed daemon keeps
                 // the count; run-gates appends to it in place, exactly as it does demotedReviewers.
+                // C (E1): a checkout-proof timeout never struck the live tally (run-gates), so a resume never seeds one.
                 const reviewNoVerdicts = new Map();
                 for (const event of journal.read()) {
                     if (event.event !== "review-no-verdict" || event.data.noVerdict !== true || typeof event.data.reviewer !== "string")
                         continue;
+                    if (proofTimeoutNote(event.data))
+                        continue;
                     reviewNoVerdicts.set(event.data.reviewer, [...(reviewNoVerdicts.get(event.data.reviewer) ?? []), String(event.data.cause)]);
                 }
                 const reviewHistory = journal.read()
@@ -2930,6 +2976,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                     return red !== undefined
                         && identicalGateFailures(journal.read(), t.id, "test", normalizeGateFailure(String(red.data.details))) < GATE_FINGERPRINT_CAP;
                 };
+                // C: an unchanged cached test red attributed wholly outside files[] is re-executed ONCE per journaled
+                // subject — the worker cannot repair those files, so a copy of the red would only buy another round.
+                const owesOutsideScopeRefresh = (t, priorRows, commit) => allOutsideScopeReds(t, priorRows, commit)
+                    && !journal.read().some((e) => e.taskId === t.id && e.event === "gate-fresh-forced"
+                        && e.data.reason === OUTSIDE_SCOPE_RED && e.data.commit === commit);
+                // C: the forced re-execution's own round failed again only outside files[]: independent evidence the
+                // worker cannot act on. It keeps its red row and parks gate-fail before any cap, consult or repair move.
+                const freshOutsideScopeRed = (t, commit) => {
+                    const own = journal.read().filter((e) => e.taskId === t.id);
+                    return allOutsideScopeReds(t, own.slice(own.map((e) => e.event === "phase-start" && e.data.phase === "gates").lastIndexOf(true) + 1), commit);
+                };
+                const outsideScopePark = (t) => gateFailApprovalReason(t.id, "test: a fresh re-execution of the unchanged subject failed again only in files outside files[] — no repair can reach them");
                 // OBS-1106 residual: before a timeout or wall-budget red accompanied by runner infra diagnostics is
                 // charged, its attributed failing files are re-run ONCE, on the same checkout, under the suite
                 // lease. Only a reproduced assertion is charged. A pass, an infra rerun, a rerun naming none of the
@@ -3297,11 +3355,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                     }
                     // Keep one live list: recovery retries must see exclusions added by onGate during the round.
                     const badReviewers = [...replayedReviewerExclusions];
+                    // C (E1): a checkout-proof timeout is the host being slow, not the seat failing — it is excluded for
+                    // the CURRENT round only (so an always-timeout pool still ends the round), never struck task-wide.
+                    let roundTimeouts = [];
                     const noteReviewEvent = (e) => {
                         journal.append(e.name, t.id, e.payload);
                         if (e.name === "review-no-verdict" && typeof e.payload.reviewer === "string") {
-                            if (!badReviewers.includes(e.payload.reviewer))
-                                badReviewers.push(e.payload.reviewer);
+                            const strikes = proofTimeoutNote(e.payload) ? roundTimeouts : badReviewers;
+                            if (!strikes.includes(e.payload.reviewer))
+                                strikes.push(e.payload.reviewer);
                         }
                         // OBS-1196: a seat whose same-subject re-emission delivered a valid verdict was a delivery flake,
                         // not a bad reviewer — it stays seatable for this task's later rounds.
@@ -3337,17 +3399,31 @@ export async function runDaemon(repoRoot, opts = {}) {
                             gateRound: journal.read().filter((row) => row.taskId === task.id
                                 && row.event === "phase-start" && row.data.phase === "gates").length,
                         };
-                        const round = await runGates(task, ctx);
+                        roundTimeouts = [];
+                        // C: every gate-round boundary — a returned or a THROWN round — publishes the one row held behind
+                        // a still-pending sibling and forgets the pending set, before any park or task-failed row lands.
+                        const gateRound = async (subject) => {
+                            try {
+                                return await runGates(subject, { ...ctx, excludeReviewers: [...badReviewers, ...roundTimeouts] });
+                            }
+                            finally {
+                                settleParallelRound();
+                            }
+                        };
+                        const round = await gateRound(task);
                         let review = round.results.find((g) => g.gate === "review");
+                        // The recovery pick carries every preserved author, exactly as reviewGate's own pick does.
+                        const authors = ctx.carriedAuthors?.length ? [...ctx.carriedAuthors] : [channelKey(ctx.author)];
                         while (review?.meta?.noVerdict === true) {
                             // Recovery must honor the gate's floor, including the seats that just failed to
-                            // return a verdict; a below-floor alternative cannot replace the infra result.
-                            const { floor } = gateReviewerFloor(task, ctx.cfg, ctx.author, ctx.channels, [...(ctx.priorReviewers ?? []), ...badReviewers]);
-                            const next = pickReviewer(ctx.author, ctx.channels, badReviewers, cfg.review.prefer ?? [], floor, reviewHistory, undefined, demotedReviewers);
+                            // return a verdict; a below-floor alternative cannot replace the infra result. This round's
+                            // proof timeouts count too — runGates folds every excluded seat into its own floor.
+                            const { floor } = gateReviewerFloor(task, ctx.cfg, ctx.author, ctx.channels, [...(ctx.priorReviewers ?? []), ...badReviewers, ...roundTimeouts]);
+                            const next = pickReviewer(ctx.author, ctx.channels, [...badReviewers, ...roundTimeouts], cfg.review.prefer ?? [], floor, reviewHistory, undefined, demotedReviewers, carriedAuthorVendors(ctx.channels, authors), authors);
                             if (!next)
                                 break;
                             journal.append("review-infra-retry", t.id, { reviewer: channelKey(next), cause: review.meta.cause });
-                            const retried = await runGates({ ...task, gates: ["review"] }, ctx);
+                            const retried = await gateRound({ ...task, gates: ["review"] });
                             const replacement = retried.results.find((g) => g.gate === "review");
                             // A dirty tree or another pre-dispatch refusal must still fail closed.
                             if (!replacement) {
@@ -3374,13 +3450,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 gate: "review", flaked: rr.flaked, retried: rr.retried,
                                 ...(g.meta?.unparseable === true ? { secondUnparseable: true } : {}),
                             });
-                            badReviewers.push(rr.flaked);
+                            // C (E1): a seat re-routed after a checkout-proof timeout is excluded for this round only.
+                            if (!roundTimeouts.includes(rr.flaked))
+                                badReviewers.push(rr.flaked);
                         }
                     };
                     // v1.85 T3 (ruling R4): every BLOCKING review/judge result lands its findings in the journal
                     // structured — class + canonical path + stable symbol — so a retry, a consult or an auto-uphold
                     // decision reads identity instead of re-parsing prose, and line-number churn is not a new finding.
                     // One helper, both onGate sites (satisfied-gate resume + main attempt loop).
+                    // `journaledGates` narrows replayMeasurement to the gates an interrupted round already journaled (C).
                     let gateSubject;
                     const journalGateResult = (g) => {
                         const blocking = g.meta?.infra !== true && gateFailed(g) && (g.gate === "review" || g.gate === "acceptance");
@@ -3416,7 +3495,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             // for the worktree it ran in; absent only for a row that never went through the battery.
                             ...(g.meta?.verification !== undefined ? { verification: g.meta.verification } : {}),
                             ...(gateSubject ? { commit: gateSubject.commit, attempt: gateSubject.attempt } : {}),
-                            ...(gateSubject?.replayMeasurement ? { replayMeasurement: true } : {}),
+                            ...(gateSubject?.replayMeasurement && (gateSubject.journaledGates?.includes(g.gate) ?? true) ? { replayMeasurement: true } : {}),
                             ...(gateSubject?.replayedFromAttempt !== undefined ? { replayedFromAttempt: gateSubject.replayedFromAttempt } : {}),
                             ...(g.meta?.skipped === true || noVerdictReview ? { skipped: true } : {}),
                             // T9: an infra-only exit is journaled AS one. The operator reading a red `test` row has to
@@ -3530,10 +3609,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // ever held, and only while an earlier sibling is still in flight — a review that finishes first
                     // waits for acceptance, never the reverse. That keeps T4's durability where it pays (the first
                     // verdict to land is still published immediately) and bounds the exposure to one row for the
-                    // remainder of one already-running gate. A gate that THROWS kills the round before merge, so a
-                    // row held behind it is lost with the round it belonged to — not a verdict that could have merged.
+                    // remainder of one already-running gate. A gate that THROWS still ends its round: C publishes the
+                    // row held behind it at that boundary (settleParallelRound), so it is never lost or carried over.
                     const parallelPending = new Set();
                     let heldParallel;
+                    const settleParallelRound = () => {
+                        parallelPending.clear();
+                        const held = heldParallel;
+                        heldParallel = undefined;
+                        if (liveEngagement())
+                            held?.();
+                    };
                     const notePhaseStart = (e) => {
                         const active = activeGatePhases.get(t.id) ?? new Set();
                         active.add(e.gate);
@@ -4096,6 +4182,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             journal.append("gate-provisioned", t.id, provisionedRow);
                         const resumedTask = { ...t, gates: remainingGates };
                         const operatorContext = approvalReviewContext(journal.read(), t.id);
+                        let outsideScopeForced = false;
                         gateLoop: while (true) {
                             fatalStop.signal.throwIfAborted();
                             executionSignal()?.throwIfAborted();
@@ -4124,13 +4211,42 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 const own = journal.read().filter((e) => e.taskId === t.id);
                                 return own.slice(own.map((e) => e.event === "phase-start" && e.data.phase === "gates").lastIndexOf(true) + 1);
                             })();
-                            const freshTimeout = !recheck && !satisfiedGate && ((harvestAuthor !== undefined && owesTimeoutRefresh(t, lastRound, gateSubject.commit))
-                                || (lastRound.some((e) => e.event === "gate-fresh-forced" && e.data.commit === gateSubject.commit)
-                                    && !lastRound.some((e) => e.event === "gate-result" && e.data.gate === "test")));
+                            // C: a passing selected-test screen is never a forced round's conclusive test result (the
+                            // journal's own replay rule): its full suite is still owed, fresh, under the round's bypass.
+                            const measured = lastRound.filter((e) => e.event === "gate-result" && !(e.data.gate === "test"
+                                && Array.isArray(e.data.selectedTests) && e.data.fullSuite !== true && e.data.pass !== false));
+                            const forcedUnmeasured = (outside) => lastRound.some((e) => e.event === "gate-fresh-forced"
+                                && e.data.commit === gateSubject.commit && (e.data.reason === OUTSIDE_SCOPE_RED) === outside)
+                                && !measured.some((e) => e.data.gate === "test");
+                            // C: a crash after the forced re-execution journaled its red but before its park still owes that
+                            // park — restored from the journaled subject and result, never re-measured, replayed or repaired.
+                            // Infra adjudication stays authoritative, exactly as it is ahead of the live park.
+                            if (!recheck && !satisfiedGate && lastRound.some((e) => e.event === "gate-fresh-forced"
+                                && e.data.reason === OUTSIDE_SCOPE_RED && e.data.commit === gateSubject.commit)
+                                && allOutsideScopeReds(t, lastRound, gateSubject.commit)) {
+                                const restored = lastRound.filter((e) => e.event === "gate-result" && e.data.gate === "test" && e.data.pass === false)
+                                    .map((e) => ({ gate: "test", pass: false, details: String(e.data.details ?? ""), meta: e.data }));
+                                if (await adjudicateInfraShapedRed(t, restored, wt, gateSubject.commit, rs?.attempts ?? 0, true, (reason) => park(t, reason, "infra", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode)))
+                                    return;
+                                await park(t, outsideScopePark(t), "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                                return;
+                            }
+                            // C: the same out-of-scope re-execution the live loop owes, and a crash inside it still owes it. It
+                            // takes precedence over a timeout refresh: a qualifying red keeps its own bypass and park.
+                            outsideScopeForced = !recheck && !satisfiedGate && ((harvestAuthor !== undefined && owesOutsideScopeRefresh(t, lastRound, gateSubject.commit)) || forcedUnmeasured(true));
+                            const freshTimeout = !recheck && !satisfiedGate && !outsideScopeForced && ((harvestAuthor !== undefined && owesTimeoutRefresh(t, lastRound, gateSubject.commit)) || forcedUnmeasured(false));
+                            // C: a measurement this forced round EXECUTES fresh — its forced test above all — is independent
+                            // evidence, never a replay measurement; only a gate the interrupted round already journaled is.
+                            if (outsideScopeForced) {
+                                gateSubject = { ...gateSubject, journaledGates: measured.map((e) => String(e.data.gate)) };
+                            }
                             journal.phaseStart(t.id, "gates");
                             if (freshTimeout) {
                                 journal.append("gate-fresh-forced", t.id, { gate: "test", attempt: gateSubject.attempt, commit: gateSubject.commit, reason: "no-commit-timeout-red", resumed: true });
                             }
+                            if (outsideScopeForced) {
+                                journal.append("gate-fresh-forced", t.id, { gate: "test", attempt: gateSubject.attempt, commit: gateSubject.commit, reason: OUTSIDE_SCOPE_RED, resumed: true });
+                            }
                             const { results } = await withCommandContext(t.id, async () => runReviewRecovery(resumedTask, {
                                 carriedAuthors: await subjectAuthors(journal.read(), t.id, wt, taskBase),
                                 producer: producerNow(),
@@ -4155,7 +4271,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // flaking seat is re-asked on every task.
                                 reviewNoVerdicts,
                                 recheck, // OBS-1055: a recheck discards cached reds — the battery re-measures what the operator questioned
-                                cachedRedBypass: freshTimeout ? "timeout-fresh" : undefined,
+                                cachedRedBypass: freshTimeout ? "timeout-fresh" : outsideScopeForced ? "out-of-scope-fresh" : undefined,
                                 onGate: async (e) => {
                                     if (!liveEngagement())
                                         return;
@@ -4220,6 +4336,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // assignment back with it.
                                 if (await adjudicateInfraShapedRed(t, results, wt, gateSubject.commit, rs?.attempts ?? 0, false, (reason) => park(t, reason, "infra", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode)))
                                     return;
+                                if (outsideScopeForced && freshOutsideScopeRed(t, gateSubject.commit)) {
+                                    await park(t, outsideScopePark(t), "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                                    return;
+                                }
                                 const classified = journal.classifiedDispatch(t.id);
                                 if (await dispositionScopeRed(t, results, classified?.assignment ?? gateAuthor, classified ? (rs?.attempts ?? 0) : Math.max(0, (rs?.attempts ?? 0) - 1), startMs, gateFails, consults, tokens, metered, retryMode, await treeOrDiffPaths(taskBase, wt)))
                                     return;
@@ -6246,6 +6366,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         };
                         let results = [];
                         let commits = [];
+                        let outsideScopeForced = false;
                         gateLoop: while (true) {
                             fatalStop.signal.throwIfAborted();
                             executionSignal()?.throwIfAborted();
@@ -6261,12 +6382,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 && e.data.attempt === attempt - 1);
                             const previousRows = retryMode === "repair" ? lastRoundRows : [];
                             // OBS-1106 residual: see owesTimeoutRefresh — the replay below and the verdict cache are both refused.
-                            const freshTimeout = !explicitlyFundedAttempt && owesTimeoutRefresh(t, lastRoundRows, gateSubject.commit);
+                            // C: an unchanged red wholly outside files[] is re-executed once instead of copied (journal or cache);
+                            // it outranks the timeout refresh, so a timeout-shaped qualifying red keeps its own bypass and park.
+                            outsideScopeForced = !explicitlyFundedAttempt && owesOutsideScopeRefresh(t, lastRoundRows, gateSubject.commit);
+                            const freshTimeout = !explicitlyFundedAttempt && !outsideScopeForced && owesTimeoutRefresh(t, lastRoundRows, gateSubject.commit);
                             journal.phaseStart(t.id, "gates");
                             if (freshTimeout) {
                                 journal.append("gate-fresh-forced", t.id, { gate: "test", attempt, priorAttempt: attempt - 1, commit: gateSubject.commit, reason: "no-commit-timeout-red" });
                             }
-                            const replay = !explicitlyFundedAttempt && !freshTimeout && previousRows.length > 0
+                            if (outsideScopeForced) {
+                                journal.append("gate-fresh-forced", t.id, { gate: "test", attempt, priorAttempt: attempt - 1, commit: gateSubject.commit, reason: OUTSIDE_SCOPE_RED });
+                            }
+                            const replay = !explicitlyFundedAttempt && !freshTimeout && !outsideScopeForced && previousRows.length > 0
                                 && previousRows.every((e) => e.data.commit === gateSubject.commit)
                                 && previousRows.some((e) => e.data.pass === false && e.data.skipped !== true);
                             if (replay) {
@@ -6299,7 +6426,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     commands, baseline, channels: pools.review, judgeChannels: pools.judge, health, adapters, cfg, artifactDir: journal.dir,
                                     collateral: collateral.get(t.id) ?? [],
                                     selectTests: !testGateFailed,
-                                    cachedRedBypass: explicitlyFundedAttempt ? "operator-rerun" : freshTimeout ? "timeout-fresh" : undefined,
+                                    cachedRedBypass: explicitlyFundedAttempt ? "operator-rerun" : freshTimeout ? "timeout-fresh" : outsideScopeForced ? "out-of-scope-fresh" : undefined,
                                     via: cfg.visibility.llm === "pane"
                                         ? {
                                             driver: trackedDriver,
@@ -6408,6 +6535,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         if (await adjudicateInfraShapedRed(t, results, wt, gateSubject.commit, attempt, gateSubject.replayedFromAttempt !== undefined, (reason) => park(t, reason, "infra", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode)))
                             return;
+                        if (outsideScopeForced && freshOutsideScopeRed(t, gateSubject.commit)) {
+                            await park(t, outsideScopePark(t), "gate-fail", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
+                            return;
+                        }
                         // OBS-547: who pays for this red is decided by the run's collateral prediction (see
                         // dispositionScopeRed) — an authoring defect parks unchargeable before any accounting below.
                         if (await dispositionScopeRed(t, results, assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode, await treeOrDiffPaths(taskBase, wt)))

package/dist/run/git.js

@@ -9,6 +9,7 @@ import { StringDecoder } from "node:string_decoder";
 import { shq } from "../adapters/types.js";
 import { tickmarkrDir } from "../graph/graph.js";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
+import { titleEnvironment } from "./title-environment.js";
 export { ROUTING_ENV_SEAMS };
 // OBS-110: gate/baseline/tip-verify children are vitest suites; without a fork cap, concurrent
 // full-suite gate runs fork a worker-per-core pool per worktree and saturate the operator box.
@@ -324,6 +325,14 @@ function executeShell(cmd, cwd, timeoutMs, login, options, observation) {
     // OBS-854: descendants can leave the checkout (nested fixture suites do), so cwd alone cannot
     // attribute them. Every daemon shell exports the daemon pid as their durable parentage marker.
     env[SUITE_PARENT_ENV] = String(process.pid);
+    // A2: on Darwin a Node child's title writes stay in JavaScript (title-environment.ts); runnerInputsHash
+    // hashes this same effective NODE_OPTIONS, so a verdict is only reused under the identical mode. Native
+    // mode is applied too: it drops a preload a nested shell inherited from its parent (unset when that was all).
+    const { nodeOptions } = titleEnvironment(env);
+    if (nodeOptions === undefined)
+        delete env.NODE_OPTIONS;
+    else
+        env.NODE_OPTIONS = nodeOptions;
     // T7: the capacity every result of this shell carries, read HERE — off the environment the child
     // is about to receive, after the precedence above has settled. An operator export is already in
     // `env`, so what gets recorded is the operator's number, which is the case a release was re-taken

package/dist/run/journal.d.ts

@@ -650,7 +650,9 @@ export declare const rangePatch: (cwd: string, base: string, head: string) => st
  * these and is refused as ambiguous; containment never counts.
  * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
  */
-export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown): boolean;
+export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown, memo?: OwedProofMemo): boolean;
+/** I2: a caller-scoped set of completed integration re-proofs (see integrationMapped); absent, every fold re-proves. */
+export type OwedProofMemo = Set<string>;
 /**
  * Lifetime patch authors of base..head, read from the run: the daemon's subjectAuthors fold
  * (daemon.ts, not exported and not this task's to edit) restated synchronously so the waive row is
@@ -687,6 +689,8 @@ export type ChannelFact = {
  * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
  * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
  * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ * `memo` (I2, optional): a store-scoped table reusing the immutable git re-proof of an integration mapping
+ * across folds; every artifact, hash, criteria and reviewer condition is still re-read on every fold.
  */
-export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string): OwedFold;
+export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string, memo?: OwedProofMemo): OwedFold;
 export {};

package/dist/run/journal.js

@@ -2425,11 +2425,24 @@ const COMMIT_ID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
  * these and is refused as ambiguous; containment never counts.
  * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
  */
-export function integrationMapped(cwd, events, o, mergeBase, head) {
+export function integrationMapped(cwd, events, o, mergeBase, head, memo) {
     if (typeof mergeBase !== "string" || typeof head !== "string" || !COMMIT_ID.test(mergeBase) || !COMMIT_ID.test(head))
         return false;
     if (!events.some((e) => e.event === "merge" && e.taskId === o.taskId && e.data.commit === head))
         return false;
+    // Only the git component is memoised, and only a completed proof: commit ids name immutable history,
+    // so the key is the obligation's id and recorded range facts plus the claimed mergeBase..head. A refusal
+    // or git failure (a shallow or partial object store can refuse a range it later proves) is never cached
+    // and is re-proved next fold. The merge-row eligibility above is rechecked on every fold.
+    const key = JSON.stringify([o.id, mergeBase, head, o.base, o.head, o.patch, o.patches]);
+    if (memo?.has(key))
+        return true;
+    const proved = integrationProved(cwd, o, mergeBase, head);
+    if (proved)
+        memo?.add(key);
+    return proved;
+}
+function integrationProved(cwd, o, mergeBase, head) {
     try {
         const parents = owedGit(cwd, ["show", "-s", "--format=%P", head]).trim().split(" ");
         if (parents.length !== 2 || parents[0] !== mergeBase)
@@ -2609,7 +2622,7 @@ const declaredVendors = (o) => {
     return vendors;
 };
 /** Why a discharge row no longer proves its obligation, re-read from its artifact; undefined when it does. */
-function dischargeProblem(row, o, events, cwd) {
+function dischargeProblem(row, o, events, cwd, memo) {
     const d = row.data;
     if (row.taskId !== o.taskId)
         return "discharge names another task";
@@ -2617,7 +2630,7 @@ function dischargeProblem(row, o, events, cwd) {
         return "discharge proved other criteria";
     const exact = d.mapping === "exact" && d.mergeBase === o.base && d.head === o.head;
     // The integration mapping is re-proved from git on every fold, never taken from the row's claims.
-    const integration = d.mapping === "integration" && integrationMapped(cwd, events, o, d.mergeBase, d.head);
+    const integration = d.mapping === "integration" && integrationMapped(cwd, events, o, d.mergeBase, d.head, memo);
     if (!exact && !integration)
         return "discharge range does not bind the obligation";
     let artifact;
@@ -2675,16 +2688,18 @@ function dischargeProblem(row, o, events, cwd) {
  * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
  * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
  * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ * `memo` (I2, optional): a store-scoped table reusing the immutable git re-proof of an integration mapping
+ * across folds; every artifact, hash, criteria and reviewer condition is still re-read on every fold.
  */
-export function foldOwedChecks(events, cwd) {
+export function foldOwedChecks(events, cwd, memo) {
     try {
-        return foldOwedChecksOrThrow(events, cwd);
+        return foldOwedChecksOrThrow(events, cwd, memo);
     }
     catch (error) {
         return { known: false, debt: "unknown", outstanding: [], acceptedRisk: [], discharged: [], unknown: [{ reason: `owed-check fold failed: ${String(error).split("\n")[0]}` }] };
     }
 }
-function foldOwedChecksOrThrow(events, cwd) {
+function foldOwedChecksOrThrow(events, cwd, memo) {
     const accepted = new Map();
     const discharged = new Set();
     const unknown = [];
@@ -2703,7 +2718,7 @@ function foldOwedChecksOrThrow(events, cwd) {
             const ids = Array.isArray(e.data.ids) ? e.data.ids : [];
             const problems = ids.map((id) => {
                 const o = accepted.get(String(id));
-                return o ? dischargeProblem(e, o, events, cwd) : "discharge names no recorded obligation";
+                return o ? dischargeProblem(e, o, events, cwd, memo) : "discharge names no recorded obligation";
             });
             const problem = ids.length ? problems.find((p) => p !== undefined) : "discharge names no obligation";
             if (problem)

package/dist/run/launchservices-check.d.ts

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import type { AuthHealth, LaunchServicesRecord } from "../adapters/types.js";
+/**
+ * v2.6.5 T10 (A1, D-787/D-789): did launchservicesd restart since tickmarkr last looked?
+ *
+ * On 2026-09-30 a heavy local suite exhausted launchservicesd's Mach port space (0x1000600b); the daemon
+ * crashed, respawned with an empty app registry, and every GUI app launched before it read "not open
+ * anymore". The tell is the daemon's own identity: a young pid/start beside an old Dock and Finder.
+ * doctor and standalone verify read that identity with one bounded /bin/ps call, compare it with the
+ * one the FIRST doctor.json record holds (registry order — no new state file or adapter row), and
+ * persist one advisory on a change. Unreadable evidence is unknown: the prior identity is kept, never
+ * replaced by a guess. Advisory only — verdicts, retries and routing never read it.
+ */
+export declare const LAUNCHSERVICES_PROBE_CEILING_MS = 5000;
+export interface LaunchServicesIdentity {
+    pid: number;
+    start: string;
+}
+export type LaunchServicesObservation = {
+    status: "non-darwin";
+} | {
+    status: "read";
+    identity: LaunchServicesIdentity;
+} | {
+    status: "unreadable";
+    detail: string;
+};
+/** The closed identity table; "first" is the baseline row when no prior identity is held. */
+export type LaunchServicesStatus = "first" | "unchanged" | "changed-pid" | "changed-start" | "unreadable" | "non-darwin" | "skipped";
+/** Exactly one launchservicesd row, or null (absent, ambiguous or malformed output is unknown). */
+export declare function parsePsIdentity(stdout: string): LaunchServicesIdentity | null;
+export type ProbeTimer = (fire: () => void, ms: number) => () => void;
+interface ProbeSeam {
+    platform: NodeJS.Platform;
+    spawn: typeof spawn;
+    setTimer: ProbeTimer;
+    signal?: AbortSignal;
+}
+export declare const setLaunchServicesProbeForTests: (s: Partial<ProbeSeam>) => void;
+export declare const resetLaunchServicesProbeForTests: () => void;
+export declare function observeLaunchServices(s?: ProbeSeam): Promise<LaunchServicesObservation>;
+export declare function launchServicesAdvisory(prior: LaunchServicesIdentity, now: LaunchServicesIdentity): string;
+/** Pure: the table row for one observation against the held record, and the record to hold next. */
+export declare function classifyLaunchServices(prior: Partial<LaunchServicesRecord> | undefined, observed: LaunchServicesObservation): {
+    status: LaunchServicesStatus;
+    next?: LaunchServicesRecord;
+    line?: string;
+};
+/** Observe, classify against the first record of `prior`, and hold the result on the first record of `health`.
+ *  Returns `health` itself when nothing changed, else a copy — the argument is never mutated. */
+export declare function recordLaunchServices(prior: Record<string, AuthHealth> | null, health: Record<string, AuthHealth>): Promise<{
+    status: LaunchServicesStatus;
+    health: Record<string, AuthHealth>;
+    line?: string;
+}>;
+export {};

package/dist/run/launchservices-check.js

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+/**
+ * v2.6.5 T10 (A1, D-787/D-789): did launchservicesd restart since tickmarkr last looked?
+ *
+ * On 2026-09-30 a heavy local suite exhausted launchservicesd's Mach port space (0x1000600b); the daemon
+ * crashed, respawned with an empty app registry, and every GUI app launched before it read "not open
+ * anymore". The tell is the daemon's own identity: a young pid/start beside an old Dock and Finder.
+ * doctor and standalone verify read that identity with one bounded /bin/ps call, compare it with the
+ * one the FIRST doctor.json record holds (registry order — no new state file or adapter row), and
+ * persist one advisory on a change. Unreadable evidence is unknown: the prior identity is kept, never
+ * replaced by a guess. Advisory only — verdicts, retries and routing never read it.
+ */
+export const LAUNCHSERVICES_PROBE_CEILING_MS = 5_000;
+// lstart in the C locale: "Wed Sep 30 21:54:33 2026"; comm is the executable path on Darwin.
+const PS_ARGS = ["-A", "-o", "pid=,lstart=,comm="];
+const PS_LINE = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(.+?)\s*$/;
+const MAX_PS_BYTES = 4 * 1024 * 1024;
+/** Exactly one launchservicesd row, or null (absent, ambiguous or malformed output is unknown). */
+export function parsePsIdentity(stdout) {
+    const rows = stdout.split("\n").flatMap((line) => {
+        const m = PS_LINE.exec(line);
+        return m && basename(m[3]) === "launchservicesd" ? [{ pid: Number(m[1]), start: m[2].replace(/\s+/g, " ") }] : [];
+    });
+    return rows.length === 1 ? rows[0] : null;
+}
+const production = () => ({
+    platform: process.platform,
+    spawn,
+    setTimer: (fire, ms) => { const t = setTimeout(fire, ms); return () => clearTimeout(t); },
+});
+// ponytail: default-off under the test runner (the catalogRefreshAllowed precedent) so an unowned doctor
+// test never takes a real host reading or changes its doctor.json bytes; tests opt in through the seam.
+let seam;
+export const setLaunchServicesProbeForTests = (s) => { seam = { ...production(), ...s }; };
+export const resetLaunchServicesProbeForTests = () => { seam = undefined; };
+const activeSeam = () => seam ?? (process.env.VITEST === "true" ? undefined : production());
+/** One /bin/ps call that owns only its child, killed at the ceiling or on cancellation and reaped before it resolves. */
+function readIdentity(s) {
+    return new Promise((resolve) => {
+        const unknown = (detail) => resolve({ status: "unreadable", detail });
+        if (s.signal?.aborted) {
+            unknown("probe cancelled");
+            return;
+        }
+        let child;
+        try {
+            child = s.spawn("/bin/ps", PS_ARGS, { stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, LC_ALL: "C" } });
+        }
+        catch (e) {
+            unknown(`/bin/ps did not start (${e instanceof Error ? e.message : String(e)})`);
+            return;
+        }
+        let out = "";
+        let why;
+        const retire = (reason) => { why ??= reason; child.kill("SIGKILL"); };
+        const clear = s.setTimer(() => retire(`/bin/ps exceeded the ${LAUNCHSERVICES_PROBE_CEILING_MS} ms kill ceiling`), LAUNCHSERVICES_PROBE_CEILING_MS);
+        const cancel = () => retire("probe cancelled");
+        s.signal?.addEventListener("abort", cancel, { once: true });
+        child.stdout?.on("data", (chunk) => {
+            out += chunk.toString("utf8");
+            if (out.length > MAX_PS_BYTES)
+                retire("/bin/ps output exceeded its bound");
+        });
+        child.once("error", (e) => { why ??= `/bin/ps failed (${e.message})`; });
+        child.once("close", (code) => {
+            clear();
+            s.signal?.removeEventListener("abort", cancel);
+            if (why)
+                return unknown(why);
+            if (code !== 0)
+                return unknown(`/bin/ps exited ${code}`);
+            const identity = parsePsIdentity(out);
+            return identity ? resolve({ status: "read", identity }) : unknown("no single launchservicesd row in /bin/ps output");
+        });
+    });
+}
+export function observeLaunchServices(s = production()) {
+    return s.platform === "darwin" ? readIdentity(s) : Promise.resolve({ status: "non-darwin" });
+}
+// doctor.json is never schema-validated: a malformed held record is no identity at all.
+const knownPrior = (prior) => typeof prior?.pid === "number" && typeof prior.start === "string";
+export function launchServicesAdvisory(prior, now) {
+    return `launchservicesd restarted: pid ${prior.pid} → ${now.pid}, started ${prior.start} → ${now.start}. `
+        + `GUI apps launched before ${now.start} may read "not open anymore" (D-787: the daemon crashed and respawned with an empty app registry). `
+        + `Remedy: quit and relaunch each affected app, or log out / restart the Mac (a restart ends agent sessions and wipes /private/tmp); `
+        + `confirm with /usr/bin/log show (launchservicesd 0x1000600b near ${now.start}) and ~/Library/Logs/DiagnosticReports/ExcUserFault_node-*.ips (advisory — verdicts unchanged)`;
+}
+/** Pure: the table row for one observation against the held record, and the record to hold next. */
+export function classifyLaunchServices(prior, observed) {
+    const kept = knownPrior(prior) ? prior : undefined;
+    if (observed.status === "non-darwin")
+        return { status: "non-darwin", next: kept };
+    if (observed.status === "unreadable") {
+        const held = kept ? `pid ${kept.pid} started ${kept.start}` : "none";
+        return { status: "unreadable", next: kept, line: `launchservicesd identity unknown — ${observed.detail}; prior identity (${held}) retained (advisory — verdicts unchanged)` };
+    }
+    const now = observed.identity;
+    if (!knownPrior(prior))
+        return { status: "first", next: now };
+    const status = prior.pid !== now.pid ? "changed-pid" : prior.start !== now.start ? "changed-start" : "unchanged";
+    if (status === "unchanged")
+        return { status, next: prior };
+    const advisory = launchServicesAdvisory(prior, now);
+    return { status, next: { ...now, advisory }, line: advisory };
+}
+/** Observe, classify against the first record of `prior`, and hold the result on the first record of `health`.
+ *  Returns `health` itself when nothing changed, else a copy — the argument is never mutated. */
+export async function recordLaunchServices(prior, health) {
+    const held = prior ? Object.values(prior)[0]?.launchServices : undefined;
+    const s = activeSeam();
+    const r = s ? classifyLaunchServices(held, await observeLaunchServices(s)) : { status: "skipped", next: knownPrior(held) ? held : undefined };
+    const holder = Object.keys(health)[0];
+    if (!holder || !r.next || JSON.stringify(health[holder].launchServices) === JSON.stringify(r.next))
+        return { ...r, health };
+    return { ...r, health: { ...health, [holder]: { ...health[holder], launchServices: r.next } } };
+}