* 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.
* refactor(mcp): bind artifact and bundle comparison through an acquiring derived binding that owns their artifact resource scope
compare_artifacts and compare_bundles registered bespoke handlers that read caller-named files under the server's artifact resource scope and then repeated the session-derived delivery. The derived binding kind now takes an optional acquisition with the resource scope it reads under; the table passes the scope, the readers open and release handles in it (failed releases stay owned for retry), and acquisition failures are delivered unchanged. The artifact unknown and the bundle Evidence moved to application owners.
* fix(mcp): return a bundle comparison's record-pair failure as a typed Result
bundleComparisonExecution declared a Result but let compareBundles throw AnalysisInputError for missing or repeated record pairs. It now returns the typed failure; unexpected errors still propagate.
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.
* refactor(mcp): bind the investigation workflows through the session-derived binding kind
* refactor(mcp): move reconstruction verification Evidence to the application layer and bind it on the shared table (#11553)
verify_reconstruction built its Evidence and residual unknown in the MCP adapter. The application workflow verifyReconstructionEvidence now owns the parse, verification, Evidence closure and unknown, and the tool is a session-derived binding, so admission, logging, cancellation and recording follow the other investigation workflows.
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
* refactor(javascript): move the last reader effect reads into the effect log
* refactor(javascript): skip escapes when a reader asks only about member writes
* fix(javascript): order require and process rebinding by activation timing (#11479)
* refactor(javascript): ask one ordering whether require was rebound before a call
* refactor(javascript): order process replacement by activation, like require
* fix(javascript): keep instance field values out of literal-loop source ordering
* fix(javascript): stop effect ordering at instance field values inside the effect
semanticEffectFollowsReference proved that an assignment follows a read
written inside its own right-hand side, even when the read sits in an
instance field value, which runs on construction after the assignment.
process = class { value = process.env.MODE; }; new process() therefore kept
the original process identity, and require = class { fs = require('fs') }
kept a Node module origin. The first walk now stops at instance field
values like it stops at function bodies.
* fix(javascript): attribute process effects that may reach the original object (#11521)
* fix(javascript): attribute process effects that may reach the original object
A write or escape through the global process object was attributed to
node:process only when no replacement of process may precede it. Effects
need the opposite question: they reach the original unless a replacement
with a fresh object is proven to run before them. The effect log gains
ambientReplacementPrecedes (the must counterpart of the may-observe
queries), RequireOrigin owns the effect question, and member mutation
asks it for direct, qualified and ambient process effects.
Refs #11488
* fix(javascript): prove a process replacement with the global path reader
ambientReplacementPrecedes accepted any earlier fresh assignment of the
process path, even when a later write might restore the original or when
the assignment went through a possible alias of the global object. The
global path reader already owns definite replacement at a site (it checks
the written namespace and every competing write), so the effect question
asks it and keeps only the freshness check. ambientReplacementPrecedes is
removed.
* 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).
* refactor(native)!: report native initializer coverage as partial or unknown instead of incomplete
inspect_native_initializers coverage.status was `incomplete` for both a known gap
(slot budget, unreadable arrays, withheld names) and undetermined coverage
(relocation, fixup, symbol or mapping coverage, duplicate or unterminated dynamic
tags). The scans now record which one each observation causes and the report
uses the shared coverage status: `partial` for a known gap, `unknown` when
completeness cannot be determined, unknown winning when both occur. The
top-level `status` keeps `parsed` / `incomplete`.
BREAKING CHANGE: inspect_native_initializers `coverage.status` reports `partial`
or `unknown` instead of `incomplete`. Treat both as not complete; `partial`
means declared slots or names were left unreported, `unknown` means the
report could not establish completeness.
* fix(native): report a withheld object-file relocation symbol name as partial coverage
nameAt labelled every name over the budget as unknown coverage. In an MH_OBJECT
the relocation symbol it reads is the reported entry's own import or defined
name, so withholding it is a known gap. The caller now states the effect: the
object-file relocation symbol is partial (and is read only when the entry
reports it), the LC_SYMTAB address index stays unknown (#11500).
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
* test(agentenv): skip /proc session tests off Linux and release held descendants
Two LongRunTest cases need the supervisor's /proc same-session
enumeration, which only Linux provides; skip them when /proc is absent.
Every held descendant also leaked: the test touched its release file and
then removed the folder before the child's 20 ms poll saw it. A cleanup
now touches the release files and waits for the recorded descendant to
exit before the folder is removed.
Fixes#11349
* test(agentenv): report a surviving descendant instead of signalling its pid
The cleanup holds no live handle to the held descendant, so its saved
pid does not prove ownership after exit or reuse.
* test(agentenv): count an unreaped zombie descendant as exited
* 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
* fix(process): settle an observed exit in progress before reporting a process present
An exiting process closes its sockets before it becomes a zombie. A
caller that reacts to the closed transport could read the captured
identity in that window and report it as present, so Hopper cleanup
retained the document and private runtime although the application had
exited.
Wait, within the existing cleanup verification grace, only while the
same identity is positively observed exiting.
Refs #10556
* refactor(process): reuse exit settlement when observing a bridge exit
Review follow-up for observeProcessStartIdentityExit.
The exit check added its own waiting loop beside
settleExitingProcessIdentities, with the same deadline, polling interval
and same-identity exiting check, so future exit-race fixes would need
two changes. The check now hands its first observation to the shared
settlement and keeps only the final result choice. The settlement and
its identity reader accept PID-only rows, the shape the host identity
reader already takes. One liveProcessIdentity helper maps absent and
exited identities for both observeProcessStartIdentity and the settled
result.
Behavior is unchanged: an exiting identity is re-read until it leaves
exit in progress or the cleanup grace ends; a replacement, absent or
zombie identity is exited, an unreadable one unverified, and one still
exiting at the deadline present.
Tests: src/process (850), the Hopper cleanup and session tests (15) and
20 Hopper boundary test files (114) pass. check:fast passes.
---------
Co-authored-by: Davmunrey <Davmunrey@users.noreply.github.com>
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.
A merge commit stages every file brought in from the other branch, so
lint-staged's oxlint --fix rewrote incoming code that main had not
autofixed (duplicate imports and similar fixable warnings), putting
unrelated changes into PR merges and causing new conflicts with main.
Conflict resolutions are still checked by the pre-push hook and CI.
* 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.