tickmarkr 2.8.6 → 2.8.8

package/dist/gates/acceptance.js

@@ -249,18 +249,18 @@ function oracleExecutionFailure(label, code, stdout, stderr) {
     const zeroRun = testsRan(output) === 0 && classification !== "regression";
     const zeroRunEvidence = zeroRun ? "the runner reported zero tests run and no failure identity; " : "";
     if (classification === "infra" || signalKilled || zeroRun) {
-        return {
+        return { failure: "unverified", output, result: {
+                gate: "acceptance",
+                pass: false,
+                details: `oracle failed: ${label} (exit ${code}) — ${signalEvidence || zeroRunEvidence}infrastructure blocked execution before a verdict; this oracle verified nothing${tail(output)}`,
+                meta: { cause: "oracle-execution", classification: "infra", infra: true, retryable: false },
+            } };
+    }
+    return { failure: "red", output, result: {
             gate: "acceptance",
             pass: false,
-            details: `oracle failed: ${label} (exit ${code}) — ${signalEvidence || zeroRunEvidence}infrastructure blocked execution before a verdict; this oracle verified nothing${tail(output)}`,
-            meta: { cause: "oracle-execution", classification: "infra", infra: true, retryable: false },
-        };
-    }
-    return {
-        gate: "acceptance",
-        pass: false,
-        details: `oracle failed: ${label} (exit ${code})${tail(stderr || stdout)}`,
-    };
+            details: `oracle failed: ${label} (exit ${code})${tail(stderr || stdout)}`,
+        } };
 }
 // today's rule for a test oracle's run: exit 0 AND a positive printed run count (OBS-55: a zero-match run is vacuous).
 function countedTestRun(label, filter, r) {
@@ -269,8 +269,8 @@ function countedTestRun(label, filter, r) {
     const out = (r.stderr || "") + "\n" + (r.stdout || "");
     const ran = testsRan(out);
     if (ran === null || ran < 1) {
-        return { gate: "acceptance", pass: false,
-            details: `oracle failed: ${label} — name filter matched zero tests (filter: ${filter})${tail(out)}` };
+        return { failure: "untitled", output: out, result: { gate: "acceptance", pass: false,
+                details: `oracle failed: ${label} — name filter matched zero tests (filter: ${filter})${tail(out)}` } };
     }
     return undefined;
 }
@@ -290,11 +290,11 @@ function countedTestRun(label, filter, r) {
  */
 async function landedTestOracle(testCmd, title, landing, worktree) {
     const label = `test "${title}" in ${landing}`;
-    const passed = { gate: "acceptance", pass: true, details: `✓ test: ${title} (exit 0) in ${landing}` };
-    const work = (why) => ({ gate: "acceptance", pass: false, details: `oracle failed: ${label} — ${why}` });
-    const unverified = (why) => ({ gate: "acceptance", pass: false,
-        details: `oracle failed: ${label} — ${why}; unverified, failing closed`,
-        meta: { cause: "oracle-execution", classification: "infra", infra: true, retryable: false } });
+    const passed = { output: "", result: { gate: "acceptance", pass: true, details: `✓ test: ${title} (exit 0) in ${landing}` } };
+    const work = (failure, why, output = "") => ({ failure, output, result: { gate: "acceptance", pass: false, details: `oracle failed: ${label} — ${why}` } });
+    const unverified = (why, output = "") => ({ failure: "unverified", output, result: { gate: "acceptance", pass: false,
+            details: `oracle failed: ${label} — ${why}; unverified, failing closed`,
+            meta: { cause: "oracle-execution", classification: "infra", infra: true, retryable: false } } });
     const path = resolve(worktree, landing);
     const within = relative(worktree, path);
     let regular = false;
@@ -303,7 +303,7 @@ async function landedTestOracle(testCmd, title, landing, worktree) {
     }
     catch { /* absent */ }
     if (!regular)
-        return work(`suite file ${landing} is absent from the worktree or is not a regular file; the test command never started`);
+        return work("absent", `suite file ${landing} is absent from the worktree or is not a regular file; the test command never started`);
     if (!isVitestTestCommand(testCmd, worktree)) {
         return countedTestRun(label, title, await sh(fileFiltered(npmForwarded(testCmd), landing, title), worktree)) ?? passed;
     }
@@ -326,17 +326,18 @@ async function landedTestOracle(testCmd, title, landing, worktree) {
         const r = await shell(`${cmd} --reporter=${shq(reporterPath)} --outputFile=${shq(reportPath)}`, worktree, DEFAULT_SHELL_TIMEOUT_MS, false, { env: { ...manifestChildEnv(worktree), TICKMARKR_TEST_REPORT: reportPath, TICKMARKR_TEST_NONCE: nonce } });
         const raw = readTestReport(reportPath);
         const report = raw?.nonce === nonce ? raw : undefined;
+        const output = [r.stderr, r.stdout].filter(Boolean).join("\n");
         if (r.code !== 0) {
             // the reporter replaces the runner's own output: its failure identities are the evidence of a red.
             const named = report ? [...Object.values(report.completed).flatMap((c) => c.failures ?? []), ...(report.certificate?.diagnostics ?? [])] : [];
             return oracleExecutionFailure(label, r.code, r.stdout, [r.stderr, ...named].filter(Boolean).join("\n"));
         }
         if (!raw)
-            return unverified("the runner exited 0 but wrote no per-file report");
+            return unverified("the runner exited 0 but wrote no per-file report", output);
         if (!report)
-            return unverified(`the per-file report carries nonce "${raw.nonce}", not this invocation's`);
+            return unverified(`the per-file report carries nonce "${raw.nonce}", not this invocation's`, output);
         if (report.certificate?.exitCode !== 0)
-            return unverified("the per-file report never reached its run-end certificate with exit 0");
+            return unverified("the per-file report never reached its run-end certificate with exit 0", output);
         const key = toManifestPath(within, worktree);
         // a module completed more than once (one path in several projects) keeps only its LAST counters, so its record
         // cannot show that no earlier completion ran a body: it counts as run.
@@ -346,9 +347,9 @@ async function landedTestOracle(testCmd, title, landing, worktree) {
             return file !== key && (repeated.has(file) || !t || t.passed + t.failed > 0);
         }).sort();
         if (elsewhere.length)
-            return work(`the runner's per-file report shows a test body run outside ${landing}, in ${elsewhere.join(", ")} — only ${landing} can satisfy this criterion`);
+            return work("elsewhere", `the runner's per-file report shows a test body run outside ${landing}, in ${elsewhere.join(", ")} — only ${landing} can satisfy this criterion`, output);
         if (!((report.completed[key]?.tests?.passed ?? 0) > 0))
-            return work(`the runner's per-file report shows no passing test of that title in ${landing}`);
+            return work("untitled", `the runner's per-file report shows no passing test of that title in ${landing}`, output);
         return passed;
     }
     finally {
@@ -456,38 +457,54 @@ function citesChangedLocation(evidence, changed) {
 export async function acceptanceGate(task, worktree, baseRef, 
 // OBS-1182: the judge seat's OWN effort (absent = CLI default) — never the worker's.
 judge, via, opts = {}) {
-    // 1. deterministic oracles — exit code decides, fail-closed, zero LLM calls (spec §2, T2).
-    //    A failure returns here, before any runLlm() call: a judge can never override it.
+    // Queue row 234(b) (D-2134): measure every deterministic oracle in declaration order before judging.
     const passedDet = [];
-    for (const a of task.acceptance) {
+    const failures = [];
+    const record = (index, a, run) => {
+        if (run.result.pass)
+            passedDet.push(run.result.details);
+        else
+            failures.push({ run, oracle: {
+                    index, kind: a.oracle, criterion: isCommand(a) ? a.command : a.test,
+                    ...(isTest(a) && a.landing !== undefined ? { landing: a.landing } : {}),
+                    failure: run.failure, output: run.output,
+                } });
+    };
+    for (const [index, a] of task.acceptance.entries()) {
         if (isCommand(a)) {
             const r = await sh(a.command, worktree);
             if (r.code !== 0) {
-                return oracleExecutionFailure(`$ ${a.command}`, r.code, r.stdout, r.stderr);
+                record(index, a, oracleExecutionFailure(`$ ${a.command}`, r.code, r.stdout, r.stderr));
             }
-            passedDet.push(`✓ $ ${a.command} (exit 0)`);
+            else
+                passedDet.push(`✓ $ ${a.command} (exit 0)`);
         }
         else if (isTest(a)) {
             if (!opts.testCmd) {
-                return { gate: "acceptance", pass: false,
-                    details: `oracle failed: test "${a.test}" — no test command configured to run it (failing closed)` };
+                record(index, a, { failure: "no-runner", output: "", result: { gate: "acceptance", pass: false,
+                        details: `oracle failed: test "${a.test}" — no test command configured to run it (failing closed)` } });
+                continue;
             }
             // queue row 179: a declared suite file is the only file that can satisfy its criterion.
             if (a.landing !== undefined) {
-                const landed = await landedTestOracle(opts.testCmd, a.test, a.landing, worktree);
-                if (!landed.pass)
-                    return landed;
-                passedDet.push(landed.details);
+                record(index, a, await landedTestOracle(opts.testCmd, a.test, a.landing, worktree));
                 continue;
             }
             // OBS-55: exit 0 alone is vacuous when the name filter matched zero tests — fail closed.
             const red = countedTestRun(`test "${a.test}"`, a.test, await sh(testFiltered(opts.testCmd, a.test), worktree));
             if (red)
-                return red;
-            passedDet.push(`✓ test: ${a.test} (exit 0)`);
+                record(index, a, red);
+            else
+                passedDet.push(`✓ test: ${a.test} (exit 0)`);
         }
     }
-    // 2. judge items — only after every deterministic oracle passed (a failed one returned above).
+    if (failures.length) {
+        const first = failures[0].run.result;
+        const infra = failures.find(({ run }) => run.result.meta?.infra === true)?.run.result.meta;
+        return { ...first, details: failures.map(({ run }) => run.result.details).join("\n"),
+            meta: { ...first.meta, ...infra, oracles: failures.map(({ oracle }) => oracle) } };
+    }
+    // Queue row 234(b) (D-2134): only an entirely green deterministic round reaches the judge.
     const judgeItems = task.acceptance.filter(isJudge);
     const detBlock = passedDet.length ? passedDet.join("\n") + "\n" : "";
     if (!judgeItems.length) {

package/dist/gates/baseline.js

@@ -428,11 +428,30 @@ export function classifyFailureOutput(output) {
 // and `stderr | <task id>` (digits and underscores) when the reporter no longer knows the task
 // (dist/chunks/index.*.js, `headerText`). The stripper knew only the first form.
 const VITEST_ECHO_BLOCK_RE = /^\s*std(?:out|err)\s+\|\s+(?:unknown test\s*$|\d+_[\d_]+\s*$|\S+\.(?:test|spec)\.[cm]?[jt]sx?(?:\s*$|\s+>\s+\S))/;
-/** Keep runner output while omitting Vitest's echoed test-owned stdout/stderr diagnostic blocks. */
+// Queue row 211 (D-2118): only Jest's complete, column-zero recovery warning is noise. A missing
+// neighbour, changed hint, indented copy or multi-line Watchman error remains failure evidence.
+const JEST_WATCHMAN_HEADER = "jest-haste-map: Watchman crawl failed. Retrying once with node crawler.";
+const JEST_WATCHMAN_HINT = "  Usually this happens when watchman isn't running. Create an empty `.watchmanconfig` file in your project's root folder or initialize a git or hg repository in your project.";
+const JEST_WATCHMAN_ERROR_RE = /^ {2}Error: Watchman error: [^\r\n]+\. Make sure watchman is running for this project\. See https:\/\/facebook\.github\.io\/watchman\/docs\/troubleshooting\.$/;
+/** Queue row 211 (D-2118): display readers retain raw Vitest echo lines while dropping this warning. */
+const withoutJestWatchmanBlocks = (output) => {
+    const kept = [];
+    const lines = output.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === JEST_WATCHMAN_HEADER && lines[i + 1] === JEST_WATCHMAN_HINT && JEST_WATCHMAN_ERROR_RE.test(lines[i + 2] ?? "")) {
+            i += 2;
+            continue;
+        }
+        kept.push(line);
+    }
+    return kept;
+};
+/** Queue row 211 (D-2118): omit the recovered Jest warning alongside Vitest's test-owned echo blocks. */
 const withoutVitestEchoBlocks = (output) => {
     const outside = [];
     let inVitestEchoBlock = false;
-    for (const line of output.split("\n")) {
+    for (const line of withoutJestWatchmanBlocks(output)) {
         const clean = line.replace(ANSI_RE, "");
         const runnerLine = stripTurboPrefix(clean) ?? clean;
         if (inVitestEchoBlock) {
@@ -625,8 +644,7 @@ function fingerprintOccurrences(output) {
 }
 // The diagnostic channel for a runner we cannot read: raw output lines, never fingerprints, never a
 // verdict. They exist so the operator sees SOMETHING when a green command turns red unrecognizably.
-const unrecognizedEvidence = (raw) => raw
-    .split("\n")
+const unrecognizedEvidence = (raw) => withoutJestWatchmanBlocks(raw)
     .map((l) => l.replace(ANSI_RE, "").trimEnd())
     .filter((l) => VOCAB_RE.test(l))
     .slice(0, 10)
@@ -1028,11 +1046,33 @@ export async function detectVacuousOracles(cwd, tasks) {
 // drop a FAIL line that fingerprint-collides with baseline noise). No headline anchors → byte-identical
 // fallback to today's text (non-vitest runners lose nothing). RED-pinned by tests/gates/baseline.test.ts
 // "HYG-08: details headlines the failing test, not the noise".
+// Queue row 224(a) (D-2118): Jest identities and their first message are display-only; Console and
+// column-zero validation bullets are not identities. Keep the existing metadata extraction separate.
+const JEST_IDENTITY_RE = /^ {2}● (?!Console\s*$)\S.*$/;
 function headlineDetails(raw, fresh, freshLines) {
-    const headlines = raw
+    const namedHeadlines = raw
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
         .filter((l) => namesFailureEitherForm(l) || SUMMARY_FAIL_RE.test(l));
+    const outputLines = withoutJestWatchmanBlocks(raw).map((l) => l.replace(ANSI_RE, ""));
+    let inVitestEchoBlock = false;
+    const headlines = outputLines.flatMap((line, index) => {
+        const runnerLine = stripTurboPrefix(line) ?? line;
+        const echoed = inVitestEchoBlock || VITEST_ECHO_BLOCK_RE.test(runnerLine);
+        if (inVitestEchoBlock) {
+            if (runnerLine.trim() === "")
+                inVitestEchoBlock = false;
+        }
+        else if (echoed)
+            inVitestEchoBlock = true;
+        // Queue row 224(a) (D-2118): preserve raw FAIL/summary headlines; only Jest identities exclude echoes.
+        if (namesFailureEitherForm(line) || SUMMARY_FAIL_RE.test(line))
+            return [line];
+        if (echoed || !JEST_IDENTITY_RE.test(line))
+            return [];
+        const message = withoutVitestEchoBlocks(outputLines.slice(index + 1).join("\n")).find((l) => l.trim() !== "");
+        return message === undefined ? [line] : [line, message];
+    });
     // S22: the ORIGINAL runner lines behind v2 comparison keys are the diagnostic; the keys are secondary.
     // A legacy entry's lines ARE its keys, so its details stay byte-identical.
     const lines = [...new Set(freshLines)].join("\n");
@@ -1042,7 +1082,7 @@ function headlineDetails(raw, fresh, freshLines) {
         return { details: same ? `new failures vs baseline:\n${lines}` : `new failures vs baseline:\n${lines}\n\n${keys}` };
     return {
         details: `failing tests:\n${headlines.join("\n")}\n\n${same ? "" : `new failure lines vs baseline:\n${lines}\n\n`}${keys}`,
-        meta: { failingTests: headlines.filter(namesFailureEitherForm) },
+        ...(namedHeadlines.length ? { meta: { failingTests: namedHeadlines.filter(namesFailureEitherForm) } } : {}),
     };
 }
 export async function compareToBaseline(cwd, commands, baseline, enabled, opts = {}) {
@@ -1225,7 +1265,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         if (classification === "infra") {
             const evidence = failingLines.length
                 ? failingLines.slice(0, 10).join("\n")
-                : unrecognizedEvidence(raw) || raw.trim().split("\n").slice(0, 10).join("\n");
+                : unrecognizedEvidence(raw) || withoutJestWatchmanBlocks(raw).join("\n").trim().split("\n").slice(0, 10).join("\n");
             record({
                 gate: name,
                 pass: false,

package/dist/gates/run-gates.js

@@ -1147,7 +1147,21 @@ export async function runGates(task, ctx) {
                 invocations: [],
             };
         }
-        const judgeAdapter = getAdapter(ctx.cfg.judge.adapter, ctx.adapters);
+        // Queue row 34(a) (D-2134 R5): resolve every lifetime author through both role pools.
+        const channels = [...(ctx.judgeChannels ?? []), ...ctx.channels];
+        const authors = ctx.carriedAuthors?.length ? ctx.carriedAuthors : [channelKey(ctx.author)];
+        const authorVendors = carriedAuthorVendors(channels, authors);
+        const independent = (seat) => !!seat.vendor
+            && !authorVendors.has(seat.vendor) && !authors.includes(channelKey(seat));
+        const judgePool = () => (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
+        const rankJudges = (pool) => [...pool]
+            .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y));
+        const pickJudge = (pool, adapter) => rankJudges(pool.filter((c) => c.adapter !== adapter))[0] ?? rankJudges(pool)[0];
+        const configured = channels.find((c) => channelKey(c) === channelKey(ctx.cfg.judge));
+        const primary = authors.includes(channelKey(ctx.cfg.judge)) || (configured && authorVendors.has(configured.vendor))
+            ? pickJudge(judgePool().filter(independent), ctx.cfg.judge.adapter) ?? ctx.cfg.judge
+            : ctx.cfg.judge;
+        const judgeAdapter = getAdapter(primary.adapter, ctx.adapters);
         const jvia = via
             ? { driver: via.driver, keep: via.keep, onSlot: via.onSlot, name: via.nameFor("judge", judgeAdapter.id), label: via.labelFor("judge") }
             : undefined;
@@ -1181,11 +1195,11 @@ export async function runGates(task, ctx) {
                     ...(unparseable ? { transcript: output } : {}),
                 });
             }
-            return captured.value;
+            const result = captured.value;
+            const seat = channels.find((c) => channelKey(c) === result.meta?.judge);
+            return typeof result.meta?.judge === "string" && result.meta.unparseable !== true && (!seat || !independent(seat))
+                ? { ...result, meta: { ...result.meta, judgeIndependent: false } } : result;
         };
-        const judgePool = () => (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
-        const rankJudges = (pool) => [...pool]
-            .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y));
         // OBS-1151 (+add.1): the fresh judgment always stands on its own reading — a prior PASS is never
         // reused. Only a criterion that REVERSES the newest prior ruling on the same subject key over
         // identical cited blobs needs a second, distinct judge; agreement stands (a sound FAIL included),
@@ -1210,16 +1224,18 @@ export async function runGates(task, ctx) {
             if (!disputed.length)
                 return stamped;
             await ctx.onGate?.({ phase: "note", gate: "acceptance", name: "judge-disagreement", payload: { primary, commit, disputed } });
+            let notIndependent = fresh.meta?.judgeIndependent === false;
+            const independence = () => notIndependent ? { judgeIndependent: false } : {};
             const park = (why, adjudicator) => ({
                 gate: "acceptance", pass: false,
                 details: `judge disagreement on ${disputed.map((d) => d.id).join(", ")}: ${primary} reverses an earlier ruling over identical cited blobs (${[...new Set(disputed.flatMap((d) => d.paths))].join(", ")}) — ${why}; parked for an operator ruling, no worker charge`,
-                meta: { classification: "infra", infra: true, retryable: false, cause: "judge-disagreement", judge: primary,
+                meta: { classification: "infra", infra: true, retryable: false, cause: "judge-disagreement", judge: primary, ...independence(),
                     judgeDisagreement: { primary, ...(adjudicator ? { adjudicator } : {}), disputed, outcome: why } },
             });
             const primaryAdapter = primary.slice(0, primary.indexOf(":"));
             // One DISTINCT seat: never the primary channel, a different adapter when the pool has one.
             const pool = judgePool().filter((c) => channelKey(c) !== primary);
-            const seat = rankJudges(pool.filter((c) => c.adapter !== primaryAdapter))[0] ?? rankJudges(pool)[0];
+            const seat = pickJudge(pool.filter(independent), primaryAdapter) ?? pickJudge(pool, primaryAdapter);
             if (!seat)
                 return park("no distinct eligible judge is available");
             const adjudicator = channelKey(seat);
@@ -1230,13 +1246,14 @@ export async function runGates(task, ctx) {
             const subjectPark = (leg, found, ran) => ({
                 gate: "acceptance", pass: false,
                 details: `the adjudication subject ${SUBJECT_LEG_TEXT[leg]}: sampled ${commit.slice(0, 12)}, found ${found.slice(0, 12)} (${leg}); parked for an operator ruling, no worker charge`,
-                meta: { classification: "infra", infra: true, retryable: false, cause: "subject-moved", judge: primary,
+                meta: { classification: "infra", infra: true, retryable: false, cause: "subject-moved", judge: primary, ...independence(),
                     adjudication: { primary, ...(ran ? { adjudicator: ran } : {}), sampled: commit, found, leg } },
             });
             const s0 = await openSubjectWitness(ctx.worktree, commit);
             if ("leg" in s0)
                 return subjectPark(s0.leg, s0.leg === "unreadable" ? "unreadable" : commit);
             const second = await invokeJudge(seatAdapter, seat.model, seatVia, configuredEffort(ctx.cfg, seat));
+            notIndependent ||= second.meta?.judgeIndependent === false;
             const changed = await adjudicationSubjectChange(ctx.worktree, commit, s0);
             if (changed)
                 return subjectPark(changed.leg, changed.found, adjudicator);
@@ -1248,10 +1265,10 @@ export async function runGates(task, ctx) {
             const agreed = disputed.every((d) => rulings.some((r) => r.id === d.id && r.met === d.met && r.paths.length > 0));
             if (!agreed)
                 return park("the adjudicating judge split from the fresh ruling", adjudicator);
-            return { ...stamped, meta: { ...stamped.meta, adjudication: { primary, adjudicator, criteria: disputed.map((d) => d.id), agreed: true } } };
+            return { ...stamped, meta: { ...stamped.meta, ...independence(), adjudication: { primary, adjudicator, criteria: disputed.map((d) => d.id), agreed: true } } };
         };
         // OBS-1182: every judge seat launches at its OWN configured effort, never the worker's.
-        let a = await invokeJudge(judgeAdapter, ctx.cfg.judge.model, jvia, configuredEffort(ctx.cfg, ctx.cfg.judge));
+        let a = await invokeJudge(judgeAdapter, primary.model, jvia, configuredEffort(ctx.cfg, primary));
         // GATE-09: an unparseable judge verdict retries the JUDGE exactly once on a failover channel — never
         // the worker (run-20260711-185020 P43-03 L70-72 billed a judge flake as a worker attempt). The flaked
         // first verdict NEVER enters results (no false gate-result journal event, no operator notify, no stale
@@ -1268,18 +1285,10 @@ export async function runGates(task, ctx) {
         if (!cancelled && a.meta?.unparseable === true && typeof a.meta.judge === "string") {
             const flakedKey = a.meta.judge;
             const flakedAdapter = flakedKey.slice(0, flakedKey.indexOf(":"));
-            const pick = (pool) => pool
-                // pickReviewer's sort (review.ts:37): TIER_RANK desc, marginalCostRank asc — proven ordering; both
-                // symbols already imported by a sibling gate file.
-                .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
-            // v1.87 T2: the failover seat obeys the same policy the primary judge just passed — a denied
-            // channel is refused here too, never reached by falling through the exclusion arms below.
-            const judgePool = (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
-            const crossAdapter = pick(judgePool.filter((c) => c.adapter !== flakedAdapter));
-            const sameAdapter = pick(judgePool.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
-            // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
-            // that adapter; if the fleet has only one channel, fall back to the original judge config.
-            const retry = crossAdapter ?? sameAdapter ?? judgeSeat;
+            // Queue row 34(a) (D-2134 R5): keep GATE-09's exclusions and fallback when independence is unavailable.
+            const pool = judgePool().filter((c) => channelKey(c) !== flakedKey);
+            const retry = pickJudge(pool.filter(independent), flakedAdapter)
+                ?? pickJudge(pool, flakedAdapter) ?? judgeSeat;
             const retryAdapter = getAdapter(retry.adapter, ctx.adapters);
             const retryJvia = via
                 // unconditional -r1 suffix: under keepPanes:forever a same-channel retry cannot collide with the

package/dist/report/bundle.d.ts

@@ -1,7 +1,8 @@
 import type { EvidenceCitation } from "../gates/acceptance.js";
 import type { RunEnvironment } from "../run/environment.js";
 import type { JournalEvent } from "../run/journal.js";
-export declare const BUNDLE_SCHEMA_VERSION = 2;
+import { type SessionEnvironment } from "./compare.js";
+export declare const BUNDLE_SCHEMA_VERSION = 3;
 export declare const gateDeclined: (data: Record<string, unknown>) => boolean;
 export declare const KNOWN_LIMITS: readonly string[];
 export type BundleEvidence = string | EvidenceCitation;
@@ -18,6 +19,7 @@ export interface BundleGateResult {
     /** T11: true when the gate declined to run (journaled skipped:true, e.g. review below its
      * complexity threshold) — neither a pass nor a fail; the details carry the reason. */
     declined?: boolean;
+    held?: boolean;
     details: string;
 }
 export interface BundleTask {
@@ -28,7 +30,7 @@ export interface BundleTask {
     judgeCriteria: BundleJudgeCriterion[];
 }
 export interface BundleContentHashes {
-    /** sha256 of the canonical JSON of the source journal events used to build this packet. */
+    /** Queue 35 (D-2134 R6): sha256 of JSON.stringify of the parsed source events. */
     journal: string;
     /** graphDefinitionHash from run-start when recorded. */
     graphDefinitionHash?: string;
@@ -38,6 +40,7 @@ export interface ProofBundle {
     schemaVersion: number;
     runId: string;
     environment?: RunEnvironment;
+    environments: SessionEnvironment[];
     contentHashes: BundleContentHashes;
     tasks: BundleTask[];
     /** Plain-language known limits — this is not an unconditional proof of correctness. */

package/dist/report/bundle.js

@@ -4,11 +4,13 @@
 // redactSecrets seam. No I/O and no network: the caller (report CLI) owns the write.
 import { createHash } from "node:crypto";
 import { redactSecrets } from "../run/redact.js";
-import { recordedEnvironment } from "./compare.js";
+import { normalizeGateOutcome } from "../run/outcome.js";
+import { recordedEnvironment, recordedEnvironments } from "./compare.js";
 // Bump when the packet shape changes in a way a future reader must branch on before parsing.
 // 2 (T11): gates gained `declined`, and `pass` narrowed from "the gate did not fail" to "the gate
 // ran and passed" — a schema-1 reader would read a decline as a plain failure.
-export const BUNDLE_SCHEMA_VERSION = 2;
+// Queue 35 (D-2134 R6): held gates and session environments change the packet's meaning.
+export const BUNDLE_SCHEMA_VERSION = 3;
 // T11: the one predicate every decline surface shares — the record, the text tickmark rate, the
 // comparison metrics and this packet must agree on what "never ran" means. Modern runs journal
 // `skipped: true`; runs from before that field carry the same decline only in the details prefix
@@ -19,7 +21,7 @@ export const gateDeclined = (data) => data.skipped === true || /^skipped\b/.test
 export const KNOWN_LIMITS = [
     "This packet is a portable snapshot of journaled run facts, not an independent re-verification of the work or its gates.",
     "Judge evidence citations are copied from the journal as the judge recorded them; this packet does not re-validate citations against the judged diff.",
-    "Content hashes bind this packet to the journal bytes used to build it; they do not prove the underlying gates, merges, or tip verification were correct.",
+    "Content hashes bind this packet to the JSON.stringify serialization of parsed journal events used to build it; they do not prove the underlying gates, merges, or tip verification were correct.",
     "Secret-shaped strings are redacted by local pattern matching only; redaction is not a formal security audit.",
     "Producing this packet never contacts a network and never uploads anything.",
 ];
@@ -135,11 +137,13 @@ export function buildProofBundle(runId, events) {
         const judgeCriteria = [];
         for (const g of gateEvents) {
             const gate = typeof g.data.gate === "string" ? g.data.gate : "unknown";
-            // T11: a declined gate never ran — flagged declined, never a pass.
+            // Queue 35 (D-2134 R6): a passing screen remains held until its full suite speaks.
             const declined = gateDeclined(g.data);
-            const pass = g.data.pass === true && !declined;
+            const outcome = normalizeGateOutcome(g.data);
+            const held = outcome.kind === "held";
+            const pass = outcome.kind === "passed" && !declined;
             const details = typeof g.data.details === "string" ? g.data.details : "";
-            gates.push({ gate, pass, ...(declined ? { declined: true } : {}), details });
+            gates.push({ gate, pass, ...(declined ? { declined: true } : {}), ...(held ? { held: true } : {}), details });
             if (gate === "acceptance") {
                 for (const c of parseJudgeCriteria(g.data))
                     judgeCriteria.push(c);
@@ -156,6 +160,7 @@ export function buildProofBundle(runId, events) {
         schemaVersion: BUNDLE_SCHEMA_VERSION,
         runId,
         ...(environment ? { environment } : {}),
+        environments: recordedEnvironments(events),
         contentHashes: {
             journal: journalHash,
             ...(gHash ? { graphDefinitionHash: gHash } : {}),

package/dist/report/compare.d.ts

@@ -8,11 +8,18 @@ export type EnvironmentCompare = {
     comparable: false;
     reason: "mismatch";
     recorded: string;
+    mixedSessions?: true;
 } | {
     comparable: false;
     reason: "unbound";
 };
 export declare function hasRunStart(events: JournalEvent[]): boolean;
+export interface SessionEnvironment {
+    event: "run-start" | "run-resume";
+    ts: string;
+    environment?: RunEnvironment;
+}
+export declare function recordedEnvironments(events: JournalEvent[]): SessionEnvironment[];
 export declare function recordedEnvironment(events: JournalEvent[]): RunEnvironment | undefined;
 export declare function environmentComparable(baselineEnv: RunEnvironment | undefined, currentEnv: RunEnvironment | undefined): EnvironmentCompare;
 export interface RunMetrics {
@@ -21,6 +28,7 @@ export interface RunMetrics {
     gateFail: number;
     gateTotal: number;
     costUsd: number | undefined;
+    costPartial: boolean;
     tokensTotal: number | undefined;
 }
 export declare function runMetrics(events: JournalEvent[], rows?: TelemetryRow[], cost?: CostConfig): RunMetrics;
@@ -28,6 +36,7 @@ export interface RunDelta {
     durationMs: number | undefined;
     gateFail: number;
     costUsd: number | undefined;
+    costPartial: boolean;
     tokensTotal: number | undefined;
 }
 export type CompareOutcome = {