The CDP capture handler writes redirects on every network request, empty
when the request was not redirected, so the schema requires it and
compare_web_captures no longer substitutes an empty list.
BREAKING CHANGE: browser network requests without redirects are refused as
malformed; recreate the capture.
* ci: run only the affected portable tests on pull requests
Pull-request CI now runs static checks, the build and the portable tests a change affects, selected from test imports (through test-only helpers), same-stem and directory-scanning tests, leaf-owner boundary tests and tests that name a changed path. Shared boundaries, untraced inputs, empty selections and selections above 150 files fall back to the complete fast suite. Main pushes, schedules, releases and ci:full keep the complete suite. The portable report verifies the exact selected inventory and the CI required gate accepts a selected plan only for a fast pull request with code changes.
* ci: own leaf-adapter tests by name and keep subset summaries diagnostic
* fix(native): count a killed LLDB target awaiting reap as terminated
ensureTerminated proved target exit with kill(pid, 0), which succeeds for a
zombie. A target that SIGKILL ended but debugserver had not reaped yet was
reported as "verified target did not exit after SIGKILL" and the run as
cleanup_incomplete. With the captured start identity, exit is now read
through observeProcessStartIdentityExit, the owner Hopper cleanup already
uses: a zombie or replaced PID counts as terminated.
Refs #2397
* fix(native): keep why the host could not read a launched LLDB target's identity
The host acknowledged an unreadable target identity as "unavailable" and
dropped the observation's reason, so a target-identity-unavailable failure
said only that the identity could not be verified. The reason (the
identity reader's own reason, a thrown inspection failure, or that the PID
had already exited) is now diagnostics.identity_observation.
Refs #2397
* fix(native): publish the LLDB identity acknowledgement complete and stop the zombie fixture's group
* refactor(javascript): charge the worker's retained result bytes through an over-committing Budget
Static checkpoints may retain past the result budget up to the static capacity, and the worker reports that exhaustion itself. Budget.chargeOverCommitting records the excess (overCommitted) and reports no remainder until refunds bring use back under the maximum. The budget-arithmetic baseline is now empty.
* refactor(domain): charge hand-written allowances through Budget and count limit-checked fields (#11405)
* refactor(domain): charge hand-written allowances through Budget and count limit-checked fields
Pyc report and key-walk tallies, reverse-engineering capture admission, Playwright trace fact retention and semantic alias selections now charge a Budget. The budget-arithmetic guard also counts a field outside Budget classes that is adjusted by hand and compared with a limit-named value; the eleven remaining sites are a counted baseline.
* fix(verify): scope limit-checked fields to their class and match limit names in any case
* fix(native): report a target-selected plist against the target, not the unsent path input
inspect_plist resolved a plist that the open target itself selects with the same origin as a caller's path input, so an unreadable target plist was reported as an input issue on path even when the caller never sent path. The selection now records a target origin, and unreadablePlist reports it as a BinaryTargetError for the target. The inspect-plist CLI command is projected from its contract, so its --relative-path issues are named by the CLI key.
* refactor(cli)!: route analyze to the contract its target selects (#10808)
* refactor(cli): route analyze to the contract its target selects
analyze hand-declared both lanes: native open options for binary_overview and the JavaScript integrity policy and source selection for analyze_javascript_application, with its own routing and refusals. registerTargetRoutedCommand now projects each route from its contract, takes the union of their options, runs the first route that owns every given option and takes the target, and refuses options the chosen route does not own by their CLI key. Omitted union fields, including a root discriminator, no longer need an argv projection.
* fix(cli): give a routed command's chosen route its CLI-only option defaults
Routing strips option defaults so an omitted option routes no target. Contract fields regain theirs on admission, but CLI-only options have no later parse, so a defaulted one reached the handler as undefined. The chosen route's omitted CLI-only options now receive their defaults before the handler runs.
* refactor(cli): deliver decompile and inspect-macho Evidence by the contract's detail (#10813)
* refactor(cli): deliver decompile and inspect-macho Evidence by the contract's detail
decompile and inspect-macho omitted the contract's detail field and always printed complete Evidence. Both now declare evidenceDelivery, adding --detail and --evidence_output from the contract. Publishing a result never used the provider id it required, so publication takes no provider and runOnSessionTarget no longer needs one to deliver.
* refactor(cli): project managed artifact and native-boundary inspectors from their contracts (#10816)
inspect-managed-artifact and inspect-managed-native-boundaries re-declared the managed budget fields by hand. Both now register from their contracts on a session target, and inspect-managed-artifact gains --detail and --evidence_output from its detail field.
* fix(cli): name every contract command's input issues by their CLI key
Commands applied their CLI field binding only where a session-target or
direct handler returned an undelivered result. With evidenceDelivery,
decompile publishes through the shared delivery, which returned a
provider failure unprojected, so an issue about the procedure would be
reported at ["procedure"] instead of the advertised positional
"address". Handlers that run a service or publish themselves never
applied it: inspect-il2cpp-metadata reported ["generic_instances"],
inspect-go-binary ["max_string_literals"] and inspect-apple-ips
["join_path"] rather than the CLI keys other commands report.
The contract command now projects whatever its handler returns through
the binding it owns, for plain and target-routed commands alike, and
the handler context no longer carries the binding.
* fix(analysis-view): summarize pseudocode that selected an independent fresh decompile
The pseudocode view parsed its parent's parameters with a selection
schema that admitted only procedure and document. A procedure_pseudo_code
observation made with analysis independent_fresh records that field, so
its summary view refused the parent. Through the CLI's new summary
delivery, `decompile --analysis independent_fresh --detail summary
--evidence_output <file>` would fail after a successful decompile and
never save the bundle; an inline inspect_analysis_view of such Evidence
failed the same way.
The selection schema now admits the analysis the contract offers, and
the contract reads that enum from the same owner.
* test(cli): restore the worker's exit status after synthetic contract command runs
logCliCommand sets process.exitCode on a refused or failed command. The
synthetic routed and input-field harnesses ran in the cli-boundary
project's shared workers (isolate: false) and left that status for later
tests. Each invocation now restores the previous status.
* refactor(cli)!: deliver inspect-managed-members Evidence through the shared --evidence_output (#10845)
inspect-managed-members was the last command with its own Evidence
delivery: a hand-written registration passed --detail and
--evidence-bundle to runProviderAnalysis, whose members-only delivery
variant re-checked heap headroom and published through
deliverAnalysisEvidence. Every other producer writes its bundle with
--evidence_output through publishCliAnalysisEvidence, and elsewhere on
the CLI --evidence-bundle names an input bundle to read.
The command now registers from the inspect_managed_members contract on
a session target with evidenceDelivery, like inspect-managed-artifact;
--type is the contract's type_names. runProviderAnalysis loses its
delivery parameter and its two refusals, and deliverAnalysisEvidence,
now unused, is deleted. Its lifecycle tests drive publishEvidenceDelivery
directly or the CLI delivery; the managed-only headroom pre-check tests
are removed, since the shared delivery deliberately does not
re-authenticate immutable Evidence and keeps the writer's check for
mutable sources.
BREAKING CHANGE: `rea inspect-managed-members --evidence-bundle <path>`
is now `--evidence_output <path>`; the old flag is refused as an unknown
flag. With `--detail summary`, stdout is now
`{"summary": <summary Evidence>, "evidence_bundle": {"path", "bytes"}}`
instead of the summary Evidence alone, and a publication failure is the
shared delivery's error projection without the `error` label or
`input_path`. A summary without a destination names `evidence_output`
in its issue path. Migrate by renaming the flag and reading
`.summary`. Compatibility is not kept: one spelling cannot mean "read
this bundle" on view and workflow commands and "write this bundle" on
one producer.
* refactor(cli): project analyze-javascript-application and analyze's JavaScript route from one contract projection
analyze-javascript-application declared its options by hand, mapped
about twelve option names to contract fields itself, parsed its delivery
separately and resolved its own caller path. analyze's JavaScript route,
projected from the same contract, omitted every field but the path,
source selection and integrity policy, so the two commands for one
contract offered different options.
Both now use javaScriptApplicationCliProjection and
runJavaScriptApplicationCommand: the path positional, --artifact-format,
--source-path, and the two options that accept a JSON file
(--source-paths-json, --semantic-precision), with contract delivery.
analyze therefore takes the JavaScript budgets, --artifact-format,
--semantic-precision and --detail/--evidence_output/--view for
JavaScript targets, and refuses them by CLI key for native targets.
javascriptApplicationOptions is deleted.
The command's missing-target refusal now names its CLI key, "path",
as every contract command does.
* refactor(cli): project the apktool commands from their contracts (#10878)
* refactor(cli): project the apktool commands from their contracts
* refactor(cli): project the Flutter commands from their contracts (#10882)
* refactor(cli): project the Flutter commands from their contracts
* refactor(cli): project the JEB commands from their contracts (#10888)
* refactor(cli): project the JEB commands from their contracts
* refactor(cli): project the Android package, class, method and reference commands from their contracts (#10893)
* refactor(cli): compose compare-managed-members from its contract over two inspected targets (#10914)
* refactor(cli): compose compare-managed-members from its contract over two inspected targets
The contract command builder takes Evidence targets: required contract
fields that each take the Evidence a source contract produces for one
positional target, with the source's options admitted for every target.
compare-managed-members now inspects each path through the typed managed
runner, as inspect-managed-members does, and compares the records as MCP
compare_managed_members does. A failing candidate names its argument and
retains the baseline's Evidence; a cancellation as the comparison settles
retains the comparison. The path-only comparison service is removed.
* fix(cli): drain queued interrupts before a composed command settles
Select snapshot faults by file identity, guard real permission denial to
hosts that enforce it, and release retained owners when a test fails.
* refactor(cli): project the ADB commands from their contracts (#10934)
Each ADB command is registered from its ADB_TOOL_CONTRACTS entry through
registerContractCommand, keeping its positionals, flags and kebab-case path
keys. start-adb-activity keeps its repeatable --extra type:key:value option,
which supplies the contract's extras.
* refactor(cli): project Frida discovery from its contracts and share Frida request mapping with MCP (#10951)
list-frida-devices and list-frida-processes are registered from their
contracts, with each remote member as its own option, and admit the request
MCP would send. instrument-with-frida keeps its argv but builds and admits
the instrument_with_frida contract input. One application owner maps Frida
contract inputs to service requests for both adapters.
* refactor(cli): finalize the Evidence-target composition through runOwned
runOnEvidenceTargets turned a completed comparison into a cancellation by reading the abort signal by hand, which main's architecture guard now refuses outside runOwned. The composition now finalizes through runOwned: its close drains queued interrupts (it owns no resource), and a cancellation observed as it settles keeps the completed Evidence as the partial observation, as before.
* fix(errors)!: keep every completed argument's observation beside a composite failure's own partial (#10961)
* fix(errors): keep every completed argument's observation beside a composite failure's own partial
* test(errors): cover argument observations through cleanup composition and the partial-free fallback
* test(errors): settle the cleanup through its owner's release in the argument-observation case
* refactor(cli): project instrument-with-frida through the contract builder (#10962)
* refactor(cli): project instrument-with-frida through the contract builder with CLI-only positionals and handler-filled fields
* fix(cli): keep omitted flattened members omitted so partial capture limits keep their Evidence
* refactor(cli): project the CDP page-target browser commands from their contracts (#10976)
* refactor(cli): project the CDP page-target browser commands from their contracts
* refactor(cli): project inspect-web-page from its contract with a branch-selecting flag
* test(cli): enroll the browser commands in the parity registration check and refuse unenrolled argv fixtures
* refactor(cli): project the V8 Inspector and Electron commands from their contracts (#10977)
* refactor(cli): project the V8 Inspector runtime commands from their contracts
* test(cli): enroll the V8 Inspector runtime commands in the parity registration check
* refactor(cli): project the Electron page observation commands from their contracts (#10987)
* refactor(cli): project the Electron page observation commands from their contracts
* test(cli): enroll the Electron page observation commands in the parity registration check
* refactor(cli): project inspect-electron-fuses from its contract with the shared caller-path rule
The command now registers through registerContractCommand with `path` as a
caller path, so the builder's absoluteCallerPath owns relative-path
anchoring and the command's own absoluteElectronFusePath copy is removed.
inspectWithService records the caller's spelling as caller_input_path.
The named file is unchanged: every `..` is kept for the filesystem, and
Win32 resolves as before. The recorded selected_path drops `.` segments
and repeated separators (`App.app/./` -> `App.app/`), and an empty path is
now refused at argv parsing (VALIDATION_ERROR) like every other
caller-path command.
* test(cli): derive contract-built commands from the builder registries instead of a hand list
Every command named after a public tool contract must register through a contract builder unless it is in a shrinking list of hand registrations, and the renamed contract commands are listed exactly, so an earlier migration that reverts fails instead of dropping out of the parity cases. The JSON-document command hand list is covered by the same check and removed.
* test(cli): drop the empty inspect-electron-fuses path mismatch the CLI now refuses
* refactor(cli): project compare-web-screenshots and analyze-web-bundle from their contracts with builder JSON inputs (#11012)
* refactor(cli): project compare-web-screenshots from its contract with builder JSON inputs read from inline text or a file
The contract command builder gains jsonInputs: structured fields taken as inline JSON or a JSON file path (- reads stdin), read when the command runs and admitted with the contract input before any target is opened. Inline text that is not JSON is refused under its CLI key; a file that cannot be read keeps its own failure. compare-web-screenshots takes both artifacts this way, replacing its hand-written JSON argument parsing.
* refactor(cli): project analyze-web-bundle from its contract
analyze-web-bundle now registers through registerContractCommand with Evidence and view delivery, semantic_precision as a builder JSON input, and source_map_limits flattened onto the existing --source-map-* flags. Page-inspection extras stay omitted, and script sources stay on as the contract default. The superseded javascriptRouteDelivery options, passive browser scope options, observation duration helper and fetched source-map option set are removed.
* refactor(cli): take semantic_precision of JavaScript application analysis as a builder JSON input
analyze-javascript-application and the analyze route read --semantic-precision through the contract builder's jsonInputs instead of a CLI-only option decoded in the handler, so the decoded budgets are admitted with the contract input before analysis.
* refactor(cli): route compare-web-captures to the contract input shape its documents select (#11027)
* refactor(cli): route compare-web-captures to the contract input shape its documents select
* fix(cli): keep routed defaults advertised and reuse the admitted capture parse
* fix(cli): keep explicit routed options distinct from advertised defaults
* refactor(cli): project inspect-ntfs-journal from its contract (#11043)
* refactor(cli): project inspect-ntfs-journal from its contract
* refactor(cli): project the pcap commands from their contracts (#11045)
* refactor(cli): project the pcap commands from their contracts
* refactor(cli): project inspect-playwright-trace, the Cutter commands and execute-rizin-command from their contracts (#11046)
* refactor(cli): project inspect-playwright-trace from its contract
* refactor(cli): project the Cutter commands from their contracts (#11047)
* refactor(cli): project the Cutter commands from their contracts
* refactor(cli): project execute-rizin-command from its contract (#11048)
* fix(cli): refuse a selected page without summary delivery before opening the target
* refactor(cli): project export-web-scripts and trace-web-module-imports from their contracts (#11053)
* refactor(cli): project export-web-scripts and trace-web-module-imports from their contracts
* fix(cli): describe export-web-scripts paths as resolved against the working directory
* refactor(cli): project the web runtime and JavaScript recovery commands from their contracts (#11084)
* refactor(cli): project the web runtime commands from their contracts
* refactor(cli): project recover-javascript-sources from its contract
* refactor(cli): select a contract input branch by its literal field and project guided-workflows (#11085)
* refactor(cli): select a contract input branch by its literal field and project guided-workflows
* fix(cli): refuse delivery options before reading JSON inputs
* fix(cli): keep branch-only defaults to their branch and name admission issues by CLI key
A branch-only field no longer carries its default into the shared options, so another branch never receives it; the selected branch applies the default on parse. Contract admission failures are projected to CLI keys like handler failures. CLI defaults are typed only on top-level fields, the one place that applies them.
* refactor(cli): project compare-process-captures from its contract, checking each capture before reading the next (#11114)
* refactor(cli): project compare-process-captures from its contract, checking each capture before reading the next
The contract builder gains jsonInputChecks: each check runs on a decoded JSON input as soon as it is read, in argv order, so a refused input stops the command before the next is read; the handler receives what each check admitted. compare-process-captures authenticates the left capture before reading the right and the right before the trace specification, then compares the authenticated facts. It now also takes inline JSON, stdin and --max-capture-age-ms like MCP. Empty JSON input text is refused at argv. A JSON input whose final file close fails is reported as cleanup_incomplete naming the file instead of an unclassified failure. compareProcessEvidenceFiles and its trace-spec parser are removed.
* fix(cli): retry a refused JSON input close and keep the read's refusal beside incomplete cleanup
parseCliJsonInput gives the file's owner a resource scope, so a transient close refusal is retried before the command fails. A close that still fails reports cleanup_incomplete composed with the read's own refusal. Routed commands refuse routes that check a shared JSON input differently, since it is checked before the route is chosen.
* refactor(cli): project inspect-web-network-capture from its contract with nested protobuf options
The contract builder flattens a nested optional object member in turn (protobuf.schema), resolves a flattened caller-path member and reports it as spelled under its dotted path in callerInputs, keeps a flattened member's contract default out of argv so an omitted member stays omitted, and takes an array of numbers as repeated decimal tokens within its bounds. inspect-web-network-capture registers from its contract with the same option names; Evidence keeps the capture and descriptor paths as the caller spelled them. CLI input issues name the capturePath argument.
* fix(cli): name a selector field by its own option in admission issues
A selector parameter's positional may share another key (decompile's procedure positional is address), so mapping the field to its positional key renamed selection issues that already name the option, such as a missing or conflicting --procedure. Map a selector field to its option.
* fix(cli): retain a JSON input file whose close fails and keep why its read stopped
parseCliJsonInput dropped its per-read scope after the owner's close retry failed, so the handle lost its owner, and a read or cancellation failure recorded before the close was replaced by the cleanup failure. The read's scope now stays with the CLI process until final CLI cleanup retries it, and the recorded outcome is translated once into the primary failure with the cleanup attached. The module moves into src/cli so it can register with the CLI process owner without a layer cycle.
* refactor(cli): project inspect-with-objdump and inspect-api-contract from their contracts (#11142)
* refactor(cli): project inspect-with-objdump, list-objdump-architectures and inspect-api-contract from their contracts
The contract builder selects input branches by a field that is a literal in
one branch and an enum in another, takes the default of the one branch that
admits omission, and lets a command take a subset of a union's branches by
their discriminating values, fixing the field when one value is selected.
* refactor(cli): project trace-web-source-location from its contract with flattened positional objects (#11167)
* refactor(cli): project trace-web-source-location from its contract with flattened positional objects
The contract builder flattens required objects as well as optional ones; a
flattened field listed in positionals takes its members as positionals in
member order. The hand-written source-map limit options and the separate CLI
delivery schema are removed.
* fix(cli): refuse to flatten a required object without a required member
* fix(cli): refuse a malformed Evidence-input document before reading the selected bundle
runEvidenceInputCommand admits the document with its transport frame before
it reads --evidence-bundle, so every Evidence-input command refuses a
malformed document first, as compare-static-and-observed-endpoints already
did by hand.
* test(cli): expect a selector field to be named by its option in input issues
* fix(cli): report a refused view before the delivery rule it would trip
Refusing delivery options before JSON inputs are read checked --evidence_output before the view's own schema, so a summary view naming an unknown field reported only the missing bundle. Admit the view with the contract's view field first, as full admission does.
* refactor(cli): project inspect-android-jni-bindings from its contract with a grouped --query option (#11196)
* refactor(cli): project inspect-android-jni-bindings from its contract with a grouped --query option
A projection's fieldGroups take several optional top-level contract fields as the members of one JSON object option. The text is decoded when the command runs, refused with the group's message when it is not a JSON object, a member that is not one of the group's fields is refused by its path, and the contract admits each member as its field. inspect-android-jni-bindings keeps its --query selection through a group and now registers through the contract builder, so the hand-registered contract command list is empty; the superseded parseCliAnalysisEvidenceDelivery and androidJniDeliverySchema are removed.
* fix(cli): refuse an object rule that names a grouped field
A grouped field is a JSON member, not an option, so a contract rule such as dependentRequired naming it would be advertised over an option that does not exist. Registration now refuses that combination.
* fix(cli): describe the --view and --maxCaptureAgeMs options of projected commands
A projected view field kept no help because the contract's own description was skipped and none replaced it, and compare-process-captures exposed max_capture_age_ms without help. The canonical CLI catalog test refused both. The view option now takes the same help in both builders.
* refactor(cli): derive the CLI command inventory from the contract registry (#11248)
A contract now declares `cli: true` when the CLI exposes it as the command
named by its kebab-case name. The primary CLI inventory (CLI_COMMAND_NAMES,
now owned by catalogIdentity.ts) is derived from those declarations plus the
commands no contract names, and a contract projection omits `command`: the
builder names the command from the contract and refuses a contract that does
not declare one. CLI_COMMANDS keeps only the 32 commands no contract names;
the 164 contract-named entries and the copied MCP-only list in
cliToolCoverage.test.ts are removed.
* fix(managed): keep decoded members when only their loaded literals exceed capacity
A capacity failure while decoding #US literals discarded the member facts already decoded, because the shared representation budget threw through the whole inspection. Literals carry their own coverage, so the inspection is retried without them and reports user_strings as partial with the capacity issue. compare-managed-members, which now runs full inspections, keeps comparing members it used to read with literals disabled.
* test(cli): expect builder-admitted issues by CLI key and option help with its default
Builder admission of compare-web-captures, compare-web-screenshots and analyze-web-bundle names input issues by the CLI key (beforeJson, afterJson, normalizationJson, endpoint), and --integrity-policy help states its default. Four test files still expected the contract field names and the old help, so they failed on the stack.
* test(cli): read each refused browser input's CLI path directly now that every case names one
Every invalid browser input now carries its CLI key, so the fallback branch narrowed to never and failed the TypeScript compiler's typecheck.
* chore(verify): carry the moved cliJsonInput baseline entry into its per-guard file
Rebased on main after #11316 split the guard baselines and #11181 threaded the launch environment into the web bundle command; the contract-built analyze-web-bundle command now passes that environment to the browser provider.
* refactor(cli): hand whole-input contract handlers the admitted parse instead of parsing again (#11301)
* refactor(cli): hand whole-input contract handlers the admitted parse instead of parsing again
* refactor(cli): parse an argv whole input only when the handler reads it
Admission parsed every argv whole-input command eagerly, so handlers that
hand the raw input to a service (inspectWithService) parsed it twice.
parseWholeInput now parses on the first admittedContractInput call and
reuses the result; run-time JSON and view delivery still parse at
admission. The test counts whole-schema evaluations.
* refactor(cli): hand JSON-document handlers the admitted parse of their document (#11332)
observe-native-calls, capture-electron-scenario and match-native-functions
parsed their resolved document against the contract schema in the handler.
registerContractDocumentCommand now gives each document handler
parseWholeInput, a memoized parse of the resolved document as the whole
contract input whose refusal names the caller's spelling, so
admittedContractInput serves argv and document commands alike. A handler
whose document is not the whole input never calls it, so it adds no parse.
* fix(cli): admit checked JSON inputs through their checks only
compare-process-captures walked and copied both capture records again in
the whole-input parse after their checks had admitted them. Admission now
parses the remaining fields with the contract and hands the handler the
checked documents uncopied. The managed summary example names
--evidence_output.
* refactor(mcp): bind web network capture through the shared service binding table
* refactor(mcp): bind web runtime tools through the shared service binding table (#11395)
inspect_analysis_view and inspect_il2cpp_metadata wrote "--evidence-bundle"
and "--ghidra-seeds needs --binary" into their own input issues, copying
the CLI's option spelling into the service. They now name the field
(binary_path) or the input ("An Evidence bundle"), and the CLI's field
binding keeps owning option spellings.
A counted architecture guard records the 41 remaining REA CLI option
spellings outside src/cli (mostly "(CLI: --flag)" remediation hints) so
the list can only shrink.
* refactor(domain): charge the Interface Builder, NativeAOT, managed and runtime budgets through Budget
* test(browser): show a refused runtime retention charge leaves the room intact
* refactor(domain): charge the remaining fixed allowances through Budget (#11383)
* refactor(domain): charge CUDA metadata and SQLite reply budgets through Budget
CudaMetadataBudget (visits, section reads, temporary index) and the SQLite
OutputBudget kept hand-written allowances whose field names escaped the
budget-arithmetic guard; the SQLite reply budget also charged each part
before checking it. Both now charge Budget, which refuses an oversized
charge without changing the remainder.
The guard now also counts, inside any hand-written ...Budget class, a field
that is adjusted by hand and compared with < or >, whatever its name.
Unchecked tallies (a yield counter, a reservation ledger) stay uncounted.
Firmware arena cursors are write offsets, not allowances: they are renamed
#arenaWriteOffset and leave the guard's scope. Baseline 17 -> 15.
* refactor(domain): move cache, re-priced, checkpointed and ledger retention onto Budget
Budget gains chargeEvicting (evict the oldest cache entries until a charge
fits) and restore (refund everything charged since a used mark, never
re-charging). With them:
- the Bun metadata range cache evicts through chargeEvicting and charges
physical reads through a second Budget;
- Playwright scenario events refund an event's old cost and try-charge its
re-priced cost, and admission charges with tryCharge;
- WebNetworkProjectionAccumulator keeps one shared allowance plus retained
and temporary shares whose checkpoints restore by refunding;
- EvidenceLedger commits its admitted delta (charge, or refund when a
replacement shrinks) and clears with restore(0);
- the web bundle worker charges an admitted result, and on the completed-
snapshot path retains facts only when they still fit;
- the Pyc nested code walk charges steps and retained references.
budget-arithmetic 15 -> 4 (JavaScriptAnalysisWorker only).
* build(verify): declare the budget-arithmetic guard's counter for typed tests
* test(lifecycle): let phase gates release with a value or a rejection
phaseGate<T, R> now hands R back from hold, and reject(error) makes hold
throw, so gates around a late module load or a descriptor read that
completes or fails after cancellation fit the shared harness. Migrates the
src/application gates (AnalysisProviderRegistry x5, LazyAnalysisProvider,
BinarySessionLiveness, CapabilityScope, McpClientRegistration) and
fileHandleChunks, which exercises reject.
* test(lifecycle): cover an early phase-gate rejection and first-decision release
* test(lifecycle): move src/artifacts and src/process phase gates onto the harness (#11371)
Bun, Deno, FIT, NTFS and Mach-O slice reader gates, and the artifact
resources, owned worker, owned lease and launcher grace gates now use
phaseGate. The lipo capture and launcher grace gates release with their
command result and exit verdict. Arrival-only acknowledgements (ESP and HEX
decoder writes, process cleanup start) and the abort-aware process listing
fake stay as they are.
The repository is user-owned, and GitHub offers merge queues only to organization-owned repositories, so no merge_group event can occur. Revert what 5efaedda88 (#11297) added only for merge groups. Reapply that commit if the repository moves to an organization.
* ci: run required checks on merge-queue groups
Add the merge_group trigger to CI and PR title validation so every required
check reports on the queued group's exact head. Group runs use exact-head
concurrency groups that pushes cannot cancel, classify the group's combined
diff from its base (a non-ancestor base fails planning), and keep the CI
required gate running when a group is cancelled so it fails instead of
reporting a skipped check. Title validation checks every squash commit
subject between the group base and head.
* ci: read the merge-group comparison from a file
A plain `rea --version` reached loadCliRuntime with no command name, so
selectCliRegistration returned undefined and the complete CLI, with every
registrar and its schemas, loaded only for Incur to print the version.
selectCliRegistrations now returns the registrars an invocation needs:
none for a standalone --version, one for a recorded command, and
undefined when the complete CLI must answer. Combined flags, help and
shell completion keep the complete CLI.
Ported from #4083 onto main's lazy registration loader.
Co-authored-by: jianghh <3232826884@qq.com>
Every counted-baseline change edited scripts/verify/architecture-guard-baselines.json, so PRs touching unrelated guards conflicted there. Each guard now keeps its baseline in scripts/verify/baselines/<guard-key>.json with paths sorted by code unit; --shrink-baselines rewrites, and deletes a guard's file when its last count is removed, and the guard rejects unsorted files and files that name no counted guard.
* refactor(verify): give the native verifiers' roots to VerifierFixture
* fix(verify): report every nested JEB cleanup failure reason
* test(verify): give the isolated ADB verifier runs the fixture owner it now imports
* feat(javascript): make the member-mutation work allowance a runtime setting
The member-mutation alias-state allowance from #11144 was a fixed constant, so a refused source could not be admitted without a code change.
Register javascript.member_mutation_alias_states (default 524288, 1 to 8388608 alias states) with the launch seed REA_JAVASCRIPT_MEMBER_MUTATION_ALIAS_STATES. The application, web bundle and reference-source boundaries resolve it from the accepted operation snapshot and launch environment, refuse a malformed seed before analysis, and send it to the workers with each source. A refusal names the setting, its effective value, source and range, and the recovery; worker parents rebuild it from the allowance they sent.
Refs #8294
* fix(javascript): keep the setting and recovery of a refused web script
A web bundle script refused by the member-mutation allowance kept only its reason and reported limits, so the public unknown lost the setting, value, source and recovery. Carry the refusal's structured limit and remediation on the per-script result and its javascript_analysis unknown, grouping scripts only when that recovery agrees. Assert structured limit facts and the owning formatter's recovery instead of fixed wording.
* fix(browser): keep only registered setting limits on a refused web script
* feat(javascript): keep syntax facts for a source whose member-mutation phase is refused (#11187)
* feat(javascript): keep syntax facts for a source whose member-mutation phase is refused
A source refused by the member-mutation work allowance during static analysis lost every fact, so the application graph counted it as skipped. Reference-source import failed outright on such a file.
Checkpoint the parser, comment and text facts the static owner can still state, with parse status partial, examination not-examined and refused_phase member-mutations, before reporting the refusal; the semantic phase is not started because it indexes the same mutations. Reference-source import keeps the file's declaration-level imports and records that its CommonJS require calls were not examined.
Refs #8294
* test(javascript): compare the reference-source refusal with its owning formatter
* feat(javascript): keep a refused web script's parse and text facts
A captured script whose member-mutation phase was refused lost every fact in analyze_web_bundle, so it was neither counted as parsed nor kept its vendor markers.
The analyzer now returns the script as unavailable with partial facts: refused phase, parse status and the inferences read from script text alone. Findings gathered before the refusal are dropped, because they may have read an incomplete mutation index. The worker parent states the refusal and its setting recovery from the allowance it sent, through the same helper the isolated analyzer uses for every unavailable script. The bundle counts the script as parsed, keeps its text inferences, and its javascript_analysis unknown carries refused_phase.
Refs #8294
* chore(mcp): record the member-mutation setting in the advertised summary
* fix(javascript): rebuild a parked source worker when the member-mutation allowance changes
A worker parked on a resource scope was reused when heap, timeout and precision matched, but its requests carry the allowance it was built with. After update_analysis_settings accepted a new allowance, the next analysis on that scope kept the old one.
The reuse check now compares the allowance's value and source, so a changed setting gets a worker built with it. The web bundle worker already takes the allowance per script.
* refactor(verify): give the remaining verifiers' roots to VerifierFixture
* fix(verify): let the loader-relocation supervisor dispose itself so a retried stop can observe its exit
* test(verify): give the isolated bridge-sources and packaged-wasm runs the fixture owner they now import
* test(verify): observe the Bun and Go verifier roots where VerifierFixture loads them
* refactor: report NativeAOT, Interface Builder and owned-MCP output limits through the shared limit owners
* refactor(errors): carry a parser's required value on its limit reference and in adjustable-budget refusals (#11201)
* fix(android): keep the JADX output-limit refusal's retained process output
* refactor(native): name PE and native-export allowances in the BinaryResourceFailure limit (#11253)
PeImportLimitFailure, PeLoadConfigLimitFailure and NativeExportLimitFailure kept a parallel `limit` field beside the LimitRef their BinaryResourceFailure base already carries (named only "structure"). The allowance name now lives in the LimitRef, consumers read it with binaryResourceAllowance against the parser's exported allowance list, and the three subclasses are removed. The local-limit-error-class guard also counts limit subclasses of BinaryResourceFailure.
* fix(verify): recognize the ownership ps inventory from the process owner's arguments
* fix(verify): match the recorded-crash ps inventory against REA's fixed ps locations
* fix(javascript): report version-comparison coverage unknown when a source graph cannot tell
* refactor(javascript): name the unavailable-graph coverage mapping once
* fix(javascript): give the version change graph and its edges the same unknown coverage
* fix(javascript): report export-shape comparison coverage unknown when a source graph cannot tell (#11218)
* fix(javascript): report export-shape comparison coverage unknown when a source graph cannot tell
* test(javascript): keep unknown export-shape coverage beside a truncated projection
* fix(javascript): read runtime-reconciliation input coverage once and report unknown when a static graph cannot tell (#11230)
* fix(javascript): read runtime-reconciliation input coverage once and report unknown when a static graph cannot tell
* fix(javascript): keep a known input truncation beside unknown reconciliation coverage
* fix(javascript): report export-shape source omission counts unknown when a side has no projection (#11261)
compare_export_shapes reported left/right_omitted_fields and omitted_property_coverage as 0 for a side whose export selection recovered no return-shape projection (missing, ambiguous or unavailable), while the sibling source_omitted_variants already reported null. Add Known<T> (src/domain/known.ts) and read each side's source coverage once through it; the counts are now null (unknown) with a limitation naming why. The runtime-reconciliation graph's omission sum and its parallel 'omissions known' flag become one Known<number> via sumKnownCounts (no output change).
compare_managed_members reported partial when a side's member inspection was unavailable or when selected-scope agreement could not be established, and verify_managed_native_boundaries reported partial when the boundary inspection was unavailable. Both now fold their inputs with joinCoverageStatus, so unknown wins beside a known gap. The status enums gain unknown (additive).
* refactor(mcp): register service-backed tools through one contract binding loop
registerContractTools registers every bound contract from the registry through the shared Evidence or retained-summary handler its binding selects, and refuses a binding that names no registered contract. createServer declares the bindings by exact contract name; 41 per-tool register files are deleted.
* refactor(mcp): bind service-backed tools from one shared table and make each binding select one handler
serviceToolBindings owns the binding of every service-backed contract, keyed by its service; createServer and the MCP tests bind from it, so tests exercise the production handler kind, admission and dependencies. A binding can no longer carry both run and summary. The Go real-binary workflow follows the new registration owners.
* test(mcp): assert binding exclusivity with type-level checks that hold under every checker
* refactor(mcp): derive every advertised tool through one owner
The server's registration and tools/list rewrite, catalog identity and the
Copilot verifier each assembled the advertised description, input and
output schema themselves. src/contracts/advertisedTool.ts now owns that
composition; served environment catalogs (MCP listing and card) go through
the same owner's dialect projection, keeping argument descriptions.
* test(mcp): pin each remaining environment dialect violation to its query union
* test(support): copy isolated-repository scripts with their runtime import closure
* fix(test): resolve package imports to the file Node loads in the import closure
* test(rizin): expect closeAll to abort in-flight starts and cancel TTY validation with a real signal
* fix(process): relay a caller abort dispatched while the start registered its listener
Fail visibly with a dispatcher hint and exit status 1 when the compiled command registry is executed directly. Reuse the existing argv/module identity owner for both entry modules and preserve normal imports and supported dispatch.
Fixes#10762.
Builds on #10766.
Co-authored-by: 2SinceJuly <202121119+2SinceJuly@users.noreply.github.com>
Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
summary.json held every advertised pattern's site list and every tool's
schema digests in one file. Each new path-taking tool appended to the
shared path pattern's list, so concurrent tool PRs conflicted on it, and
updating it required a local build.
Each tool's digests and patterns now live in
scripts/verify/advertised-schemas/tools/<tool>.json. The check still prints
aggregated review lines such as "N tool schemas gained pattern /.../", and
on failure also prints the expected contents of each missing or stale file
so a PR can commit them from CI output without building. --update-summary
writes those files and deletes summaries of removed tools. The existing
summary was split into per-tool files from its recorded data.
Fixes#11189
Admit ELF machine 94 as the canonical Xtensa family through Ghidra's header-selected import. Share generic-header exclusions between static target types and live CLI/MCP summaries, preserving ELF-only format constraints and other providers' decline paths.
Fixes#10765.
Adapted from #10774.
Co-authored-by: Josh <joshuakrishna21@gmail.com>
Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>