From 09ea6b5a36f6a18a40735481f81b4d6d622e4910 Mon Sep 17 00:00:00 2001 From: Noah Gift Date: Mon, 21 Sep 2026 07:30:34 +0200 Subject: [PATCH 1/2] =?UTF-8?q?fix(guard=5Ftree):=20a=20passing=20guard's?= =?UTF-8?q?=20UNMEASURED=20/=20SUMMARY=20lines=20reach=20the=20log=20?= =?UTF-8?q?=E2=80=94=20a=20bare=20PASS=20could=20not=20say=20"not=20measur?= =?UTF-8?q?ed=20here"=20(#3651)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refs #3651 #3567 #3633 guard_tree.sh recorded a passing guard as its label alone and dropped its output. Twelve guards exit 0 on UNMEASURED by design, so `PASS [run]` meant "measured and passed" or "not measured here" and no log could tell which. Main's guard-tree on intel-clean-room-5 (run 35563537942) and gx10-build (run 35561048727) both show only `PASS scripts/check_fleet_pv_shapes_gate.sh [run]`, so #3567's criterion — the verdict measured inside a runner — was unobservable. - guard_tree.sh: `surface_pass_summary` prints, under a PASS row, every captured line whose FIRST token is UNMEASURED or SUMMARY, indented ` ~ `, capped at 5 plus a `(+N more …)` count. UNMEASURED needs no opt-in; SUMMARY is how a guard puts its measured row into the log. Mid-line words and prefixes (`UNMEASUREDX`) are not markers. - check_fleet_pv_shapes_gate.sh: a measured PASS is re-printed as `SUMMARY PASS verdict=… runner=… pin=… pv=… version=…`; UNMEASURED is surfaced unasked. Self-test row 1b asserts the SUMMARY row; row 5 now also refuses `SUMMARY PASS` on the UNMEASURED path. 11 rows pass. - guard_tree_test.sh rows 22-27: UNMEASURED surfaced with no opt-in; SUMMARY surfaced and nothing else of that guard's output; mid-line and prefix words not surfaced; a silent pass prints only its row; 7 SUMMARY lines -> 5 + (+2 more); and the mutant with the surfacing deleted loses 22 and 23. 29/0. Four more mutants of the awk, each RED: cap removed (26), marker unanchored (24), SUMMARY dropped (23, 26), word boundary dropped (24). Measured while proving it, NOT fixed here: on this box the fleet pv (~/.cargo/bin/pv 0.68.2, pin 0.68.2) returns rc=2 with no JSON on `lint contracts --gate shapes --format json` — it refuses 7 tracked evidence/parity/l0-1{,b}/*.json records as "UNMIGRATED logit-parity record" — while the pv built from HEAD returns verdict=Pass, 2320 focus nodes, pc_shape fired, 3 planted. So a converged runner (pin + fleet pv) will show this guard as ENV, and the surfaced row is what will say so. Reported on #3567. Gates: bashrs-gate PASS, pipe-into-grep-q at ceiling, hardcoded-paths +0, apr pinned, guards-are-wired PASS, no-timing-in-required PASS, roadmap aggregate idempotent + sorted/unique/additive; fmt, deny, aprender-contracts --lib 1666. Co-Authored-By: Claude Opus 5 (1M context) --- docs/roadmaps/entries/PMAT-3651.yaml | 17 ++++++ docs/roadmaps/roadmap.yaml | 17 ++++++ scripts/check_fleet_pv_shapes_gate.sh | 14 ++++- scripts/guard_tree.sh | 25 ++++++++ scripts/tests/guard_tree_test.sh | 87 +++++++++++++++++++++++++++ 5 files changed, 158 insertions(+), 2 deletions(-) create mode 100644 docs/roadmaps/entries/PMAT-3651.yaml diff --git a/docs/roadmaps/entries/PMAT-3651.yaml b/docs/roadmaps/entries/PMAT-3651.yaml new file mode 100644 index 0000000000..ea37f3252f --- /dev/null +++ b/docs/roadmaps/entries/PMAT-3651.yaml @@ -0,0 +1,17 @@ +- id: PMAT-3651 + github_issue: 3651 + item_type: task + title: 'guard_tree.sh drops a passing guard''s output — an UNMEASURED exit-0 reads as PASS in every CI log, so #3567''s verdict can never be observed' + status: planned + priority: critical + assigned_to: null + created: 2026-09-21T05:28:51Z + updated: 2026-09-21T05:28:51Z + spec: null + acceptance_criteria: [] + phases: [] + subtasks: [] + estimated_effort: null + labels: + - kind:code + notes: 'ACCEPTANCE (quoted from issue #3651 "What lands"): 1. guard_tree.sh: under a PASS row, surface every captured line whose first token is UNMEASURED or SUMMARY (indented " ~ ", capped at 5 lines + a "(+N more)" count so a chatty guard cannot flood the log). Lines where the word is not the first token are not surfaced. A guard opts a pass-summary in by printing SUMMARY …; an UNMEASURED line is surfaced whether or not the guard opted in. 2. check_fleet_pv_shapes_gate.sh: its pass row is printed as SUMMARY PASS verdict=… so the measured row reaches the log. 3. scripts/tests/guard_tree_test.sh rows: UNMEASURED surfaced; SUMMARY surfaced; the word mid-line not surfaced; a silent pass prints only its PASS row; the cap; and a mutant with the surfacing removed goes RED. NOT in scope: closing #3567 (that needs one guard-tree run on an intel runner after this lands), and the fleet pv''s own verdict.' diff --git a/docs/roadmaps/roadmap.yaml b/docs/roadmaps/roadmap.yaml index 618b9a93ca..63a6a325ef 100644 --- a/docs/roadmaps/roadmap.yaml +++ b/docs/roadmaps/roadmap.yaml @@ -18990,3 +18990,20 @@ roadmap: labels: - kind:code notes: 'ACCEPTANCE (hand-entered from issue #3627 done_when; minted on the PR branch so the AD-04 quorum can run -- pmat work status refuses a missing item). Done when: contracts/rmsnorm-kernel-v1.yaml Scale invariance obligation carries either the ε>0 formal or the α²·mean(x²) ≫ ε precondition; pv validate passes ~~regenerated with pv probar --binding~~ **WITHDRAWN 21:40Z** — b3 measured that pv probar --binding emits 7 #[ignore = "no binding available"] stubs for this contract; the tracked file''s 5 real tests were produced by the pre-monorepo external generator (20dda945b, 2026-02-18) and the header is false (class row: #3630). Instead: the tracked test is edited **directly**, the commit says so, and the file''s header is replaced by a true one (hand-maintained, contract-bound) the minimal input above ([0.0, -0.15964308], α=0.012254778) is a committed regression case that PASSES under the new assertion (i.e. the fixed test is exercised on the exact input that killed #3621), and a mutation that restores the ε=0 assertion turns it RED cargo' +- id: PMAT-3651 + github_issue: 3651 + item_type: task + title: 'guard_tree.sh drops a passing guard''s output — an UNMEASURED exit-0 reads as PASS in every CI log, so #3567''s verdict can never be observed' + status: planned + priority: critical + assigned_to: null + created: 2026-09-21T05:28:51Z + updated: 2026-09-21T05:28:51Z + spec: null + acceptance_criteria: [] + phases: [] + subtasks: [] + estimated_effort: null + labels: + - kind:code + notes: 'ACCEPTANCE (quoted from issue #3651 "What lands"): 1. guard_tree.sh: under a PASS row, surface every captured line whose first token is UNMEASURED or SUMMARY (indented " ~ ", capped at 5 lines + a "(+N more)" count so a chatty guard cannot flood the log). Lines where the word is not the first token are not surfaced. A guard opts a pass-summary in by printing SUMMARY …; an UNMEASURED line is surfaced whether or not the guard opted in. 2. check_fleet_pv_shapes_gate.sh: its pass row is printed as SUMMARY PASS verdict=… so the measured row reaches the log. 3. scripts/tests/guard_tree_test.sh rows: UNMEASURED surfaced; SUMMARY surfaced; the word mid-line not surfaced; a silent pass prints only its PASS row; the cap; and a mutant with the surfacing removed goes RED. NOT in scope: closing #3567 (that needs one guard-tree run on an intel runner after this lands), and the fleet pv''s own verdict.' diff --git a/scripts/check_fleet_pv_shapes_gate.sh b/scripts/check_fleet_pv_shapes_gate.sh index 788f95cad9..5b91564285 100755 --- a/scripts/check_fleet_pv_shapes_gate.sh +++ b/scripts/check_fleet_pv_shapes_gate.sh @@ -148,6 +148,8 @@ STUB mkpv "$d/pv_ok" capable Pass out=$(FLEET_PV_BIN="$d/pv_ok" FLEET_PV_PIN="$d/pin" FLEET_PV_CONTRACTS="$d/contracts" RUNNER_NAME=probe-runner bash "$0" 2>&1); rc=$? [ "$rc" -eq 0 ] && grep -q '^PASS .*verdict=Pass.*runner=probe-runner' <<<"$out" && ok "capable pv + Pass verdict -> PASS, row names the runner" || nok "expected PASS row, got rc=$rc: $out" + # 1b. ...and re-prints it as SUMMARY, the line guard_tree.sh carries into the CI log (#3651) + [ "$rc" -eq 0 ] && grep -q '^SUMMARY PASS .*verdict=Pass.*runner=probe-runner.*version=' <<<"$out" && ok "a measured PASS is re-printed as SUMMARY for the guard-tree log" || nok "expected a SUMMARY PASS row, got rc=$rc: $out" # 2. PLANTED VIOLATION: lint says Fail -> the guard is RED (verdict parsed, not grepped) mkpv "$d/pv_fail" capable Fail @@ -165,7 +167,7 @@ STUB # 5. no pin -> UNMEASURED, exit 0, the row says so and names the runner and infra#708 out=$(FLEET_PV_BIN="$d/pv_ok" FLEET_PV_PIN="$d/no-such-pin" FLEET_PV_CONTRACTS="$d/contracts" RUNNER_NAME=never-converged bash "$0" 2>&1); rc=$? - [ "$rc" -eq 0 ] && grep -q '^UNMEASURED runner=never-converged.*infra#708' <<<"$out" && ! grep -q '^PASS' <<<"$out" && ok "no pin -> UNMEASURED row (exit 0, never a PASS line)" || nok "expected UNMEASURED row, got rc=$rc: $out" + [ "$rc" -eq 0 ] && grep -q '^UNMEASURED runner=never-converged.*infra#708' <<<"$out" && ! grep -qE '^(SUMMARY )?PASS' <<<"$out" && ok "no pin -> UNMEASURED row (exit 0, never a PASS line)" || nok "expected UNMEASURED row, got rc=$rc: $out" # 6. pv's own control silent (pc_shape != fired) -> RED even with verdict=Pass mkpv "$d/pv_silent" capable Pass silent @@ -200,7 +202,15 @@ echo "=== shapes gate on the FLEET-PINNED pv, on this runner (check_fleet_pv_sha # The row is the verdict. No trailer may begin with PASS unless the row did: a trailer # reading "PASS-OR-UNMEASURED" is exactly what a consumer's grep would misread (the # self-test's row 5 refused it). +# A measured PASS is re-printed as `SUMMARY `: guard_tree.sh surfaces SUMMARY +# and UNMEASURED lines under a passing guard (#3651), so the runner, pv, version, +# verdict and corpus reach the CI log instead of a bare "PASS" (#3567). UNMEASURED +# needs no SUMMARY -- guard_tree surfaces it unasked. row=$(judge 2>&1); rc=$? printf '%s\n' "$row" -case "$rc" in 0) printf '%s\n' "${row%% *}";; 1) echo "FAIL" >&2;; *) echo "ENV (rc=$rc)" >&2;; esac +case "$rc" in + 0) case "$row" in "PASS "*) printf 'SUMMARY %s\n' "$row" ;; *) printf '%s\n' "${row%% *}" ;; esac ;; + 1) echo "FAIL" >&2 ;; + *) echo "ENV (rc=$rc)" >&2 ;; +esac exit "$rc" diff --git a/scripts/guard_tree.sh b/scripts/guard_tree.sh index 882271a3ef..e508eba974 100755 --- a/scripts/guard_tree.sh +++ b/scripts/guard_tree.sh @@ -233,6 +233,30 @@ advertises_self_test() { # process group with it, a pool that is torn down) leaves rows and no verdict, # and the parent turns a MISSING verdict into a FAILURE -- fail-closed. The # one thing a run-all dispatcher may never do is drop a guard quietly. +# A PASS ROW IS NOT A VERDICT WHEN THE GUARD SAID "NOT MEASURED" (#3651). +# A passing guard's output was dropped: only its label reached the log. Twelve +# guards exit 0 on UNMEASURED by design (a runner without the tool must not red +# every PR), so `PASS [run]` meant either "measured and passed" or "not +# measured here", and the log could not say which -- main run 35561048727 showed +# check_fleet_pv_shapes_gate.sh as a bare PASS on gx10-build, and #3567's +# criterion (the verdict measured inside a runner) was unobservable anywhere. +# +# So under a PASS row, every captured line whose FIRST token is UNMEASURED or +# SUMMARY is surfaced, indented ` ~ `. UNMEASURED needs no opt-in: a guard +# that says it did not measure is heard whether or not it meant to be. SUMMARY +# is how a guard puts its measured row (runner, tool, version, verdict, corpus) +# into the log. The word anywhere else on a line is not a marker. Capped at 5 +# lines plus a count, so a chatty guard cannot bury the rows around it. +surface_pass_summary() { # surface_pass_summary + awk ' + /^(UNMEASURED|SUMMARY)([[:space:]]|$)/ { + n++ + if (n <= 5) printf " ~ %s\n", $0 + } + END { if (n > 5) printf " ~ (+%d more UNMEASURED/SUMMARY line(s))\n", n - 5 } + ' "$1" +} + worker_run_one() { spec="$1" w_idx="${spec%%:*}" @@ -254,6 +278,7 @@ worker_run_one() { w_total=$((w_total + 1)) if "$@" >"$w_cap" 2>&1; then printf 'PASS %s\n' "$label" >> "$w_rows" + surface_pass_summary "$w_cap" >> "$w_rows" else w_failed=$((w_failed + 1)) printf 'FAIL %s\n' "$label" >> "$w_rows" diff --git a/scripts/tests/guard_tree_test.sh b/scripts/tests/guard_tree_test.sh index 40ace8b4c4..3cc33cc181 100755 --- a/scripts/tests/guard_tree_test.sh +++ b/scripts/tests/guard_tree_test.sh @@ -554,6 +554,93 @@ else "matches=${n_real_ledger:-0}" fi +# --------------------------------------------------------------------------- +# 22-27. A PASSING guard's UNMEASURED / SUMMARY lines reach the log (#3651). +# guard_tree.sh recorded a passing guard as its label alone, so a guard +# that exits 0 on "not measured here" and one that measured and passed +# printed the same `PASS` row. The fixture holds one guard per shape; the +# rows assert what is surfaced AND what is not, and 27 deletes the +# surfacing and proves 22 and 23 turn RED. +# --------------------------------------------------------------------------- +sfix="$(mktemp -d)" || exit 1 +cleanup_dirs="$cleanup_dirs $sfix" +mkdir -p "$sfix/.empty-git-template" "$sfix/scripts" +git -C "$sfix" init -q --template="$sfix/.empty-git-template" +git -C "$sfix" config user.email test@example.invalid +git -C "$sfix" config user.name "guard_tree_test" +cp "$GUARD_TREE" "$sfix/scripts/guard_tree.sh" +printf '#!/usr/bin/env bash\necho "noise before"\necho "UNMEASURED runner=r1 reason=no-pin -- not measured here"\nexit 0\n' \ + >"$sfix/scripts/check_s_unmeasured.sh" +printf '#!/usr/bin/env bash\necho "SUMMARY PASS verdict=Pass runner=r2 pv=/x version=9"\necho "detail line"\nexit 0\n' \ + >"$sfix/scripts/check_s_summary.sh" +printf '#!/usr/bin/env bash\necho "ok row 3 the word UNMEASURED mid-line and SUMMARY mid-line are not markers"\necho "UNMEASUREDX is not the word"\nexit 0\n' \ + >"$sfix/scripts/check_s_midline.sh" +printf '#!/usr/bin/env bash\nexit 0\n' >"$sfix/scripts/check_s_silent.sh" +printf '#!/usr/bin/env bash\nfor i in 1 2 3 4 5 6 7; do echo "SUMMARY line $i"; done\nexit 0\n' \ + >"$sfix/scripts/check_s_chatty.sh" +git -C "$sfix" add -A +git -C "$sfix" -c commit.gpgsign=false commit -q -m fixture + +s_out="$(cd "$sfix" && bash scripts/guard_tree.sh 2>&1)" +# the row a guard's line lands under: the nearest PASS/FAIL row above it +under() { # under -> the surfaced lines beneath that guard's [run] row + awk -v g="scripts/$1 [run]" ' + /^(PASS|FAIL) / { cur = ($0 == "PASS " g || $0 == "FAIL " g); next } + cur && /^ ~ / { print } + ' <<<"$s_out" +} + +u="$(under check_s_unmeasured.sh)" +if [ "$u" = " ~ UNMEASURED runner=r1 reason=no-pin -- not measured here" ]; then + pass_row "22: a passing guard's UNMEASURED line is surfaced under its PASS row (no opt-in)" +else + fail_row "22: a passing guard's UNMEASURED line is surfaced under its PASS row" "got [$u] in: $s_out" +fi + +u="$(under check_s_summary.sh)" +if [ "$u" = " ~ SUMMARY PASS verdict=Pass runner=r2 pv=/x version=9" ]; then + pass_row "23: a passing guard's SUMMARY line is surfaced; its other output is not" +else + fail_row "23: a passing guard's SUMMARY line is surfaced" "got [$u]" +fi + +u="$(under check_s_midline.sh)" +if [ -z "$u" ]; then + pass_row "24: the words mid-line (or as a prefix of another word) are not markers" +else + fail_row "24: the words mid-line are not markers" "surfaced [$u]" +fi + +u="$(under check_s_silent.sh)" +if [ -z "$u" ] && grep -qx 'PASS scripts/check_s_silent.sh \[run\]' <<<"$s_out"; then + pass_row "25: a silent passing guard prints its PASS row and nothing under it" +else + fail_row "25: a silent passing guard prints only its PASS row" "got [$u]" +fi + +u="$(under check_s_chatty.sh)" +n_u="$(grep -c . <<<"$u")" +if [ "${n_u:-0}" -eq 6 ] && grep -qx ' ~ (+2 more UNMEASURED/SUMMARY line(s))' <<<"$u"; then + pass_row "26: seven SUMMARY lines are capped at 5 plus a (+2 more) count" +else + fail_row "26: SUMMARY lines are capped at 5 plus a count" "got $n_u line(s): [$u]" +fi + +# 27. The mutant: surfacing deleted. 22 and 23 must turn RED over the same fixture. +sed 's/^ surface_pass_summary "\$w_cap" >> "\$w_rows"$/ :/' \ + "$GUARD_TREE" >"$sfix/scripts/guard_tree.sh" +if cmp -s "$GUARD_TREE" "$sfix/scripts/guard_tree.sh"; then + fail_row "27: mutant with the surfacing deleted" "the sed did not apply -- the mutant is the original" +else + s_out="$(cd "$sfix" && bash scripts/guard_tree.sh 2>&1)" + if [ -z "$(under check_s_unmeasured.sh)" ] && [ -z "$(under check_s_summary.sh)" ]; then + pass_row "27: mutant with the surfacing deleted loses rows 22 and 23 (the assertion can fail)" + else + fail_row "27: mutant with the surfacing deleted" "rows 22/23 still green under the mutant" + fi +fi +cp "$GUARD_TREE" "$sfix/scripts/guard_tree.sh" + printf '%d checks, %d failed\n' "$total" "$failed" if [ "$failed" -gt 0 ]; then exit 1 From 0539924489ed6d5df4ac65f9aa10a48d2b18b713 Mon Sep 17 00:00:00 2001 From: Noah Gift Date: Mon, 21 Sep 2026 07:37:48 +0200 Subject: [PATCH 2/2] =?UTF-8?q?PMAT-3651:=20AD-04=20quorum=20receipt=20for?= =?UTF-8?q?=20#3653=20=E2=80=94=203/3=20PASS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Lanes gemini-3.1-pro-high / gemini-3.1-pro-low / gemini-3.6-flash-high; no transcript reads a sibling lane file. Refs #3651 Co-Authored-By: Claude Opus 5 (1M context) --- docs/audits/quorum-PMAT-3651.json | 171 ++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 docs/audits/quorum-PMAT-3651.json diff --git a/docs/audits/quorum-PMAT-3651.json b/docs/audits/quorum-PMAT-3651.json new file mode 100644 index 0000000000..0b521b7ec7 --- /dev/null +++ b/docs/audits/quorum-PMAT-3651.json @@ -0,0 +1,171 @@ +{ + "ticket": "PMAT-3651", + "base": "origin/main", + "base_resolved": "origin/main", + "base_note": "no origin/origin/main exists; judged against the local ref", + "head": "09ea6b5a36f6a18a40735481f81b4d6d622e4910", + "diff_sha256": "16860b2a04b90581da01cab5f669a0edcafe29e53e8a5d86bd9416c11814e007", + "width": 3, + "executor": "agy", + "prompt_mode": "inline", + "prompt_bytes": 15106, + "author": { + "model": "claude-opus-5", + "family": "claude", + "source": "flag" + }, + "agreed": true, + "lanes": [ + { + "lane": 1, + "status": "SUCCESS", + "verdict": "PASS", + "summary": "The diff perfectly satisfies all acceptance criteria for PMAT-3651. `guard_tree.sh` correctly surfaces `UNMEASURED` and `SUMMARY` pass lines using `awk`, limiting output to 5 lines with a count for any extras, and only matches them as the first token. `check_fleet_pv_shapes_gate.sh` successfully re-prints its measured pass row with the `SUMMARY` prefix. The tests in `guard_tree_test.sh` are robust, verifying the cap, the mid-line exclusions, silent pass behavior, and importantly, including a mutation test to guarantee the assertions properly catch failures. Nothing out of scope (like closing #3567) is touched.", + "findings": [], + "raw_bytes": 3395, + "err_bytes": 0, + "envelope_status": "SUCCESS", + "verdict_source": "structured_output", + "grounding_check": "parity", + "model": "gemini-3.1-pro-high", + "model_measured": "gemini-3.1-pro-high", + "model_source": "measured", + "family": "gemini" + }, + { + "lane": 2, + "status": "SUCCESS", + "verdict": "PASS", + "summary": "The diff perfectly aligns with PMAT-3651. It introduces the `surface_pass_summary` awk script in `guard_tree.sh` to extract and cap the necessary lines, modifies `check_fleet_pv_shapes_gate.sh` to correctly prefix `SUMMARY` on a `PASS` verdict so it's picked up by `guard_tree`, and includes extensive tests in `guard_tree_test.sh` that assert the surfacing, the 5-line cap, the mutant failure, and ignore midline matches. No requirements are violated.", + "findings": [ + { + "claim": "The guard_tree.sh correctly surfaces lines starting with UNMEASURED or SUMMARY, indented and capped at 5 lines + count", + "file": "scripts/guard_tree.sh", + "grounding": "cited", + "line": 253 + }, + { + "claim": "check_fleet_pv_shapes_gate.sh pass row is prefixed with SUMMARY so that it reaches the log", + "file": "scripts/check_fleet_pv_shapes_gate.sh", + "grounding": "cited", + "line": 207 + }, + { + "claim": "guard_tree_test.sh adds tests for the surfaced rows, the cap, the midline negative case, and the mutant", + "file": "scripts/tests/guard_tree_test.sh", + "grounding": "cited", + "line": 557 + } + ], + "raw_bytes": 4222, + "err_bytes": 0, + "envelope_status": "SUCCESS", + "verdict_source": "structured_output", + "grounding_check": "parity", + "model": "gemini-3.1-pro-low", + "model_measured": "gemini-3.1-pro-low", + "model_source": "measured", + "family": "gemini" + }, + { + "lane": 3, + "status": "SUCCESS", + "verdict": "PASS", + "summary": "Lane 3 of 3 Independent Review for PMAT-3651: PASS. The diff satisfies all acceptance criteria in issue #3651. 1) guard_tree.sh surfaces lines starting with UNMEASURED or SUMMARY under PASS rows (indented ' ~ ', capped at 5 lines + (+N more) count). 2) check_fleet_pv_shapes_gate.sh re-prints passing rows as SUMMARY PASS verdict=... for log surfacing. 3) guard_tree_test.sh tests 22-27 pass cleanly, including non-vacuous mutation check 27. No gates weakened, no out-of-scope changes.", + "findings": [ + { + "claim": "guard_tree.sh surfaces lines starting with UNMEASURED or SUMMARY under PASS rows, capped at 5 lines plus (+N more) count", + "command": "bash scripts/tests/guard_tree_test.sh", + "file": "scripts/guard_tree.sh", + "grounding": "measured", + "line": 233, + "output": "PASS 22: a passing guard's UNMEASURED line is surfaced under its PASS row (no opt-in)\nPASS 23: a passing guard's SUMMARY line is surfaced; its other output is not\nPASS 24: the words mid-line (or as a prefix of another word) are not markers\nPASS 25: a silent passing guard prints its PASS row and nothing under it\nPASS 26: seven SUMMARY lines are capped at 5 plus a (+2 more) count\nPASS 27: mutant with the surfacing deleted loses rows 22 and 23 (the assertion can fail)\n29 checks, 0 failed" + }, + { + "claim": "check_fleet_pv_shapes_gate.sh re-prints a measured PASS row with a SUMMARY prefix so guard_tree.sh captures and surfaces it in CI logs", + "command": "bash scripts/check_fleet_pv_shapes_gate.sh --self-test", + "file": "scripts/check_fleet_pv_shapes_gate.sh", + "grounding": "measured", + "line": 205, + "output": "=== fleet pv shapes gate: case table (stub pvs, no network, no real fleet binary) ===\nok row 1 capable pv + Pass verdict -> PASS, row names the runner\nok row 2 a measured PASS is re-printed as SUMMARY for the guard-tree log\n...\nSELF-TEST PASSED: 11 rows" + } + ], + "raw_bytes": 5912, + "err_bytes": 100, + "envelope_status": "SUCCESS", + "verdict_source": "structured_output", + "grounding_check": "parity", + "model": "gemini-3.6-flash-high", + "model_measured": "gemini-3.6-flash-high", + "model_source": "measured", + "family": "gemini" + } + ], + "dissent": [], + "dedup": [ + { + "file": "scripts/check_fleet_pv_shapes_gate.sh", + "line": 205, + "lanes_agreeing": [ + 3 + ], + "claims": [ + "check_fleet_pv_shapes_gate.sh re-prints a measured PASS row with a SUMMARY prefix so guard_tree.sh captures and surfaces it in CI logs" + ] + }, + { + "file": "scripts/check_fleet_pv_shapes_gate.sh", + "line": 207, + "lanes_agreeing": [ + 2 + ], + "claims": [ + "check_fleet_pv_shapes_gate.sh pass row is prefixed with SUMMARY so that it reaches the log" + ] + }, + { + "file": "scripts/guard_tree.sh", + "line": 233, + "lanes_agreeing": [ + 3 + ], + "claims": [ + "guard_tree.sh surfaces lines starting with UNMEASURED or SUMMARY under PASS rows, capped at 5 lines plus (+N more) count" + ] + }, + { + "file": "scripts/guard_tree.sh", + "line": 253, + "lanes_agreeing": [ + 2 + ], + "claims": [ + "The guard_tree.sh correctly surfaces lines starting with UNMEASURED or SUMMARY, indented and capped at 5 lines + count" + ] + }, + { + "file": "scripts/tests/guard_tree_test.sh", + "line": 557, + "lanes_agreeing": [ + 2 + ], + "claims": [ + "guard_tree_test.sh adds tests for the surfaced rows, the cap, the midline negative case, and the mutant" + ] + } + ], + "uncovered": [], + "coverage_source": "lanes", + "partial": false, + "partial_reasons": [], + "auto_merge": { + "checked": true, + "was_armed": false, + "disarmed": false, + "note": "auto-merge not armed" + }, + "lint": { + "ok": true, + "output": "receipt complete: kind=artifact lanes=3 author=claude-opus-5/claude" + } +}