Repository navigation
Port verdict to a single static Go binary - #9
Conversation
A new docs/ci-recipe.md page plus examples/verdict-review.yml run fetch, agent review, and post behind the ready pre-check and the report --check merge gate in the operator's own CI via the setup-verdict action. A new eval case grades the page, the SHA pins, and the gate mechanics.
usage now names which verbs run on any provider bundle and which need GitHub, and dates the GitHub-only incremental re-review exception.
Unknown-path review comments render under Unanchored observations instead of posting inline; bodies past the hosting limit post across follow-up COMMENT reviews instead of trimming.
Ticket 02 replaced the 65,536-char trim with a split into follow-up COMMENT reviews; the manual still described the trim, and a stale note about the deleted shell leg. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Corpus-* bundles carry corpus.json with ground-truth bugs; calibrate grades findings against it and trend aggregates precision/recall/false-positive rate per model and panel. local-* keeps refusing the live join. Adds the corpus manifest schema and record support for the marked kind.
Eight deterministic seeded cases with two fake agent outputs each, assembled through record into corpus bundles. The bench-corpus eval proves exact calibrate/trend numbers, the local refusal boundary, additive trend output, and the offline/read-only contract.
Documents the matching rule, corpus construction, operator runbook for real PRs and agent runs, cost estimates, reproducibility tolerance, and what the comparison page may cite after 06b.
Replace auto-discovered harness transcripts with an explicit usage contract (VERDICT_USAGE, schemas/usage.schema.json); vendor parsing moves to examples/usage-adapters/. No release ever shipped discovery.
The Go binary never spawns jq or shasum, so doctor no longer fails a healthy harness without them; install-skill.sh's doctor gate stops aborting too. Docs now name the real runtime tools; goldens lose only the two removed rows (and the summary count).
Delete internal/install, the top-level install verb, its usage block, and the copy-installer eval. The embedded, atomic, receipted verdict skill install is now the single install path; install-skill.sh and docs point at it, and uninstall/upgrade are unchanged.
Fetch and post persisted raw forge stderr at 0644 while report already staged the same .recheck.err path at 0600; route all three through one atomic.WriteErrSidecar and document the sidecars as owner-only debug residue.
Move the duplicated backoff classifier into internal/retry so fetch retries GitHub's transient internal-error note on the same 3-attempt budget post already used; plain auth and validation failures still fail fast.
Read agent files through a limiter and stat guard, bound every commander's captured output with a typed over-cap error or truncation marker, and route store JSON through jq.Capped while keeping each store's refusal codes.
Route ready, report --live, and calibrate through readcommon.Threads and OpenThreadCount. Non-object, missing, and non-bool isResolved nodes count as unresolved everywhere (fail-closed), gh spawns through the injected commander (including the report adapter), and the duplicate queries/counters are deleted.
Export readcommon.TopOpenInline and decorate the eight ranked keys once per entry, then sort. Fix's default pick now uses the same comparator as report and next instead of its four-key severity/path/line/sig order, and Rank drops from per-comparison key slices to two allocations at 500 entries.
Delete bundle.ResolveSig and point triage and fix at readcommon.ResolveSig, whose tally counts matching entries. Two identical entries now read MANY everywhere, so fix --sig refuses the store show already refuses instead of acting on it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Anchor, counter, threshold, adopt, verify, and jq parses now refuse an int overflow instead of wrapping, and every hand-rolled digit/bool/tag parser is replaced by strconv or the shared jq helpers.
fetch and fetch-local read .review/{panel,budget,max_bytes,chunk,kb.jsonl,
kb-policy,learnings.md,overrides/*} from the PR base commit with
git show <base>:<path> through the Commander seam, instead of the working
tree a pull request can edit. The bytes are snapshotted into the bundle
(controls/) with a controls.json manifest (policy, base_sha, sha, per-file
path/status/bytes/sha256; schemas/controls.schema.json).
--allow-head-controls is the one opt-out: it reads the worktree as before,
warns once, and stamps policy head. A base the clone does not hold refuses
controls-unavailable; verdict never fetches it. Control files are capped at
256 KiB each (1 MiB total) and never truncated. The default run prints
nothing extra; the JSON envelope gains data.controls.
The repo .gitignore now tracks the control files, and the CI recipe checks
out with fetch-depth: 0 so the base commit is present.
post and record load the bundle's controls.json before any merge read and verify it: schema/policy valid, base_sha equal to the bundle base (PR.json baseRefOid or source.json base_sha), a base-policy snapshot read at exactly that base, and every used file re-hashed. A missing or invalid snapshot refuses controls-unavailable; a base or hash mismatch refuses controls-stale. A pre-D1 bundle must be re-fetched. The merge reads its decisions from the snapshot instead of the worktree: kb.jsonl citations and kb-policy thresholds, and the four overrides fragments (locked-block checks and the footer/attribution). The KB credit read-modify-write paths (counters, joins, retirement) stay on the worktree store. The prompts point the agent at the snapshot learnings.md, and the manual and SECURITY.md document the base-owned control plane. Adds the controls-base eval and seeds hand-crafted eval bundles with a head snapshot.
When git cannot supply the PR base (not a repository, or the object is missing), a GitHub fetch reads each inventory path through gh api repos/<owner>/<repo>/contents/<path>?ref=<base> on the same Commander seam: 404 is an absent control, any other failure refuses, and the per-file and total caps apply to the reported size before any byte is decoded. Other providers keep refusing controls-unavailable.
A chunked fetch told the agent to feed full.diff, the very file the cap refused. The envelope and human next lines now name chunks/manifest.json and the chunks it lists; unchunked output is unchanged.
The local-worktree/branch/stash/paths/untracked/dump goldens record head_ref and the stash commit (whose hash covers 'WIP on <branch>'); git init took the runner's default branch (master on CI), so they only passed where init.defaultBranch=main.
NTFS carries no executable bit, so the embed-drift, skill-install, and npm-tree checks read 'not executable' for files git marks 0755. Linux and macOS CI keep pinning the modes.
runCapture wrote the whole usage block into an unread pipe; a Windows pipe buffers 4 KiB, so the front-door tests blocked until the 25-minute test timeout killed the package.
When a child held the output pipe past WaitDelay, Wait returned ErrWaitDelay for a command that had exited 0 and the watchdog recorded exit 1. The orphan sweep already flags that run through the decoy marker; the exit now stays 0. The orphan test moves out of the Windows-only file so every OS pins it.
The harness wrote the gh stub as an extensionless script, which Windows
exec.LookPath never resolves, so every Windows parity run executed the
runner's real gh ('To use GitHub CLI in a GitHub Actions workflow, set
GH_TOKEN', 'gh version 2.103.3'). Each stub now gets a stubshim.exe copy
that hands the script to bash with the argv untouched (a .cmd shim would
re-parse quotes and pipes through cmd.exe), and the fetch suite installs its
smart stubs through the same path.
…t waiting The guard `attempt >= retry.MaxAttempts-1` in runReadRetry is not an equivalent mutant: dropping it sleeps after the final failed attempt (up to the 60s backoff cap) and, under cancellation, surfaces the context error instead of the attempt's exit failure. Cancelling as the third attempt returns observes exactly that.
- the 300-byte head cap and the 65,536 hosting limit are literals, not the production constants they guard (a changed constant used to move test and code together) - the dry-run recheck leg runs as a non-author reviewer and asserts APPROVE, so it reaches the guard it names - postCounts uses three distinct counts, so swapped statuses fail - the stale-downgrade test no longer pins the literal backslash-n separator the production code emits (not specified by the manual) - the no-base fetch control asserts the fetch really ran - failed-post marker check globs instead of recomputing a hash - errcheck, gofumpt, fieldalignment, unparam, QF1008 fixes; repo-style nolint on the long table tests
The awk-port branches that decide which side rows a hunk gets, whether a header indexes at all, and where a span ends were all unexercised: gremlins left 8 mutants alive and 3 uncovered, at 88.06% test efficacy and 95.71% mutator coverage. `branches_test.go` adds the four cases those mutants hide behind: `Parse` skips the zero-count side (a new file indexes only NEW, so no anchor on it reads as outside its hunk), the header field gate keeps a 3-field header and drops a 2-field one, `spanEnd` keeps the last non-saturating span exact, and `Files` counts a combined `@@@` header in both counters. `diffpath_test.go` gains a single unquoted token (the only header shape that reaches `cutGitPath`'s not-found branch) and an empty quoted b-side, and `TestUnquotePath` gains the invalid-escape and empty-quoted rows that pin `unquoteGitPath`'s fallbacks. Now 67 killed, 3 lived (all equivalent: two boundary flips and the unquoted branch's discarded remainder), 1 non-terminating mutant timed out; efficacy 95.71%, mutator coverage 100%.
`report`, `next`, `show`, `ready` and `trend` all read bundles through this package, and gremlins found the shared seams nearly untested: 29 mutants alive and 43 uncovered, at 83.43% test efficacy and 80.28% mutator coverage. The new tests pin, with literal or independently derived expectations, the finding rank tiebreak chain (severity, the rigor rungs, the path normalization) and the two status counters, the usage handoff's record index, zero-value guards, size cap and session tiebreak, the cost rollup's tier and top totals, modelless gate and estimate sentinel, the slug cap and both character-range edges (plus `ASCIILower`'s), `ShortSHA`'s seven-byte head, the threads page argv and decoder with their refusal paths, and the overrides placeholder gate on the preamble as well as the attribution file. Now 196 killed, 7 lived (each argued as equivalent in `.scratch/audit2/A3d-tests-findings.md`), 15 uncovered (instrumentation artifacts and two legs only other packages' tests reach); efficacy 96.55%, mutator coverage 93.12%.
…g and a lone-quote path The eight-key rank fixtures put each winner first on sig as well, so disabling the anchored or inBounds comparison stayed green. Add pairs whose winner carries the larger path and sig. The manifest chunk names are not equivalent to the chunk-* glob (the manual allows any <name>), so pin a manifest-only chunk. A lone quote token must come back whole, not panic. Tighten the est_usd null check to require a present null.
`Decode` ends its tail check on `json.Decoder.More`, which also reports
false in front of a stray `}` or `]`: `{"a":1}}` decoded as a clean
document and the extra byte vanished. Only a clean EOF now ends the
stream; `decodeSequence` shared the same `More`-plus-tail-check shape, so
both call one `sealTail` helper instead of two copies of the check.
The stricter tail immediately caught a malformed fixture: the fetch
golden stub's fallback threads envelope carried one closing brace too
many, and only ever decoded because the stray closer was dropped. Fixing
the literal leaves every golden byte-identical.
…ering The gremlins run lived through the ordered-object edits (Set keeps a key's position, Delete drops it from both the map and the order slice), the tolerant `NewObj` pairing loop, and the pretty printer every findings store is frozen with.
Adds the missing half of the front door: the `--json` failure envelope byte for byte (key order, `data: null`, candidates, retry_at, the injected clock), the `canceled` exit-3 rule at the renderer, the human/envelope stream split, `--no-color` precedence in all four directions, the value-operand helper, `PeekJSON`, the seven boolean setters no test named, and `--flag=value` spellings.
The float64 arm of Str and R is the path a plain json.Unmarshal result takes, and it was unexercised; 1e7/-1e7 pin that integral floats print as integers without an exponent. Gremlins' internal/jq coverage is now 100% with 104 killed, the four survivors all proven equivalent.
The DecodeObject malformed row only required the "decode json:" prefix, which the typed non-object refusal shares, so it could not tell a decode error from a collapsed one. Require the decoder's own "unexpected EOF". The accepts-one-document comment named a helper (requireEOF) that does not exist; the tail check is sealTail.
…e it runs The child joined its kill-on-close job object only on the watchdog's first poll tick (or at kill time on an unbudgeted context), so a grandchild spawned in that window escaped the job and survived a timeout or cancel. Spawn CREATE_SUSPENDED, assign to the job, then resume the primary thread via a Toolhelp thread snapshot. A failed assignment or resume terminates and reaps the child and returns a typed error; it is never left suspended.
SIGTERM to `verdict mcp` used to take the default signal action: the server died outright, its in-flight tool call never saw a cancel, and the child `verify` (its own process group) kept running with nobody left to kill it. `runMCP` now reuses the CLI's shutdown signal context, so the per-call contexts cancel. `Serve` also has to end without stdin EOF: it reads frames in a goroutine and returns when the context is done, after waiting for the handlers, with a closed flag so a late frame is never written.
On a signal Serve left its select without synchronising with the read loop, so inflight.Go (read loop) and inflight.Wait (Serve) had no happens-before edge: the race detector flagged every signaled session, and a call dispatched in the same instant could slip past the wait. Serve now marks the session stopping under callMu before it waits, and handleToolsCall adds to the wait group under that lock, refusing a call that arrives after shutdown began. The end-to-end test missed the report because the race runtime only rewrites a zero exit, and the child exits 3; it now fails on a DATA RACE in the child's stderr and covers SIGINT as well as SIGTERM. A package test pins the stdin-open shutdown, signalling readiness through a file so the test adds no edge the real signal lacks.
…n every arch CanonNumber converted non-integer literals to float64 and then to int64. At 2^63 that conversion differs by architecture: arm64 saturates to MaxInt64 and prints 9223372036854775807, amd64 wraps to MinInt64 and prints 9.223372036854776e+18. jq prints the literal's own digits, 9223372036854775808. jq 1.8 keeps a literal's significant digits and only reformats them: plain notation while the exponent is non-positive and the adjusted exponent is at least -6, exponential notation otherwise, trailing fraction zeros and the sign of zero preserved. Rebuilt that way, no float64 or int64 conversion is left in the path, so the output is identical on arm64 and amd64 (both proved by running the same table). TestCanonNumber's table now carries jq's literal output verbatim, taken with `printf '%s\n' <lit> | jq -c '.'` on jq 1.8.2, including 9.2e18, both sides of 2^63, 1e19 and their negatives. Rows for 2.0, 1e7, -1e7 and 1e999 move from the double form to jq's literal form (2.0, 1E+7, -1E+7, 1E+999); every other package's suite is unchanged. Before the fix on arm64: 9.2e18 -> 9200000000000000000 (want 9.2E+18), 9.223372036854775808e18 -> 9223372036854775807 (want ...808), -9.223372036854775807e18 -> -9223372036854775808 (want ...807), 1e19 -> 1e+19 (want 1E+19). On amd64 the same rows report 9.223372036854776e+18.
…the file's own mode `report --output`, `report --sarif` and the MCP report artifact went through os.WriteFile: a kill mid-write left a truncated report, and reports can carry reviewed-diff excerpts. Both adapters now call atomic.WriteThrough, which stages a temp in the target directory and renames it over the target: - a symlink is resolved first, so the link survives and only the file it names is replaced; - an existing file keeps its own mode, and a new file gets the caller's 0600 (unchanged: reports can carry diff excerpts); - a device, FIFO, socket, directory or dangling link keeps the direct write, because a rename would replace the node instead of writing through it — `/dev/stdout` still works; - a failed write refuses `report-failed` and leaves the previous file byte-for-byte intact, with no staged temp left behind. No `--output -` special case exists today (`-` is a literal filename), so there was none to preserve. Tests: mode kept on overwrite; a symlink target replaced through the link; a dangling link's target created with the link intact; /dev/null left a device; an injected failure (unwritable directory) keeping the old bytes and no temp; the adapter's report-failed refusal naming the path. Proofs: before the fix both refusal tests report "want a report-failed refusal, got success"; with the adapters calling atomic.WriteFileMode instead the link tests report "link mode = -rw-------; want the symlink preserved"; with the mode-preservation dropped the mode rows report 600 against 640; writing directly for every target turns both refusal tests green-but-wrong.
… multi-line string The Codex merge is line based, by design: it never runs a TOML parser. A multi-line string breaks that assumption. `[mcp_servers.verdict]` spelled inside a `'''`/`"""` literal was read as a real table, so the merge inserted `command`/`args` into the literal — the config was corrupted and verdict silently stayed unconfigured. Refuse instead, typed `mcp-config-unmergeable` (already registered), with a message that says to add the table by hand. The check is bounded to lines at or before the table's own end: a literal in an earlier or later table can neither hide this header nor block an append, and it runs after the "already configured" decision, so a host that needs no change still reports `keep` rather than refusing. Tests: both quote styles with a fake header (refused, file byte-identical), a literal before the table, a literal inside its body, a literal in another table still allowing the append and then `keep`, and a literal in a later table still allowing the missing keys to be filled. Proofs: without the guard the first case merges (`ref = <nil>`); checking the whole file instead of the table's end refuses the later-literal case wrongly; checking before the keep decision refuses the already-configured host.
…ugh the literal canonicalizer CanonNumber now rebuilds a literal from its own digits, so feeding it the shortest 'g' form of an untyped float64 turned 1e6 into 1E+6 and 1e-05 into 0.00001 (jq prints 1000000 and 1e-05). Float renders a double from its shortest digits with jq's plain/exponential switch and no float-to-int conversion, so it cannot diverge by architecture either.
Windows reports every file as 0666 and a read-only directory still allows creating files, so the mode and unwritable-directory assertions are POSIX-only, as the neighbouring atomic tests already split them.
…rewritten in place Writing through a link with a plain os.WriteFile leaves the link and the bytes identical to the atomic path; only the target's identity tells them apart, so the test now requires the staged file to take its place.
…before an inode can be reused
🦋 Changeset detectedLatest commit: f5866bb The changes in this PR will be included in the next version bump. This PR includes changesets to release 1 package
Not sure what this means? Click here to learn what changesets are. Click here if you're a maintainer who wants to add another changeset to this PR |
|
Important Review skippedToo many files! This PR contains 1015 files, which is 915 over the limit of 100. To get a review, reduce the PR to 100 files or fewer by splitting it into smaller PRs or changing its base branch. Upgrade to a paid plan to raise the limit. Usage-priced reviews support at most 300 files.
|
Summary
Replaces the ~6.6k-line
scripts/review.shwith a single static Go binary. Every verb is aninternal/coreservice with typed refusals; the CLI, MCP server, and Go/TS clients are thin transports over it.New verbs and surfaces:
verdict mcp(+mcp config --agent claude|cursor|codex),verdict skill(embedded skill,skill install),verdict upgrade/uninstall(channel-aware, no prompt),VERDICT_USAGEopen usage contract (schemas/usage.schema.json) — verdict never reads other tools' files.Security fix landed with the port — a PR can no longer edit the rules it is judged by:
--allow-head-controlsis the only opt-out; it is recorded incontrols.jsonand warned. CI recipes now usefetch-depth: 0;fetchoutside a checkout reads the base controls through the contents API, so the no-clone flow keeps working.Final Go audit + host/agent hardening (fixed here; the rest is ticketed as follow-ups):
jq.Cappeddoctorjq/shasum(the binary never runs them)ready/report --live/calibrate), one finding rank (next/report/fix), one sig resolver.errsidecars0600; one gh retry helper; integer parsing refuses overflowverdict install(useverdict skill install)next, Forgejodiff_url, AzureremoteUrl) must match the configured API origin before a token is sentpostalso refuses repeats found in the PR's live reviews (hiddenverdict-reviewmarker), so a fresh CI checkout can't double-posttriage(a human-owned status flip) is opt-in viaverdict mcp --operator; every tool carries readOnly/destructive/idempotent/openWorld hints, enums in input schemas, andinitializeinstructionsfetch --jsonadvertises what each host supports (data.capabilities), so agents learn post is GitHub-only up frontcurl -fsSL https://stainless-code.com/verdict/install.sh | sh/irm …/install.ps1 | iex: the docs deploy publishes the latest release's scripts (sha256-verified against the release assets); binaries, checksums and signatures still come from GitHub Releasesstainless-code/homebrew-tapatFormula/verdict.rb(whatbrew install stainless-code/tap/verdictreads), shared-tap safe with rebase-and-retry on contended pushes; the push is opt-in behind theTAP_PUSHvariableinternal/threadsclassified in the import guards + a coverage test that fails on any unclassified verb adapter; MCPfirstKeymade deterministicthreads.jsonin every bundle: normalized threads for all six hosts from each host's authoritative API (GitHub GraphQLisResolved/isOutdated), author kind human/bot/verdict,finding_siglinks via a hidden marker on verdict's inline comments;verdict threads(+ MCP tool) refreshes it; address-reviews/incremental-review prompts read it instead of rawgh apiEvidence
Real PR (Add deepseek-lossless adapter, web presets, e2e recipe lossless#8, 757 KB / 122 files):
fetch --chunkfrom a non-checkout dir → 2 chunks, controls at base;post --dry-runanchored; a realCOMMENTpost landed and a repeat refusedalready-posted;readysaw the new thread;fetch-local --rangeread controls at base;verdict mcphandshake listed the tool set;verdict threadsread 55 real threads (54 resolved / 44 outdated via GraphQL).CI: the
setup-verdictAction workflow is green on all three OSes, and all 16 CI jobs are green on the current headf5866bba0— run41793046944, 16 of 16 succeeded (Go on Linux/macOS/Windows, installers on all three OSes, evals, TS client, release dry-run, lint, audit, docs). Three test-only problems were found and fixed on this branch, none in the product:ce7e64437(the kb recall test expected backslash bundle paths; slash literals are now asserted on every OS),a3278b8d9(the tree-kill test now gives the stub time to report its pid before the deadline), and the atomic-symlink identity test, which broke twice —1b4688875compares identity after one write, because Linux reuses the first staged file's inode for the second (macOS hides that), andf5866bba0pins the target's Windows file id before the write, because Go resolves it lazily.Branch size:
git diff --shortstat main...agent/go-port= 1,018 files, +149,679 / −8,784 over 342 commits (69 of them since6590c0592). Evals are unchanged in number at 66 passed, 0 failed, 0 skipped, with 0 realghcalls (latest gate log, on this head's tree).Before: bash parity suite + evals against
scripts/review.sh.After:
go test -race ./...green (65 packages),golangci-lint0 issues,make schemas-checkclean,GOOS=windows go vetclean,make deadcode0 baselined,make evals66 passed, 0 failed, 0 skipped (parallel).Before: a PR adding
.review/overrides/*or editingkb.jsonlchanged its own review.After:
evals/cases/controls-base.sh— hostile head controls don't change fetch or the posted body; a tampered snapshot refusescontrols-stale; a missing one refusescontrols-unavailable.Before:
TestCostRecordsStoreCap& co. stayed green with the size cap removed (NUL-padded fixture).After: valid over-cap fixtures; removing the cap turns all five red (mutation-probed).
Test and CI hardening also in this PR:
$ref; a committed baseline fails breaking schema changes; all 216 envelope goldens validate againstenvelope.schema.json.CI completefails on skipped or cancelled jobs.scripts/release.shruns as idempotenttag → goreleaser → npm → tapstages, so a mid-chain failure can be re-run.Hardening sweep (everything this branch introduced is finished in this branch — Linear project "Verdict · Hardening" is 62/62 closed: 60 Done, 2 Canceled):
--jsontoggle, one diff scanner + file-role heuristic, one store reader per file (readcommon), one jq value model, one item locator, one CLI adapter plumbing (Progress/RouteHuman/RefuseTyped), one golden engine for every suiteResult.Datacarried a re-encoded struct, SDKFetch/FetchLocalcould never succeed;nullPR fields read as"null";false/truesorted equal; object-valued costmodelsunreadable; a corpus slug collision resolved differently per verb; a value flag with no value silently used a default (fetch … --provider)BenchmarkRenderOverviewon a synthetic 200-file / 2 MB diff: 17.8 s and 47.2 GB per op → 1.3 s and 261 MB per op; anchor classification no longer scales with the hunk indexmake deadcodebaseline is empty (any new one fails CI)verifytails redact credentials by shape (bearer/basic, vendor token prefixes, URL userinfo) and strip control bytesinternal/schemacheck,schemas/validate.shis a shim); retryable refusals carryretry_at; MCP hidden tools answer-32602with typed data; result-text budgetAudit 2 (evidence-gated second audit)
A second, tool-driven audit ran on this branch after the Hardening sweep, in isolated
worktrees, one lane per area. A finding only counted with objective evidence — a surviving
mutant a new test now kills, a fuzz crasher, a test that fails before the fix and passes
after, or a command whose output contradicts the docs — and a different model family then
verified every lane, with the right to regrade, repair or reject it. Mutation testing
(
gremlins), native fuzzing (60 s per target) and parity guards (internal/archtestoverrefusal codes and the four verb surfaces) did the discovery; every new test was checked
against a banned-tautology list.
fetch,record,reportpost,pkg/verdictreadcommon,hunkscli,jq114 findings across the lanes and the step-1 pass; 112 are issues in Linear project "Verdict · Audit 2" (97 Done, 15
Backlog, 7 High).
A2-parity-06was disputed and stays in its lane report;C1-D1-02wasrecorded as a non-defect rather than filed.
Highs fixed here, one line each:
$(…)hid a tool word from the string gate — a realrmwas reproduced; the gate now refuses nesting past its scan bound.$( (…) )span glued to a word still hid it; a glued span now refuses.Runnerhad noWaitDelay, so a cancelled verb waited forever on a grandchild holding the pipe.PR.jsonwith no files at all.{}, so an empty list was reported as complete.GO-CLI-05documents 3.\nin the posted body (A3c-V-05): the stale-downgrade note wrote a literal\ninto a review — a port-era parity artifact; now a real blank line, pinned by a test that fails before the fix.Step 1 — the last fixable Backlog items, three F lanes each with an independent verifier:
verdict mcpcancels on a signal (B2-process-A): SIGINT/SIGTERM now cancel the session through the existing watchdog and kill the process tree; the base orphaned an in-flightverifytree on SIGTERM (exit −15, grandchild alive). The fix's verifier then found the shutdown data race it introduced —inflight.Waitracinginflight.Go,DATA RACEin 30 of 30 race-built sessions and invisible in CI because the race runtime rewrites only a zero exit — fixed asV-33.CREATE_SUSPENDEDand joined to its job object before it runs, which closes the window the ticket said could only be narrowed.report --output/--sarifwritten atomically (B2-process-C): staged and renamed through a symlink to its target, keeping the file's own mode and 0600 for a new file; its verifier's two defects are fixed too —V-36(the new mode tests had no Windows skip) andV-37(withEvalSymlinksremoved the test stayed green, so anos.SameFilenew-inode check now kills that mutant).[mcp_servers.verdict]header hidden in a literal made the merge insert inside the string; the merge now refusesmcp-config-unmergeableand leaves the file byte-identical.V-32): a literal is rendered from its own digits, so9223372036854775808matches jq 1.7.1 and 1.8.2 on every arch (5392-literal differential fuzz, 0 mismatches); thefloat64callers that this turned into1E+6are back on jq's dtoa rule throughjq.Float(V-35, 3939-double differential fuzz, 0 mismatches).canceled(V-34): a cancel that won the race between the Windows spawn and the resume exited 1 (verify-failed) whereGO-CLI-05says 3; thectx.Err()check now precedes the refusal.Three Backlog items stay open on purpose —
A1-06(deferred to F2 /STA-118),V-05andV-07— each with the reason on its issue. Audit 2 now totals 112 issues, 97 Done, 15 Backlog.Mutation efficacy, before → after (killed / lived):
internal/core/fetchinternal/core/recordinternal/core/reportinternal/core/verifyinternal/envsecretinternal/readcommoninternal/hunksinternal/cliinternal/jqinternal/core/postV-18…V-20internal/mcpmeasured 93.7% at phase 0 and was not re-measured;verifyread 97.8% afterthe lane's own pass and 98.2% once the verifier's fix landed.
jqdecoders,hunksdiff paths,mcpconfigJSON + TOML merges, the MCP stdio loop,threadsmapping,releasetar/zip). 11 × 60 s = 59,197,132 executions, 0 crashers; the re-fuzz after the fixes is clean.core.RefusalCodes) is now the single source for the code set: the TypeScriptRefusalCodeunion went from 57 of 128 codes to 128 of 128, andinternal/archtestfails in both directions — a code sighted at an emission site but unregistered, or a registered code with no emission site.V-01…V-38), 12 defects no lane had found (2 High: V-01 verify gate, V-12 Bitbucket; 5 Medium: V-13, V-14, V-22, V-33 the mcp shutdown race, V-35 thefloat64rendering the arm64 fix broke; 5 Low: V-09, V-16, V-17, V-32, V-34), 25 defects in the lanes' own evidence (11 tests that could not fail, 1 test file that would not have passed on Windows, 7 gaps the mutation sweep missed or wrote off, 1 disproved equivalent-mutant claim, 1 copied oracle, 1 gate never run, 2 proposed fixes that did not close their issue, 1 overstated report), and 1 design trade-off recorded rather than fixed (V-38). 2 of the project's 7 High issues came from a verifier.Merge Danger
Door: two-way
Merging publishes nothing: with changesets pending,
release.ymlonly opens/updates a Version Packages PR; npm/GitHub Release/Homebrew publishing happens when that PR is merged (the tap repostainless-code/homebrew-tapexists and the tap push is opt-in behindTAP_PUSH; the six npm platform packages need their one-time bootstrap publish first). Reverting this PR restores the bash script. Merge with Create a merge commit (not squash) to keep the per-change history for bisect/revert.Blast Radius: wide
Every user-facing command is reimplemented. Behaviour is pinned by 344 golden files and 66 evals, but expect edge-case differences. Breaking for anyone who: calls
scripts/review.shdirectly, depends onverdict install, or runsfetchfor a non-GitHub host in a shallow CI checkout (refusescontrols-unavailable— usefetch-depth: 0or--allow-head-controls). The diff is large (1,018 files, +149,679 / −8,784); the bash script and its parity suite are gone. CI is green onf5866bba0— run41793046944, 16 of 16 jobs — after three test-only fixes (ce7e64437,a3278b8d9, and the atomic symlink-identity pair1b4688875/f5866bba0), none of them in the product; but watch the first run on a fresh Windows runner.