* fix(evidence)!: require ESP flash_dump and PE unsigned attribute OIDs
Both fields were optional only for Evidence recorded before REA reported
them (6.8.0 and earlier). Every producer writes them: the ESP image reader
and facts builder write `flash_dump` (null unless the file is a flash dump
read from a later address), and the PE certificate parser writes
`unsigned_attribute_oids` (null when the signer has none). They are now
required and nullable, and the inspection hint no longer branches on an
absent `flash_dump`. The ESP acceptance test that read pre-6.9 inventory
Evidence now checks that such Evidence is refused.
A call-path comment called Evidence without relationship coverage "legacy";
providers that report no coverage still produce it, so the comment now says
so.
BREAKING CHANGE: inline inventory Evidence for an ESP image root without
`format_metadata.flash_dump`, and PE certificate Evidence whose signers lack
`unsigned_attribute_oids`, are refused as invalid input. Recreate the
observation with the current REA.
Refs #10510
* test(certificates): refuse a signer without unsigned_attribute_oids; update the guide
When a Cutter response exceeded the framed transport limit after the command
was sent, the client kept the structured limit error only as message prose:
the command result's `message` named the bytes and the launch seed, and the
returned failure (completion unknown) carried no limit. The client result now
keeps that error's setting limit, and the service attaches it to the failure,
so it projects as `details.limit` (`bridge.max_request_bytes` with its
effective value and source). The test asserts the fact instead of the prose.
Refs #10508
* fix(native): keep unreported value-flow truncation and archive decode coverage unknown
* test(verify): count multiline optional-fact defaults and pin the guard's exclusions
* fix(domain): keep unknown counts and costs unknown in comparison and coverage summaries (#11325)
* fix(domain): keep unknown counts and costs unknown in comparison and coverage summaries
* refactor(verify): exempt legitimate optional-fact defaults with a reasoned marker (#11355)
* refactor(verify): exempt legitimate optional-fact defaults with a reasoned marker
The optional-fact-default guard counted request defaults and absence that
is modelled elsewhere as hidden unknowns. A comment
`// optional-fact-default: <reason>` on the default's line or the line
before now exempts it; the guard reads unstripped source for the marker and
ignores matches inside comment lines.
Marked: the two evidence paging offsets and four Swift literal reads whose
absence swiftLiteralCoverage reports. Removed instead of marked: jsdiff 9
types Change.count as required, so its two `?? 0` defaults were dead; the
evidence link traversal now carries retained records, so it no longer
re-looks them up behind `?? []`. Baseline 31 -> 22.
* fix(verify): blank comment spans instead of skipping comment-led lines in the optional-fact guard
Skipping a match whose line starts like a comment hid live code after a
leading block comment and counted defaults inside a block comment without
leading stars. The counter now blanks comment text (keeping offsets and line
breaks, skipping string literals) and matches the blanked code, while
exemption markers are still read from the original lines.
* refactor(domain): mark optional-fact defaults whose absence is not an observation (#11389)
* refactor(domain): mark optional-fact defaults whose absence is not an observation
Per-site review of the remaining optional-fact-default entries. Each marked
default is a caller option (trace ignore_fields, environment rules), a list
whose producer omits the empty case (unknown_size_frames, the schema's
min-1 representation_node_ids), caveat text whose completeness another field
carries (call diagnostics, unresolved calls, semantic resource limits), or
absence that already turns the result unknown (Wasm interface inventory,
WebMCP discovery, managed ExportedType rows, legacy integrity mismatch IDs).
Left counted: webCaptureDiff redirects (2; the CDP producer always records
them, so absence is a legacy record that should compare as unknown, not
as no redirects) and HopperCallerReconciliation (2; index-miss semantics not
yet verified). Baseline 22 -> 4.
* fix(browser): compare redirects as unknown when a capture predates redirect recording (#11402)
* fix(browser): compare redirects as unknown when a capture predates redirect recording
The CDP producer records every request's redirect chain, empty when there was none; a record without one predates redirect recording (#986). Comparing it against a current capture reported the network dimension as unchanged, treating the missing chain as "no redirects". Redirects are now compared only when both captures recorded them, and the network dimension is otherwise unknown with a reason; proven membership changes are still reported.
* refactor(hopper): interpret a caller-index miss once at the lookup (#11403)
The forward index holds observations from the examined procedures only, and relationship coverage stays unknown with the scan facts as its reason. A miss therefore adds no callers without showing there are none; the lookup now says so once instead of four optional reads defaulting at each site. The optional-fact-default baseline is now empty.
* docs(javascript): state why an omitted representation list adds no nodes
* fix(verify): count optional-fact defaults from parsed TypeScript, not comment-blanked text
The guard blanked comments with a hand-written scanner and matched a regular expression on the rest, so a default quoted in a string counted and a regular expression holding /* hid the code after it. It now walks the TypeScript syntax tree for property reads defaulted with ?? 0, ?? [] or ?? false, and reads exemption markers only from comment trivia.
* fix(verify): tokenize optional-fact defaults without a compiler and count chained defaults
* fix(verify): match whole optional-fact default expressions across calls and operators
* fix(verify): count optional-fact defaults in template substitutions and after postfix updates, and tie markers to their own expression
* refactor(verify): exempt generation and sample caps from the constant-maximum-slice guard by reason marker (#11454)
* refactor(verify): exempt generation and sample caps from the constant-maximum-slice guard by reason marker
* fix(verify): read reason markers only from real line comments
* fix(verify): read reason markers from the shared source tokenizer
* fix(verify): read a regular expression after a control head as a statement start
The shared tokenizer treated every closing parenthesis as the end of an operand,
so in `if (ready) /[/*]/.test(v)` it read `/[` as division and `/*` inside the
regex as a block comment, hiding the rest of the file from the marker-aware
guards. Parentheses are now tracked: the `)` closing an if/while/for/with head
allows a regular expression, while a call's `)` still means division.
* fix(verify): keep a keyword-named member call out of control-head detection
`policy.if(ready) / (…)` was read as an if-statement head, so the division was
taken for a regular expression and the denominator's optional-fact default was
not counted. A control keyword after `.` or `?.` is a member call.
* refactor(verify): exempt budget-arithmetic cursors and tallies by a not-an-allowance marker (#11493)
* refactor(verify): exempt budget-arithmetic cursors and tallies by a not-an-allowance marker
The budget-arithmetic guard cannot tell a scan cursor, an observed total, a
string being assembled or a tail buffer's retained length from an allowance
when each is compared with a limit. A field declaration marked
`// not-an-allowance: <reason>` (read through the shared reason-marker scan)
is no longer counted. The four remaining sites carry a marker, so the
baseline is empty and removed.
* refactor(verify): exempt detail levels, lifecycle states and domain vocabularies from the completeness-enum guard by reason marker (#11510)
A zod enum containing "complete" is counted as a local coverage vocabulary. Eleven
are not coverage: a caller-chosen detail level, how far a command or session
ran, and format states (GPU decode depth, WASM name section, SQLite column
details). They now carry `// detail-level:`, `// lifecycle-state:` or
`// domain-vocabulary:` with a reason, read through the shared reason-marker
scan (which gains an optional predicate for the matches a guard counts).
local-completeness-enum: 22 -> 11 on this branch.
* fix(verify): bind a not-an-allowance marker to its own class field
Exemptions were a file-wide set of names, so a marked tally in one class hid an
unmarked allowance with the same name in another, and a marked object property
could exempt a class field. Markers now exempt only a member declaration (at
class member depth) of the top-level class that contains it, and the named-
allowance count is taken per class so the same scoping applies to it.
* fix(artifacts): keep main's resources import in the Deno standalone reader after merging main
* fix(verify): start an expression after a template substitution and a non-member keyword, and accept any marker reason
The shared tokenizer read the `/` after `${` as division, so a regular
expression holding `/*` in a substitution hid the rest of the file from
every tokenizer-based guard, and it treated property names such as
`row.return` as keywords. Tokens now record whether template text opens a
substitution and whether a name is an expression keyword (not after `.` or
`?.`), and the regular-expression rule and the optional-fact-default operand
rule read those facts. The optional-fact-default guard reads markers through
reason-marker's isReasonMarker, so any non-empty reason exempts, as for the
other reason markers.
* fix(verify): blank comments with the shared tokenizer before matching architecture guards (#11573)
* fix(verify): blank comments with the shared tokenizer before matching architecture guards
The guards stripped comments with a regular expression that took a `/*`
inside a string, template or regular expression for a comment opener and
deleted code up to the next `*/`. src/flutter/FlutterBuildProvider.ts's
"lib/*/libapp.so" text hid four --pool-policy remediation strings from
cli-option-text-outside-cli. blankComments in source-tokens.mjs now owns
comment removal for the architecture guards and the reason-marker scan: it
blanks comment tokens in place (newlines kept) and keeps strings, templates
and regular expressions. The scan behind it retains only the last tokens it
reads, and whitespace runs are skipped at once.
The cli-option-text-outside-cli baseline records FlutterBuildProvider.ts at
its true count of 4; no other baseline changed.
Fixes#11477
* fix(verify): read a regular expression after a statement block and keep comment offsets for wide characters
The tokenizer now records whether each `{` opens a statement block or an
object literal (from the token before it) and marks the `}` that closes a
block, after which a statement, and so a regular expression, can start; an
object literal's `}` still ends an operand. blankComments replaces each run
of comment text with one space per UTF-16 unit, so a surrogate pair no longer
shifts later offsets.
* chore(verify): drop the Flutter CLI-text baseline entry now that main names no option there
* feat(debuggers): name why an owned debugger stop is incomplete
Owned debugger stop results carry a cleanup code; retained Rizin and GDB
cleanup failures project it as details.diagnostics.debugger_cleanup, close-all
failures carry it, and GDB detach refusals name multiple inferiors, a missing
durable output sink, unknown inferior state or a changed inferior TTY.
GdbSessionManagerCoverage asserts the codes instead of reason prose.
* fix(debuggers): put the cleanup code on every returned failure
incompleteStopFacts builds the cleanup observation and debugger_cleanup
diagnostic together, so GDB startup, cancellation and timeout failures carry
the code; Rizin's composed cleanup failure retains it at its top level; and
one-shot debug commands report debugger_cleanup_codes from the close-all
failure.
Thirteen application tools (feature and semantic traces, version, endpoint,
source-to-bundle and export-shape comparisons, API contract, NTFS journal and
Playwright trace inspections, the obligation ledger and the three mobile graph
projections) each had a bespoke registration repeating admission, retention
checks, logging, source retention, unknown recording and view delivery.
The shared table gains an application binding kind: a workflow that returns
the completed Evidence, its sources and its residual unknown, and an optional
view selector. One handler runs it under analysis admission, refuses a view
or summary before running when the complete Evidence cannot be retained,
delivers a failure's partial Evidence, and stages the view against the
completed Evidence before recording (deliverApplicationExecution, moved from
registerApplicationTools/helpers.ts). The comparison unknowns and the ledger's
request resolution move to src/application/ApplicationToolExecutions.ts with
their exact question text, so recorded unknown identities do not change.
* refactor(native): bind producer_limits and max_input_bytes as the per-call controls of pwntools and Apple dispatch refusals
producerLimitControl in src/domain/producerResourceLimits.ts names one producer budget as producer_limits.<field>; the shared provider outcome classifier now carries a resource signal's limit. Pwntools file-size, CPU and output refusals and the Apple dispatch input refusal bind their control, and their remediation no longer names CLI flags.
* fix(native): report the selected output allowance as the omitted file_bytes default
* fix(native): bind producer_limits.diagnostic_bytes as the pwntools command output-limit control
* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals (#11458)
* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals
* test(rust): cover the complete-report refusal's producer_limits control
* refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags (#11466)
* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals
* test(rust): cover the complete-report refusal's producer_limits control
* refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags
deadlineParameterLimit in src/domain/analysisResourceLimits.ts owns the millisecond deadline control that nativeDeadlineRecovery and the browser recoveries share. CDP command and discovery, web bundle per-script and total, network capture and source-map decode deadlines now carry it; browserDeadlineIncrease no longer takes CLI flag text.
* fix(browser): record a per-script deadline's parameter control in partial web bundle results
* refactor(providers): bind Wabt, SQLite, EVMole, Apktool and Go controls instead of naming CLI commands (#11472)
* refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands
These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control.
* refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags
* fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails
* ci(guards): count template-built CLI option and command text outside the CLI layer (#11478)
* refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands
These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control.
* refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags
* fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails
* ci(guards): count template-built CLI option and command text outside the CLI layer
The cli-option-text-outside-cli pattern now also matches "(CLI ...", "on the CLI", "or use rea ..." and backticked `rea <command>` references, so remediation built from a template such as --${name} or rea inspect-... <path> is counted. Doctor.ts is exempt: setup and doctor run only through the CLI. The baseline records the newly counted pre-existing sites (22 -> 45 across 21 files).
* ci(guards): extract the CLI text matcher, exempt host-only commands with written reasons, and test each spelling
* ci(guards): exempt a host-only command and its own arguments in any matched CLI phrase
* fix(native): bind producer_limits.output_bytes for oversized pwndbg debugger replies through one owner
* fix(cli): name an Evidence target source failure's control by the source option that sets it
* feat(cli): render the flags of result-recorded controls in the full-output envelope (#11507)
* feat(cli): render the flags of result-recorded controls in the full-output envelope
* fix(cli): collect result controls only for a full-output envelope, in its requested format, past undefined values
* ci(guards): end a host-only command's arguments before the next CLI command
* refactor(reverse): record the output budget that stopped a one-shot command as a parameter control (#11528)
* fix(cli): read result controls only at positions the output schema declares as recorded controls
* refactor(providers): record the controls that bounded Rust compiler paths and kernel module text instead of naming CLI options (#11532)
* refactor(rust): record the control that bounded compiler-path coverage instead of naming CLI options
* refactor(native): record the controls that omitted kernel module .modinfo text instead of naming CLI options (#11534)
* fix(rust): describe compiler coverage from the retained result after report trimming
* refactor(providers): record managed representation and JavaScript semantic ceiling controls instead of naming CLI options (#11537)
* refactor(managed): record the representation budget on a resource-limit issue instead of naming its CLI option
* refactor(javascript): record the semantic retention ceilings that stopped a graph instead of naming CLI options (#11540)
* fix(cli): name a composed command's source options for the controls its result records
* fix(cli): read result controls from the delivered Evidence when a summary wraps it
* fix(rust): keep the report-byte control recorded when trimming omits every compiler path
When the complete-report allowance left room for no compiler path, rustc_commit became null and its coverage.limit was lost, so --full-output could not name the option that raises the allowance. The report now records rustc_commit_omission { reason, limit } outside the dropped record, and the summary view carries it.
* refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option (#11541)
* refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option
* test(flutter): assert the complete set of recorded string-pool budgets
* feat(cli): name the options of controls a failure's partial Evidence records (#11557)
meta.cli_controls was collected only from a successful result. A failure whose partial observation is Evidence of the command's own operation is now read the same way, at the positions the output schema declares as recorded controls; Evidence of another operation or a retained reference is not read. When --evidence_output publishes the partial, the delivery records it before replacing it.
* refactor(javascript): record the evaluator budgets that limited sources instead of naming the CLI option (#11564)
Per-value unknown reasons and the Electron wrapper limitation named --semantic-precision. The static examination now records the semantic_precision controls that limited a source (examination.controls), and analyze_javascript_application's semantic_graph.coverage.controls records every evaluator budget that limited any source (examination and semantic IR coverage), beside the retention ceilings. The CLI renders --semantic-precision from those records in meta.cli_controls; the reason texts name only the contract field.
* feat(snapshots)!: persist the target identity as the snapshot target
The snapshot target is now `{ kind, identity }`, where `identity` is the
FileTargetIdentity that `binaryTargetIdentity` produces and `kind` is the
binary kind query IDs commit to. The per-format target projection and
`snapshotTargetIdentity` are deleted; the schema checks the format's
selection, architecture and kind instead of keeping one union arm per format.
Entry execution subjects use the Evidence subject shape (file or explicit
unknown), so a snapshot entry commits to the same identity, including the
selection, as its Evidence record. Workflow entries take the subject of the
workflow's own Evidence. Replay no longer re-derives the selection from the
open target.
`FileTargetSelection` gains `universal-slice` (`offset`, `size`, and the FAT
`cpu_type`/`cpu_subtype` when target admission supplied the FAT table, else
null). `binaryTargetIdentity` produces it for `mach-o-universal` targets, so
Evidence and snapshots for different slices of one container no longer share
an identity.
Refs #11417
BREAKING CHANGE: analysis snapshot files change shape: `target` is
`{ kind, identity: { kind: "file", sha256, format, architecture, selection } }`
and entry `execution.subject` is the Evidence subject
(`{ identity, name, local_path }`, never null). Snapshot binding mismatch
details report `target.snapshot`/`target.selected` in the same shape. Evidence
IDs of universal Mach-O targets change because their subject identity now
carries the selected slice. Recreate saved snapshots and Evidence bundles of
universal Mach-O targets.
* docs(evidence): name the universal Mach-O slice selection in the subject contract
* fix(snapshots): read the snapshot target identity in the Ghidra verification scripts
The real Ghidra snapshot checks (lifecycle, RISC-V, MIPS, PowerPC) read
snapshot.target.sha256 and .architecture, which moved under
snapshot.target.identity, so they would fail after saving a valid snapshot.
* feat(evidence)!: name live browser page Evidence by its page URL (#11559)
Browser page observations (inspect_web_page, analyze_web_bundle,
observe_web_session, discover_webmcp_tools, capture_web_screenshot,
observe_web_execution, inspect_web_event_listeners) named an unknown
(`not-observed`) subject although the provider reports the page URL.
`TargetIdentity` gains a `url` kind: the reported URL with userinfo removed
and its origin (`null` for an opaque origin). The schema refuses a URL that
carries userinfo or an origin the URL does not have.
`browserUrlTargetIdentity` in the browser URL owner builds it from the
provider's reported URL; a withheld or unparseable URL stays unknown
(`not-observed`). Target lists and comparisons still name no single
document. Analysis views keep their parent's URL subject, as they already
keep a file subject.
BREAKING CHANGE: Evidence IDs of live browser page observations and their
analysis views change, and their subject is
`{ "kind": "url", "url", "origin" }` with `name` and `local_path` null.
Recreate stored Evidence for these tools. This lands inside Evidence format
revision 2 under the release hold (#11417); no `evidence_format` bump.
Cutter reports the path of the file it opened, but REA neither opens nor
hashes it, so the Evidence subject stays unknown (not-observed). Assert it so
a later change cannot bind the subject to the reported path.
The I/O-free PE resource tree parser moves from src/artifacts/pe to src/domain/pe and reports malformed structure, decode budgets and cancellation through the domain parse failure algebra. artifactParseFailure in src/resources maps those onto artifact reader reasons at each provider's boundary, so native no longer imports artifacts.
Fixes#11527
refactor(resources): give artifact failure translation to resources and declare JavaScript reconstruction's artifact entries
translateArtifactFailure projects ArtifactReaderFailure, which src/resources owns, and depends only on resources and domain, so it moves to src/resources and is exported from its index. JavaScript reconstruction drives the canonical inventory scan, the format reader and the source read inside one resource scope; those three artifacts files are declared entry files. application -> artifacts past-entry imports go from 7 to 1 (the ZIP reader, moved by #11525).
Refs #11359
* perf(mcp): canonicalize the tool catalog once per digest profile
* test(mcp): compare the composed combined digest with whole-document canonicalization
* feat(evidence)!: name the Evidence subject by its target identity (format revision 2)
The Evidence subject carries subject.identity (kind, sha256, format,
architecture, selection) and the Evidence ID commits to it, so raw/DOL
entry points and ESP flash offsets of the same bytes are different
subjects. Every record declares evidence_format: 2; revision 1 bundles,
standalone records and snapshots are refused with the recreate guidance.
binaryTargetIdentity is the one projection of an open target, used by
Evidence and snapshot comparison.
BREAKING CHANGE: Evidence format revision 2. Evidence IDs commit to the
subject's target identity (subject.identity, including the raw/DOL entry
point or ESP flash offsets), and every record declares evidence_format: 2.
Evidence bundles, records and analysis snapshots from earlier releases are
refused; recreate the observations with this release.
* refactor(analysis-view): read parent subjects through the Evidence identity accessors (#11423)
Analysis views compare their parent's file identity (evidenceFileTarget)
and take path and digest from evidenceSubjectTarget instead of reading
the subject's digest, format and architecture members, which duplicate
subject.identity until they are removed. A counted guard
(evidence-subject-declaration-read) keeps new direct reads out and
records the 20 remaining files.
* fix(evidence): carry format refusals through Evidence readers and bind target selections
- safeParseEvidence/safeParseImmutableEvidence return the format refusal as
an expected failure; every consumer maps it to the one integrity refusal
with the recreate guidance. An unmarked object is an earlier record only
when it has every member records have always carried.
- ArtifactProvider inventory roots and provider subjects that name the
target's own bytes carry the target's selection (ESP flash offsets).
- Snapshot rows bind only Evidence whose identity, selection included,
matches the snapshot target.
- Entry-point selections use the raw-binary entry point form.
* fix(evidence): refuse unauthenticated or earlier-format records instead of reading them as absent
- recognizeEvidence (evidenceValidation) replaces tryParseEvidence: input
without an evidence_id is not Evidence (ok(undefined)); a record that names
one but fails authentication or is from another format revision is an
EvidenceIntegrityError carrying the recreate guidance, never undefined.
- Direct analysis retains that refusal as a secondary failure instead of
silently skipping source capture; cleanup projection, source-closure
annotation and the flutter, debugger and release-exposure recoveries use
the same owner (the last three previously read the unauthenticated schema).
- A desktop capture.json from an earlier format is refused with the recreate
guidance instead of "not desktop application capture Evidence".
* fix(evidence): advertise revision 2 ledger examples and rank delivery omissions by serialized size
- The obligation ledger and reconstruction coverage examples named
evidence_format 1, which revision 2 refuses; they now use
EVIDENCE_FORMAT_REVISION.
- MCP delivery chose which unretained recovery to omit by a parsed-storage
lower bound clipped at the response budget. Once revision 2 subjects made
the source record's estimate cross the budget, both candidates tied at the
clip and the smaller source was omitted ahead of the larger completed
observation. Candidates are now ranked by serialized size, which is what
the budget counts.
* refactor(native): compare function snapshots by their Evidence target identity (#11450)
Function snapshots carry the subject's file target identity instead of the
duplicated subject declaration. Call paths and function comparisons compare
targets through sameTargetIdentity, so the same bytes opened at a different
raw entry point or ESP flash offset no longer count as one coordinate space:
build_call_path refuses the mix, and compare_functions no longer matches
entries by address across selections. Structural candidates and native
function matching read the architecture and digest through
evidenceFileTarget.
Refs #11417
* refactor(artifacts): compare artifact and WASM summaries by their Evidence target identity (#11461)
Artifact comparison authenticates a summary against its retained inventory
through sameTargetIdentity and rebinds the alias with the whole target,
selection included, so a flash-selected inventory summary taken under an
alias path is no longer refused. WASM comparison, the analysis view
artifact projection and the inventory root check read the digest, format
and display path through the Evidence identity accessors.
Refs #11417
* refactor(evidence): read record subjects through the identity accessors in JS, managed, ledger and bundle readers (#11470)
JavaScript application graphs, runtime reconciliation, managed inspection
and native verification sources, the record summary filter, the ledger's
residual-unknown target and bundle scope selection read the subject digest,
format and display path through evidenceFileTarget and
evidenceSubjectDisplay. No comparison changes: each reader matches one
record's facts against its own payload or a caller filter.
Refs #11417
* refactor(evidence)!: name the Evidence subject only by its target identity (#11497)
* refactor(evidence)!: name the Evidence subject only by its target identity
The subject keeps `identity` and the display facts `name` and `local_path`.
The duplicated `digest`, `format` and `architecture` members are removed; the
format-owned declaration now validates the identity itself. Readers the type
checker found move to the owner accessors; untyped reads in verify scripts,
the efficiency harness and test matchers move to `subject.identity`. The
`evidence-subject-declaration-read` text guard and its baseline are deleted.
Fixes#11473
Refs #11417
BREAKING CHANGE: the Evidence subject no longer has `digest`, `format` or
`architecture`; read `subject.identity.sha256`, `subject.identity.format` and
`subject.identity.architecture`. A record that still carries them is refused.
* test(evidence): give the Flutter verifier fixture the identity subject and check the DOL declaration without the ID
* test(evidence): drop the removed subject members from the declaration matrix and tamper fixtures
* feat(evidence)!: give every Evidence record an explicit subject identity (#11536)
* feat(evidence)!: give every Evidence record an explicit subject identity
A producer that cannot name a file passes an `unknown` target identity
with a closed reason (derived-from-linked-evidence, not-observed,
unsupported-subject) instead of no subject. The subject is non-null;
unknown subjects have no display facts. The generic missing-subject
limitation and `subjectUnavailableReason` are removed; producer-specific
explanations are ordinary limitations. Comparison identity requires the
derived unknown, and null-subject consumers ask the owner accessors.
Refs #11417
BREAKING CHANGE: every Evidence record has a subject. A record without a
file target names `subject.identity` `{ "kind": "unknown", "reason": … }`
with `name` and `local_path` null, instead of `subject: null` and the
limitation "Artifact identity is unavailable for this observation.".
Their Evidence IDs change.
* fix(evidence): name explicit unknown subjects in JavaScript callers and keep a managed graph's file subject
The verification scripts are not type-checked, so five createEvidence
callers still passed undefined (or a missing first target) after the subject
became required. They now pass unknownTarget("not-observed").
A managed application graph chose the first present input subject. Every
subject is now present, so an unknown artifact subject hid a file subject on
the member or boundary Evidence. The graph now takes the first input subject
that names a file.
* test(evidence): assert the subject kind instead of a presence the type now guarantees
Every Evidence record has a subject after this change, so test guards and
assertions that checked it for null always passed. Each now checks that the
fixture subject names a file, or is removed where a later fileIdentity,
fileSubjectTarget or fileSubjectDisplay call already requires that. Non-null
assertions on Evidence subjects are removed; analysis-view inputs, whose
subject is optional, keep an undefined check.
* test(evidence): expect the Evidence subject format under its identity
Two boundary tests still matched subject.format, which slice 2e moved into
subject.identity. toMatchObject is not type-checked against the Evidence
shape, so they failed only when run (the signature test on macOS).
The CLI already treats ENOTCONN on stdout as a closed reader (#11275).
The MCP transport classifier still reported it as an unknown transport
error. It now shares one set of peer-gone codes: EPIPE, ECONNRESET and
ENOTCONN.
Fixes#11362
The backstop supervisor was created in the finally block after the
child had already closed, so it never observed the close and waited out
the 1 s output-close grace. Create it at launch, as the JADX fixture
does since #11283.
Fixes#11363
* refactor(mcp): bind analysis settings tools through the shared binding table and count bespoke registrations
* refactor(mcp): bind inspect_analysis_view through the shared binding table (#11514)
* refactor(javascript): bind JavaScript source analysis in composition (#11467)
* refactor(mcp): bind inspect_analysis_view through the shared binding table
* ci(guards): count typed tool registrations and name each registration owner with its reason
* refactor(mcp): bind session-derived comparison tools through a derived binding kind on the shared table (#11547)
* ci: trace shared script modules to the tests that import them
A pull request that changed any scripts/lib module ran the complete
suite. Shared script modules now pass a change through to the tests,
verifiers and other shared modules that import them, like test helpers.
Another consumer (a build or test-runner script, root configuration,
package metadata, a hook or a workflow) that imports the module or names
it by file name still selects the complete suite.
The tracing core is exported as traceAffectedTests so a bounded local
gate can reuse it.
Fixes#11381
* ci: follow verifier source loads and named verifiers when tracing script modules
- Module URLs (new URL("./x.mts", import.meta.url), as loaded by
importVerifierSource) are import edges.
- A test that names a verifier or shared module the change reaches is
selected, not only one that names a changed path.
- A changed shared module that no test reaches runs the complete suite
even when other changes select tests.
* ci: select tests that start the built server beside a changed presentation owner (#11519)
* ci: select tests that start the built server beside a changed presentation owner
A test that starts the built CLI or MCP server reaches server, contract,
entrypoint and CLI modules through the build, not an import, so a change
there selected none of them (#11146 failed on main this way). Such a
test is now selected when it, or a helper it imports, starts
scripts/rea.mjs or dist/, and it imports a module from the changed
owner's directory.
Fixes#11366
* ci: recognise only the repository's built entry points as runtime launchers
A package subpath such as ajv/dist/2020.js matched the dist/ pattern, so
in-process tests importing Ajv counted as built-runtime launchers.
* ci: balance selected test shards by recorded duration (#11522)
A selected PR run split its files across groups round-robin, so a few
slow files could land together. The plan now records the selected files
and a shard count (version 3), and each job runs one --shard of the
selection through the exact-test runner with the timing history main
already publishes, so the CI sequencer balances shards by per-file
duration (the median for files without a timing). Without history,
Vitest's own deterministic sharding applies.
Fixes#11382
On the fast tier a shared-boundary file selected a provider lane only
when exactly one lane matched it. Lanes that cover src/process/** by
directory glob counted as matches too, so a file one lane names
explicitly (src/process/RegularFileRead.ts for agentenv, moved there in
#11299) selected no lane. Only patterns without ** now count as owners;
files several lanes name still run code and runtime only on the fast
tier.
Fixes#11404
* refactor(process): compose supervision and provider-client cleanup failures through the shared owner
* refactor(native): compose LLDB, native UI and signature cleanup failures through the shared owner (#10908)
* refactor(native): compose LLDB, native UI and signature cleanup failures through the shared owner
* refactor(server): compose close, reset and session-status cleanup failures through the shared owner (#10915)
* refactor(dotnet): compose managed snapshot cleanup failures through the shared owner (#10917)
* refactor(dotnet): compose managed snapshot cleanup failures through the shared owner
* refactor(flutter): compose build cleanup failures through the shared owner (#10918)
* refactor(flutter): compose build cleanup failures through the shared owner
* refactor(apple): compose asset catalog and keyed archive cleanup failures through the shared owner (#10919)
* refactor(ghidra): join session cleanup failures through the shared owner (#10920)
* refactor(ghidra): join session cleanup failures through the shared owner
* refactor(desktop): compose build-setup cleanup failures through the shared owner (#10921)
* refactor(desktop): compose build-setup cleanup failures through the shared owner
* refactor(cutter): compose bridge service cleanup failures through the shared owner (#10922)
* refactor(cutter): compose bridge service cleanup failures through the shared owner
* refactor(electron): compose fuse and file-scope cleanup failures through the shared owner (#10923)
* refactor(electron): compose fuse and file-scope cleanup failures through the shared owner
* refactor(browser): compose scenario, web-bundle and capture cleanup failures through the shared owner (#10924)
* refactor(application): compose uninstall, session retirement and decompile-all cleanup failures through the shared owner (#10933)
* refactor(application): compose uninstall, session retirement and decompile-all cleanup failures through the shared owner
* refactor(ghidra): compose Java probe, NativeAOT snapshot and provider-client cleanup failures through the shared owner (#10927)
* refactor(ghidra): compose Java probe, NativeAOT snapshot and provider-client cleanup failures through the shared owner
* refactor(hopper): compose provider close cleanup failures through the shared owner (#10928)
* refactor(hopper): compose provider close cleanup failures through the shared owner
* refactor(javascript): compose analysis worker runtime and inspection failures through the shared owner (#10929)
* refactor(javascript): compose analysis worker runtime and inspection failures through the shared owner
* refactor(kuna): compose project-cache and target-command cleanup failures through the shared owner (#10930)
* refactor(kuna): compose project-cache and target-command cleanup failures through the shared owner
* refactor(native): compose macOS provider, pwndbg and pwntools cleanup failures through the shared owner (#10931)
* refactor(native): compose macOS provider, pwndbg and pwntools cleanup failures through the shared owner
* refactor(wasm): compose WABT artifact cleanup failures through the shared owner (#10932)
* refactor(wasm): compose WABT artifact cleanup failures through the shared owner
* refactor(application): compose analysis-view cancellation and retained-content cleanup failures through the shared owner (#10941)
* refactor(application): compose analysis-view cancellation and retained-content cleanup failures through the shared owner
* refactor(kuna): compose span-close cancellation cleanup through the shared owner (#10942)
* refactor(decompile): bind the initialization failure with its cleanup through the shared owner (#10965)
* refactor(decompile): bind the initialization failure with its cleanup through the shared owner
* refactor(cli): bind environment serve listener and close failures through the shared owner (#10966)
* refactor(cli): bind environment serve listener and close failures through the shared owner
* refactor(kuna): bind project export and span-read failures with their cleanup through the shared owner (#10967)
* refactor(kuna): bind project export and span-read failures with their cleanup through the shared owner
* refactor(cutter): bind descriptor read failures with their cleanup through the shared owner (#10968)
* refactor(cutter): bind descriptor read failures with their cleanup through the shared owner
* refactor(ida): bind workspace file failures with their cleanup through the shared owner (#10969)
* refactor(ida): bind workspace file failures with their cleanup through the shared owner
* refactor(rizin): bind debug finalization failures with their cleanup through the shared owner (#10970)
* refactor(rizin): bind debug finalization failures with their cleanup through the shared owner
* refactor(application): compose close rejections with unknown completion through one owner (#10971)
* refactor(application): compose close rejections with unknown completion through one owner
* refactor(hopper): compose startup and launcher close rejections through the shared owner (#10972)
* refactor(hopper): compose startup and launcher close rejections through the shared owner
* refactor(desktop): compose task-file close rejections through the shared owner (#10973)
* fix(hopper): confirm reported close failures when a later close of the client succeeds
* fix(hopper): keep owned close failures reading their own owner on retry
HopperClient bound every failed close part to its client retry, so a launcher
aggregate that already follows its child failures stayed pending after the
launcher released them. AnalysisCleanupRelease.bindUnowned now owns the rule
that a retry claims only ownerless failures; BinarySession's local copy of it
is removed.
* fix(hopper): release each close part's earlier failures when that part succeeds
One shared retry release made the session part's earlier failures wait for
the launcher part too, so a later close whose session cleanup succeeded kept
reporting the session's released resources. HopperClient keeps one release per
part (session, launcher), and each part confirms its own failures when it
succeeds.
* feat(managed): give each member comparison limitation a structured reason
* feat(managed)!: state member comparison item limitations as tagged objects
Each method and field comparison item limitation is now {code, side?, message}
instead of a prefixed sentence beside a parallel limitation_reasons list.
BREAKING CHANGE: compare_managed_members item limitations are objects, not
strings, and limitation_reasons is removed. Read limitations[].code (and side)
instead of matching message prefixes such as "signature-not-resolved:".
Comparison Evidence written by earlier builds is refused; recreate it.
* test(managed): assert limitation codes instead of banning a message prefix
The last raw JSON Schema keywords in CLI .meta() calls move to src/domain/schemaConstraints helpers: requirePresence gains requiresValue (the --outline-depth rule) and jsonDocumentText declares JSON document arguments. contractCliDescription reads the root discriminator from its typed annotation; since #10693 the x-rea-root-discriminator keyword no longer reached .meta(), so the check that the discriminator is the delivery's was dead. The raw-json-schema-meta baseline is now empty.
* refactor(ghidra)!: key analysis profiles on the producer identity instead of hand-bumped markers
Ghidra snapshot validity depended on 53 hand-maintained "-vN" semantic
markers in the analysis profile; a behaviour fix that forgot to bump its
marker left old snapshots admissible (#3664). #10562 added a digest of the
bridge sources, but TypeScript projection changes still needed a bump and
the REA release was not committed.
- src/filesystem/ProducerIdentity.ts owns the producer identity: the REA
release plus a framed SHA-256 of a producer's packaged scripts, read once
per process.
- Ghidra profiles commit `producer` in place of `bridge_sources_sha256` and
the constant revision markers (shared semantics block, load-image, entry
seed, PDB, jump-table, DOL import, MIPS ISA-mode markers) are removed.
- Runtime-selected values keep their meaning without a revision suffix
(language_selection, annotation_policy, relocation/no-return/launch
policy, MIPS/PowerPC/PSP lanes, MIPS ABI basis). Bridge wire policy ids
shared with the Java scripts (ilp32-prototype-v1,
o32-soft-float-prototype-v1) are unchanged.
BREAKING CHANGE: Ghidra Evidence `analysis_profile.parameters` replace the
semantic marker keys and `bridge_sources_sha256` with `producer`
({rea_version, sources_sha256}), and selection values lose their "-vN"
suffix (for example `language_selection: "provider-pinned"`). Ghidra
Evidence IDs and profile digests change, and analysis snapshots saved by
earlier builds are refused at open. Migration: open the target without the
old snapshot and save a fresh one; consumers reading the removed marker keys
should read `producer` instead.
* fix(hopper)!: commit the REA release and bridge script in Hopper analysis profiles (#11324)
Hopper analysis profiles committed the launcher digest and one hand-bumped
marker (function_dossier_coverage "...-v1"), but neither the REA release
nor bridge/hopper_bridge.py. A snapshot saved before a bridge or REA change
replayed results the current bridge would not produce.
HopperBridgeSources owns the packaged bridge script URL (used to launch it)
and hopperProducerIdentity() on the shared ProducerIdentity owner; the
profile commits `producer` in place of the marker.
BREAKING CHANGE: Hopper Evidence `analysis_profile.parameters` replace
`function_dossier_coverage` with `producer` ({rea_version, sources_sha256}).
Hopper profile digests and Evidence IDs change, and analysis snapshots saved
by earlier builds are refused at open. Migration: open the target without
the old snapshot and save a fresh one.
* fix(ghidra): build the legacy reference snapshot from another producer and use the shared temp directory
* refactor(providers): key Kuna exports and the Native AOT profile on the producer identity (#11353)
* fix(ghidra): keep the bridge source table import-free for the Node-loaded verifier
scripts/verify-ghidra-bridge-sources.mjs loads GhidraBridgeSources.ts with
Node type stripping, which does not resolve .js specifiers to .ts sources.
The producer identity import made every verifier run fail with
ERR_MODULE_NOT_FOUND; the identity now lives in GhidraProducerIdentity.ts.
* fix(artifacts): import the moved file source and abort check from their resources owner after merging main
* refactor(contracts): move the CLI command name owner into src/contracts
* refactor(contracts): own catalog identity in contracts and server identity in process (#11435)
* refactor(contracts): move catalog identity into contracts and server identity into process
* refactor(contracts): own the advertised MCP schema presentation in contracts
* test(mcp): import the advertised presentation from contracts in toolSchemaValidity
* test(release): expect the catalog identity at its contracts path in the canary
* test(mcp): import the catalog identity from contracts in syntheticContractSurfaces
* refactor(contracts): import CLI command names from contracts in the capability conformance test
* refactor(resources): own the stable-root digest with classification as an observer
* refactor(resources): move the artifact file source into src/resources (#11484)
* refactor(javascript): bind max_heap_mb and analysis_timeout_ms flags from the limit, not remediation text
The CLI projection now also names the flag of a registered setting limit that carries a request parameter (javascript.max_heap_mb, javascript.analysis_timeout_ms). The JavaScript worker heap and timeout remediation and the web bundle heap remediation no longer name CLI flags; a web bundle heap exhaustion that a larger max_heap_mb raises now binds max_heap_mb as its per-call control.
* test(javascript): assert the adapter-neutral heap remediation in the worker order audit
* refactor(managed): bind max_snapshot_bytes as the per-call control of a managed snapshot refusal (#11453)
* test(lifecycle): map every registered provider to its lifecycle regressions or explicit gaps
* test(lifecycle): track the web module and source-map processes and resolve test files against the repository URL
* test(lifecycle): record gaps where named tests did not exercise the claimed stage
* test(lifecycle): cover objdump cleanup and command-provider cleanup retry (#11487)
Close five provider lifecycle gaps: objdump cleanup and retry, sigrok and tshark process cleanup retry, and WABT retry (an existing literal-titled regression).
inspect_model_artifact `coverage.array_values` used `preview` for metadata
arrays cut to their eight-element preview. That is a known gap with exact
declared counts, so it now uses the shared coverage vocabulary: `partial`.
BREAKING CHANGE: inspect_model_artifact `coverage.array_values` reports
`partial` where it reported `preview`; `complete` is unchanged.
inspect_kernel_build_config coverage.status was `incomplete` for a config cut by the
searched bytes or a budget-stopped search (known gaps), for a malformed framed
config, and for a payload that was never searched (examined_bytes 0). Coverage
now uses the shared status: `partial` for the known gaps, `unknown` when a
config's existence or contents cannot be determined; `unsupported` is
unchanged. config.status keeps its own values, and the service's consistency
check pairs each config state with its coverage.
BREAKING CHANGE: inspect_kernel_build_config `coverage.status` reports `partial`
(config_gzip_truncated, config_search_exhausted) or `unknown` (malformed config,
payload not searched) instead of `incomplete`.
* refactor(mcp): bind web script export through the shared service binding table
* refactor(mcp): give SDK-admitted bindings their contract's parsed input type
* refactor(mcp): type SDK-admitted bindings by the contract's request frame
* refactor(mcp): bind guidance, Cutter discovery and session status as value-returning bindings (#11439)
The shared binding table gains a value binding kind for contracts that return a plain JSON value rather than Evidence. It logs and delivers against the contract's output schema, records no Evidence and runs outside analysis admission, so provider-free guidance stays outside admission even though the shared dependencies carry one.
search_guidance, read_guidance_section, list_cutter_sessions and binary_session move onto it; registerGuidanceTools.ts is deleted and registerSessionStatusTool.ts becomes the sessionStatusTool.ts reader its binding calls.
* test(conformance): require a conformance case for every declared provider capability
* test(conformance): accept only public-workflow test projects as capability cases
* refactor(domain): move the native section directory and ELF string readers into domain
* test(native): fingerprint the moved section directory in the JNI qualification script
* refactor(browser): take the host in Chromium, Electron and capture adapters
chromiumSandboxEnabled and safeElectronEnvironment take a required platform. The scenario browser, native module resolver, Electron provider and capture cleanup, mitmproxy adapter and web script artifacts take an optional platform seam (default HOST_PLATFORM); Electron fuses read the host architecture from HOST_PLATFORM. Their tests inject the platform instead of redefining process.platform. src/browser no longer reads process.platform or process.arch.
* refactor(pcap): take the host platform in the packet tools, native bound and batch launch (#11141)
* refactor(pcap): take the host platform in the packet tools, native bound and batch launch
* test(pcap): cover the selected host in batch launch and capture-host support
* refactor(apktool): take the host platform in launcher selection, version probe and decode (#11164)
* refactor(apktool): take the host platform in launcher selection, version probe and decode
* test(apktool): cover the provider's selected host in launcher selection
* refactor(hopper): give the launcher the provider's host platform
* refactor(native): inject the host into the pwntools decoders and native capability defaults (#11173)
* refactor(native): inject the host into the pwntools decoders and native capability defaults
* fix(native): give composed pwntools services the capability host and drop empty test hooks
* refactor(adb): take the host platform in binary selection and pulled file names (#11176)
* refactor(adb): take the host platform in binary selection and pulled file names
* refactor(cli): pass the resolved host platform through rea mcp add (#11179)
* refactor(cli): pass the resolved host platform through rea mcp add
* refactor(composition): default composition entry points to HOST_PLATFORM and pass it to Hopper and IDA (#11183)
* refactor(kuna): require the host platform in admission and installation, and give it to the session client (#11186)
* refactor(kuna): require the host platform in admission and installation, and give it to the session client
* fix(kuna): pass the host platform from the JavaScript installation callers
verify-real-kuna, both native oracle helpers and the command-lifetime child script call inspectKunaInstallation from dist, where TypeScript cannot see the now-required platform. They passed undefined and got unsupported_host on supported hosts.
* refactor(server): give createServer a host option and pass it to session tools, sigrok and EVM (#11203)
* refactor(server): give createServer a host option and pass it to session tools, sigrok and EVM
createServer read process.platform and process.arch live for its capability services, and registerSessionTools read process.platform for process capture. A host option (default HOST_PLATFORM) now selects both, and composition passes the capability host to the sigrok provider and the EVM provider (execution gate, limiter probe and environment rules), as it does for pwntools.
hostRestrictedAvailabilityMcp selects its host through the option instead of redefining process.platform and process.arch, and moves to the MCP boundary lane since it no longer touches process-global state. evmCleanupRetry passes SIMULATED_LINUX_X64 to the provider instead of 52 property redefinitions; the fixture moves to tests/fixtures/simulatedHost.ts.
* refactor(desktop): require the host platform in build computer and secret folder paths (#11210)
* refactor(desktop): require the host platform in build computer and secret folder paths
buildComputerArchiveDirectory, defaultBuildComputerArchive, resolveBuildComputerEnvironment and buildSecretsDirectory defaulted to process.platform. Every caller but DesktopBuildComputers' secret folder already passed the platform; it now passes HOST_PLATFORM.platform, which it reads for the build environment.
* refactor(filesystem): default caller paths and ChangeTime settling to HOST_PLATFORM (#11212)
appendCallerPath, absoluteCallerPath and the ChangeTime settle seams defaulted to a live process.platform read. Their defaults now come from HOST_PLATFORM: the 59 callers that omit the platform join or settle paths they open on this host, and callers describing another host's layout already pass it.
The webScriptExport case that redefined process.platform to reach the Windows settle budget moves to its own file, which selects Windows by mocking HostPlatform.
* fix(server): report process capture availability for the server's host
sessionAvailabilityPolicy imported platform from node:process, so with a selected host binary_session reported capture_process_scenario from the running host while planning and capture used the selected one. It takes the platform from createServer and registerSessionTools. hostRestrictedAvailabilityMcp checks discovery against a dry-run plan on win32 and linux hosts.
* build(guards): count platform and arch imports from node:process and node:os as ambient host reads
sessionAvailabilityPolicy's named import of platform from node:process escaped the ambient-host-platform guard. The guards now also match named platform/arch imports from node:process or node:os and os.platform()/os.arch(). The one other site, DesktopApplicationCapture's os.arch(), records the capturing host and now reads HOST_PLATFORM.architecture.
* refactor(config): take the host platform in parseConfig and give debugger managers the capability host (#11237)
* refactor(config): take the host platform in parseConfig and give debugger managers the capability host
parseConfig read process.platform for the default Hopper launcher; it takes the platform (default HOST_PLATFORM). GdbSessionManager and RizinDebugSessionManager default their platform to HOST_PLATFORM, and composition passes the capability host that already decides their availability. GDB's /proc descriptor check reads HOST_PLATFORM explicitly: it inspects this host's /proc whatever host the manager models.
* refactor(firmware): give the firmware and Wakaru providers the capability host (#11239)
* refactor(firmware): give the firmware and Wakaru providers the capability host
resolveFirmwareCommand and resolveWakaruCommand read process.platform (and process.arch) for their host gate. They take the platform or host as a parameter; FirmwareProvider and WakaruProvider take a host (default HOST_PLATFORM) for the gate and their environment snapshots, and composition passes the capability host that already decides their availability. The JavaScript analysis source transfer defaults to HOST_PLATFORM.
artifactSelectedCommand passes SIMULATED_LINUX_X64 to both providers instead of redefining process.platform and process.arch, and the Wakaru limiter configuration cases now run on any POSIX host.
* refactor(captures): give tshark the capability host and default Cutter to HOST_PLATFORM (#11240)
* refactor(captures): give tshark the capability host and default Cutter to HOST_PLATFORM
TsharkCaptureProvider and CutterBridgeClient defaulted their platform to process.platform. Both default to HOST_PLATFORM now, and composition passes the capability host to the packet capture service, which already decides its availability.
* refactor(platform): read HOST_PLATFORM explicitly in host-only path checks (#11241)
* refactor(platform): read HOST_PLATFORM explicitly in host-only path checks
Electron's readlink target split, IDA's host path comparison, the inspector's reported runtime path, the server identity check and WABT's executable names all describe paths on the running host. They read HOST_PLATFORM instead of process.platform.
* test(native): select the native UI verifier's host through HostPlatform (#11242)
verify-native-ui.mjs reads its macOS requirement from HOST_PLATFORM, and its action test resolves the script's HostPlatform import to a simulated darwin host instead of redefining process.platform in the child preload. Simulating linux there fails the macOS requirement, so the redirect is effective.
* test(mcp): check that composition forwards the selected host to execution
hostRestrictedAvailabilityMcp ran execution only on darwin, where the runner's own host also refuses. The new case calls the firmware, Wakaru, tshark, sigrok and EVM tools under a darwin and a linux x64 host and requires different outcomes, so dropping a provider's host forwarding fails on any runner (checked by removing the firmware forwarding).
* fix(composition): give the pcap, Apktool and ADB providers the capability host
createServer's selected host decided pcap capture discovery, but the default pcap, Apktool and ADB factories built their providers with HOST_PLATFORM. The factories take the platform (default HOST_PLATFORM) and capabilityServices passes its context platform, so availability and execution follow one host.
* test: import moved resources owners in host-platform fixtures
* refactor(config): drop the unused host parameter from parseConfig
* refactor(cli)!: name a failure's per-call control flag at the CLI boundary
Services name the contract field a deadline failure reports in
details.limit.parameter; a contract command's output projection adds
details.limit.cli_flag from the command's own field-to-flag binding.
BREAKING CHANGE: MCP failures no longer carry details.limit.cli_flag, and
native deadline remediation text no longer names the CLI flag. CLI output
still reports cli_flag for the command that ran.
* fix(cli): key nested flattened members by their dotted path; restore the test's exit status
* refactor(reverse): bind command_timeout_ms as the per-call control of an objdump or Rizin deadline (#11442)
* refactor(reverse): bind command_timeout_ms as the per-call control of an objdump or Rizin deadline
The deadline failure now comes from nativeDeadlineRecovery: it names command_timeout_ms and carries limit {control_kind: "parameter"}, so the CLI projection adds --command-timeout-ms and MCP output names the field only. The service no longer writes CLI flag text.
* refactor(wasm): bind max_artifact_paths as the per-call control of an auxiliary path admission refusal (#11444)