fix(pe): bound decoded certificate serial and validity text

Serial numbers and validity times now share the 64 KiB decoded-text
budget with certificate names. The hex and time strings are charged
before conversion, so a wide field cannot expand through JSON hashing.

Co-authored-by: morluto <morluto@users.noreply.github.com>

.agents/skills/reverse-engineer-anything/SKILL.md

@@ -219,6 +219,13 @@ explicit path or endpoint and do not need it.
   delivery requires `--evidence_output`.
   See the
   [Rust binary guide](https://github.com/morluto/rea/blob/main/docs/rust-binaries.md).
+- PE Authenticode certificate table: `inspect_pe_certificates` with the explicit
+  local PE32/PE32+ file. This built-in target-free inspection requires no
+  Windows SDK. Preserve WIN_CERTIFICATE ranges, types, payload SHA-256, and
+  PKCS#7 signer/X.509 identity fields. A missing security directory is observed
+  absence of that table, not proof the image is unsigned in every catalog sense.
+  Signatures are not verified. See the
+  [PE certificate guide](https://github.com/morluto/rea/blob/main/docs/pe-certificates.md).
 
 - Explicit local SQLite database snapshot: `inspect_sqlite_database`. Inspect
   with Node.js 24.x >=24.15 or 26+ providing native SQLite limits. Read schema

.agents/skills/reverse-engineer-anything/references/javascript-applications.md

@@ -22,6 +22,11 @@ requires complete application analysis; `source_paths: []` is invalid, not an
 unfiltered request. `detail: "summary"` reduces delivery
 and does not by itself reduce analysis work.
 
+ASAR header/index admission defaults to 16 MiB / 16777216 bytes;
+`REA_ASAR_MAX_HEADER_BYTES` (at most 256 MiB, set where REA starts) changes it.
+`source_paths`, `detail`, and `max_heap_mb` do not bypass or raise it. Or
+analyze an extracted directory.
+
 Exact `#alias` specifiers resolve through the importer's
 enclosing package `imports` map to package-local files; nested `node_modules`
 packages use their own map. Wildcard, recursive, and external-package import

.agents/skills/reverse-engineer-anything/references/native-and-artifacts.md

@@ -45,7 +45,8 @@ See [desktop installations](https://github.com/morluto/rea/blob/main/docs/deskto
 
 ## Go build metadata
 
-Use `inspect_go_binary` for an explicit local ELF, PE or thin Mach-O when the
+Use `inspect_go_binary` for an explicit local ELF, PE or Mach-O (universal
+files need `architecture`) when the
 question concerns the embedded compiler version, module/dependency versions,
 local replacements or build settings. No `open_binary`, Go installation or
 target execution is required. The CLI equivalent is `inspect-go-binary PATH`.
@@ -84,7 +85,8 @@ See [IL2CPP metadata](https://github.com/morluto/rea/blob/main/docs/il2cpp-metad
 
 ## Rust dependency metadata
 
-Use `inspect_rust_binary` for an explicit local ELF, PE, or thin Mach-O when
+Use `inspect_rust_binary` for an explicit local ELF, PE, or Mach-O (universal
+files need `architecture`) when
 the question concerns the cargo-auditable crate list embedded in `.dep-v0`
 (Mach-O: `__DATA,.dep-v0`). No `open_binary`, Rust installation, or target
 execution is required. The CLI equivalent is `inspect-rust-binary PATH`.
@@ -94,6 +96,19 @@ dependencies. An omitted package kind stays null. A rustc commit hash is
 inferred from a read-only `/rustc/<40-hex>/` path and does not by itself
 identify the compiler. See [Rust binaries](https://github.com/morluto/rea/blob/main/docs/rust-binaries.md).
 
+## PE Authenticode certificate tables
+
+Use `inspect_pe_certificates` for an explicit local PE32/PE32+ image when the
+question concerns the Authenticode certificate table, WIN_CERTIFICATE types, or
+embedded PKCS#7 signer and X.509 identity fields. No `open_binary`, Windows SDK,
+or target execution is required. The CLI equivalent is
+`inspect-pe-certificates PATH`. Preserve artifact SHA-256, table file ranges,
+payload hashes, and original validity-time spellings. A missing
+`IMAGE_DIRECTORY_ENTRY_SECURITY` directory is observed absence of that table,
+not proof the image is unsigned in every catalog or overlay sense. Signatures,
+chains, timestamps, and Authenticode digest coverage remain unobserved. See
+[PE Authenticode certificate tables](https://github.com/morluto/rea/blob/main/docs/pe-certificates.md).
+
 ## SQLite snapshots
 
 Use `inspect_sqlite_database` with an explicit local database snapshot for its

README.md

@@ -191,6 +191,7 @@ Additional tools and host support depend on the target:
 | IL2CPP metadata         | Unity global-metadata.dat assembly images, type and method names and index ranges                 | Built-in static decoding of versions 24, 27, 29, 31 and 39; no Unity required                                                         |
 | Godot PCK               | Archive inventory and extraction, original header/directory facts and selected content identities | Built-in static formats 2, 3 and 4; no Godot required                                                                                 |
 | Rust binaries           | Embedded cargo-auditable crate names, versions, sources and dependency edges                      | Built-in static ELF/PE/thin Mach-O inspection; [Rust binaries](docs/rust-binaries.md)                                                 |
+| PE certificates         | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                      | Built-in static PE inspection; [PE certificates](docs/pe-certificates.md)                                                             |
 | WASM artifact           | Validation, sections, exact import/export WAT forms and decoded WAT                               | Caller-supplied WABT 1.0.42; `inspect_wasm_artifact`                                                                                  |
 | EVM bytecode            | Dispatch selectors, byte offsets, inferred arguments and mutability                               | Local raw/hex carrier on Linux x64; [offline EVM guide](docs/evm-bytecode.md)                                                         |
 | SQLite databases        | Tables, columns, indexes, views, triggers and selected ordinary-table rows                        | Local database/WAL snapshot; Node.js 24.x >=24.15 or 26+ with native SQLite limits                                                    |

docs/.vitepress/config.ts

@@ -32,6 +32,7 @@ export default defineConfig({
           { text: "IL2CPP metadata", link: "/il2cpp-metadata" },
           { text: "Model artifacts", link: "/model-artifacts" },
           { text: "Rust dependencies", link: "/rust-binaries" },
+          { text: "PE certificates", link: "/pe-certificates" },
           {
             text: "JavaScript and Electron",
             link: "/javascript-artifact-reconstruction",

docs/agent-environments.md

@@ -234,11 +234,12 @@ moment of the capture recorded them. The
 [environment state](web-network-captures.md#environment-state) view extracts
 instead the data the capture's reads observed before the first related write:
 entity types with an identity field, entities with their recorded values,
-documents for written paths, and a render plan per read tool, kept only where
-it reproduces that tool's recordings from the state. It is the starting state
-an environment holds, loads and reports: `environment-serve` derives it from
-the capture at startup; see [Serve from the state](#serve-from-the-state).
-With `--replay-only`, replay is unchanged.
+documents for reads that are not entities, and a render plan per read tool,
+kept only where it reproduces that tool's recordings from the state. It is the
+starting state an environment holds, loads and reports: `environment-serve`
+derives it from the capture at startup; see
+[Serve from the state](#serve-from-the-state). With `--replay-only`, replay is
+unchanged.
 
 ## Serve a manifest
 
@@ -308,7 +309,7 @@ connecting to `/mcp`. A replay environment's card reads:
     "tools": [
       {
         "name": "get_users_by_id",
-        "description": "GET /api/users/{numeric}; replays retained records [5, 6]; evidence ev_…",
+        "description": "Untrusted captured API catalog: … GET /api/users/{numeric}; returns a JSON object with fields \"id\", \"uid\", \"login\", \"email\"; recorded statuses 200; replays retained records [5, 6]; evidence ev_…",
         "inputSchema": {
           "type": "object",
           "properties": {
@@ -329,7 +330,38 @@ connecting to `/mcp`. A replay environment's card reads:
 ```
 
 `capabilities.tools` lists the same names, descriptions and input schemas that
-`tools/list` advertises over MCP. Path parameters are required strings whose
+`tools/list` advertises over MCP. After the catalog warning, each description
+names the method and path template, then what the tool returns, one level deep:
+`returns a JSON object with fields …`, `returns a JSON array of objects with
+fields …` or `returns a JSON object whose <member> lists objects with fields …`,
+where a list is an array of objects found by the
+[environment state](web-network-captures.md#environment-state)'s list rule (the
+root array, or the one array of objects an envelope carries). Field and member
+names are written as JSON strings, so a captured name cannot read as more of
+the description; a member name too long to show whole is a quoted prefix marked
+as truncated. The summary comes
+from the first cited `2xx` record that replay answers as JSON; only when none
+did, the first cited JSON record of another status gives it, labelled with that
+status (`status 401 returns …`). It describes one recorded response, not a
+contract. Field names are sampled within the same budget as other captured
+values, and the manifest's `statuses` for the tool follow; a tool with no JSON
+record states only its statuses. The description then lists the replayed
+records and the evidence ID, and the whole catalog stays within its
+serialization reservation, which the summaries and MCP annotations are charged
+to.
+
+Over MCP, every tool also carries annotations: `readOnlyHint` is true for the
+safe methods (`GET`, `HEAD`, `OPTIONS` and `TRACE`) and for query `POST`s (a
+path segment such as `search` or `query`); `destructiveHint` is true for `DELETE` and left unset for other
+writes, so the MCP default (destructive) applies to them, and read-only tools
+omit it because clients ignore it there; `idempotentHint` is true for the safe
+methods, `PUT` and `DELETE`; and `openWorldHint` is false for every tool,
+because answers come from the capture rather than the captured application. The
+hints describe the captured method; replay itself changes nothing. The card
+keeps the `name`, `description` and `inputSchema` of the echo example's tool
+shape and carries no annotations.
+
+Path parameters are required strings whose
 description names the segment index, the templating rule and the observed
 values (sampled within the list budget above; the manifest keeps them all);
 query parameter names are optional strings; write methods accept an
@@ -399,7 +431,9 @@ naming the entity, collection or document path, or `{"source": "recording",
 "reason": …}` with the view's reason, `no-view` or `unrecorded-request`. A
 state answer carries the base record's status, content type and `replay`
 provenance with `truncated: false`; one whose JSON would exceed 256 KiB is
-refused as a `resource_constraint` tool error rather than cut. Serving is
+refused as a `resource_constraint` tool error rather than cut. Extraction does
+not state-back a document whose rendered JSON exceeds 256 KiB; that read stays
+recorded (`rendered-oversize`) and replays the captured body. Serving is
 read-only: `POST`, `PUT`, `PATCH` and `DELETE` tools, other than query `POST`s,
 are not served, so nothing a call does changes the state. Query `POST`s stay
 served and answer from their recordings with the reason `query-body`.

docs/browser-observation.md

@@ -385,7 +385,8 @@ section explicitly truncated.
 Disallowed-origin entries are filtered before retention.
 
 Selected script-source collection shares a 32 MiB aggregate UTF-8 retention
-budget and a 20-second deadline across the capture. An oversized source is
+budget and the `command_timeout_ms` deadline (default 20000 ms) across the
+capture. The byte budget has no runtime override. An oversized source is
 omitted while later smaller sources may still fit. When the deadline expires,
 remaining source reads are skipped. Script metadata, per-item omission reasons,
 and `script_sources` completeness remain available. A single CDP response can
@@ -393,19 +394,25 @@ still be materialized up to the separate 64 MiB transport limit before source
 admission; the retention budget does not bound that transient allocation.
 
 Bundle parsing and semantic inspection run sequentially in an owned child,
-without executing captured code. `max_heap_mb` defaults to 1024 MiB V8
-old-space; `analysis_timeout_ms` defaults to 30000 per script, including startup
-and transfer. A failed or timed-out script becomes an explicit unknown while
-completed findings and later scripts remain available. `total_analysis_timeout_ms`
-defaults to 300000 across script analysis; expiry returns a typed timeout with
-partial Evidence and identifies unstarted scripts. These controls are also
-available as CLI flags with hyphenated names. Capture and optional source-map
-fetching have separate budgets.
+without executing captured code. These are separate phases. `max_heap_mb`
+defaults to 1024 MiB V8 old-space (range 128..16384). `analysis_timeout_ms`
+defaults to 30000 per script, including startup and transfer.
+`total_analysis_timeout_ms` defaults to 300000 across script analysis. A
+per-script deadline above the effective total is rejected. A failed or
+timed-out script becomes an explicit unknown while completed findings and later
+scripts remain available. Total-deadline expiry returns a typed timeout with
+partial Evidence and identifies unstarted scripts. `source_map_fetch_timeout_ms`
+defaults to 30000 and is an item limitation, not that analysis timeout. These
+controls are also available as CLI flags with hyphenated names. Worker protocol
+and result byte budgets have no runtime override.
 
 One web-bundle capture/analysis is admitted per REA process at a time. Completed
 script results share an 8 MiB serialized transfer budget, with host heap
 reservation checked before decoding and validating another result.
-Exhausted result capacity stops further script launches and returns a typed
+When the host reservation is what reaches zero, the failure names that heap
+headroom and the remaining fixed budget. When the 8 MiB allowance itself is
+exhausted, the failure names that fixed budget and says it has no runtime
+override. Either stop ends further script launches and returns a typed
 resource failure with completed facts and explicit unstarted-script unknowns.
 Worker control frames are limited to 64 KiB. Cleanup must confirm child termination
 before releasing its private files; failed cleanup retains its exact owner and
@@ -415,8 +422,10 @@ facts, including cancellation during final cleanup.
 The worker heap setting is not a process-family RSS limit. Node enforces V8
 old-space flags; Bun ignores them. Windows Bun instead uses an owned process
 commit limit with a 512 MiB runtime reserve; other Bun hosts have no enforced
-memory limit. These bounds do not establish an aggregate host-memory limit
-across other REA operations or external processes.
+memory limit. An allocation failure before that Windows limit is reported as
+reached still names the configured limit and says it was not reached. These
+bounds do not establish an aggregate host-memory limit across other REA
+operations or external processes.
 
 Resource-tree inventories distinguish a valid empty `resources` array from a
 missing or malformed collection. Invalid resource entries are omitted with
@@ -430,12 +439,24 @@ an invalid supplied size remains unknown with incomplete resource coverage while
 the resource's other facts are retained. Zero and nonnegative fractional sizes
 are preserved.
 
-CDP discovery has a 10-second deadline. Each WebSocket handshake and command
-response has its own 20-second deadline, separate from the caller-selected
-observation window. A stalled handshake or command reports `provider_timeout`;
-caller cancellation still reports cancellation. WebSocket messages remain subject
-to the [64 MiB limit](#request-boundary). REA does not impose a message-count or
-pending-command quota. On cancellation, it closes only its own WebSocket,
+CDP discovery has a 10-second response deadline. HTTP discovery documents
+use an 8 MiB budget. Browser-socket discovery (`Browser.getVersion`,
+`Target.getTargets`) uses the 64 MiB protocol message budget. Neither budget
+nor the discovery deadline has a runtime override. `list_browser_targets` accepts no
+`command_timeout_ms`: HTTP discovery and browser-socket discovery
+(`Browser.getVersion`, `Target.getTargets`) stay on that fixed deadline, and
+the socket closes without a later command. Other CDP tools use
+`command_timeout_ms` (default 20000) for each WebSocket handshake and command
+response, separate from the caller-selected observation window, discovery, and
+the 5000 ms cleanup grace. A browser-level socket's handshake and the following
+`Target.attachToTarget` each receive that full deadline; they do not share one
+budget. A stalled handshake or command reports
+`provider_timeout` and names `command_timeout_ms` only when that operation
+accepts it; caller cancellation still reports cancellation. WebSocket messages
+remain subject to the [64 MiB limit](#request-boundary), which has no runtime
+override. REA does
+not impose a message-count or pending-command quota. On cancellation, it closes
+only its own WebSocket,
 waiting up to one second before terminating it. Malformed unsolicited events
 and malformed replies to pending commands poison the connection so later
 commands fail closed. A correlated reply's session ID must match the command's
@@ -444,7 +465,7 @@ rejects it as unknown; other command rejections retain their reported failure.
 
 Network and console coverage starts only after REA attaches and enables the relevant CDP domains. `prior_activity_available` is always `false`; absence from these arrays is not evidence that an event never occurred. Scripts are different: scripts the page parsed before REA attached are still reported under `scripts`. A page that loaded before attach can therefore list its scripts while `network.requests` lacks the requests that fetched them. If CDP reuses a request ID without supplying redirect metadata, REA retains the predecessor observation and marks network coverage incomplete.
 
-Source maps are not fetched by inspection. Bundle analysis fetches them only when `fetch_source_maps` is selected, with exact-origin redirect checks and no credentials, cookies, or referrer. Each fetch operation has a 30-second deadline and a 64 MiB aggregate streamed-response budget across redirects. A deadline or byte-limit failure remains explicitly unavailable and makes bundle completeness partial. Source-map decoding also bounds raw resolved identities to 64 MiB and aggregate inline evidence to 32 MiB. Failed maps preserve their failure context when it fits; if another context cannot fit, collection stops with the full requested count, the returned processed count, and an explicit unknown-results limitation. Retained mappings and original sources are returned inline. See [source-location limits](web-source-location.md) for the structural decoder bounds. Original source artifacts with `.ts`, `.tsx`, `.mts`, or `.cts` suffixes carry `text/typescript`; other source names retain `text/javascript`.
+Source maps are not fetched by inspection. Bundle analysis fetches them only when `fetch_source_maps` is selected, with exact-origin redirect checks and no credentials, cookies, or referrer. Each fetch operation uses `source_map_fetch_timeout_ms` (default 30000) and a 64 MiB aggregate streamed-response budget across redirects. The byte budget has no runtime override. A fetch overrun is an item limitation, not a thrown analysis timeout. A deadline or byte-limit failure remains explicitly unavailable and makes bundle completeness partial. Source-map decoding also bounds raw resolved identities to 64 MiB and aggregate inline evidence to 32 MiB. Failed maps preserve their failure context when it fits; if another context cannot fit, collection stops with the full requested count, the returned processed count, and an explicit unknown-results limitation. Retained mappings and original sources are returned inline. See [source-location limits](web-source-location.md) for the structural decoder bounds. Original source artifacts with `.ts`, `.tsx`, `.mts`, or `.cts` suffixes carry `text/typescript`; other source names retain `text/javascript`.
 
 source-map items retain the script's `declared_url` separately from the observed
 `effective_url`. successful maps use the latter as their source-resolution base.

docs/browser-scenario-contract.md

@@ -23,9 +23,21 @@ that rejection does not roll back browser effects. REA removes its owned
 future-document scripts, restores live frame methods, then disconnects.
 Add secret declarations, storage seeds, and additional artifact or event
 capture only when needed. Action, secret, and storage counts are not capped.
-Duration, action, and navigation timeouts remain fixed provider-owned liveness
-limits. `capture.limits` controls retained event and network-content budgets;
-it does not change those liveness deadlines.
+Duration, action, and navigation timeouts remain separate from CDP command
+deadlines. `command_timeout_ms` (default 20000; omit it to keep that default
+and leave it out of Evidence) bounds launch startup, the connect-over-CDP
+handshake, target lookup, environment commands, and storage CDP commands,
+including replies from attached child targets. Set it in the scenario JSON.
+`capture-browser-scenario` has no `--command-timeout-ms` option.
+It does not change action `timeout_ms`, `wait_for_timeout.duration_ms`, or
+navigation. Service-worker restoration keeps a fixed 5000 ms grace and does
+not inherit a raised `command_timeout_ms`. CDP discovery stays on its own
+fixed deadline. When service workers are blocked, the registration check
+before discovery has its own fixed 10000 ms deadline; `command_timeout_ms`
+does not apply because discovery has not started. The discovery deadline
+covers endpoint discovery only. The following WebSocket handshake and
+`Target.attachToTarget` each use `command_timeout_ms`. `capture.limits` controls retained event and network-content
+budgets; it does not change those liveness deadlines.
 
 ## Minimal launch example
 

docs/cli.md

@@ -63,6 +63,16 @@ or repeat it to select several types.
 Selection limits decoding to the selected types; member references remain an
 assembly-wide inventory, so the output can still be large.
 
+Select `--detail summary --evidence-bundle /absolute/path/members.json` to
+receive identity, selection, coverage, limitations and collection counts while
+saving the complete original Evidence in a new bundle. Summary requires that
+explicit destination; existing files are preserved. Later
+`inspect-analysis-view` calls can page the exact parent from the saved bundle
+without reopening the assembly. See
+[CLI summary and saved member rows](managed-code-analysis.md#cli-summary-and-saved-member-rows)
+for the complete command sequence. Omitted or `--detail complete` retains the
+full inline response.
+
 Choose the workflow from the artifact's contents rather than its `.exe` or
 `.dll` extension. The managed parser requires PE/CLI metadata; it does not
 unpack .NET single-file hosts or decode IL2CPP. For the image, type and method
@@ -145,6 +155,18 @@ dependency edges, and the section's file range. A missing `.dep-v0` section is
 null metadata, not proof that the binary has no dependencies. See
 [Rust binaries](rust-binaries.md).
 
+Inspect a PE Authenticode certificate table without executing the image or
+verifying signatures:
+
+```bash
+rea inspect-pe-certificates /absolute/path/to/application.exe --json
+```
+
+The workflow reports `WIN_CERTIFICATE` entries and, for PKCS#7 signedData,
+embedded X.509 serial, issuer, subject, and validity fields. A missing security
+directory is observed absence of that table. See
+[PE Authenticode certificate tables](pe-certificates.md).
+
 Configure [Hopper or Ghidra](installation.md#hopper), the
 [IDA adapter](ida-provider.md), or [Kuna](kuna-provider.md) before analyzing a
 native target. Substitute
@@ -279,7 +301,12 @@ Exports preserve an existing destination unless `--overwrite` is explicit.
 For application traces and version comparisons, see
 [JavaScript application workflows](javascript-application-workflows.md).
 MCP [retained Evidence references](mcp-contracts.md#retained-application-evidence-inputs)
-belong to one connection. Separate CLI calls consume full saved records.
+belong to one connection. Separate CLI calls can consume full saved records.
+`inspect-analysis-view REQUEST.json --evidence-bundle BUNDLE.json` resolves
+the request's `retained-evidence` source ID from that authenticated bundle,
+including bundles exported from an MCP session. The same view JSON works for
+every supported parent kind; no target is reopened and no record is selected
+by file order. Omit `--evidence-bundle` when the request supplies inline Evidence.
 
 ## Import historical source
 
@@ -536,6 +563,14 @@ command, objdump, Rizin and GDB, and the agent environment server
 signal-derived status. This describes the current source routing; it is not a
 claim that every command or provider runtime has been independently exercised.
 
+Commands with `--evidence_output` select their delivered view, then publish the
+complete Evidence bundle atomically. Cancellation before publication leaves no
+new file. A publication that has committed can win a later cancellation; the
+`cancelled` result then keeps the written path and byte count under
+`details.diagnostics.evidence_bundle`. If staging cleanup stays incomplete
+after commit, the `cleanup_incomplete` error reports the same file as
+`details.published_path` and `details.bytes`.
+
 When the reader of piped output closes early, as `rea ... | head` does, the
 CLI stops writing, prints no error and exits `141` (`128 + 13`, the status of a
 SIGPIPE-terminated writer). The operation itself may have completed; only its

docs/electron-observation.md

@@ -245,4 +245,10 @@ application path and capture outcome to the static graph, while frames, scripts,
 workers, and execution claims remain unavailable until a separate passive runtime
 capture provides them.
 
-ASAR observation reads the header through one open file handle, validates its declared lengths against the archive size, and limits encoded JSON headers to 16 MiB before parsing. The header cache also retains at most 16 MiB of encoded headers across eight archives. Oversized headers produce a scope refusal.
+ASAR observation reads the header through one open file handle and validates its
+declared lengths against the archive size. Header/index admission is the same
+budget used by static ASAR reads: 16 MiB / 16777216 bytes by default, or
+`REA_ASAR_MAX_HEADER_BYTES` (at most 256 MiB) when set. An oversized header is
+not parsed; selecting a member path does not bypass admission, and the page
+stays unauthorized. The header cache separately retains at most that many bytes
+of already-admitted encoded headers across eight archives. Evicting that cache does not raise admission.

docs/go-binaries.md

@@ -109,11 +109,21 @@ module record and no dependency records has an observed empty dependency list.
 
 ## Supported boundary
 
-The built-in TypeScript reader supports ELF, PE and thin Mach-O images with Go's
-inline or historical pointer build-info encoding. Source ranges refer to the
-original stable file snapshot, including pointer-backed strings. It does not
-scan arbitrary byte strings as compiler metadata or interpret a fat Mach-O
-container as one selected architecture.
+The built-in TypeScript reader supports ELF, PE and thin Mach-O images, and one
+selected slice of a universal Mach-O, with Go's inline or historical pointer
+build-info encoding. Source ranges refer to the original stable file snapshot,
+including pointer-backed strings. It does not scan arbitrary byte strings as
+compiler metadata.
+
+A universal (FAT) Mach-O needs `architecture` (`x86`, `x86_64`, `arm`
+or `arm64`; CLI `--architecture`). REA reads its own FAT table, without `lipo`,
+and validates the selected slice's range, alignment and Mach-O header CPU
+against the table. The result keeps the universal file as `artifact` (its
+SHA-256 and size), adds `selected_slice` with the slice offset, length, raw CPU
+type/subtype and the FAT table digest, and reports every source range as a
+file offset inside that slice. Without `architecture`, or when the file has no
+such slice or several, the request fails on `architecture` and lists the slices
+present. `architecture` on any other image is rejected rather than ignored.
 
 For ELF images without a named build-info section, discovery checks each
 nonempty writable, non-executable load segment in program-header order. This

docs/index.md

@@ -50,7 +50,7 @@ For runtime instrumentation, see the [Frida guide](./frida-instrumentation.md).
 | Task                                                | Guides                                                                                                                                                                                                                                                                                                                                                                                                     |
 | --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Identify a desktop installation                     | [Runtime candidates, evidence and follow-up files](desktop-applications.md)                                                                                                                                                                                                                                                                                                                                |
-| Inspect native functions, references, or types      | [Native binaries](native-investigation.md), [Go metadata](go-binaries.md), [Rust dependencies](rust-binaries.md), [offline ELF layout](binary-diagnostics.md), [recorded crashes](recorded-crashes.md)                                                                                                                                                                                                     |
+| Inspect native functions, references, or types      | [Native binaries](native-investigation.md), [Go metadata](go-binaries.md), [Rust dependencies](rust-binaries.md), [PE certificates](pe-certificates.md), [offline ELF layout](binary-diagnostics.md), [recorded crashes](recorded-crashes.md)                                                                                                                                                              |
 | Select a native provider or import format           | [Ghidra semantics](ghidra-provider.md), [Windows](windows-ghidra-p0.md), [DOS](ghidra-dos.md), [raw bytes](raw-binary.md), [MIPS](ghidra-mips.md), [PSP](ghidra-psp.md), [NativeAOT](ghidra-nativeaot.md), [IDA](ida-provider.md), [Kuna](kuna-provider.md), [JEB](jeb-analysis.md)                                                                                                                        |
 | Analyze JavaScript or Electron artifacts            | [Static analysis](javascript-artifact-reconstruction.md), [tracing and comparisons](javascript-application-workflows.md), [application graph](javascript-application-graph.md), [source recovery](javascript-recovery.md)                                                                                                                                                                                  |
 | Compare static JavaScript with runtime observations | [Runtime attribution](javascript-runtime-observation.md), [reconciliation](javascript-runtime-reconciliation.md), [Electron observation](electron-observation.md), [Electron fuses](electron-fuses.md)                                                                                                                                                                                                     |

docs/javascript-artifact-reconstruction.md

@@ -106,6 +106,18 @@ only reduces delivery; source selection reduces text acquisition and analysis.
 Explicit native provider or snapshot routing rejects `--source-path` rather
 than ignoring it.
 
+ASAR header/index admission defaults to 16 MiB / 16777216 bytes. Set
+`REA_ASAR_MAX_HEADER_BYTES` in the environment that starts REA to a decimal
+byte count of at most 268435456 (256 MiB) to raise or lower it; restart REA
+after changing it. Invalid values are configuration errors, never a silent
+fallback. The archive index is read before any member can be selected, so
+`source_paths`, `--source-path`, `detail: "summary"`, `max_heap_mb`, and
+available host memory do not bypass or raise it. When the header exceeds the
+effective allowance, the failure names it, whether it came from the default or
+the setting, and the setting's limits. Alternatively, analyze an extracted
+application directory, which does not admit an ASAR header. Repeating the unchanged
+request fails the same way.
+
 ## Read the analysis
 
 `analyze_javascript_application` returns the complete analysis Evidence by
@@ -172,7 +184,8 @@ for the tool-result contract.
 
 Use MCP `detail: "summary"` for a large application, then read selected views of
 the retained analysis. Summary changes delivery only. To reduce source parsing,
-select exact [source paths](#select-sources-before-analysis).
+select exact [source paths](#select-sources-before-analysis). Source selection
+does not bypass ASAR header/index admission.
 
 If a complete response exceeds the transport budget, use its retained Evidence
 ID for a summary, module page, or item, or export the bundle. See

docs/javascript-runtime-reconciliation.md

@@ -106,7 +106,12 @@ nodes. REA evaluates compatible static candidates conservatively:
    that disagreement. If a mapped candidate's digest is unavailable and no
    mapped content match is known, the comparison remains `unknown`.
 6. Missing authorization mappings and incomplete or truncated input coverage
-   remain unknown or truncated rather than becoming absence claims.
+   remain unknown or truncated rather than becoming absence claims. A runtime
+   location with no automatic artifact-root or caller-declared mapping into
+   any layer, and no content match, is `unknown` with
+   `no-authorized-location-mapping`, with or without captured bytes; several
+   content matches remain `ambiguous` under rule 4. Only a mapped location can
+   be `unmatched` with `no-static-content-match`.
 
 Every successful cross-layer `observed_as` edge has
 `authority: cross-layer-reconciliation` and `state: inferred`. The underlying

docs/kuna-provider.md

@@ -68,7 +68,7 @@ The background export belongs to the session. `close_binary`, or the end of a CL
 
 The assembly label index is scanned once per export reader. Cancelling a request stops its wait without interrupting other readers; closing the session aborts and drains the shared scan before releasing its files.
 
-Regex procedure and string search uses ECMAScript Unicode matching in a cancellable worker with a five-second matching deadline and a 128 MiB worker heap. Literal matching remains the default. Cancellation or a matching deadline leaves the session available. This release has no runtime override for that deadline or heap.
+Regex procedure and string search uses ECMAScript Unicode matching in a cancellable worker with a five-second matching deadline and a worker old-generation heap. Literal matching remains the default. Cancellation or a matching deadline leaves the session available. This release has no runtime override for that deadline. The worker requests 128 MiB. A positive Node.js `--max-old-space-size` on the process that starts REA, including `NODE_OPTIONS`, overrides that request and sets the effective heap. `--max-old-space-size-percentage` takes precedence over that flag in either order. REA does not turn the percentage into a MiB, so the effective heap stays unestablished instead of the 128 MiB request or the absolute flag. The reported `NODE_OPTIONS` value is the process initial environment when that block can be read. A later edit to the environment is not the value Node applied, and an unreadable initial value leaves the effective heap unestablished. The launch Node options are the initial command line on Linux when that buffer still has a program entry, not a later edit to `process.execArgv`. A preload can clear that array after V8 has applied the flags. Setting `process.title` or `--title` overwrites the command line, so a buffer without a program entry leaves the effective heap unestablished. `--env-file` or `--env-file-if-exists` can supply `NODE_OPTIONS` when the initial environment has none. That file is not part of the initial environment block, so the effective heap stays unestablished instead of the 128 MiB request. An initial `NODE_OPTIONS` is still used, because Node does not let the file replace it. A positive `--max-heap-size`, including the underscore form and launch `NODE_OPTIONS` on Node versions that allow it, sets the total heap rather than the old generation and can be lower than the 128 MiB request. The effective old generation stays unestablished while that value is in effect. A zero or empty value clears it. `--experimental-config-file` or `--experimental-default-config-file` can set `nodeOptions`, including a heap percentage, from a file that is not read back. The effective heap stays unestablished when either flag is present, including when an absolute `--max-old-space-size` is also on the command line or in the recovered `NODE_OPTIONS`. Node accepts the config path as `=` or the next argument.
 
 Single-function subprocess output and each cached source facet share a 16 MiB buffered-text capacity. Cached spans are checked before allocation; larger text remains in the local export and the error identifies the file and range. `analyze_function` initially returns the complete dossier, which can still be large; later retained views do not remove that first transfer. Prefer the individual text tools for a focused question.
 

docs/managed-code-analysis.md

@@ -85,7 +85,7 @@ rejects selected summary before analysis; complete delivery remains available.
 
 Complete `inspect_managed_members` delivery always includes the assembly-wide
 `member_refs` and `exported_types`, which `type_names` does not narrow, so even
-one selected or unmatched type can return megabytes. Select
+one selected or unmatched type can return megabytes. In MCP, select
 `{"path":"/absolute/path/Assembly.dll","type_names":["Namespace.Type"],"detail":"summary"}`
 to keep the complete source in the session and receive identity, metadata
 status, the selection with its unmatched names, coverage/issues, the separate
@@ -115,6 +115,49 @@ literal pool's own coverage. Older Evidence that never examined exported types
 or user strings reports a null count and refuses those pages rather than
 returning an empty one.
 
+#### CLI summary and saved member rows
+
+The CLI accepts the same `complete` and `summary` detail choices. Omitted or
+`--detail complete` returns complete Evidence. To receive a summary, choose a
+new Evidence bundle destination so its original complete parent remains
+available after the command exits:
+
+```bash
+rea inspect-managed-members /absolute/path/Assembly.dll --type Namespace.Type \
+  --detail summary --evidence-bundle /absolute/path/evidence/members.json --json
+```
+
+`--evidence-bundle` writes the complete original Evidence in REA's canonical
+bundle format. Its parent directory must exist, and it never replaces an
+existing path. Relative paths resolve against the command's working directory.
+The option also works with complete delivery when a saved bundle is useful.
+Summary without a destination is rejected before analysis. A publication failure
+returns a typed error with the completed Evidence under
+`details.partial_observation`; it does not report successful summary delivery.
+Cancellation before publication prevents the new output. Once atomic
+publication has started, it can complete despite cancellation; a cancelled
+delivery then retains the committed path and byte count under
+`details.diagnostics.evidence_bundle`.
+
+Copy `normalized_result.parent_evidence_id` from the summary into the
+`source.evidence_id` field of the `managed-members` request above, then save that
+small request as `members-page.json` and run:
+
+```bash
+rea inspect-analysis-view /absolute/path/evidence/members-page.json \
+  --evidence-bundle /absolute/path/evidence/members.json --json
+```
+
+The view command authenticates the selected bundle and resolves that exact
+parent ID. It does not reopen the assembly, so the original target may have
+been moved or removed. Subsequent calls can select another collection or use
+the returned `coverage.next_offset` to continue the same collection. An inline
+source already includes its parent and cannot also select `--evidence-bundle`.
+
+Summary changes delivery, while type selection still controls decoding and the
+same inspection resource limits apply. Each separate CLI page reads and
+authenticates the saved bundle; the full source is retained on disk.
+
 ## Shipped scope
 
 The canonical parser admits PE/CLI bytes and their metadata/CIL without loading
@@ -622,6 +665,9 @@ which managed methods executed or how the CLR resolved them.
 
 Managed member comparisons report a `metadata` dimension when an observed
 MethodDef flags or implementation flags value differs, including accessibility
-or synchronization changes. This is separate from the CIL/signature matching
-tiers: identical instructions do not establish unchanged method metadata. The
-reported difference is static metadata evidence, not proof of runtime behavior.
+or synchronization changes. Observed method-body `init_locals` and `max_stack`
+differences also contribute to `metadata`, even when CIL decoding is incomplete.
+An unavailable header value keeps body coverage unknown rather than establishing
+equality or a difference. These comparisons are separate from the CIL/signature
+matching tiers: identical instructions do not establish unchanged method metadata.
+The reported difference is static metadata evidence, not proof of runtime behavior.

docs/mcp-contracts.md

@@ -234,11 +234,14 @@ The destination changes only when a complete export is atomically published.
 
 Clients that explicitly configure a larger receive buffer can set the REA
 server's `REA_MCP_MAX_RESPONSE_BYTES` environment variable to the same byte
-count. This setting must be a safe decimal integer at least 10485760; REA
-reserves 1024 bytes for the envelope. Raising it restores complete inline
-delivery for responses that fit that buffer and Node's single-string limit.
-It does not change the client's buffer, analysis coverage, or retained content.
-Ordinary responses keep their existing complete result contract.
+count. This setting must be a safe decimal integer at least 10485760 (10 MiB);
+REA reserves 1024 bytes for the envelope. The value is read when the REA
+process starts, so a change requires a restart and a matching client receive
+buffer. Raising it restores complete inline delivery for responses that fit
+that buffer. It does not raise REA's reserved single-string limit, which is
+1024 UTF-16 code units below Node's single-string ceiling, and it does not
+raise that Node ceiling. It does not change analysis coverage or retained
+content. Ordinary responses keep their existing complete result contract.
 
 ### Error recovery and deadline ownership
 
@@ -329,7 +332,7 @@ See [environment manifests](web-network-captures.md#environment-manifest).
 
 `inspect_analysis_view` also accepts `environment-state` for the same parents,
 extracting the initial state the recorded reads observed: entity types with an
-identity field, entities, documents for written non-entity paths, and a render
+identity field, entities, documents for non-entity reads, and a render
 plan per read tool that reproduces its recordings from the state or names why it
 cannot. Types and identity are inferences, so the Evidence is always inferred.
 See [environment state](web-network-captures.md#environment-state).

docs/native-investigation.md

@@ -202,10 +202,38 @@ Function dossiers retain this same string evidence. Native call edges retain
 Hopper's partial `CallReference` classification and exact endpoints; detailed
 reference flags remain unavailable rather than being invented.
 Regex searches use ECMAScript Unicode syntax in a cancellable worker with a
-five-second matching deadline and a 128 MiB worker heap. Deadline or
+five-second matching deadline and a worker old-generation heap. Deadline or
 cancellation stops matching while leaving the Hopper API available. This
-release has no runtime override for that deadline or heap. Literal mode
-retains Unicode casefold matching.
+release has no runtime override for that deadline. The worker requests 128
+MiB. A positive Node.js `--max-old-space-size` on the process that starts
+REA, including `NODE_OPTIONS`, overrides that request and sets the effective
+heap. `--max-old-space-size-percentage` takes precedence over that flag in
+either order. REA does not turn the percentage into a MiB, so the effective
+heap stays unestablished instead of the 128 MiB request or the absolute flag.
+The reported `NODE_OPTIONS` value is the process initial environment when that
+block can be read. A later edit to the environment is not the value Node
+applied, and an unreadable initial value leaves the effective heap
+unestablished. The launch Node options are the initial command line on Linux
+when that buffer still has a program entry, not a later edit to
+`process.execArgv`. A preload can clear that array after V8 has applied the
+flags. Setting `process.title` or `--title` overwrites the command line, so a
+buffer without a program entry leaves the effective heap unestablished.
+`--env-file` or `--env-file-if-exists` can supply `NODE_OPTIONS`
+when the initial environment has none. That file is not part of the initial
+environment block, so the effective heap stays unestablished instead of the
+128 MiB request. An initial `NODE_OPTIONS` is still used, because Node does
+not let the file replace it. A positive `--max-heap-size`, including the
+underscore form and launch `NODE_OPTIONS` on Node versions that allow it,
+sets the total heap rather than the old generation and can be lower than the
+128 MiB request. The effective old generation stays unestablished while that
+value is in effect. A zero or empty value clears it.
+`--experimental-config-file` or `--experimental-default-config-file` can set
+`nodeOptions`, including a heap percentage, from a file that is not read
+back. The effective heap stays unestablished when either flag is present,
+including when an absolute `--max-old-space-size` is also on the command
+line or in the recovered `NODE_OPTIONS`. Node accepts the config path as
+`=` or the next argument.
+Literal mode retains Unicode casefold matching.
 
 ## Bounded static traces
 
@@ -439,6 +467,14 @@ complete observation.
   vtable descriptors. Records include exact virtual addresses/file offsets and
   artifact evidence. Vtable indexes are metadata word offsets; witness indexes
   start after the conformance header. Names unavailable in metadata remain null.
+  The byte reader holds the whole selected file in memory, so it admits files up
+  to 64 MiB / 67108864 bytes by default. Select a larger budget with
+  `max_input_bytes` (CLI `--max-input-bytes`), at most 1 GiB / 1073741824
+  bytes. The whole file counts, including every slice of a universal Mach-O.
+  Results record `input_admission` with the effective budget, its source
+  (`default` or `caller`) and the bytes retained. A refusal names the observed
+  file size, the effective budget and its source, and either the budget to
+  select or, above 1 GiB, a deep analysis provider.
   The `swift_class_vtable_descriptors` coverage counters count examined vtable
   slots and successfully decoded slots, rather than type-section entries.
   The `objc_class_method_ivar_metadata` counters count admitted class and

docs/pe-certificates.md

@@ -0,0 +1,49 @@
+# PE Authenticode certificate tables
+
+`inspect_pe_certificates` / `inspect-pe-certificates` answers whether one
+selected local PE32/PE32+ image declares an `IMAGE_DIRECTORY_ENTRY_SECURITY`
+table, which `WIN_CERTIFICATE` entries that table stores, and which PKCS#7
+signer and X.509 fields those entries carry. It reads the file without
+executing it and does not require a Windows SDK, catalog file, or disassembler.
+
+```bash
+rea inspect-pe-certificates /absolute/path/to/application.exe --json
+```
+
+The CLI resolves relative paths against the caller's working directory. MCP
+requires an absolute filesystem path and preserves that exact selection:
+
+```json
+{
+  "name": "inspect_pe_certificates",
+  "arguments": { "path": "/artifacts/application.exe" }
+}
+```
+
+## Observations
+
+The inline Evidence result contains the artifact path, SHA-256, and byte length.
+`table` is the file-offset security directory, or `null` when the directory is
+absent or zero. Each `entries[]` item reports `WIN_CERTIFICATE` length,
+revision, type, and the payload SHA-256.
+
+For `WIN_CERTIFICATE` type 2 (PKCS#7 signedData) `pkcs7` contains digest
+algorithm OIDs, embedded X.509 serial/issuer/subject/validity fields, and
+signer identifier facts. Other certificate types keep `pkcs7` null.
+
+A missing table is observed absence of that directory. It is not proof the
+image is unsigned in every catalog or overlay sense.
+
+## Limits and failures
+
+The selected file is limited to 64 MiB by default (512 MiB maximum). At most
+eight `WIN_CERTIFICATE` entries are examined by default. Malformed PE headers,
+truncated certificate entries, and PKCS#7 that is not structurally signedData
+fail without partial success. A security directory that ends in fewer than
+eight header bytes, including zeros, is a truncated `WIN_CERTIFICATE` and
+fails the same way. SignedData must contain at least one `SignerInfo`, and
+each `SignerInfo` must carry a non-empty signature value. Decoded certificate
+name text shares a 64 KiB budget per PKCS#7 payload.
+
+This workflow does not verify signatures, certificate chains, timestamps, or
+Authenticode digest coverage of image bytes.

docs/readme/README_ar.md

@@ -143,6 +143,7 @@ npx rea-agents@latest setup
 | ------------------------------- | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
 | الملفات الثنائية للشيفرة الأصلية | شيفرة شبه برمجية، وتعليمات تجميع، وسلاسل نصية، ورموز، واستدعاءات، ومراجع                                    | Hopper أو Ghidra أو IDA؛ [تحليل الشيفرة الأصلية](../native-investigation.md)                                                   |
 | بنية ELF دون تشغيل              | الأقسام والمقاطع والرموز ومعلومات إعادة التموضع الأصلية، وآليات الحماية المحتملة المستدلّ عليها بالفحص الثابت | pwntools يوفّره المستدعي على Linux x64؛ [تشخيص الملفات الثنائية](../binary-diagnostics.md)                                     |
+| PE certificates                 | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                               | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                       |
 | شيفرة EVM البايتية              | محددات التوجيه، وإزاحات البايتات، والمعاملات المستنتجة، وقابلية تغيير الحالة                                | مدخل محلي يحمل بايتات خامًا أو تمثيلًا سداسيًا عشريًا على Linux x64؛ [دليل EVM دون تشغيل](../evm-bytecode.md)                      |
 | Rust binaries                   | Embedded cargo-auditable dependency list                                                                   | [Rust binaries](../rust-binaries.md)                                                                                          |
 | أعطال Linux المسجّلة             | سجلات note الخام، ومسجّلات المعالج/الإشارات لكل خيط مسجّل، وترشيحات اختيارية لخرائط الذاكرة                     | pwntools يوفّره المستدعي على Linux x64؛ GDB/pwndbg اختياريان؛ [الأعطال المسجّلة](../recorded-crashes.md)                         |

docs/readme/README_de.md

@@ -143,6 +143,7 @@ REA benötigt Node.js 22.x (>=22.19), 24.x (>=24.11) oder 26+ sowie npm. Zusätz
 | ----------------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
 | Native Binärdateien                 | Pseudocode, Assemblercode, Zeichenketten, Symbole, Aufrufe und Verweise                                         | Hopper, Ghidra oder IDA; [native Analyse](../native-investigation.md)                                                                       |
 | Offline-ELF-Struktur                | Sektionen, Segmente, ursprüngliche Symbole/Relokationen und mögliche Schutzmaßnahmen aus statischer Analyse     | Vom Aufrufer bereitgestelltes pwntools unter Linux x64; [Binärdiagnostik](../binary-diagnostics.md)                                         |
+| PE certificates                     | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                    | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                     |
 | EVM-Bytecode                        | Dispatch-Selektoren, Byte-Offsets, abgeleitete Argumente und Veränderbarkeit des Zustands                       | Lokale Eingabe mit Rohbytes oder Hexdarstellung unter Linux x64; [Offline-EVM-Leitfaden](../evm-bytecode.md)                                |
 | Rust binaries                       | Embedded cargo-auditable dependency list                                                                        | [Rust binaries](../rust-binaries.md)                                                                                                        |
 | Aufgezeichnete Linux-Abstürze       | Unverarbeitete Note-Einträge, Register/Signale aller aufgezeichneten Threads und optionale Zuordnungskandidaten | Vom Aufrufer bereitgestelltes pwntools unter Linux x64; optional GDB/pwndbg; [aufgezeichnete Abstürze](../recorded-crashes.md)              |

docs/readme/README_el.md

@@ -149,6 +149,7 @@ npx rea-agents@latest setup
 | Δομή ELF χωρίς εκτέλεση                | Ενότητες, τμήματα, αρχικά σύμβολα/εγγραφές μετεγκατάστασης και ενδείξεις πιθανών μέτρων προστασίας από στατική ανάλυση      | pwntools που παρέχει ο χρήστης σε Linux x64· [διαγνωστικά δυαδικών αρχείων](../binary-diagnostics.md)                               |
 | Δυαδικά αρχεία Go                      | Ενσωματωμένη έκδοση μεταγλωττιστή, modules, αντικαταστάσεις και ρυθμίσεις μεταγλώττισης                                     | Ενσωματωμένη στατική εξέταση ELF/PE/thin Mach-O· δεν απαιτείται εγκατάσταση του Go                                                  |
 | Δυαδικά αρχεία Rust                    | Ενσωματωμένα ονόματα, εκδόσεις, πηγές και σχέσεις εξάρτησης των crates από το cargo-auditable                               | Ενσωματωμένη στατική εξέταση ELF/PE/thin Mach-O· [δυαδικά αρχεία Rust](../rust-binaries.md)                                         |
+| PE certificates                        | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                                | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                             |
 | Αρχείο WASM                            | Έλεγχο εγκυρότητας, ενότητες, ακριβείς μορφές εισαγωγών/εξαγωγών σε WAT και αποκωδικοποιημένο WAT                           | WABT 1.0.42 που παρέχει ο χρήστης· `inspect_wasm_artifact`                                                                          |
 | Bytecode EVM                           | Selectors επιλογής συνάρτησης, μετατοπίσεις σε bytes, εκτιμώμενα ορίσματα και δυνατότητα μεταβολής της κατάστασης           | Τοπική είσοδος σε ακατέργαστα bytes ή δεκαεξαδική μορφή σε Linux x64· [οδηγός EVM χωρίς εκτέλεση](../evm-bytecode.md)               |
 | Βάσεις δεδομένων SQLite                | Πίνακες, στήλες, ευρετήρια, όψεις, triggers και επιλεγμένες γραμμές κανονικών πινάκων                                       | Τοπικό στιγμιότυπο βάσης δεδομένων/WAL· Node.js 24.x >=24.15 ή 26+ με εγγενή όρια SQLite                                            |

docs/readme/README_es.md

@@ -143,6 +143,7 @@ REA requiere Node.js 22.x (>=22.19), 24.x (>=24.11) o 26+, además de npm. Las h
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
 | Binarios nativos            | Pseudocódigo, ensamblador, cadenas, símbolos, llamadas y referencias                                                           | Hopper, Ghidra o IDA; [análisis nativo](../native-investigation.md)                                                                    |
 | Estructura ELF sin ejecutar | Secciones, segmentos, símbolos/reubicaciones originales y posibles medidas de mitigación detectadas mediante análisis estático | pwntools proporcionado por quien llama, en Linux x64; [diagnóstico de binarios](../binary-diagnostics.md)                              |
+| PE certificates             | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                                   | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                |
 | Bytecode EVM                | Selectores de despacho, desplazamientos en bytes, argumentos inferidos y mutabilidad                                           | Entrada local con bytes sin procesar o representación hexadecimal, en Linux x64; [guía de EVM sin ejecutar](../evm-bytecode.md)        |
 | Rust binaries               | Embedded cargo-auditable dependency list                                                                                       | [Rust binaries](../rust-binaries.md)                                                                                                   |
 | Fallos de Linux registrados | Registros note sin procesar, registros/señales de cada hilo registrado y posibles correspondencias de memoria opcionales       | pwntools proporcionado por quien llama, en Linux x64; GDB/pwndbg opcionales; [fallos registrados](../recorded-crashes.md)              |

docs/readme/README_fa.md

@@ -135,6 +135,7 @@ REA به Node.js 22.x (>=22.19)، 24.x (>=24.11) یا 26+، به‌همراه np
 | ---------------------- | ----------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | باینری‌های بومی         | شبه‌کد، اسمبلی، رشته‌ها، نمادها، فراخوانی‌ها و ارجاعات                                 | Hopper، Ghidra یا IDA؛ [تحلیل بومی](../native-investigation.md)                                                                   |
 | ساختار ELF آفلاین       | بخش‌ها، سگمنت‌ها، نمادها و relocationهای اصلی و گزینه‌های احتمالی کاهش آسیب‌پذیری ایستا | pwntools تأمین‌شده توسط فراخواننده روی Linux x64؛ [تشخیص باینری](../binary-diagnostics.md)                                         |
+| PE certificates        | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields        | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                           |
 | بایت‌کد EVM             | selectorهای dispatch، offsetهای بایتی، آرگومان‌های استنباط‌شده و قابلیت تغییر وضعیت   | دادهٔ خام/hex محلی روی Linux x64؛ [راهنمای EVM آفلاین](../evm-bytecode.md)                                                          |
 | Rust binaries          | Embedded cargo-auditable dependency list                                            | [Rust binaries](../rust-binaries.md)                                                                                              |
 | کرش‌های ثبت‌شدهٔ لینوکس   | یادداشت‌های خام، رجیسترها/سیگنال‌های تمام threadهای ثبت‌شده و گزینه‌های احتمالی نگاشت   | pwntools تأمین‌شده توسط فراخواننده روی Linux x64؛ GDB/pwndbg اختیاری؛ [کرش‌های ثبت‌شده](../recorded-crashes.md)                      |

docs/readme/README_fr.md

@@ -146,6 +146,7 @@ REA nécessite Node.js 22.x (>=22.19), 24.x (>=24.11) ou 26+, ainsi que npm. Les
 | ---------------------------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | Binaires natifs              | Pseudo-code, assembleur, chaînes, symboles, appels et références                                            | Hopper, Ghidra ou IDA ; [analyse native](../native-investigation.md)                                                              |
 | Structure ELF hors ligne     | Sections, segments, symboles et relocations d'origine, et protections statiques candidates                  | pwntools fourni par l'utilisateur sous Linux x64 ; [diagnostics binaires](../binary-diagnostics.md)                               |
+| PE certificates              | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                           |
 | Artefact WASM                | Validation, sections, formes WAT exactes d'import/export et WAT décodé                                      | WABT 1.0.42 fourni par l'utilisateur ; `inspect_wasm_artifact`                                                                    |
 | Bytecode EVM                 | Sélecteurs de dispatch, offsets en octets, arguments inférés et mutabilité                                  | Fichier local brut ou hexadécimal sous Linux x64 ; [guide EVM hors ligne](../evm-bytecode.md)                                     |
 | Rust binaries                | Embedded cargo-auditable dependency list                                                                    | [Rust binaries](../rust-binaries.md)                                                                                              |

docs/readme/README_id.md

@@ -149,6 +149,7 @@ Alat tambahan dan dukungan sistem host bergantung pada target yang dianalisis:
 | -------------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
 | Biner native               | Pseudocode, assembly, string, simbol, pemanggilan, dan referensi                                      | Hopper, Ghidra, atau IDA; [analisis native](../native-investigation.md)                                                        |
 | Tata letak ELF offline     | Bagian, segmen, simbol/relokasi asli, dan kandidat mitigasi statis                                    | pwntools yang disediakan pemanggil pada Linux x64; [diagnostik biner](../binary-diagnostics.md)                                |
+| PE certificates            | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                          | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                        |
 | Artefak WASM               | Validasi, bagian, bentuk WAT import/ekspor yang tepat, dan WAT yang didekode                          | WABT 1.0.42 yang disediakan pemanggil; `inspect_wasm_artifact`                                                                 |
 | Bytecode EVM               | Selector dispatch, offset byte, argumen yang disimpulkan, dan sifat mutabilitas                       | Pembawa data raw/hex lokal; [panduan EVM offline](../evm-bytecode.md)                                                          |
 | Rust binaries              | Embedded cargo-auditable dependency list                                                              | [Rust binaries](../rust-binaries.md)                                                                                           |

docs/readme/README_it.md

@@ -146,6 +146,7 @@ REA richiede Node.js 22.x (>=22.19), 24.x (>=24.11) o 26+, oltre a npm. Strument
 | ---------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
 | Binari nativi                | Pseudocodice, assembly, stringhe, simboli, chiamate e riferimenti                                 | Hopper, Ghidra o IDA; [analisi nativa](../native-investigation.md)                                                              |
 | Layout ELF offline           | Sezioni, segmenti, simboli/relocazioni originali e candidati mitigazioni statiche                 | pwntools fornito dal chiamante su Linux x64; [diagnostica binaria](../binary-diagnostics.md)                                    |
+| PE certificates              | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                      | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                         |
 | Artefatto WASM               | Convalida, sezioni, forme WAT di import/export esatte e WAT decodificato                          | WABT 1.0.42 fornito dal chiamante; `inspect_wasm_artifact`                                                                      |
 | Bytecode EVM                 | Selettori di dispatch, offset dei byte, argomenti inferiti e mutabilità                           | Carrier raw/hex locale; [guida EVM offline](../evm-bytecode.md)                                                                 |
 | Rust binaries                | Embedded cargo-auditable dependency list                                                          | [Rust binaries](../rust-binaries.md)                                                                                            |

docs/readme/README_ja.md

@@ -143,6 +143,7 @@ REA には Node.js 22.x（>=22.19）、24.x（>=24.11）、または 26+ と npm
 | -------------------------------- | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
 | ネイティブバイナリ               | 疑似コード、アセンブリ、文字列、シンボル、呼び出し、参照                                    | Hopper、Ghidra、または IDA；[ネイティブ分析](../native-investigation.md)                                                                       |
 | オフライン ELF レイアウト        | セクション、セグメント、元のシンボル／再配置情報、静的解析によるセキュリティ対策の候補      | Linux x64 で利用者が用意する pwntools；[バイナリ診断](../binary-diagnostics.md)                                                                |
+| PE certificates                  | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                        |
 | EVM バイトコード                 | ディスパッチセレクター、バイトオフセット、推定された引数と状態変更の可否                    | Linux x64 上のローカルの生バイト／16 進数の入力ファイル；[オフライン EVM ガイド](../evm-bytecode.md)                                           |
 | Rust binaries                    | Embedded cargo-auditable dependency list                                                    | [Rust binaries](../rust-binaries.md)                                                                                                           |
 | 記録済みの Linux クラッシュ      | 生の note レコード、記録された全スレッドのレジスター／シグナル、任意のマッピング候補        | Linux x64 で利用者が用意する pwntools；GDB/pwndbg は任意；[記録済みクラッシュ](../recorded-crashes.md)                                         |

docs/readme/README_ko.md

@@ -153,6 +153,7 @@ REA에는 Node.js 22.x(>=22.19), 24.x(>=24.11) 또는 26+와 npm이 필요합니
 | 오프라인 ELF 레이아웃  | 섹션, 세그먼트, 원본 심볼/재배치 정보, 정적 분석으로 얻은 보안 완화 기법 후보 | Linux x64에서 호출자가 제공하는 pwntools; [바이너리 진단](../binary-diagnostics.md)                                               |
 | Go 바이너리            | 내장된 컴파일러 버전, 모듈, `replace` 지시어, 빌드 설정                       | REA 내장 ELF/PE/thin Mach-O 정적 검사; Go 설치 불필요                                                                             |
 | Rust 바이너리          | cargo-auditable이 내장한 크레이트 이름, 버전, 소스, 의존성 관계               | REA 내장 ELF/PE/thin Mach-O 정적 검사; [Rust 바이너리](../rust-binaries.md)                                                       |
+| PE certificates        | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields  | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                           |
 | WASM 아티팩트          | 유효성 검사, 섹션, import/export의 정확한 WAT 형식, 디코딩된 WAT              | 호출자 제공 WABT 1.0.42; `inspect_wasm_artifact`                                                                                  |
 | EVM 바이트코드         | 디스패치 선택자, 바이트 오프셋, 추론한 인자와 상태 변경 가능 여부             | Linux x64의 로컬 원시 바이트/16진수 입력 파일; [오프라인 EVM 가이드](../evm-bytecode.md)                                          |
 | SQLite 데이터베이스    | 테이블, 열, 인덱스, 뷰, 트리거, 선택한 일반 테이블의 행                       | 로컬 데이터베이스/WAL 스냅샷; Node.js 24.15 이상의 24.x 또는 26 이상(네이티브 SQLite 한도 적용)                                   |

docs/readme/README_ml.md

@@ -151,6 +151,7 @@ REA-യ്ക്ക് Node.js 22.x (>=22.19), 24.x (>=24.11), അല്ലെ
 | Offline ELF layout     | Sections, segments, യഥാർത്ഥ symbols/relocations, static mitigation candidates         | Linux x64-ൽ caller നൽകുന്ന pwntools; [binary diagnostics](../binary-diagnostics.md)                                                 |
 | Go binaries            | ഉൾച്ചേർത്ത compiler version, modules, replacements, build settings                    | Built-in static ELF/PE/thin Mach-O പരിശോധന; Go installation ആവശ്യമില്ല                                                              |
 | Rust binaries          | ഉൾച്ചേർത്ത cargo-auditable crate പേരുകൾ, versions, sources, dependency edges           | Built-in static ELF/PE/thin Mach-O പരിശോധന; [Rust binaries](../rust-binaries.md)                                                  |
+| PE certificates        | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields        | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                           |
 | WASM artifact          | Validation, sections, കൃത്യമായ import/export WAT രൂപങ്ങൾ, decoded WAT                    | Caller നൽകുന്ന WABT 1.0.42; `inspect_wasm_artifact`                                                                                 |
 | EVM bytecode           | Dispatch selectors, byte offsets, അനുമാനിച്ച arguments, mutability                     | Linux x64-ൽ local raw/hex carrier; [offline EVM guide](../evm-bytecode.md)                                                        |
 | SQLite databases       | Tables, columns, indexes, views, triggers, തിരഞ്ഞെടുത്ത സാധാരണ table rows                | Local database/WAL snapshot; native SQLite പരിമിതികളോടെ Node.js 24.x >=24.15 അല്ലെങ്കിൽ 26+                                         |

docs/readme/README_pl.md

@@ -143,6 +143,7 @@ REA wymaga Node.js 22.x (>=22.19), 24.x (>=24.11) lub 26+ oraz npm. Dodatkowe na
 | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
 | Natywne pliki binarne                   | Pseudokod, kod asemblera, ciągi znaków, symbole, wywołania i odwołania                                                | Hopper, Ghidra lub IDA; [analiza kodu natywnego](../native-investigation.md)                                                         |
 | Układ pliku ELF w trybie offline        | Sekcje, segmenty, oryginalne symbole/relokacje i potencjalne mechanizmy zabezpieczeń wskazane przez analizę statyczną | pwntools dostarczone przez użytkownika w systemie Linux x64; [diagnostyka plików binarnych](../binary-diagnostics.md)                |
+| PE certificates                         | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                          | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                              |
 | Kod bajtowy EVM                         | Selektory wywołań, przesunięcia bajtowe, wywnioskowane argumenty i mutowalność                                        | Lokalny plik z surowymi bajtami lub zapisem szesnastkowym w systemie Linux x64; [przewodnik EVM offline](../evm-bytecode.md)         |
 | Rust binaries                           | Embedded cargo-auditable dependency list                                                                              | [Rust binaries](../rust-binaries.md)                                                                                                 |
 | Zarejestrowane awarie systemu Linux     | Surowe rekordy note, rejestry/sygnały każdego zarejestrowanego wątku i opcjonalni kandydaci na mapowania              | pwntools dostarczone przez użytkownika w systemie Linux x64; opcjonalnie GDB/pwndbg; [zarejestrowane awarie](../recorded-crashes.md) |

docs/readme/README_pt-BR.md

@@ -143,6 +143,7 @@ O REA requer Node.js 22.x (>=22.19), 24.x (>=24.11) ou 26+, além do npm. As fer
 | --------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | Binários nativos            | Pseudocódigo, assembly, strings, símbolos, chamadas e referências                                                       | Hopper, Ghidra ou IDA; [análise nativa](../native-investigation.md)                                                               |
 | Estrutura ELF sem execução  | Seções, segmentos, símbolos/relocações originais e possíveis mecanismos de mitigação identificados por análise estática | pwntools fornecido pelo chamador no Linux x64; [diagnóstico de binários](../binary-diagnostics.md)                                |
+| PE certificates             | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                            | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                           |
 | Bytecode EVM                | Seletores de despacho, offsets de bytes, argumentos inferidos e mutabilidade                                            | Entrada local com bytes brutos ou representação hexadecimal no Linux x64; [guia de EVM sem execução](../evm-bytecode.md)          |
 | Rust binaries               | Embedded cargo-auditable dependency list                                                                                | [Rust binaries](../rust-binaries.md)                                                                                              |
 | Falhas do Linux registradas | Registros note brutos, registradores/sinais de cada thread registrada e candidatos opcionais a mapeamentos              | pwntools fornecido pelo chamador no Linux x64; GDB/pwndbg opcionais; [falhas registradas](../recorded-crashes.md)                 |

docs/readme/README_ru.md

@@ -145,6 +145,7 @@ REA требует Node.js 22.x (>=22.19), 24.x (>=24.11) или 26+, а так
 | Структура ELF без запуска           | Секции, сегменты, исходные символы/релокации и возможные механизмы защиты по данным статического анализа                   | pwntools, предоставленный вызывающей стороной, в Linux x64; [диагностика бинарных файлов](../binary-diagnostics.md)                      |
 | Байт-код EVM                        | Селекторы диспетчеризации, смещения байтов, предполагаемые аргументы и изменяемость состояния                              | Локальные необработанные байты или шестнадцатеричное представление в Linux x64; [руководство по EVM без запуска](../evm-bytecode.md)     |
 | Rust binaries                       | Embedded cargo-auditable dependency list                                                                                   | [Rust binaries](../rust-binaries.md)                                                                                                     |
+| PE certificates                     | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                               | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                  |
 | Записанные сбои Linux               | Необработанные записи note, регистры/сигналы каждого записанного потока и необязательные кандидаты сопоставления с памятью | pwntools, предоставленный вызывающей стороной, в Linux x64; необязательные GDB/pwndbg; [записанные сбои](../recorded-crashes.md)         |
 | Установленные настольные приложения | Возможные среды выполнения, файлы с доказательствами, компоненты и дальнейшие шаги                                         | Ограниченная проверка каталогов и заголовков；[Настольные приложения](../desktop-applications.md)                                        |
 | JavaScript / Electron               | Модули, импорты, карты исходного кода, маршруты, IPC и связи с нативными дополнениями                                      | Node.js и npm; [анализ приложений](../javascript-application-workflows.md)                                                               |

docs/readme/README_th.md

@@ -143,6 +143,7 @@ REA ต้องใช้ Node.js 22.x (>=22.19), 24.x (>=24.11) หรือ 26
 | ---------------------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
 | ไบนารีเนทีฟ                    | โค้ดเทียม แอสเซมบลี สตริง สัญลักษณ์ การเรียก และการอ้างอิง                                | Hopper, Ghidra หรือ IDA; [การวิเคราะห์เนทีฟ](../native-investigation.md)                                                       |
 | โครงสร้าง ELF แบบออฟไลน์       | เซกชัน เซกเมนต์ สัญลักษณ์/รีโลเคชันต้นฉบับ และตัวเลือกกลไกป้องกันที่พบจากการวิเคราะห์แบบสถิต      | pwntools ที่ผู้ใช้จัดเตรียมบน Linux x64; [การวินิจฉัยไบนารี](../binary-diagnostics.md)                                                |
+| PE certificates              | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields    | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                    |
 | ไบต์โค้ด EVM                   | ตัวเลือกฟังก์ชันสำหรับการเรียก ออฟเซ็ตไบต์ อาร์กิวเมนต์และความสามารถในการเปลี่ยนสถานะที่อนุมานได้ | ไฟล์บนเครื่องที่มีไบต์ดิบหรือข้อมูลเลขฐานสิบหกบน Linux x64; [คู่มือ EVM แบบออฟไลน์](../evm-bytecode.md)                                    |
 | Rust binaries                | Embedded cargo-auditable dependency list                                        | [Rust binaries](../rust-binaries.md)                                                                                       |
 | ข้อมูลการแครชของ Linux ที่บันทึกไว้ | ระเบียน note ดิบ รีจิสเตอร์/สัญญาณของทุกเธรดที่บันทึกไว้ และตัวเลือกการแมปเพิ่มเติม              | pwntools ที่ผู้ใช้จัดเตรียมบน Linux x64; เลือกใช้ GDB/pwndbg เพิ่มเติมได้; [การแครชที่บันทึกไว้](../recorded-crashes.md)                     |

docs/readme/README_tr.md

@@ -147,6 +147,7 @@ REA; Node.js 22.x (>=22.19), 24.x (>=24.11) veya 26+ ve npm gerektirir. Ek araç
 | Çevrimdışı ELF yapısı                   | Bölümler, segmentler, özgün semboller/yeniden konumlandırmalar ve statik analizden olası güvenlik önlemleri | Linux x64 üzerinde çağıranın sağladığı pwntools; [ikili dosya tanılama](../binary-diagnostics.md)                                  |
 | Go ikili dosyaları                      | Gömülü compiler sürümü, modüller, replacement'lar ve build ayarları                                         | Yerleşik statik ELF/PE/thin Mach-O incelemesi; Go kurulumu gerekmez                                                                |
 | Rust ikili dosyaları                    | Gömülü cargo-auditable crate adları, sürümleri, kaynakları ve bağımlılık ilişkileri                         | Yerleşik statik ELF/PE/thin Mach-O incelemesi; [Rust ikili dosyaları](../rust-binaries.md)                                         |
+| PE certificates                         | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                            |
 | WASM artefaktı                          | Doğrulama, bölümler, tam import/export WAT biçimleri ve decode edilmiş WAT                                  | Çağıranın sağladığı WABT 1.0.42; `inspect_wasm_artifact`                                                                           |
 | EVM bayt kodu                           | Yönlendirme seçicileri, bayt ofsetleri, çıkarımla belirlenen argümanlar ve durum değiştirilebilirliği       | Linux x64 üzerinde yerel ham bayt/onaltılık girdi; [çevrimdışı EVM rehberi](../evm-bytecode.md)                                    |
 | SQLite veritabanları                    | Tablolar, sütunlar, index'ler, view'lar, trigger'lar ve seçilen sıradan tablo satırları                     | Yerel database/WAL snapshot'ı; native SQLite sınırlarıyla Node.js 24.x >=24.15 veya 26+                                            |

docs/readme/README_uk.md

@@ -143,6 +143,7 @@ REA потребує Node.js 22.x (>=22.19), 24.x (>=24.11) або 26+, а та
 | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Нативні бінарні файли                | Псевдокод, асемблерний код, рядки, символи, виклики й посилання                                                   | Hopper, Ghidra або IDA; [нативний аналіз](../native-investigation.md)                                                                             |
 | Структура ELF без запуску            | Секції, сегменти, початкові символи/релокації та можливі захисні механізми за даними статичного аналізу           | pwntools, наданий стороною, що викликає інструмент, у Linux x64; [діагностика бінарних файлів](../binary-diagnostics.md)                          |
+| PE certificates                      | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                      | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                           |
 | Байт-код EVM                         | Селектори диспетчеризації, зміщення байтів, виведені припущення про аргументи та змінюваність стану               | Локальні необроблені байти або шістнадцяткове представлення у Linux x64; [посібник EVM без запуску](../evm-bytecode.md)                           |
 | Rust binaries                        | Embedded cargo-auditable dependency list                                                                          | [Rust binaries](../rust-binaries.md)                                                                                                              |
 | Записані аварійні завершення в Linux | Необроблені записи note, регістри/сигнали кожного записаного потоку й необов'язкові кандидати зіставлення пам'яті | pwntools, наданий стороною, що викликає інструмент, у Linux x64; необов'язкові GDB/pwndbg; [записані аварійні завершення](../recorded-crashes.md) |

docs/readme/README_vi.md

@@ -145,6 +145,7 @@ REA yêu cầu Node.js 22.x (>=22.19), 24.x (>=24.11) hoặc 26+, cùng với np
 | Bố cục ELF ngoại tuyến            | Các section, segment, ký hiệu/thông tin tái định vị gốc và các biện pháp giảm thiểu có thể có từ phân tích tĩnh | pwntools do bên gọi cung cấp trên Linux x64; [chẩn đoán tệp nhị phân](../binary-diagnostics.md)                                           |
 | Bytecode EVM                      | Bộ chọn điều phối, độ lệch byte, tham số suy luận và khả năng thay đổi trạng thái                               | Đầu vào cục bộ chứa byte thô hoặc dạng thập lục phân trên Linux x64; [hướng dẫn EVM ngoại tuyến](../evm-bytecode.md)                      |
 | Rust binaries                     | Embedded cargo-auditable dependency list                                                                        | [Rust binaries](../rust-binaries.md)                                                                                                      |
+| PE certificates                   | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields                                    | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                                                   |
 | Sự cố Linux đã ghi lại            | Bản ghi note thô, thanh ghi/tín hiệu của mọi luồng được ghi lại và các ứng viên ánh xạ tùy chọn                 | pwntools do bên gọi cung cấp trên Linux x64; GDB/pwndbg tùy chọn; [sự cố đã ghi lại](../recorded-crashes.md)                              |
 | Thư mục cài đặt ứng dụng máy tính | Các runtime có khả năng được dùng, tệp bằng chứng, dấu hiệu thành phần và bước tiếp theo                        | Kiểm tra thư mục và phần đầu tệp có giới hạn；[Ứng dụng máy tính](../desktop-applications.md)                                             |
 | JavaScript / Electron             | Mô-đun, các khai báo import, source map, tuyến, IPC và quan hệ với tiện ích mở rộng mã máy                      | Node.js và npm; [phân tích ứng dụng](../javascript-application-workflows.md)                                                              |

docs/readme/README_zh-TW.md

@@ -141,32 +141,33 @@ AI 代理通過 MCP 呼叫 REA，檢查目標並追蹤相關程式碼。REA 返
 
 REA 需要 Node.js 22.x（>=22.19）、24.x（>=24.11）或 26+，以及 npm。額外工具和主機支援取決於分析目標：
 
-| 目標                  | REA 返回的內容                                                  | 要求與指南                                                                                                         |
-| --------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| 原生二進位檔案        | 偽程式碼、組合語言、字串、符號、呼叫和引用                      | Hopper、Ghidra 或 IDA；[原生分析](../native-investigation.md)                                                      |
-| 離線 ELF 佈局         | 節、段、原始符號/重定位資訊及靜態防護機制候選項                 | Linux x64 上由呼叫方提供的 pwntools；[二進位診斷](../binary-diagnostics.md)                                        |
-| Go 二進位檔案         | 內嵌編譯器版本、模組、替換項和建置設定                          | 內建靜態 ELF/PE/thin Mach-O 檢查；無需安裝 Go                                                                      |
-| WASM 工件             | 驗證、節、精確的匯入/匯出 WAT 形式及解碼後的 WAT                | 呼叫方提供的 WABT 1.0.42；`inspect_wasm_artifact`                                                                  |
-| EVM 位元組碼          | 分派選擇器、位元組偏移、推斷的參數和狀態可變性                  | Linux x64 上的本地原始位元組/十六進位輸入載體；[離線 EVM 指南](../evm-bytecode.md)                                 |
-| Rust binaries         | Embedded cargo-auditable dependency list                        | [Rust binaries](../rust-binaries.md)                                                                               |
-| 已記錄的 Linux 崩潰   | 原始 note 記錄、每個已記錄執行緒的暫存器/訊號及可選的對映候選項 | Linux x64 上由呼叫方提供的 pwntools；可選的 GDB/pwndbg；[已記錄崩潰](../recorded-crashes.md)                       |
-| 桌面安裝目錄          | 執行階段候選、支持檔案、元件標記與後續操作                      | 有界的目錄與檔頭檢查；[桌面應用](../desktop-applications.md)                                                       |
-| JavaScript / Electron | 模組、匯入、source map、路由、IPC 和原生附加元件關係            | Node.js 和 npm；[應用分析](../javascript-application-workflows.md)                                                 |
-| 網站                  | 頁面結構、腳本、網路觀察結果和按請求獲取的螢幕擷取畫面          | Chrome 系瀏覽器；[瀏覽器分析](../browser-observation.md)                                                           |
-| 已保存的網路擷取      | 請求、回應、可訪問的酬載和來源位置                              | HAR；原生 mitmproxy 擷取需要 Linux 上的 mitmdump；[擷取指南](../web-network-captures.md)                           |
-| 封包擷取              | 端點、DNS、TLS SNI、通訊協定分佈和 HTTP 請求                    | 呼叫端提供的 tshark 和 capinfos；[pcap 指南](../pcap-analysis.md)                                                  |
-| .NET 程式集           | 中繼資料、CIL 指令、聲明的原生依賴和建置對比                    | 靜態檢查；[托管程式碼指南](../managed-code-analysis.md)                                                            |
-| PyInstaller           | CArchive, PYZ, Python bytecode                                  | Static inspection; [Python packaged applications](../python-packaged-applications.md)                              |
-| Android APK           | 清單聲明、類別、反編譯的方法和引用                              | Linux/macOS/Windows x64 上的無界面 JADX 和完整 JDK；[Android 指南](../android-analysis.md)                         |
-| Android 裝置          | 裝置、套件、程序、日誌、傾印、螢幕擷取以及 APK/檔案傳輸         | 呼叫端提供的 adb（模擬器或實體裝置）；[ADB 指南](../adb-device-analysis.md)                                        |
-| JEB 專案              | 引擎支援的專案單元、成品摘要和型別/方法的虛擬碼                 | 由呼叫端啟動、提供 MCP 的 JEB 用戶端，透過 REA_JEB_MCP_URL 選擇；[JEB 指南](../jeb-analysis.md)                    |
-| Android 資源          | 解碼後的清單、字串表、語系和版本資訊                            | 呼叫端提供的 Apktool 啟動器；[資源指南](../apktool-resource-analysis.md)                                           |
-| Flutter 應用          | Dart 快照雜湊、依 ABI 的程式庫雜湊及引擎建置來源                | 無（靜態 APK 解析）；[Flutter 指南](../flutter-analysis.md)                                                        |
-| 韌體                  | 區域、提取結果和轉交原生分析的內容                              | Linux 上的 Binwalk / Unblob；[韌體指南](../firmware-analysis.md)                                                   |
-| 封包記錄              | 指定欄位、重複值、篩選條件與解碼規則                            | Linux: TShark 4.x + prlimit; [封包分析指南](../packet-captures.md)                                                 |
-| 錄製的邏輯訊號        | 解碼註解、樣本範圍與診斷資訊                                    | Linux: sigrok-cli 0.7.2 + prlimit; [訊號記錄指南](../signal-recordings.md)                                         |
-| 軟體包與資源          | 檔案清單、摘要、plist、Apple bundle 結構和提取的資源            | [製品與 JavaScript 指南](../javascript-artifact-reconstruction.md)、[Apple 應用](../apple-application-analysis.md) |
-| 處理程序行為          | 終端輸出、互動、退出和檔案系統觀察結果，以及執行對比            | 支援原生 PTY 的 Linux/macOS；[處理程序擷取](../process-capture.md)                                                 |
+| 目標                  | REA 返回的內容                                                               | 要求與指南                                                                                                         |
+| --------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| 原生二進位檔案        | 偽程式碼、組合語言、字串、符號、呼叫和引用                                   | Hopper、Ghidra 或 IDA；[原生分析](../native-investigation.md)                                                      |
+| 離線 ELF 佈局         | 節、段、原始符號/重定位資訊及靜態防護機制候選項                              | Linux x64 上由呼叫方提供的 pwntools；[二進位診斷](../binary-diagnostics.md)                                        |
+| Go 二進位檔案         | 內嵌編譯器版本、模組、替換項和建置設定                                       | 內建靜態 ELF/PE/thin Mach-O 檢查；無需安裝 Go                                                                      |
+| WASM 工件             | 驗證、節、精確的匯入/匯出 WAT 形式及解碼後的 WAT                             | 呼叫方提供的 WABT 1.0.42；`inspect_wasm_artifact`                                                                  |
+| EVM 位元組碼          | 分派選擇器、位元組偏移、推斷的參數和狀態可變性                               | Linux x64 上的本地原始位元組/十六進位輸入載體；[離線 EVM 指南](../evm-bytecode.md)                                 |
+| Rust binaries         | Embedded cargo-auditable dependency list                                     | [Rust binaries](../rust-binaries.md)                                                                               |
+| PE certificates       | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                            |
+| 已記錄的 Linux 崩潰   | 原始 note 記錄、每個已記錄執行緒的暫存器/訊號及可選的對映候選項              | Linux x64 上由呼叫方提供的 pwntools；可選的 GDB/pwndbg；[已記錄崩潰](../recorded-crashes.md)                       |
+| 桌面安裝目錄          | 執行階段候選、支持檔案、元件標記與後續操作                                   | 有界的目錄與檔頭檢查；[桌面應用](../desktop-applications.md)                                                       |
+| JavaScript / Electron | 模組、匯入、source map、路由、IPC 和原生附加元件關係                         | Node.js 和 npm；[應用分析](../javascript-application-workflows.md)                                                 |
+| 網站                  | 頁面結構、腳本、網路觀察結果和按請求獲取的螢幕擷取畫面                       | Chrome 系瀏覽器；[瀏覽器分析](../browser-observation.md)                                                           |
+| 已保存的網路擷取      | 請求、回應、可訪問的酬載和來源位置                                           | HAR；原生 mitmproxy 擷取需要 Linux 上的 mitmdump；[擷取指南](../web-network-captures.md)                           |
+| 封包擷取              | 端點、DNS、TLS SNI、通訊協定分佈和 HTTP 請求                                 | 呼叫端提供的 tshark 和 capinfos；[pcap 指南](../pcap-analysis.md)                                                  |
+| .NET 程式集           | 中繼資料、CIL 指令、聲明的原生依賴和建置對比                                 | 靜態檢查；[托管程式碼指南](../managed-code-analysis.md)                                                            |
+| PyInstaller           | CArchive, PYZ, Python bytecode                                               | Static inspection; [Python packaged applications](../python-packaged-applications.md)                              |
+| Android APK           | 清單聲明、類別、反編譯的方法和引用                                           | Linux/macOS/Windows x64 上的無界面 JADX 和完整 JDK；[Android 指南](../android-analysis.md)                         |
+| Android 裝置          | 裝置、套件、程序、日誌、傾印、螢幕擷取以及 APK/檔案傳輸                      | 呼叫端提供的 adb（模擬器或實體裝置）；[ADB 指南](../adb-device-analysis.md)                                        |
+| JEB 專案              | 引擎支援的專案單元、成品摘要和型別/方法的虛擬碼                              | 由呼叫端啟動、提供 MCP 的 JEB 用戶端，透過 REA_JEB_MCP_URL 選擇；[JEB 指南](../jeb-analysis.md)                    |
+| Android 資源          | 解碼後的清單、字串表、語系和版本資訊                                         | 呼叫端提供的 Apktool 啟動器；[資源指南](../apktool-resource-analysis.md)                                           |
+| Flutter 應用          | Dart 快照雜湊、依 ABI 的程式庫雜湊及引擎建置來源                             | 無（靜態 APK 解析）；[Flutter 指南](../flutter-analysis.md)                                                        |
+| 韌體                  | 區域、提取結果和轉交原生分析的內容                                           | Linux 上的 Binwalk / Unblob；[韌體指南](../firmware-analysis.md)                                                   |
+| 封包記錄              | 指定欄位、重複值、篩選條件與解碼規則                                         | Linux: TShark 4.x + prlimit; [封包分析指南](../packet-captures.md)                                                 |
+| 錄製的邏輯訊號        | 解碼註解、樣本範圍與診斷資訊                                                 | Linux: sigrok-cli 0.7.2 + prlimit; [訊號記錄指南](../signal-recordings.md)                                         |
+| 軟體包與資源          | 檔案清單、摘要、plist、Apple bundle 結構和提取的資源                         | [製品與 JavaScript 指南](../javascript-artifact-reconstruction.md)、[Apple 應用](../apple-application-analysis.md) |
+| 處理程序行為          | 終端輸出、互動、退出和檔案系統觀察結果，以及執行對比                         | 支援原生 PTY 的 Linux/macOS；[處理程序擷取](../process-capture.md)                                                 |
 
 靜態 JavaScript 和 .NET 檢查讀取提供的檔案，不執行應用。執行階段擷取會以你的使用者權限執行目標或與之互動；各執行階段指南說明瞭具體影響。
 

docs/readme/README_zh.md

@@ -141,32 +141,33 @@ npx rea-agents@latest setup
 
 REA 需要 Node.js 22.x（>=22.19）、24.x（>=24.11）或 26+，以及 npm。额外工具和主机支持取决于分析目标：
 
-| 目标                  | REA 返回的内容                                                | 要求与指南                                                                                                         |
-| --------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| 原生二进制文件        | 伪代码、汇编、字符串、符号、调用和引用                        | Hopper、Ghidra 或 IDA；[原生分析](../native-investigation.md)                                                      |
-| 离线 ELF 布局         | 节、段、原始符号/重定位信息及静态防护机制候选项               | Linux x64 上由调用方提供的 pwntools；[二进制诊断](../binary-diagnostics.md)                                        |
-| Go 二进制文件         | 内嵌编译器版本、模块、替换项和构建设置                        | 内置静态 ELF/PE/thin Mach-O 检查；无需安装 Go                                                                      |
-| WASM 工件             | 验证、节、精确的导入/导出 WAT 形式及解码后的 WAT              | 调用方提供的 WABT 1.0.42；`inspect_wasm_artifact`                                                                  |
-| EVM 字节码            | 分派选择器、字节偏移、推断的参数和状态可变性                  | Linux x64 上的本地原始字节/十六进制输入载体；[离线 EVM 指南](../evm-bytecode.md)                                   |
-| Rust binaries         | Embedded cargo-auditable dependency list                      | [Rust binaries](../rust-binaries.md)                                                                               |
-| 已记录的 Linux 崩溃   | 原始 note 记录、每个已记录线程的寄存器/信号及可选的映射候选项 | Linux x64 上由调用方提供的 pwntools；可选的 GDB/pwndbg；[已记录崩溃](../recorded-crashes.md)                       |
-| 桌面安装目录          | 运行时候选、支持文件、组件标记和后续操作                      | 有界的目录与文件头检查；[桌面应用](../desktop-applications.md)                                                     |
-| JavaScript / Electron | 模块、导入、source map、路由、IPC 和原生扩展关系              | Node.js 和 npm；[应用分析](../javascript-application-workflows.md)                                                 |
-| 网站                  | 页面结构、脚本、网络观察结果和按请求获取的截图                | Chrome 系浏览器；[浏览器分析](../browser-observation.md)                                                           |
-| 已保存的网络捕获      | 请求、响应、可访问的载荷和来源位置                            | HAR；原生 mitmproxy 捕获需要 Linux 上的 mitmdump；[捕获指南](../web-network-captures.md)                           |
-| 数据包捕获            | 端点、DNS、TLS SNI、协议分布和 HTTP 请求                      | 调用方提供的 tshark 和 capinfos；[pcap 指南](../pcap-analysis.md)                                                  |
-| .NET 程序集           | 元数据、CIL 指令、声明的原生依赖和构建对比                    | 静态检查；[托管代码指南](../managed-code-analysis.md)                                                              |
-| PyInstaller           | CArchive, PYZ, Python bytecode                                | Static inspection; [Python packaged applications](../python-packaged-applications.md)                              |
-| Android APK           | 清单声明、类、反编译的方法和引用                              | Linux/macOS/Windows x64 上的无界面 JADX 和完整 JDK；[Android 指南](../android-analysis.md)                         |
-| Android 设备          | 设备、软件包、进程、日志、转储、屏幕截图以及 APK/文件传输     | 调用方提供的 adb（模拟器或实体设备）；[ADB 指南](../adb-device-analysis.md)                                        |
-| JEB 项目              | 引擎支持的项目单元、工件摘要和类型/方法的伪代码               | 由调用方启动、提供 MCP 的 JEB 客户端，通过 REA_JEB_MCP_URL 选择；[JEB 指南](../jeb-analysis.md)                    |
-| Android 资源          | 解码后的清单、字符串表、语言区域和版本信息                    | 调用方提供的 Apktool 启动器；[资源指南](../apktool-resource-analysis.md)                                           |
-| Flutter 应用          | Dart 快照哈希、按 ABI 的库摘要及引擎构建溯源                  | 无（静态 APK 解析）；[Flutter 指南](../flutter-analysis.md)                                                        |
-| 固件                  | 区域、提取结果和转交原生分析的内容                            | Linux 上的 Binwalk / Unblob；[固件指南](../firmware-analysis.md)                                                   |
-| 抓包文件              | 指定字段、重复值、过滤条件与解码规则                          | Linux: TShark 4.x + prlimit; [抓包分析指南](../packet-captures.md)                                                 |
-| 录制的逻辑信号        | 解码注释、样本范围和诊断信息                                  | Linux: sigrok-cli 0.7.2 + prlimit; [信号记录指南](../signal-recordings.md)                                         |
-| 软件包与资源          | 文件清单、摘要、plist、Apple bundle 结构和提取的资源          | [制品与 JavaScript 指南](../javascript-artifact-reconstruction.md)、[Apple 应用](../apple-application-analysis.md) |
-| 进程行为              | 终端输出、交互、退出和文件系统观察结果，以及运行对比          | 支持原生 PTY 的 Linux/macOS；[进程捕获](../process-capture.md)                                                     |
+| 目标                  | REA 返回的内容                                                               | 要求与指南                                                                                                         |
+| --------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| 原生二进制文件        | 伪代码、汇编、字符串、符号、调用和引用                                       | Hopper、Ghidra 或 IDA；[原生分析](../native-investigation.md)                                                      |
+| 离线 ELF 布局         | 节、段、原始符号/重定位信息及静态防护机制候选项                              | Linux x64 上由调用方提供的 pwntools；[二进制诊断](../binary-diagnostics.md)                                        |
+| Go 二进制文件         | 内嵌编译器版本、模块、替换项和构建设置                                       | 内置静态 ELF/PE/thin Mach-O 检查；无需安装 Go                                                                      |
+| WASM 工件             | 验证、节、精确的导入/导出 WAT 形式及解码后的 WAT                             | 调用方提供的 WABT 1.0.42；`inspect_wasm_artifact`                                                                  |
+| EVM 字节码            | 分派选择器、字节偏移、推断的参数和状态可变性                                 | Linux x64 上的本地原始字节/十六进制输入载体；[离线 EVM 指南](../evm-bytecode.md)                                   |
+| Rust binaries         | Embedded cargo-auditable dependency list                                     | [Rust binaries](../rust-binaries.md)                                                                               |
+| PE certificates       | Authenticode WIN_CERTIFICATE entries and PKCS#7 signer/X.509 identity fields | Built-in static PE inspection; [PE certificates](../pe-certificates.md)                                            |
+| 已记录的 Linux 崩溃   | 原始 note 记录、每个已记录线程的寄存器/信号及可选的映射候选项                | Linux x64 上由调用方提供的 pwntools；可选的 GDB/pwndbg；[已记录崩溃](../recorded-crashes.md)                       |
+| 桌面安装目录          | 运行时候选、支持文件、组件标记和后续操作                                     | 有界的目录与文件头检查；[桌面应用](../desktop-applications.md)                                                     |
+| JavaScript / Electron | 模块、导入、source map、路由、IPC 和原生扩展关系                             | Node.js 和 npm；[应用分析](../javascript-application-workflows.md)                                                 |
+| 网站                  | 页面结构、脚本、网络观察结果和按请求获取的截图                               | Chrome 系浏览器；[浏览器分析](../browser-observation.md)                                                           |
+| 已保存的网络捕获      | 请求、响应、可访问的载荷和来源位置                                           | HAR；原生 mitmproxy 捕获需要 Linux 上的 mitmdump；[捕获指南](../web-network-captures.md)                           |
+| 数据包捕获            | 端点、DNS、TLS SNI、协议分布和 HTTP 请求                                     | 调用方提供的 tshark 和 capinfos；[pcap 指南](../pcap-analysis.md)                                                  |
+| .NET 程序集           | 元数据、CIL 指令、声明的原生依赖和构建对比                                   | 静态检查；[托管代码指南](../managed-code-analysis.md)                                                              |
+| PyInstaller           | CArchive, PYZ, Python bytecode                                               | Static inspection; [Python packaged applications](../python-packaged-applications.md)                              |
+| Android APK           | 清单声明、类、反编译的方法和引用                                             | Linux/macOS/Windows x64 上的无界面 JADX 和完整 JDK；[Android 指南](../android-analysis.md)                         |
+| Android 设备          | 设备、软件包、进程、日志、转储、屏幕截图以及 APK/文件传输                    | 调用方提供的 adb（模拟器或实体设备）；[ADB 指南](../adb-device-analysis.md)                                        |
+| JEB 项目              | 引擎支持的项目单元、工件摘要和类型/方法的伪代码                              | 由调用方启动、提供 MCP 的 JEB 客户端，通过 REA_JEB_MCP_URL 选择；[JEB 指南](../jeb-analysis.md)                    |
+| Android 资源          | 解码后的清单、字符串表、语言区域和版本信息                                   | 调用方提供的 Apktool 启动器；[资源指南](../apktool-resource-analysis.md)                                           |
+| Flutter 应用          | Dart 快照哈希、按 ABI 的库摘要及引擎构建溯源                                 | 无（静态 APK 解析）；[Flutter 指南](../flutter-analysis.md)                                                        |
+| 固件                  | 区域、提取结果和转交原生分析的内容                                           | Linux 上的 Binwalk / Unblob；[固件指南](../firmware-analysis.md)                                                   |
+| 抓包文件              | 指定字段、重复值、过滤条件与解码规则                                         | Linux: TShark 4.x + prlimit; [抓包分析指南](../packet-captures.md)                                                 |
+| 录制的逻辑信号        | 解码注释、样本范围和诊断信息                                                 | Linux: sigrok-cli 0.7.2 + prlimit; [信号记录指南](../signal-recordings.md)                                         |
+| 软件包与资源          | 文件清单、摘要、plist、Apple bundle 结构和提取的资源                         | [制品与 JavaScript 指南](../javascript-artifact-reconstruction.md)、[Apple 应用](../apple-application-analysis.md) |
+| 进程行为              | 终端输出、交互、退出和文件系统观察结果，以及运行对比                         | 支持原生 PTY 的 Linux/macOS；[进程捕获](../process-capture.md)                                                     |
 
 静态 JavaScript 和 .NET 检查读取提供的文件，不运行应用。运行时捕获会以你的用户权限运行目标或与之交互；各运行时指南说明了具体影响。
 

docs/rust-binaries.md

@@ -86,7 +86,7 @@ The inline Evidence result contains the artifact path, SHA-256, byte length,
 container format, architecture, word size, and byte order. When a `.dep-v0`
 section is present, `auditable_metadata` contains:
 
-- `section_name`, `.dep-v0` for ELF and PE or `__DATA,.dep-v0` for thin Mach-O;
+- `section_name`, `.dep-v0` for ELF and PE or `__DATA,.dep-v0` for Mach-O;
 - `file_offset` and `section_bytes`, the exact file range of the compressed section;
 - `compressed_bytes` and `uncompressed_bytes`;
 - `format_version`, the embedded integer, or `null` when the field is omitted;
@@ -124,8 +124,17 @@ verified. An omitted revision remains `null` and follows revision 0 semantics.
 Embedded names and versions are file content. They do not authenticate the
 packages or the compiler.
 
-Universal Mach-O containers are unsupported. Select a thin slice first. ELF,
-PE, and thin Mach-O are the supported containers.
+ELF, PE, thin Mach-O and one selected slice of a universal Mach-O are the
+supported containers.
+A universal (FAT) Mach-O needs `architecture` (`x86`, `x86_64`, `arm`
+or `arm64`; CLI `--architecture`). REA reads its own FAT table, without `lipo`,
+and validates the selected slice's range, alignment and Mach-O header CPU
+against the table. The result keeps the universal file as `artifact` (its
+SHA-256 and size), adds `selected_slice` with the slice offset, length, raw CPU
+type/subtype and the FAT table digest, and reports the section and rustc-path offsets as a
+file offset inside that slice. Without `architecture`, or when the file has no
+such slice or several, the request fails on `architecture` and lists the slices
+present. `architecture` on any other image is rejected rather than ignored.
 
 Package and dependency counts are checked against the minimum required JSON
 representation before graph allocation or schema cloning. Oversized graphs

docs/specs/agent-environments/state-coverage/plan.md

@@ -0,0 +1,32 @@
+# Implementation plan
+
+1. In `environmentStateRules.ts`, parse pointers into tokens and let `at` and
+   `replaceAt` read and replace element 0 of a one-element array at the root
+   or in one member; extend `locateItem` with those forms after the object
+   forms, requiring an identity name there; add `identityCandidates`, the
+   identity names then suffix-named fields, and let `locateList` prefer arrays
+   identified by name, then arrays of two or more items identified by suffix.
+2. In `EnvironmentStateExtraction.ts`, plan lists with the shared candidates,
+   treat an empty recording as unconstraining, accept a suffix-named field only
+   once a recording shows it distinct across two or more items, leave reads
+   without a list or identity to documents, drop the written-path requirement
+   and the `not-entity` fallback, record `path-varies` apart from
+   `query-varies`, and keep each entity's earliest sighting;
+   `environmentStateMerge.ts` cites records in timeline order. Remove
+   `not-entity` from the reason type and result schema, add `path-varies`, and
+   describe the new pointer forms and `field-name` basis.
+3. Move the classification of retained bodies (none, base64, cut, JSON, text)
+   into `replayedBody` in `environmentSource.ts`, which owns recorded
+   exchanges; replay renders from it and tool descriptions read its JSON case.
+4. Make `environmentToolDefinitions` take the `EnvironmentSource`; describe the
+   first `2xx` JSON record, else the first JSON record labelled with its status,
+   one level deep with the state's list rule and the existing sample budget;
+   list the manifest tool's statuses; and charge the whole description and the
+   tool's MCP annotations to the catalog reservation. Update the serve and
+   bundle callers.
+5. Let the tool definitions own the MCP annotations derived from the method and
+   the query-`POST` rule; `serveEnvironment.ts` registers them and the card
+   leaves them out.
+6. Cover domain, services, adapters and the compiled MCP boundary; document the
+   rules in the capture guide, descriptions and hints in the agent environments
+   guide, and the contract text.

docs/specs/agent-environments/state-coverage/spec.md

@@ -0,0 +1,99 @@
+# Wider environment state coverage and tool descriptions
+
+Issue: https://github.com/morluto/rea/issues/4933
+
+## Outcome
+
+The `environment-state` view backs more read tools with state, and a served
+environment tells agents more about each tool. Read-only paths whose responses
+are not entities become documents, listed items may be identified by an
+`…Id` or `…_id` field, an item wrapped in a one-element array is located
+inside it, and reads that vary by path get their own recorded reason. Each tool description says what the tool returns and which statuses
+were recorded, and every MCP tool carries method hints. This increment adds no
+tool, view kind, provider, network activity or write effect.
+
+## Requirements
+
+- A `GET` list tool (its template does not end in a parameter) that yields no
+  item or list plan holds its latest initial value as a `document` when its
+  initial reads have one request line, whether or not the capture writes its
+  path, unless its value changed between two of those reads across any
+  recorded write (even under another root), which leaves it `fields-differ`. A
+  value whose rendered JSON exceeds 256 KiB stays `rendered-oversize` and is
+  replayed from the recorded body, which itself fit. More request lines give
+  `path-varies` when they differ by path (a template with a parameter before
+  its end) and `query-varies` when they share one path. With every such read
+  now a document, `path-varies`, `query-varies`, `body-unusable` or
+  `rendered-oversize`, the unreachable `not-entity` reason leaves the result
+  schema, and `no-identity` names item tools only. A document holds the value
+  of its one `path`.
+- When no path parameter proves an identity and no identity name identifies
+  the listed items, the `field-name` identity is the first key of the first
+  listed item, in its order, whose name ends in `Id` or `_id`, that every item
+  carries as a distinct string or number, and that at least one initial
+  recording shows distinct across two or more items. The last condition goes
+  beyond "every item carries it distinctly": one item satisfies that
+  vacuously, and a lone item's suffix-named fields are often foreign keys (a
+  reaction keyed by its user, a comment by its post), so a list that only ever
+  held one item stays a document. Empty recordings constrain no field.
+  Identity names keep precedence, also when choosing among an envelope's
+  arrays, where a suffix-named field identifies only an array of two or more
+  items.
+- An item response that is a root array of exactly one object, or an object
+  with one member holding such an array, locates its entity at `/0` or
+  `/<member>/0` when one of the identity names in that object repeats the path
+  value. Objects at the root or in one member keep precedence. `at` and
+  `replaceAt` read and replace exactly these forms besides the root and one
+  member, so the gate and renderers run unchanged.
+- An entity's state order is its earliest sighting on the timeline and it cites
+  its records in timeline order, whichever plan observed it first.
+- Each tool description reads `METHOD template; <returns>; recorded statuses
+  …; replays retained records […]; evidence ev_…` after the untrusted-catalog
+  warning. `<returns>` describes one level deep the first cited `2xx` record
+  replay answers as JSON: an object's fields, an array of objects' fields, or
+  an envelope whose member lists objects, where a list is an array of objects
+  found by the state's list rule; an empty field set reads `with no fields`.
+  Only when no `2xx` record replays as JSON does the first cited JSON record of
+  another status give it, labelled `status <code> returns …`; with no JSON
+  record it is omitted. The statuses are the manifest tool's `statuses`, the
+  one owner of that set (`no recorded status` when it is empty). Field names
+  and statuses are sampled within the description sample budget and charged
+  with the whole description to the catalog reservation before it is retained.
+  One owner in the environment source classifies each retained body as none,
+  base64, cut, JSON or text; replay answers from that classification and
+  descriptions read only its JSON case.
+- MCP tools carry `readOnlyHint` (true for the safe methods `GET`, `HEAD`,
+  `OPTIONS` and `TRACE`, and for query `POST`s),
+  `destructiveHint: true` for `DELETE` (unset for other writes, so the MCP
+  default applies, and for reads, where clients ignore it), `idempotentHint`
+  (true for the safe methods, `PUT` and `DELETE`) and `openWorldHint: false`. The
+  tool definitions own the hints and charge them to the catalog reservation;
+  the environment card keeps its `name`, `description`, `inputSchema` tool
+  shape.
+
+## Acceptance and limits
+
+Synthetic captures cover read-only documents, `path-varies` and
+`query-varies`, suffix-named identities with their key order, their
+two-item proof, empty first recordings and their precedence (including the
+choice between an envelope's arrays), a Ghost-like `{"posts":[...]}` item under
+a trailing-slash path merging with its list view, a root one-element array, a
+one-element filtered list that stays unidentified, and the pointer forms. The
+Grafana-shaped fixture covers documents for its read-only paths (its one-member
+team list among them) and object, array and enveloped-list descriptions;
+synthetic sources cover the `2xx` preference over an earlier error body, the
+first of several JSON records, the labelled fallback, the manifest's statuses,
+empty, scalar and fieldless bodies, a truncated member name, a name whose
+JSON quoting exceeds the sample, a recorded body under 256 KiB whose rendered
+JSON exceeds it, non-JSON bodies and the catalog budget; the in-process and
+compiled MCP servers advertise the
+hints. A filtered list may still answer with one element whose identity name
+repeats the requested value; list filters, pagination, lossless big integers
+and cross-endpoint entity linking remain out of scope. Documents inline whole
+recorded values and enlarge the state result; agent tokens, CPU time and peak
+memory of the state and description build were not measured.
+
+## Deferred issue criteria
+
+Serving from the state, the AgentEnv data plane and write effects remain later
+increments of #4933. This PR must reference rather than close the issue.

docs/specs/agent-environments/state-coverage/tasks.md

@@ -0,0 +1,16 @@
+# Tasks
+
+- [x] Record the coverage and description contract and its limits.
+- [x] Extend pointers, item location and identity candidates.
+- [x] Require two distinct items before a suffix-named field identifies a list.
+- [x] Hold read-only non-entity reads as documents, retire `not-entity` and
+      separate `path-varies` from `query-varies`.
+- [x] Order entities by earliest sighting and cite records in timeline order.
+- [x] Classify retained bodies in one owner and describe tool responses,
+      preferring `2xx` records, with the manifest's statuses.
+- [x] Advertise MCP tool annotations, charged to the catalog, without changing
+      the card.
+- [x] Add domain, services, adapters and compiled-boundary coverage.
+- [x] Document the rules, descriptions and hints; update the contract text.
+- [x] Run static, formatting, duplication, documentation and test gates and the
+      real-capture measurement.

docs/specs/agent-environments/state-coverage/verification.md

@@ -0,0 +1,123 @@
+# Verification
+
+Verified base: 7a668b73f4783b42eb0e8ce1eeff079f86d53e22 (the environment-state
+view branch).
+
+Executed on the implementation worktree with its existing locked installation
+under Node.js v22.23.1 (the repository pins 24.18.0, which was not available);
+every check below ran as written in this pass, after the last source change.
+
+- `npm run format` then `npm run format:check`: passed.
+- `npm run check:fast`: typecheck and lint passed (3959 files, no errors). The
+  touched files carry two lint warnings, both present on the base: `max-params`
+  in `environmentReplay.ts` and an unused `_` in `environmentCapacity.test.ts`.
+- `npx knip`: passed (exit 0).
+- `npm run jscpd`: 3.40% duplicated lines over 3348 files, under the 3.5%
+  gate. The three clones that touch changed test files pair the same blocks as
+  on the base; none involves code this change adds.
+- `npm run scan:todos`: no markers.
+- `npm run docs:check`: the built documentation checks and the README
+  consistency conformance test (5 tests) passed.
+- `npx vitest run --project domain --project services`: 341 files, 5859 tests
+  passed, 5 pre-existing skips.
+- `npm run build:cached`: passed.
+- `npm run test:focused --` the environment serve adapters and capacity tests,
+  the environment serve MCP boundary, the environment serve and export CLI
+  boundaries, the environment serve shutdown process boundary, the
+  analysis-view MCP and CLI boundaries, the compact input-schema contract and
+  MCP boundary, the tool-schema validity boundary, the analysis-detail and
+  advertised-input-example contracts and the qlog acceptance test: 14 files,
+  113 tests passed, 1 pre-existing skip.
+
+Real captures (outside the test suite): the built view ran through the
+application service on the same 44 recorded captures (39 HAR, 5 browser
+scenario) with all three template rules, in 7 to 50 ms each. 42 produced a
+state, and the same two browser-scenario captures are refused with
+`resource_constraint` as on the base. The base column is the brief's baseline,
+which the same script reproduced on the base build in an earlier pass; this
+pass did not rebuild the base.
+
+| Measure                            | Base  | This change |
+| ---------------------------------- | ----- | ----------- |
+| Types                              | 568   | 576         |
+| Entities                           | 2,213 | 2,246       |
+| Documents                          | 2     | 299         |
+| Item views                         | 211   | 213         |
+| List views                         | 497   | 504         |
+| Document views                     | 2     | 299         |
+| State-backed read tools (of 1,258) | 710   | 1,016       |
+| Recorded: `not-entity`             | 306   | (retired)   |
+| Recorded: `no-identity`            | 129   | 32          |
+| Recorded: `path-varies`            | (new) | 32          |
+| Recorded: `query-varies`           | 5     | 69          |
+| Recorded: `body-unusable`          | 32    | 32          |
+| Recorded: `list-differs`           | 31    | 31          |
+| Recorded: `no-init-recording`      | 26    | 26          |
+| Recorded: `query-body`             | 12    | 12          |
+| Recorded: `fields-differ`          | 3     | 4           |
+| Recorded: `envelope-varies`        | 4     | 4           |
+
+Seven list types gained a suffix-named identity (`permissionId`, `product_id`,
+`ItemId`, `user_id`, `channel_id`, `spl_id` and `eventId`). Seven more had one
+before the two-item proof and lost it, because every initial response listed a
+single item: an Airbyte organization, a Mattermost reaction and team
+membership, and a Redpanda broker and schema reference became documents; a
+NOAA station read is `query-varies` and a Redpanda consumer read
+`path-varies`. Two Ghost item tools render from `/members/0` and `/tags/0`. A
+third Ghost item tool is located at `/posts/0` but stays `fields-differ`: its
+recordings differ by an `include` query.
+
+State result size, as the JSON length of each Evidence summed over the 42
+states: 2,677 KiB on the base and 3,196 KiB now (+19%), measured by the same
+script. The largest growth per capture is Metabase (133 to 236 KiB), Directus
+(21 to 93), Redpanda Console (26 to 68) and Vault (9 to 43). Documents take
+492,516 of the 3,274,243 UTF-8 bytes of the results now; the base held two.
+Agent tokens, CPU time and peak memory of the state view were not measured.
+
+Tool descriptions on the 44 captures' manifests: all 44 catalogs were admitted
+within their reservation. 1,336 of 1,400 tools state what they return: 1,333
+from a `2xx` record and three labelled with another status (Miniflux and
+NocoDB 404, Shlink 501), because none of their records succeeded as JSON. The
+summaries add 261,502 bytes to a 1,185,893-byte catalog of names, descriptions
+and input schemas (median 136, 95th percentile 554, maximum 1,133 bytes per
+tool); five reached the field sample bound (one Keycloak, one Lychee and three
+Sentry tools with 46 to 105 fields). The MCP annotations add 113,182 bytes to
+`tools/list` and none to the card. Building a catalog took a median 1.6 ms and
+at most 7.6 ms (Metabase), after the source was loaded. Agent tokens, CPU time
+and peak memory of the description build were not measured.
+
+After merging the environment state view's review fixes (its branch at
+6ad63bcc, which also brings main's evidence-file sources), every gate ran
+again on the merged tree: `npm run check:fast`, `npm run format:check`,
+`npx knip`, `npm run scan:todos` and `npm run docs:check` passed; `npm run
+jscpd`: 3.39% duplicated lines over 3362 files; `npx vitest run --project
+domain --project services`: 344 files, 5914 tests passed, 5 pre-existing
+skips; `npm run build:cached`, then `npm run test:focused --` the serve and
+tool-definition adapters, the serve MCP and CLI boundaries, the export CLI
+boundary, the analysis-view MCP and CLI boundaries, the compact input-schema
+budget and the analysis-detail and advertised-input-example contracts: 10
+files, 98 tests passed.
+
+The real-capture comparison was repeated on the merged code, with the base
+measured on the merged state view without this change: all 44 captures now
+produce a state, and 1,011 of 1,277 read tools are state-backed against 625
+on the base (216 item, 416 list and 379 document views against 214, 409 and
+2). Recorded reasons: `no-identity` 216 to 32 and `not-entity` 310 to none;
+`query-varies` 5 to 76 and `path-varies` 36 are document reads under more
+than one query or path; `list-differs` 35, `body-unusable` 33,
+`no-init-recording` 28, `query-body` 12, `envelope-varies` 4 are unchanged,
+and `fields-differ` is 9 to 10.
+
+Not covered here: serving from the state, the AgentEnv data plane and write
+effects, which are later increments.
+
+## After the squash onto main
+
+The branch was squashed onto main once the state-serve branch merged (166fb082). Against a merge of the previous head
+into that main, the squash keeps both sides of every conflict and drops nothing of this branch. Two tests then failed
+on it and were refitted with the oversized-document fix in 2a926a0a: the bundle test of a state catalog over the
+discovery budget uses 300 read tools, inside the window where the state's catalog is refused and replay's, with its
+response summaries, still fits (280–320 by a probe), and the rea-state validation test names the pushed document by
+the count of documents the state holds. The replay-only card test pinned main's 11,131-byte card; it now pins this
+branch's 12,818-byte card, whose descriptions name each tool's recorded responses. The branch then merged main at
+d7ca93cc without conflicts.

docs/testing.md

@@ -65,6 +65,18 @@ API dependency, and independent fixture compiler oracles keep their existing
 TypeScript versions.
 
 `npm run build:cached` compiles the CLI/MCP runtime and its packaged skill.
+The build also records `dist/mcp-catalog.json` (compact inputs) and
+`dist/mcp-catalog-full.json` from the canonical SDK registrations and binds
+each to the runtime with its own SHA-256 digest. These are
+runtime artifacts, separate from the test catalog below. Default target-free
+MCP startup serves its schemas without constructing analysis validators;
+the first tool or guided-workflow request materializes the canonical runtime
+on that same SDK server. Explicit compact/full input selections preserve
+their advertised schemas throughout materialization. Initial-target,
+HTTP and output-schema-off startup keep the eager path; source runs without
+recorded artifacts also use eager composition. Compare memory both after discovery and after a completed
+request; report diagnostic GC separately from normal resident memory.
+
 Turbo's strict task environment preserves caller-selected `GOMAXPROCS`,
 `GOMEMLIMIT`, and `UV_THREADPOOL_SIZE` for resource-constrained builds and
 checks. These execution controls do not change artifact content, so changing

docs/web-network-captures.md

@@ -522,9 +522,9 @@ Pass the same parent to `inspect_analysis_view` with
 `view: {"kind":"environment-state"}` to extract the initial state the
 capture's reads observed, and a render plan per read tool that reproduces those
 reads from it. Where the environment manifest names an application's tools, the
-state holds its data: entities by type and identity, plus documents for written
-paths whose reads are not entities. Use the `template_rules` of the manifest the
-state accompanies so tool names match; the view groups records the same way.
+state holds its data: entities by type and identity, plus documents for reads
+that are not entities. Use the `template_rules` of the manifest the state
+accompanies so tool names match; the view groups records the same way.
 
 ```json
 {
@@ -560,13 +560,27 @@ refused for them, as the manifest is not.
 
 Each `GET` tool whose template ends in a parameter is an item tool, and its
 type's `collection_template` is the template without that parameter; any other
-`GET` tool is a list tool of its own template. An item tool proves its type's
+`GET` tool is a list tool of its own template. Empty segments are ignored, so a
+trailing slash names the same collection. An item tool proves its type's
 `id_field` when every initial response carries the requested path value in the
-same field, at the root or in one wrapper member (`id_basis: "path-parameter"`).
-Otherwise the field is the first of `id`, `uid`, `uuid`, `_id`, `ID`, `UID`,
-`Id`, `guid`, `key`, `slug` and `name` that every listed item carries as a
-distinct string or number (`id_basis: "field-name"`). A list is the response
-array, or the one array of objects in an envelope that is not itself an entity.
+same field of one entity object (`id_basis: "path-parameter"`). The object is
+the response itself or one wrapper member; failing both, it is the only element
+of a one-element array at the root (pointer `/0`) or in one member
+(`/<member>/0`), as in `{"posts":[{...}]}` or `{"data":[{...}]}`, provided one
+of the identity names below repeats the value, since a filtered list may also
+answer with one element that repeats its parent's value. Otherwise the field is
+the first of `id`, `uid`, `uuid`, `_id`, `ID`, `UID`, `Id`, `guid`, `key`,
+`slug` and `name` that every listed item carries as a distinct string or
+number; when none does, it is the first key of the first listed item, in its
+order, whose name ends in `Id` or `_id` (such as `orgId` or `user_id`), that
+every item carries as a distinct string or number, and that at least one
+initial response shows distinct across two or more items
+(`id_basis: "field-name"`). A single listed item is distinct from nothing, and
+its suffix-named fields are often foreign keys, so a list that only ever held
+one item is left to a document. Empty initial lists constrain no field. A list
+is the response array, or the one array of objects in an envelope that is not
+itself an entity, preferring an array whose items an identity name identifies,
+then an array of two or more items a suffix-named field identifies.
 
 `entities` merge every initial observation of one identity within one
 collection path: an item view's latest values win over a list view's, a view
@@ -583,9 +597,9 @@ Every entity cites its `record_ordinals`.
 
 | Shape      | Plan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `item`     | The entity object at `pointer` (the root or one member), the ordered `fields` the view shows and the `required_fields` every recording had, and `envelope_ordinal`: the recording whose response, with the entity replaced, every item response shares                                                                                                                                                                                                                                                                      |
+| `item`     | The entity object at `pointer` (the root, one member, or `/0` or `/<member>/0`), the ordered `fields` the view shows and the `required_fields` every recording had, and `envelope_ordinal`: the recording whose response, with the entity replaced, every item response shares                                                                                                                                                                                                                                              |
 | `list`     | The array at `pointer`, its `fields`, `membership` (`all`: every entity of the collection in state order, when each recording listed exactly that, had no query, no item-total member (`total`, `count`, `totalCount`, `item_count`, `totalcount`, `itemcount`, but not `total_pages` or `per_page`; a number or a string of digits) differing from the number listed, and no `has_more`, `next` or next-page token member set; `recorded`: the entities each recording listed) and `counters` that equal the number listed |
-| `document` | The path's latest initial value, held in `documents`                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `document` | The latest initial value of a list tool whose responses hold no identified list, when its initial reads share one request line; held in `documents` with that `path`, whether or not the capture writes it, unless its value changed across any recorded write between those reads (`fields-differ`)                                                                                                                                                                                                                        |
 | `recorded` | A `reason` the tool replays its recordings instead                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 
 An item or list plan is kept only when it reproduces the latest initial
@@ -594,11 +608,13 @@ regard to member order; a volatile field compares its recorded value. Each
 plan lists the `checked_record_ordinals`. Otherwise the tool is a recorded view
 with reason `envelope-varies`, `fields-differ` or `list-differs`; the other
 reasons are `query-body` (a query `POST`), `no-init-recording`,
-`body-unusable`, `not-entity`, `no-identity` and `query-varies` (a document
-read under several queries). Documents are held only for list-shaped paths
-that a `POST`, `PUT` or `PATCH` tool writes: a non-entity read of an item path
-such as `/api/files/{id}`, or of a path that is only deleted, stays recorded
-with `no-identity` or `not-entity`. A body is usable when its content type is
+`body-unusable`, `no-identity` (an item read without a proved identity),
+`path-varies` (another read under more than one path, as a template with a
+parameter before its end), `query-varies` (another read of one path under
+more than one query) and `rendered-oversize` (a document value whose JSON
+renders to more than 256 KiB). A document holds the value of its one `path`, so for such
+a template it says nothing about the template's other paths. A body is usable
+when its content type is
 JSON-like, it is UTF-8 text of at most 256 KiB, every number survives native
 conversion exactly, and no member is named `__proto__`.
 
@@ -610,7 +626,9 @@ that the state establishes no authorization model, no way the application
 computes responses or derived values, and no effects of writes. The state
 accumulator charges the manifest's admission and grouping, every record line,
 each body as temporary bytes before it is decoded and parsed, and every value
-it keeps, within the same 96 MiB budget. The view performs no network activity
+it keeps, within the same 96 MiB budget. Documents hold whole recorded response
+values whose recorded text and rendered JSON are each at most 256 KiB, so a
+capture with many read-only paths yields a correspondingly larger state result. The view performs no network activity
 and serves nothing; `rea environment-serve` derives it from the capture at
 startup, serves read tools from it and loads replacement states through the
 AgentEnv data plane, as
@@ -619,13 +637,14 @@ AgentEnv data plane, as
 ## Resource and lifecycle boundaries
 
 Complete evidence has a 32 MiB input, 96 MiB decoder reply and 64-level nesting
-budget. Exceeding a budget returns no partial success.
+budget. Those budgets have no runtime override. `capture_timeout_ms` does not
+raise them. Exceeding a budget returns no partial success.
 Oversized selected captures return an input error identifying `capture_path`
 and the byte budget; owned reply/output failures remain output or provider errors.
 HAR, SAZ and qlog run in an owned
 192 MiB Node old-generation heap with one V8 worker. Mitmproxy decoding applies
 Linux limits of 768 MiB address space, 30 seconds CPU and 96 MiB file output;
-both commands have a 30-second wall deadline and independently supervised
+both commands use `capture_timeout_ms` (default 30000) and independently supervised
 process cleanup. Owned decoder diagnostics retain at most 1 MiB across stdout
 and stderr; the collector drops overflow as it arrives, reports the limit
 failure and verifies cleanup. Heap limits alone do not establish aggregate RSS limits.

docs/web-runtime.md

@@ -52,7 +52,7 @@ The result contains directly registered listener types/flags, callback coordinat
 
 ## Bounds and verification
 
-Each protocol message has a 64 MiB budget; script/context metadata and request metadata each have an 8 MiB retained budget. Complete retained source text has a 32 MiB budget. Oversized or malformed evidence returns no partial successful result. Each command and the complete inspection/source-join phase have a 20-second deadline; cleanup has a separate 5-second command deadline plus transport closure. The selected observation duration must fit the host timer's positive 32-bit millisecond range. REA does not control the externally owned browser's CPU or memory.
+Each protocol message has a 64 MiB budget; script/context metadata and request metadata each have an 8 MiB retained budget. Complete retained source text has a 32 MiB budget. Oversized or malformed evidence returns no partial successful result. Each command and the complete inspection/source-join phase use `command_timeout_ms` (default 20000). Cleanup uses a separate 5000 ms grace; `command_timeout_ms` does not raise or shorten it, and this release has no runtime override for that grace. Transport closure follows the grace. The selected observation duration must fit the host timer's positive 32-bit millisecond range. REA does not control the externally owned browser's CPU or memory.
 
 `npm run verify:browser:runtime` uses caller-supplied `REA_BROWSER_EXECUTABLE` and the native `ps` command on Linux/macOS against an owned synthetic fixture, through real public CLI and stdio MCP. It checks exact Unicode/CRLF text/digests, same-URL identities, same-document navigation, inert declared names, executed and zero-count branches, function-only unknowns on repeated observation, listener selection, initiator association, actual arming and preservation of the external page. A separate fixture page closes during an armed MCP window to verify prompt termination and inline cleanup diagnostics. The optional positional entrypoint to `scripts/verify-browser-runtime.mjs` permits the same checks against an isolated installed tarball.
 

docs/web-source-location.md

@@ -71,7 +71,7 @@ implement every current source-map extension.
 One owned Node subprocess decodes the map. Its private request directory is
 removed before success is returned. Only this child's inherited `NODE_OPTIONS`
 is removed; explicit V8 flags set a 192 MiB old-generation and 8 MiB semi-space
-budget, one V8 worker and a 20-second deadline. Reported actual V8 heap limits
+budget, one V8 worker and `decode_timeout_ms` (default 20000). The codec heap, map budget, and reply budget have no runtime override. Reported actual V8 heap limits
 are checked. These are heap limits, not an aggregate process RSS limit. When
 REA runs on Bun, the subprocess is Bun, which ignores these V8 flags: `runtime`
 records `id: "bun"`, the Bun version, its Node.js compatibility version and a
@@ -86,7 +86,8 @@ cleanup overrides success with `cleanup_incomplete` and the owning
 operation/resources.
 
 Complete evidence is bounded by a 4 MiB map, 32 MiB codec reply, 262144 decoded
-rows/segments and 64 nested section levels. Exceeding a budget returns an explicit
+rows/segments and 64 nested section levels. Those structural budgets and the
+192 MiB codec heap have no runtime override. Exceeding a budget returns an explicit
 failure, without partial results. The existing 32 MiB manifest and 16 MiB selected
 script boundaries also apply. No global toolchain or browser configuration changes
 are made.

experiments/analysis-efficiency/managed-cli-costs.py

@@ -0,0 +1,84 @@
+"""Summarize completed CLI trials; token counts are estimates, not model usage."""
+import argparse
+import hashlib
+import json
+import statistics
+from pathlib import Path
+import tiktoken
+
+parser = argparse.ArgumentParser()
+parser.add_argument('root', type=Path)
+parser.add_argument('--output', type=Path, required=True)
+args = parser.parse_args()
+root = args.root
+inputs = json.loads((root / 'measurement-inputs.json').read_text())
+expected = inputs['expected_runtime_bindings']
+assert expected['complete']['git_revision'] == inputs['baseline_revision']
+assert expected['selected']['git_revision'] == inputs['feature_parent_revision']
+assert expected['complete']['root'] != expected['selected']['root']
+assert expected['complete']['compiled_cli_sha256'] != expected['selected']['compiled_cli_sha256']
+assert expected['complete']['source_diff_sha256'] == hashlib.sha256(b'').hexdigest()
+assert expected['complete']['untracked_source_sha256'] == hashlib.sha256(b'[]').hexdigest()
+enc = tiktoken.get_encoding('cl100k_base')
+count = lambda text: len(enc.encode(text, disallowed_special=()))
+compact = lambda obj: json.dumps(obj, ensure_ascii=False, separators=(',', ':'))
+runs = []
+for case in sorted(root.glob('pair-*')):
+    if not case.is_dir():
+        continue
+    report = json.loads((case / 'report.json').read_text())
+    assert report['status'] == 'passed' and report['cleanup_verified']
+    assert report['runtime_binding_verified']
+    assert report['runtime_binding'] == expected[report['mode']], case.name
+    assert str(Path(report['runtime']).resolve()) == report['runtime_binding']['root']
+    receipt = next(json.loads(line) for line in reversed(case.with_name(case.name + '.log').read_text().splitlines()) if line.startswith('{"resource_scope":'))
+    obs = receipt['payload_resource_observation']
+    assert receipt['abort'] is None and receipt['payload_resource_observation_verified']
+    assert obs['payload_exit_code'] == 0 and obs['payload_cleanup_verified']
+    assert obs['resource_events']['memory.events']['oom_kill'] == 0
+    tokens = {'question_and_recipe': count(report['question'] + '\n' + report['recipe']),
+              'arguments': sum(count(compact(call['arguments'])) for call in report['calls']),
+              'help_and_replies': sum(count((case / call['stdout_file']).read_text()) for call in report['calls'])}
+    tokens['whole_task'] = sum(tokens.values())
+    runs.append({'case': case.name, 'mode': report['mode'], 'cache': report['cache'], 'runtime': report['runtime'], 'runtime_binding': report['runtime_binding'], 'runtime_binding_audit_ms': report['runtime_binding_audit_ms'],
+                 'wall_seconds': receipt['elapsed_seconds'], 'cpu_seconds': obs['cpu_stat']['usage_usec'] / 1e6,
+                 'peak_process_family_bytes_including_page_cache': obs['memory_peak_bytes'],
+                 'tokens_estimated': tokens, 'calls': report['calls'],
+                 'parent_evidence_id': report['parent_evidence_id'], 'parent_semantic_sha256': report['parent_semantic_sha256'],
+                 'answer_sha256': report['answer_sha256'], 'oracle_verified': report['oracle_verified'],
+                 'cleanup_verified': True, 'resource_events': obs['resource_events']})
+assert len(runs) == 12
+for key in ['answer_sha256', 'parent_semantic_sha256', 'parent_evidence_id']:
+    assert len({row[key] for row in runs}) == 1, key
+summary = {}
+for cache in ['cold', 'warm']:
+    summary[cache] = {}
+    for mode in ['complete', 'selected']:
+        rows = [r for r in runs if r['mode'] == mode and r['cache'] == cache]
+        assert len(rows) == 3
+        summary[cache][mode] = {key: {'median': statistics.median(r[key] for r in rows), 'min': min(r[key] for r in rows), 'max': max(r[key] for r in rows)} for key in ['wall_seconds', 'cpu_seconds', 'peak_process_family_bytes_including_page_cache']}
+        summary[cache][mode]['whole_task_tokens_estimated'] = [r['tokens_estimated']['whole_task'] for r in rows]
+result = {'status': 'passed', 'tokenizer': 'tiktoken==0.12.0/cl100k_base; estimates, not model usage',
+          'context_scope': 'Question, supplied command recipe, actual selected-command help, all logical CLI argv and all stdout. No model invoked; reasoning, framing, irrelevant tool discovery and actual native-agent usage unmeasured.',
+          'cache_scope': 'cold disables Node compile cache; warm primes the identical workflow once per runtime/mode before timing. Fresh processes and isolated HOME each trial; OS page cache uncontrolled.',
+          'resource_scope': 'Whole task driver plus all CLI children; includes pre/post source-and-compiled-runtime binding verification, bundle publication/authentication, help, extra calls and local answer/oracle checking. Kernel cgroup peak includes file cache; not sampled RSS. Download/build/oracle preparation and priming excluded.',
+          'acquisition': json.loads((root / 'acquisition.json').read_text()), 'measurement_inputs': inputs,
+          'summary': summary, 'runs': runs}
+native = root / 'native-control'
+if native.exists():
+    binding = json.loads((native / 'runtime-binding.json').read_text())
+    assert binding['runtime_binding_verified'] and binding['runtime_binding'] == expected['complete']
+    assert str(Path(binding['runtime']).resolve()) == binding['runtime_binding']['root']
+    receipt = next(json.loads(line) for line in reversed((root / 'native-control.log').read_text().splitlines()) if line.startswith('{"resource_scope":'))
+    obs = receipt['payload_resource_observation']
+    assert receipt['abort'] is None and receipt['payload_resource_observation_verified'] and obs['payload_exit_code'] == 0 and obs['payload_cleanup_verified']
+    baseline_case = root / next(run['case'] for run in runs if run['mode'] == 'complete')
+    assert json.loads((native / 'answer.json').read_text()) == json.loads((baseline_case / 'answer.json').read_text())
+    control_source = Path(__file__).with_name('managed-cli-local-control.py').read_text()
+    result['existing_native_control'] = {'runtime': binding['runtime'], 'runtime_binding': binding['runtime_binding'], 'runtime_binding_audit_ms': binding['runtime_binding_audit_ms'], 'repetitions': 1,
+        'tokens_estimated_script_plus_help_plus_answer': count(control_source) + count((native / 'help.txt').read_text()) + count((native / 'answer.json').read_text()),
+        'token_scope': 'Projection source, original CLI help and returned answer; excludes shared question and launcher argv. No actual model usage measured.',
+        'wall_seconds': receipt['elapsed_seconds'], 'cpu_seconds': obs['cpu_stat']['usage_usec'] / 1e6,
+        'peak_process_family_bytes_including_page_cache': obs['memory_peak_bytes'], 'answer_matches': True, 'cleanup_verified': True}
+args.output.write_text(json.dumps(result, indent=2) + '\n')
+print(json.dumps(summary, indent=2))

experiments/analysis-efficiency/managed-cli-local-control.py

@@ -0,0 +1,44 @@
+"""Existing native code-composition control: save complete stdout, return selected facts."""
+import argparse
+import json
+import subprocess
+import time
+from pathlib import Path
+
+parser = argparse.ArgumentParser()
+parser.add_argument('runtime', type=Path)
+parser.add_argument('target', type=Path)
+parser.add_argument('output', type=Path)
+parser.add_argument('--measurement-inputs', type=Path, required=True)
+args = parser.parse_args()
+args.output.mkdir()
+node = 'node'
+inputs = json.loads(args.measurement_inputs.read_text())
+expected = inputs['expected_runtime_bindings']['complete']
+assert expected['git_revision'] == inputs['baseline_revision']
+helper = Path(__file__).with_name('managed-cli-runtime.mjs')
+def capture_binding():
+    return json.loads(subprocess.check_output([node, str(helper), str(args.runtime)], text=True))
+binding_started = time.monotonic()
+binding = capture_binding()
+binding_audit_ms = {'before': (time.monotonic() - binding_started) * 1000}
+assert binding == expected
+
+entry = str(args.runtime / 'scripts/rea.mjs')
+help_result = subprocess.run([node, entry, 'inspect-managed-members', '--help'], check=True, capture_output=True, text=True)
+(args.output / 'help.txt').write_text(help_result.stdout)
+with (args.output / 'parent.json').open('w') as file:
+    subprocess.run([node, entry, 'inspect-managed-members', str(args.target), '--type', 'Newtonsoft.Json.JsonConvert', '--json'], check=True, stdout=file)
+parent = json.loads((args.output / 'parent.json').read_text())
+data = parent['normalized_result']
+answer = {'parent_evidence_id': parent['evidence_id'], 'artifact_sha256': data['artifact']['sha256'],
+          'selection': data['selection'], 'source_coverage': data['coverage'],
+          'total_methods': len(data['methods']), 'total_member_refs': len(data['member_refs']),
+          'methods': data['methods'][:8], 'member_refs': data['member_refs'][:16],
+          'limitation': 'MemberRef rows are assembly-wide; methods are selected-type rows. Page exhaustion is not an absence claim.'}
+(args.output / 'answer.json').write_text(json.dumps(answer))
+binding_finished = time.monotonic()
+assert capture_binding() == binding
+binding_audit_ms['after'] = (time.monotonic() - binding_finished) * 1000
+(args.output / 'runtime-binding.json').write_text(json.dumps({'runtime': str(args.runtime), 'runtime_binding': binding, 'runtime_binding_verified': True, 'runtime_binding_audit_ms': binding_audit_ms}))
+print(json.dumps(answer))

experiments/analysis-efficiency/managed-cli-oracle.py

@@ -0,0 +1,18 @@
+import json,hashlib,argparse
+from pathlib import Path
+import dnfile
+parser=argparse.ArgumentParser();parser.add_argument('root',type=Path);root=parser.parse_args().root;path=root/'Newtonsoft.Json.dll'
+pe=dnfile.dnPE(str(path));assert pe.net is not None
+counts={name:len(getattr(pe.net.mdtables,name).rows) if getattr(pe.net.mdtables,name,None) else 0 for name in ['TypeDef','MethodDef','MemberRef','Field','Property','Event','Param','StandAloneSig','TypeSpec','ExportedType']}
+selected=[]
+for index,row in enumerate(pe.net.mdtables.TypeDef.rows,1):
+ name=(str(row.TypeNamespace)+'.' if str(row.TypeNamespace) else '')+str(row.TypeName)
+ if name!='Newtonsoft.Json.JsonConvert':continue
+ selected.append({'token':f'0x{0x02000000|index:08x}','name':name,'methods':[{'token':f'0x{0x06000000|m.row_index:08x}','name':str(m.row.Name),'rva':m.row.Rva,'signature_hex':m.row.Signature.value.hex()} for m in row.MethodList]})
+assert len(selected)==1
+refs=[{'token':f'0x{0x0a000000|i:08x}','name':str(row.Name),'signature_hex':row.Signature.value.hex()} for i,row in enumerate(pe.net.mdtables.MemberRef.rows[:16],1)]
+assembly=pe.net.mdtables.Assembly.rows[0]
+oracle={'decoder':'dnfile==0.18.0 (independent Python PE/CLI parser)','assembly_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'assembly_name':str(assembly.Name),'assembly_version':'.'.join(str(getattr(assembly,k)) for k in ['MajorVersion','MinorVersion','BuildNumber','RevisionNumber']),'row_counts':counts,'selected_types':selected,'member_refs_first_16':refs,'target_execution':False}
+(root/'oracle.json').write_text(json.dumps(oracle,indent=2)+'\n')
+print(json.dumps({'assembly':oracle['assembly_name'],'version':oracle['assembly_version'],'row_counts':counts,'selected_type':selected[0]['name'],'selected_methods':len(selected[0]['methods']),'target_execution':False}))
+pe.close()

experiments/analysis-efficiency/managed-cli-runtime.mjs

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile, readdir, realpath } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+const sha = (value) => createHash("sha256").update(value).digest("hex");
+
+/** Bind a trial to its source checkout and compiled runtime, including deferred assets. */
+export const captureRuntimeBinding = async (runtime, kind = "cli") => {
+  assert.ok(kind === "cli" || kind === "mcp", "Unknown runtime entry");
+  const root = await realpath(runtime);
+  const git = (args) =>
+    execFileSync("git", args, { cwd: root, maxBuffer: 16 * 1024 * 1024 });
+  const gitRevision = git(["rev-parse", "HEAD"]).toString().trim();
+  const sourcePaths = ["src", "scripts", "package.json", "package-lock.json"];
+  const sourceDiff = git([
+    "diff",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--binary",
+    "HEAD",
+    "--",
+    ...sourcePaths,
+  ]);
+  const untracked = git([
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    ...sourcePaths,
+  ])
+    .toString()
+    .split("\0")
+    .filter(Boolean)
+    .sort();
+  const untrackedEntries = [];
+  for (const name of untracked)
+    untrackedEntries.push([name, sha(await readFile(join(root, name)))]);
+  const files = ["scripts/rea.mjs", "package.json", "package-lock.json"];
+  const visit = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) =>
+      a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
+    )) {
+      const path = join(directory, entry.name);
+      assert.ok(!entry.isSymbolicLink(), `Unbound compiled CLI link: ${path}`);
+      if (entry.isDirectory()) await visit(path);
+      else if (entry.isFile() && /\.(?:[cm]?js|json)$/.test(entry.name))
+        files.push(relative(root, path));
+    }
+  };
+  // MCP materializes additional workers and reads build-owned JSON after
+  // discovery. Bind every compiled JS/JSON asset, rather than only its entry.
+  await visit(join(root, kind === "mcp" ? "dist" : "dist/cli-runtime"));
+  assert.ok(
+    files.includes(
+      kind === "mcp"
+        ? join("dist", "mcp", "main.js")
+        : join("dist", "cli-runtime", "cli.js"),
+    ),
+    "Missing compiled runtime entry",
+  );
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for (const name of files.sort()) {
+    const value = await readFile(join(root, name));
+    bytes += value.length;
+    hash.update(JSON.stringify([name, value.length, sha(value)]) + "\n");
+  }
+  return {
+    binding_version: kind === "mcp" ? 2 : 1,
+    root,
+    node: process.version,
+    git_revision: gitRevision,
+    source_diff_sha256: sha(sourceDiff),
+    untracked_source_sha256: sha(JSON.stringify(untrackedEntries)),
+    ...(kind === "mcp"
+      ? {
+          compiled_runtime_sha256: hash.digest("hex"),
+          compiled_runtime_files: files.length,
+          compiled_runtime_bytes: bytes,
+        }
+      : {
+          compiled_cli_sha256: hash.digest("hex"),
+          compiled_cli_files: files.length,
+          compiled_cli_bytes: bytes,
+        }),
+  };
+};
+
+export const assertRuntimeBinding = (actual, expected, mode) => {
+  assert.ok(expected, `Missing expected runtime binding for ${mode}`);
+  assert.deepEqual(actual, expected, `Runtime binding differs for ${mode}`);
+};
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  console.log(
+    JSON.stringify(
+      await captureRuntimeBinding(process.argv[2], process.argv[3]),
+      null,
+      2,
+    ),
+  );
+}

experiments/analysis-efficiency/managed-cli-shared-read.json

@@ -0,0 +1,72 @@
+{
+  "status": "passed",
+  "scope": "Single completed SDK regression after shared JSON reader/admission changes; not a new paired source-to-bundle performance comparison. Existing semantic-node cap one answers static correspondence only; no equal semantic-graph coverage claim. Corpus/reference preparation performed earlier and excluded.",
+  "artifact": {
+    "name": "Redux Toolkit 2.2.7",
+    "tarball_sha256": "f2517c466b50424b661a27e48039f15db7783e5822f46b5c7d39f20104ac67a9"
+  },
+  "runtime_parent_revision": "4fab2dfda16236dc407aa179920780d6a970dda3",
+  "production_manifest": "managed-cli.json#measurement_inputs.production_sources_sha256",
+  "input_schema_profile": "default compact",
+  "output_schema_profile": "full",
+  "tokens_estimated": {
+    "input_catalog_once": 49054,
+    "arguments": 307,
+    "text_replies": 7017,
+    "whole_task": 56378
+  },
+  "token_scope": "tiktoken==0.12.0/cl100k_base; one name/description/input-schema catalog plus actual arguments and MCP text replies; excludes output schemas, framing, model prompts/reasoning and actual model usage. Not actual native-agent token usage.",
+  "actual_model_usage": null,
+  "wall_seconds": 21.38,
+  "cpu_seconds": 21.022683,
+  "peak_process_family_bytes_including_page_cache": 974041088,
+  "calls": [
+    {
+      "name": "analyze_javascript_application",
+      "elapsed_ms": 9837.265845000002,
+      "is_error": false,
+      "reply_bytes": 25941
+    },
+    {
+      "name": "compare_source_to_bundle",
+      "elapsed_ms": 256.3669919999993,
+      "is_error": false,
+      "reply_bytes": 13199
+    },
+    {
+      "name": "inspect_analysis_view",
+      "elapsed_ms": 3012.057904000001,
+      "is_error": false,
+      "reply_bytes": 19393
+    },
+    {
+      "name": "export_evidence_bundle",
+      "elapsed_ms": 148.9011160000009,
+      "is_error": false,
+      "reply_bytes": 364
+    }
+  ],
+  "independent_proof": {
+    "status": "passed",
+    "method": "Independent Python JSON/SHA-256/POSIX path and basename joins; no REA parser or matcher.",
+    "source_files": 180,
+    "embedded_nodes": 99,
+    "candidate_relations": 210,
+    "strong_location_rows": 33,
+    "limitation": "Static multiple-location projections; no semantic-equivalence or removal claim."
+  },
+  "resource_events": {
+    "memory.events": {
+      "low": 0,
+      "high": 0,
+      "max": 0,
+      "oom": 0,
+      "oom_kill": 0,
+      "oom_group_kill": 0
+    },
+    "pids.events": {
+      "max": 0
+    }
+  },
+  "cleanup_verified": true
+}

experiments/analysis-efficiency/managed-cli-task.mjs

@@ -0,0 +1,266 @@
+import {
+  captureRuntimeBinding,
+  assertRuntimeBinding,
+} from "./managed-cli-runtime.mjs";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const execute = promisify(execFile);
+const [runtime, root, output, mode, cache = "cold"] = process.argv.slice(2);
+for (const value of [runtime, root, output])
+  assert.equal(resolve(value), value);
+assert.ok(["complete", "selected"].includes(mode));
+assert.ok(["cold", "warm"].includes(cache));
+await mkdir(output);
+await mkdir(join(output, "tmp"));
+const oracle = JSON.parse(await readFile(join(root, "oracle.json"), "utf8"));
+const target = join(root, "Newtonsoft.Json.dll");
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+assert.equal(hash(await readFile(target)), oracle.assembly_sha256);
+const stable = (value) =>
+  Array.isArray(value)
+    ? value.map(stable)
+    : value !== null && typeof value === "object"
+      ? Object.fromEntries(
+          Object.keys(value)
+            .sort()
+            .map((key) => [key, stable(value[key])]),
+        )
+      : value;
+const report = {
+  status: "incomplete",
+  runtime,
+  mode,
+  cache,
+  node: process.version,
+  question:
+    "Report identity/selection/source coverage for JsonConvert, its total method count and the first eight complete method records, plus the first sixteen assembly-wide MemberRef records and continuation coverage.",
+  recipe:
+    mode === "selected"
+      ? "Use --detail summary --evidence-bundle FILE; pass the exact parent_evidence_id to inspect-analysis-view --evidence-bundle FILE with source kind retained-evidence and view {kind:managed-members,collection:methods|member_refs,offset:0,limit:8|16}."
+      : "Use inspect-managed-members --type Newtonsoft.Json.JsonConvert; the completed full Evidence supplies the requested rows and remains accessible.",
+  calls: [],
+  cleanup_verified: false,
+};
+const began = performance.now();
+const environment = {
+  PATH: process.env.PATH,
+  HOME: output,
+  TMPDIR: join(output, "tmp"),
+  LANG: "C.UTF-8",
+  REA_LOG_LEVEL: "silent",
+  UV_THREADPOOL_SIZE: "1",
+  NODE_OPTIONS: "--max-old-space-size=2048",
+  ...(cache === "cold"
+    ? { NODE_DISABLE_COMPILE_CACHE: "1" }
+    : { NODE_COMPILE_CACHE: join(root, `compile-cache-${mode}`) }),
+};
+const call = async (label, args, json = true) => {
+  const started = performance.now();
+  const result = await execute(
+    process.execPath,
+    [join(runtime, "scripts/rea.mjs"), ...args],
+    {
+      cwd: output,
+      env: environment,
+      maxBuffer: 16 * 1024 * 1024,
+      timeout: 120000,
+    },
+  );
+  await writeFile(join(output, label + ".stdout"), result.stdout);
+  await writeFile(join(output, label + ".stderr"), result.stderr);
+  report.calls.push({
+    label,
+    arguments: ["rea", ...args],
+    elapsed_ms: performance.now() - started,
+    stdout_bytes: Buffer.byteLength(result.stdout),
+    stdout_file: label + ".stdout",
+  });
+  return json ? JSON.parse(result.stdout) : result.stdout;
+};
+let parent, summary, methods, refs;
+try {
+  const inputs = JSON.parse(
+    await readFile(join(root, "measurement-inputs.json"), "utf8"),
+  );
+  const expected = inputs.expected_runtime_bindings?.[mode];
+  assert.ok(expected, `Missing expected runtime for ${mode}`);
+  assert.equal(
+    expected.git_revision,
+    mode === "complete"
+      ? inputs.baseline_revision
+      : inputs.feature_parent_revision,
+  );
+  assert.notEqual(
+    inputs.expected_runtime_bindings.complete.root,
+    inputs.expected_runtime_bindings.selected.root,
+  );
+  assert.notEqual(
+    inputs.expected_runtime_bindings.complete.compiled_cli_sha256,
+    inputs.expected_runtime_bindings.selected.compiled_cli_sha256,
+  );
+  const bindingStarted = performance.now();
+  report.runtime_binding = await captureRuntimeBinding(runtime);
+  report.runtime_binding_audit_ms = {
+    before: performance.now() - bindingStarted,
+  };
+  assertRuntimeBinding(report.runtime_binding, expected, mode);
+  await call("help-members", ["inspect-managed-members", "--help"], false);
+  if (mode === "complete") {
+    parent = await call("complete", [
+      "inspect-managed-members",
+      target,
+      "--type",
+      "Newtonsoft.Json.JsonConvert",
+      "--json",
+    ]);
+    methods = parent.normalized_result.methods.slice(0, 8);
+    refs = parent.normalized_result.member_refs.slice(0, 16);
+  } else {
+    await call("help-view", ["inspect-analysis-view", "--help"], false);
+    const bundlePath = join(output, "parent.json");
+    summary = await call("summary", [
+      "inspect-managed-members",
+      target,
+      "--type",
+      "Newtonsoft.Json.JsonConvert",
+      "--detail",
+      "summary",
+      "--evidence-bundle",
+      bundlePath,
+      "--json",
+    ]);
+    const id = summary.normalized_result.parent_evidence_id;
+    assert.ok(id);
+    const bundle = JSON.parse(await readFile(bundlePath, "utf8"));
+    assert.equal(bundle.records.length, 1);
+    parent = bundle.records[0];
+    assert.equal(parent.evidence_id, id);
+    for (const [collection, limit] of [
+      ["methods", 8],
+      ["member_refs", 16],
+    ]) {
+      const value = await call(collection, [
+        "inspect-analysis-view",
+        JSON.stringify({
+          source: { kind: "retained-evidence", evidence_id: id },
+          view: { kind: "managed-members", collection, offset: 0, limit },
+        }),
+        "--evidence-bundle",
+        bundlePath,
+        "--json",
+      ]);
+      const page = value.normalized_result;
+      assert.equal(page.parent_evidence_id, id);
+      assert.deepEqual(page.source_coverage, parent.normalized_result.coverage);
+      assert.deepEqual(
+        page.page.rows,
+        parent.normalized_result[collection].slice(0, limit),
+      );
+      assert.equal(
+        page.coverage.total,
+        parent.normalized_result[collection].length,
+      );
+      assert.equal(page.coverage.next_offset, limit);
+      assert.equal(page.coverage.exhausted, false);
+      if (collection === "methods") methods = page.page.rows;
+      else refs = page.page.rows;
+    }
+  }
+  const data = parent.normalized_result;
+  assert.equal(data.artifact.sha256, oracle.assembly_sha256);
+  assert.equal(data.methods.length, 72);
+  assert.equal(data.member_refs.length, 2149);
+  assert.equal(data.types.length, 1);
+  assert.equal(data.types[0].token, oracle.selected_types[0].token);
+  for (let i = 0; i < data.methods.length; i++) {
+    const row = data.methods[i],
+      wanted = oracle.selected_types[0].methods[i];
+    assert.equal(row.token, wanted.token);
+    assert.equal(row.name, wanted.name);
+    assert.equal(row.rva, wanted.rva);
+    assert.equal(
+      row.signature.raw_sha256,
+      hash(Buffer.from(wanted.signature_hex, "hex")),
+    );
+  }
+  for (let i = 0; i < refs.length; i++) {
+    const row = refs[i],
+      wanted = oracle.member_refs_first_16[i];
+    assert.equal(row.token, wanted.token);
+    assert.equal(row.name, wanted.name);
+    assert.equal(
+      row.signature.raw_sha256,
+      hash(Buffer.from(wanted.signature_hex, "hex")),
+    );
+  }
+  assert.equal(methods.length, 8);
+  assert.equal(refs.length, 16);
+  if (summary) {
+    assert.equal(summary.normalized_result.summary.reported_counts.methods, 72);
+    assert.equal(
+      summary.normalized_result.summary.reported_counts.member_refs,
+      2149,
+    );
+    assert.deepEqual(summary.normalized_result.summary.coverage, data.coverage);
+    assert.deepEqual(
+      summary.normalized_result.summary.selection,
+      data.selection,
+    );
+  }
+  const answer = {
+    parent_evidence_id: parent.evidence_id,
+    artifact_sha256: oracle.assembly_sha256,
+    selection: data.selection,
+    source_coverage: data.coverage,
+    total_methods: data.methods.length,
+    total_member_refs: data.member_refs.length,
+    methods,
+    member_refs: refs,
+    limitation:
+      "MemberRef rows are assembly-wide; methods are selected-type rows. Page exhaustion is not an absence claim.",
+  };
+  report.parent_evidence_id = parent.evidence_id;
+  report.parent_semantic_sha256 = hash(JSON.stringify(stable(parent)));
+  report.answer_sha256 = hash(JSON.stringify(stable(answer)));
+  report.oracle_verified = {
+    all_selected_method_metadata: 72,
+    returned_methods: 8,
+    returned_member_refs: 16,
+  };
+  const bindingFinished = performance.now();
+  assertRuntimeBinding(
+    await captureRuntimeBinding(runtime),
+    report.runtime_binding,
+    mode,
+  );
+  report.runtime_binding_audit_ms.after = performance.now() - bindingFinished;
+  report.runtime_binding_verified = true;
+  report.status = "passed";
+  await writeFile(join(output, "parent-evidence.json"), JSON.stringify(parent));
+  await writeFile(join(output, "answer.json"), JSON.stringify(answer));
+} finally {
+  report.elapsed_ms = performance.now() - began;
+  report.cleanup_verified = true;
+  await writeFile(
+    join(output, "report.json"),
+    JSON.stringify(report, null, 2) + "\n",
+  );
+}
+console.log(
+  JSON.stringify({
+    status: report.status,
+    mode,
+    cache,
+    parent: report.parent_evidence_id,
+    answer: report.answer_sha256,
+    calls: report.calls.map((c) => ({
+      label: c.label,
+      elapsed_ms: c.elapsed_ms,
+      bytes: c.stdout_bytes,
+    })),
+  }),
+);

experiments/analysis-efficiency/managed-cli.md

@@ -0,0 +1,219 @@
+# Portable managed CLI member views
+
+Issue #5148 / PR #5167. Baseline `main@3dbe314ada9f6dcc994ca4655dc0faf082503847`;
+feature integrates the original `7b3ed4d025edd24d062cde0327a53bd311e174fc`.
+The measured production-file SHA-256 manifest is in [managed-cli.json](managed-cli.json).
+These are working-tree measurements. Each trial verifies both source and the
+complete compiled CLI graph before and after execution against its explicitly
+selected build. The two roles have distinct checkout roots and compiled digests.
+Identity-audit time is included in whole-task costs and recorded separately.
+The audit reads compiled files before timing individual CLI calls, warming those
+filesystem pages; cold means disabled Node compile cache, not disk-cold startup.
+
+## Question and independent checks
+
+Report identity, selected type, source coverage, the total method count, the first
+eight complete method records, and the first sixteen assembly-wide MemberRef
+records, including continuation coverage. Keep complete original Evidence available.
+The question deliberately does not ask for every method or reference.
+
+Public artifact: [Newtonsoft.Json 13.0.3](https://www.nuget.org/packages/Newtonsoft.Json/13.0.3),
+from the NuGet flat-container archive. The 2,441,966-byte archive SHA-256 is
+`872fc189e638ab1056555b03aaa38f68bcb54286e221aa646eb1129babf63c77`.
+Selected member `lib/net6.0/Newtonsoft.Json.dll`, 712,464 bytes, SHA-256
+`22c649f75fce5be7c7ccda8880473b634ef69ecf33f5d1ab8ad892caf47d5a07`.
+Package version 13.0.3 is distinct from metadata assembly version 13.0.0.0.
+No library code is executed; REA parses PE/CLI statically.
+
+An independent Python oracle uses `dnfile==0.18.0` and `pefile==2024.8.26`.
+It finds 494 TypeDefs, 4,208 MethodDefs and 2,149 MemberRefs. The selected
+`Newtonsoft.Json.JsonConvert` has 72 methods. Every trial checks all 72 method
+tokens, names, RVAs and original signature hashes, plus the sixteen returned
+MemberRef tokens, names and signature hashes, against this oracle. This does
+not independently establish complete CIL semantics or opcode correctness.
+The full parent Evidence and requested answers are identical across all twelve
+trials; returned rows equal the exact parent slices. Selection and source
+coverage remain distinct from page exhaustion. MemberRefs remain assembly-wide.
+
+## Completed-task cost
+
+Linux x64, Node 24.18.0/npm 11.16.0. Three alternating pairs per cache condition,
+serial, one CPU; 4 GiB hard / 3 GiB early-stop family guard, no swap, 192-task
+ceiling. Every task includes actual selected-command help, all CLI calls,
+provider parsing, bundle publication/authentication, local answer extraction
+and oracle comparisons, plus both runtime-identity audits. Build, download, oracle preparation and warm priming
+are excluded. OS page cache is uncontrolled. No build/test overlapped timing.
+
+Complete mode starts two CLI processes (help plus analysis). Selected mode starts
+five (two help commands, summary/publication, methods page, MemberRef page).
+Cold disables the Node compile cache; warm primes the exact workflow once per
+runtime/mode, then still starts fresh processes with isolated HOME each trial.
+All trials complete with verified process cleanup and no OOM/resource-stop event.
+
+| Whole task, median                              | Complete | Summary + two pages |
+| ----------------------------------------------- | -------: | ------------------: |
+| Estimated context tokens, both cache conditions |  451,373 |              13,078 |
+| Cold wall seconds                               |    9.969 |              14.801 |
+| Cold family CPU seconds                         |    9.743 |              14.555 |
+| Cold kernel family peak MiB                     |  393.281 |             400.098 |
+| Warm wall seconds                               |   10.339 |              24.141 |
+| Warm family CPU seconds                         |   10.097 |              23.842 |
+| Warm kernel family peak MiB                     |  401.809 |             407.164 |
+
+Context estimates include the question, supplied command recipe, all logical
+argv, actual help and stdout. Tokenizer `tiktoken==0.12.0`, `cl100k_base`.
+The reduction is 97.1% for this fixed task. There is no model invocation;
+actual billed/native-agent usage, reasoning and transport framing are unmeasured.
+The memory counter is the kernel cgroup process-family peak including file
+cache, not sampled RSS. Ranges and individual receipts are in the JSON.
+
+This is an opt-in context/portability improvement with extra latency and CPU,
+not a speed or memory optimization. Complete provider parsing and full authentication of file-supplied bundles
+remain. Fresh managed Evidence is sealed at its producing factory and reused
+without another payload clone, including low-headroom error projection. Complete output remains the default and is preferable
+for small outputs or questions requiring every row. No cache or parser cap
+was introduced.
+
+## Existing native code composition
+
+The unchanged baseline can already redirect full stdout to a file and select
+rows in code. [The measured control](managed-cli-local-control.py) returns the
+identical answer and retains the complete original Evidence. One cold run:
+11.249 s wall, 11.000 s family CPU,
+375.3 MiB kernel peak. Projection source,
+original help and returned answer together estimate 10,555 tokens; the shared
+question and launcher argv are excluded. This single-run control does not
+establish stable performance or actual native-agent usage. It does demonstrate
+that raw CLI reply savings are not universal savings over code composition.
+The additive interface supplies authenticated reusable projections through the
+same application/domain owner as MCP, without caller-maintained JSON slicing.
+
+## Correctness and resource boundaries
+
+The public CLI regression pages all eight managed collections after process
+exit, target deletion and a working-directory change. Complete parent identity,
+original row order, signatures, source/page coverage and unknowns survive.
+Existing outputs are not replaced; failed publication retains completed facts.
+
+The Evidence factory parses mutable caller data into independent trees, computes
+identity, then seals its fresh owned snapshot with active ancestry/iterators.
+It does not retain a set/array of every completed object. Existing sealed roots
+can be shared; mutable input aliases are cloned independently. General graph
+sealing keeps its separate cycle, sharing, hidden-field and atomic-failure rules.
+Managed and derived-view factories seal their own completed Evidence, so CLI
+error projection can borrow it without reauthentication or another payload copy.
+The view owner retains strict JSON normalization for optional-field contracts;
+the CLI no longer copies its already validated completed projection again.
+
+Shared heap admission traverses by depth rather than queueing every report row
+or allocating an entries array. It reserves parsed working copies and actual
+escaping expansion before cloning/hashing, reporting UTF-16 storage explicitly.
+Canonical bundle equality streams existing ordinary JSON encoder parts, preserving
+native key order, omission, negative zero and Unicode semantics without two
+whole-document strings. All production bundle readers explicitly pass their
+operation: CLI import/export/compare/inspection, retained views, MCP import/
+comparison and both native-matching read passes. Errors retain the original
+cause, cleanup primary and lease through retry.
+
+One process primitive dispatches queued callbacks and then their OS signal
+notifications. The managed producer checks it before accepting complete Evidence.
+Publication/read stages use it before their final checks. Inline, file and bundle
+CLI views share the existing command finalizer and actual resource scope; the
+finalizer checks interruption after close while preserving any primary/cleanup
+failure. Existing inline error labels remain intact. Synchronous analysis is
+cooperatively cancellable between stages, not preemptible.
+
+Four compiled publication cases (SIGINT/SIGTERM × event/actual POSIX signal)
+fail without their checkpoint and pass restored. Eight additional compiled
+completion cases cover default complete delivery and inline projection; all fail
+with only their new completion checkpoints removed and pass restored. Fixture
+hooks match the selected target path or exact parent ID. Two real Newtonsoft
+publication runs and four real default/inline completion runs retain the identical
+parent or independently checked selected summary, exit 130/143 and preserve
+committed receipts where applicable. No target library code is executed.
+
+All 556 focused tests across 36 files pass, including direct
+finalizer/cleanup ownership, WASM/Android cancellation and native matching.
+All six `npm run check` tasks plus architecture guards, and all six
+`npm run docs:check` tasks plus five README tests pass. The expanded domain
+project passes 5,617 tests in 287 files with
+3 skipped cases; this overlaps the focused gate. Its first
+batched shard hit two existing 30-second timeouts in unchanged large synthetic
+tests. Both passed isolated and in the fresh shard rerun under the same timeout;
+the cause of the batch variation is unverified. No production/timeout change
+was made for those cases. An earlier unsplit expansion was manually stopped
+before its heap ceiling; that incomplete attempt is not counted as a pass.
+
+Eight producing/operation negative controls also catch graph-sized sealing/
+admission scratch and wrong operation attribution, including native reload.
+Native built-in instrumentation is confined to the isolated process-global lane.
+Initial test-only spy/probe/schema-import issues were corrected before these
+passing gates. No actual heap exhaustion is induced. Simulated providers do not
+qualify foreign engines; Windows OS signals remain unverified locally.
+
+## Shared-reader real-artifact regression
+
+The existing Redux Toolkit 2.2.7 source/bundle task also completes through the
+updated reader with default full output schemas and compact input schemas.
+An independent Python SHA-256/path oracle verifies 180 historical files,
+99 embedded source nodes and 210 candidate relations (33 strong-location rows,
+147 unknown). Original signals and partial source coverage remain visible.
+This uses the existing explicit semantic-node cap of one for static correspondence;
+it does not establish equivalent semantic-graph coverage or behavioral equivalence.
+
+One completed task: 21.380 s wall,
+21.023 s family CPU,
+928.9 MiB kernel family peak,
+56,378 estimated context tokens (one input catalog,
+all arguments and MCP text replies; excludes output schemas, framing and model
+reasoning). Corpus/reference preparation was performed earlier and excluded.
+This is a regression verification with resource observation, not a new paired
+performance comparison. Actual model usage remains unmeasured. Details:
+[managed-cli-shared-read.json](managed-cli-shared-read.json).
+
+## Reproduction
+
+Extract the selected DLL to a private lab as `Newtonsoft.Json.dll`. Create an
+`acquisition.json` containing the URL, hashes, sizes and selected ZIP member
+shown above; never commit the DLL. Prepare the independent oracle:
+
+```bash
+uv run --no-project --with dnfile==0.18.0 --with pefile==2024.8.26 python \
+  experiments/analysis-efficiency/managed-cli-oracle.py /absolute/lab
+```
+
+Build baseline and feature separately with the pinned toolchain. Run each under
+the shared resource guard, alternating complete/selected, selected/complete,
+complete/selected for cold and warm. Use a new output directory for every run:
+
+```bash
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+  node experiments/analysis-efficiency/managed-cli-task.mjs \
+  /absolute/runtime /absolute/lab /absolute/lab/pair-cold-1-selected selected cold
+```
+
+Save each guard output to the adjacent `pair-*.log`. Warm mode uses the lab's
+mode-specific compile-cache directory; prime each identical workflow once first.
+Supply a `measurement-inputs.json` with exact revisions and production hashes,
+plus `expected_runtime_bindings.complete` and `.selected`. Capture each with
+`node experiments/analysis-efficiency/managed-cli-runtime.mjs /absolute/runtime`
+after building. Bind complete to the clean baseline revision, selected to the
+feature parent revision plus tracked/untracked source digests, with different
+roots and compiled-graph digests. The collector rejects a wrong build before any
+CLI call, rechecks it afterward, and aggregation independently enforces identity.
+A real wrong-runtime attempt is rejected before analysis. A copied trial with a
+tampered revision fails aggregation; removing only that consumer guard accepts it.
+The twelve-trial aggregation reproduces without private pilots. The native
+control also requires `--measurement-inputs /absolute/lab/measurement-inputs.json`
+and performs the same before/after identity checks.
+Then aggregate with:
+
+```bash
+uv run --no-project --with tiktoken==0.12.0 python \
+  experiments/analysis-efficiency/managed-cli-costs.py /absolute/lab \
+  --output /absolute/results.json
+```
+
+The original issue reporter's executable, foreign operating systems and actual
+model sessions remain unverified. Setup pilots and earlier unbound cohorts, including one failed setup run
+while compiled artifacts were absent after a typecheck failure, are excluded.

experiments/analysis-efficiency/mcp-input-catalog.md

@@ -226,3 +226,8 @@ keeps default valid calls and typed refusals while checking full producer
 constraints separately. Five isolated suites passed 14 tests across call paths,
 ADB start, browser scenarios, source selection and managed analysis. The first
 browser attempt failed and remains recorded; no performance cohort changed.
+
+The subsequent [startup audit](mcp-startup.md) extends this harness with
+source/bundle bindings and a post-materialization directory check. Its new
+measurements are a separate cohort; reproduce this report at its recorded
+revision when comparing the original timing and model-session receipts.

experiments/analysis-efficiency/mcp-input-catalog.mjs

@@ -7,6 +7,11 @@ import { parseArgs } from "node:util";
 import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Ajv2020 } from "ajv/dist/2020.js";
+import { sampleRetainedHeap } from "./mcp-retained-heap.mjs";
+import {
+  captureRuntimeBinding,
+  assertRuntimeBinding,
+} from "./managed-cli-runtime.mjs";
 
 const { values } = parseArgs({
   options: {
@@ -15,54 +20,135 @@ const { values } = parseArgs({
     oracle: { type: "string" },
     output: { type: "string" },
     profile: { type: "string", default: "default" },
+    phase: { type: "string", default: "analysis" },
+    cache: { type: "string", default: "cold" },
+    "cache-root": { type: "string" },
+    bindings: { type: "string" },
+    role: { type: "string" },
+    "diagnostic-heap": { type: "boolean", default: false },
   },
 });
-for (const key of ["runtime", "artifact", "oracle", "output"])
+assert.ok(["analysis", "discovery"].includes(values.phase));
+assert.ok(["cold", "warm"].includes(values.cache));
+assert.ok(!values["diagnostic-heap"] || values.phase === "analysis");
+for (const key of values.phase === "analysis"
+  ? ["runtime", "artifact", "oracle", "output"]
+  : ["runtime", "output"])
   assert.ok(
     values[key] && resolve(values[key]) === values[key],
     `${key} must be absolute`,
   );
 assert.ok(["default", "full", "compact"].includes(values.profile));
+if (values.cache === "warm")
+  assert.ok(
+    values["cache-root"] &&
+      resolve(values["cache-root"]) === values["cache-root"],
+  );
 await mkdir(values.output, { recursive: false });
 const hash = (value) => createHash("sha256").update(value).digest("hex");
-const oracle = JSON.parse(await readFile(values.oracle, "utf8"));
-const artifactSha = hash(await readFile(values.artifact));
-assert.equal(artifactSha, oracle.artifact_sha256);
+let oracle;
+let artifactSha;
+if (values.phase === "analysis") {
+  oracle = JSON.parse(await readFile(values.oracle, "utf8"));
+  artifactSha = hash(await readFile(values.artifact));
+  assert.equal(artifactSha, oracle.artifact_sha256);
+}
+let expectedBinding;
+let bindingBefore;
+let auditBeforeMs;
+let measurementInputsSha256;
+const producerSources = {};
+if (values.bindings !== undefined) {
+  assert.ok(["baseline", "candidate"].includes(values.role));
+  const inputBytes = await readFile(values.bindings);
+  measurementInputsSha256 = hash(inputBytes);
+  const inputs = JSON.parse(inputBytes.toString("utf8"));
+  for (const name of [
+    "mcp-input-catalog.mjs",
+    "managed-cli-runtime.mjs",
+    "mcp-retained-heap.mjs",
+  ]) {
+    producerSources[name] = hash(
+      await readFile(new URL(name, import.meta.url)),
+    );
+    assert.equal(producerSources[name], inputs.harness_sources_sha256[name]);
+  }
+  expectedBinding = inputs.runtime_bindings[values.role];
+  const start = performance.now();
+  bindingBefore = await captureRuntimeBinding(values.runtime, "mcp");
+  auditBeforeMs = performance.now() - start;
+  assertRuntimeBinding(bindingBefore, expectedBinding, values.role);
+}
 const environment = {
   PATH: process.env.PATH,
   HOME: values.output,
   REA_LOG_LEVEL: "silent",
   UV_THREADPOOL_SIZE: "1",
   NODE_OPTIONS: "--max-old-space-size=2048",
-  NODE_DISABLE_COMPILE_CACHE: "1",
+  ...(values.cache === "cold"
+    ? { NODE_DISABLE_COMPILE_CACHE: "1" }
+    : { NODE_COMPILE_CACHE: values["cache-root"] }),
   ...(values.profile === "default"
     ? {}
     : { REA_MCP_INPUT_SCHEMA_PROFILE: values.profile }),
 };
 const transport = new StdioClientTransport({
   command: process.execPath,
-  args: [join(values.runtime, "scripts/rea.mjs"), "mcp"],
+  args: [
+    ...(values["diagnostic-heap"] ? ["--inspect=127.0.0.1:0"] : []),
+    join(values.runtime, "scripts/rea.mjs"),
+    "mcp",
+  ],
   cwd: values.output,
   env: environment,
   stderr: "pipe",
 });
+const protocolRequests = {};
+const send = transport.send.bind(transport);
+transport.send = (...args) => {
+  const method = args[0].method;
+  if (typeof method === "string")
+    protocolRequests[method] = (protocolRequests[method] ?? 0) + 1;
+  return send(...args);
+};
 const client = new Client({ name: "rea-catalog-task", version: "1" });
 const report = {
   profile: values.profile,
+  phase: values.phase,
+  cache: values.cache,
+  cache_root: values["cache-root"] ?? null,
+  role: values.role,
+  measurement_inputs_sha256: measurementInputsSha256,
+  producer_sources_sha256: producerSources,
   artifact_sha256: artifactSha,
   calls: [],
   checks: [],
   status: "incomplete",
   cleanup_verified: false,
+  protocol_requests: protocolRequests,
 };
 const transcript = [];
 let stderr = "";
+let inspectorEndpoint;
 transport.stderr?.on("data", (value) => {
   stderr += value;
+  if (values["diagnostic-heap"] && inspectorEndpoint === undefined)
+    inspectorEndpoint = stderr.match(
+      /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[^\s]+)/u,
+    )?.[1];
 });
 const began = performance.now();
 try {
   await client.connect(transport);
+  report.protocol_era = client.getProtocolEra();
+  await writeFile(
+    join(values.output, "server.json"),
+    JSON.stringify({
+      info: client.getServerVersion(),
+      capabilities: client.getServerCapabilities(),
+      instructions: client.getInstructions(),
+    }),
+  );
   const catalog = await client.listTools();
   assert.equal(catalog.nextCursor, undefined);
   const definitions = new Map(catalog.tools.map((tool) => [tool.name, tool]));
@@ -73,97 +159,154 @@ try {
       ajv.validateSchema(tool.inputSchema),
       `Invalid schema: ${tool.name}`,
     );
-  await writeFile(join(values.output, "catalog.json"), JSON.stringify(catalog));
+  {
+    const encoded = JSON.stringify(catalog);
+    await writeFile(join(values.output, "catalog.json"), encoded);
+    report.catalog_sha256 = hash(encoded);
+  }
   report.tool_names = [...definitions.keys()];
-  const call = async (name, args) => {
-    const definition = definitions.get(name);
-    assert.ok(definition, `Missing named tool ${name}`);
-    const start = performance.now();
-    const reply = await client.callTool(
-      { name, arguments: args },
-      { toolDefinition: definition },
+  if (values.phase === "discovery") {
+    const prompts = await client.listPrompts();
+    assert.equal(prompts.nextCursor, undefined);
+    await writeFile(
+      join(values.output, "prompts.json"),
+      JSON.stringify(prompts),
     );
-    report.calls.push({
-      name,
-      elapsed_ms: performance.now() - start,
-      is_error: reply.isError === true,
-    });
-    transcript.push({ name, arguments: args, reply });
-    return reply;
-  };
-  const input = {
-    path: values.artifact,
-    view: {
-      collection: "packages",
-      names: ["serde"],
-      fields: ["name", "version", "kind"],
-    },
-  };
-  const first = await call("inspect_rust_binary", input);
-  assert.notEqual(first.isError, true);
-  const selected = first.structuredContent;
-  assert.ok(selected?.normalized_result?.page);
-  assert.deepEqual(selected.normalized_result.page.rows, oracle.serde_rows);
-  assert.equal(selected.subject.digest.sha256, artifactSha);
-  const parentId = selected.normalized_result.parent_evidence_id;
-  for (let index = 0; index < 2; index++) {
-    const reply = await call("inspect_analysis_view", {
-      source: { kind: "retained-evidence", evidence_id: parentId },
+    report.prompts_sha256 = hash(JSON.stringify(prompts));
+    report.answer = {
+      tools: report.tool_names,
+      prompts: prompts.prompts.map((prompt) => prompt.name),
+    };
+    report.status = "passed";
+  } else {
+    const call = async (name, args) => {
+      const definition = definitions.get(name);
+      assert.ok(definition, `Missing named tool ${name}`);
+      const start = performance.now();
+      const reply = await client.callTool(
+        { name, arguments: args },
+        { toolDefinition: definition },
+      );
+      report.calls.push({
+        name,
+        elapsed_ms: performance.now() - start,
+        is_error: reply.isError === true,
+      });
+      transcript.push({ name, arguments: args, reply });
+      return reply;
+    };
+    const input = {
+      path: values.artifact,
       view: {
-        kind: "rust",
         collection: "packages",
         names: ["serde"],
         fields: ["name", "version", "kind"],
       },
+    };
+    const first = await call("inspect_rust_binary", input);
+    assert.notEqual(first.isError, true);
+    const selected = first.structuredContent;
+    assert.ok(selected?.normalized_result?.page);
+    assert.deepEqual(selected.normalized_result.page.rows, oracle.serde_rows);
+    assert.equal(selected.subject.digest.sha256, artifactSha);
+    const parentId = selected.normalized_result.parent_evidence_id;
+    for (let index = 0; index < 2; index++) {
+      const reply = await call("inspect_analysis_view", {
+        source: { kind: "retained-evidence", evidence_id: parentId },
+        view: {
+          kind: "rust",
+          collection: "packages",
+          names: ["serde"],
+          fields: ["name", "version", "kind"],
+        },
+      });
+      assert.notEqual(reply.isError, true);
+      assert.deepEqual(
+        reply.structuredContent.normalized_result.page.rows,
+        oracle.serde_rows,
+      );
+      assert.equal(
+        reply.structuredContent.normalized_result.parent_evidence_id,
+        parentId,
+      );
+    }
+    const malformed = await call("inspect_rust_binary", {
+      path: values.artifact,
+      view: { collection: "packages", offset: -1 },
     });
-    assert.notEqual(reply.isError, true);
+    assert.equal(malformed.isError, true);
+    report.checks.push(
+      "Independent package rows and digest; repeated retained identity; canonical negative-offset refusal",
+    );
+    const exported = await call("export_evidence_bundle", {
+      path: join(values.output, "evidence.json"),
+    });
+    assert.notEqual(exported.isError, true);
+    const bundle = JSON.parse(
+      await readFile(join(values.output, "evidence.json"), "utf8"),
+    );
+    const parent = bundle.records.find(
+      (record) => record.evidence_id === parentId,
+    );
+    assert.ok(parent, "Complete original Evidence is retained");
+    assert.equal(parent.subject.digest.sha256, artifactSha);
     assert.deepEqual(
-      reply.structuredContent.normalized_result.page.rows,
-      oracle.serde_rows,
+      parent.normalized_result.auditable_metadata.packages,
+      oracle.packages,
     );
-    assert.equal(
-      reply.structuredContent.normalized_result.parent_evidence_id,
-      parentId,
+    assert.deepEqual(
+      parent.normalized_result.auditable_metadata.dependency_edges,
+      oracle.edges,
     );
+    report.parent_evidence_id = parentId;
+    report.parent_semantic_sha256 = hash(JSON.stringify(parent));
+    report.answer = oracle.serde_rows;
+    assert.deepEqual(
+      await client.listTools(),
+      catalog,
+      "Advertisement changed after canonical materialization",
+    );
+    report.checks.push(
+      "Catalog remains identical after canonical materialization",
+    );
+    report.status = "passed";
+  }
+  if (values["diagnostic-heap"]) {
+    report.status = "incomplete";
+    assert.ok(inspectorEndpoint, "Missing explicitly launched inspector");
+    report.diagnostic_heap = await sampleRetainedHeap(
+      inspectorEndpoint,
+      transport.pid,
+    );
+    report.status = "passed";
   }
-  const malformed = await call("inspect_rust_binary", {
-    path: values.artifact,
-    view: { collection: "packages", offset: -1 },
-  });
-  assert.equal(malformed.isError, true);
-  report.checks.push(
-    "Independent package rows and digest; repeated retained identity; canonical negative-offset refusal",
-  );
-  const exported = await call("export_evidence_bundle", {
-    path: join(values.output, "evidence.json"),
-  });
-  assert.notEqual(exported.isError, true);
-  const bundle = JSON.parse(
-    await readFile(join(values.output, "evidence.json"), "utf8"),
-  );
-  const parent = bundle.records.find(
-    (record) => record.evidence_id === parentId,
-  );
-  assert.ok(parent, "Complete original Evidence is retained");
-  assert.equal(parent.subject.digest.sha256, artifactSha);
-  assert.deepEqual(
-    parent.normalized_result.auditable_metadata.packages,
-    oracle.packages,
-  );
-  assert.deepEqual(
-    parent.normalized_result.auditable_metadata.dependency_edges,
-    oracle.edges,
-  );
-  report.parent_evidence_id = parentId;
-  report.parent_semantic_sha256 = hash(JSON.stringify(parent));
-  report.answer = oracle.serde_rows;
-  report.status = "passed";
 } finally {
   await client.close();
   await transport.close();
   report.cleanup_verified = transport.pid === null;
   assert.ok(report.cleanup_verified);
   report.elapsed_ms = performance.now() - began;
+  if (expectedBinding !== undefined) {
+    const start = performance.now();
+    const after = await captureRuntimeBinding(values.runtime, "mcp");
+    report.runtime_audit_ms = {
+      before: auditBeforeMs,
+      after: performance.now() - start,
+    };
+    assertRuntimeBinding(after, expectedBinding, values.role);
+    assert.deepEqual(after, bindingBefore);
+    assert.equal(
+      hash(await readFile(values.bindings)),
+      measurementInputsSha256,
+    );
+    for (const [name, digest] of Object.entries(producerSources))
+      assert.equal(
+        hash(await readFile(new URL(name, import.meta.url))),
+        digest,
+      );
+    report.runtime_binding = after;
+    report.runtime_binding_verified = true;
+  }
   await writeFile(
     join(values.output, "report.json"),
     JSON.stringify(report, null, 2) + "\n",

experiments/analysis-efficiency/mcp-integer-allocation.md

@@ -0,0 +1,143 @@
+# Integer validator allocation after MCP materialization
+
+Issue #6236; PR #4360. Linux x64, 2026-10-22.
+
+<!-- BEGIN:allocation-report:provenance -->
+
+Baseline `main@4a4bbab3c337701febeb6b532ace49041c4876e0`; candidate `461f342c71a72ef2be60912391df2393aa4e2ea3`. This is a pinned comparison.
+
+In separate inspector/forced-GC diagnostics, retained REA V8 heap decreases by about 9.6 MiB. The three-pair ranges do not overlap in either profile. Inspector perturbation is included. Normal task timing, CPU and peak memory are reported separately; these observations do not establish a general latency or peak-memory reduction.
+
+<!-- END:allocation-report:provenance -->
+
+Directory discovery uses recorded advertisements after #4424; this study separates it from completed tasks that materialize canonical handlers. Context is unchanged.
+
+## Change and compatibility
+
+Replace 1,247 argument-free `z.number().int()` constructions with `z.int()` across 175 existing source files. Keep current shared schema owners, refinements, bounds, defaults and metadata. AST-token comparison against the baseline, after normalizing this construction and formatting, is equal for every touched source file. No new tools, provider effects, caches or response contracts.
+
+The locked Zod 4.4.3 chained form retains a `ZodNumber` with a separate `ZodNumberFormat` check; direct construction uses the format itself. Incur 0.6.1 coerces argv strings only for `ZodNumber`. Existing CLI declarations and shared-input exceptions therefore retain the chained form. The actual compiled CLI registers 160 leaf commands; 104 numeric argument/option fields have identical results/errors in 974 installed-Incur parser cases across both runtimes, each field with an accepted probe. Fields are isolated from unrelated required options and no handlers are invoked. This is consumer-boundary coverage, not a real-engine claim.
+
+Seven dependency-boundary variants match parsed values and complete error issues for 126 cases, including fractions, nonfinite values, strings/null/undefined and unsafe integers; 14 JSON Schema projections match in draft-07/draft-2020-12. Actual SDK advertisements match byte-for-byte in both profiles before/after materialization and across roles.
+
+## Tasks, artifacts and bounds
+
+Reuse the shared SDK task driver and independent ELF/section/zlib/JSON oracles from [the catalog study](mcp-input-catalog.md): official Alpine v3.21 x86_64 ripgrep 14.1.1-r0 and Zellij 0.40.0-r0. All 42/422 packages and 88/1,063 edges match the independent oracles. Select serde name/version/kind, repeat exact retained-parent reads twice, verify a canonical negative-offset refusal, export/check complete Evidence and confirm the unchanged directory. `kind: null` stays unknown. Targets are not executed; dependency presence does not establish runtime use. Acquisition URLs, archive/executable/oracle hashes and complete answers are in [the receipts](mcp-integer-allocation.json). Previously acquired public bytes are rehashed, not redownloaded.
+
+Normal cohort: three alternating baseline/candidate pairs for each task × cold/warm server compile cache × default compact/full inputs: 72 trials, plus four excluded full-task warm priming runs. Separate diagnostic cohort: three alternating pairs per profile, cold Zellij tasks, 12 trials. All pass, with identical complete parent IDs/hashes and answers.
+
+Node 24.18.0/npm 11.16.0; fresh client/server and HOME per trial, driver compile cache disabled. Each trial is serial, pinned to one CPU, 4 GiB hard/3 GiB early stop, no swap, at most 192 tasks. Before/after checks bind clean source, all compiled JS/JSON assets (1,990 baseline / 1,990 candidate files), scripts and manifests; producer and resource-observer hashes are also bound. No OOM, resource stop or leftover payload processes. Whole-family measurements include SDK validation, extra calls, source/compiled audits and oracle checking; kernel peak includes file cache. Build/acquisition/oracle generation and priming are excluded. Warm uses a populated role/profile-specific Node cache; hit rate and OS page cache are unmeasured, and audits warm compiled-file pages.
+
+## Normal task costs
+
+Medians, baseline → candidate; all ranges are in the JSON. No inspector or diagnostic GC runs in this cohort.
+
+<!-- BEGIN:allocation-report:normal -->
+
+| Task      | Cache | Input profile |          Wall s |    Family CPU s | Family peak MiB |
+| --------- | ----- | ------------- | --------------: | --------------: | --------------: |
+| directory | cold  | default       |   2.739 → 2.239 |   2.553 → 2.075 |   247.4 → 248.4 |
+| directory | cold  | full          |   2.940 → 2.437 |   2.682 → 2.217 |   348.0 → 346.8 |
+| directory | warm  | default       |   2.639 → 2.135 |   2.461 → 1.980 |   251.8 → 246.2 |
+| directory | warm  | full          |   2.840 → 2.338 |   2.666 → 2.144 |   348.6 → 347.2 |
+| ripgrep   | cold  | default       |   7.571 → 7.169 |   7.372 → 6.918 |   798.8 → 791.1 |
+| zellij    | cold  | default       |   7.876 → 7.373 |   7.623 → 7.134 |   812.2 → 810.5 |
+| ripgrep   | cold  | full          |   7.876 → 7.475 |   7.710 → 7.295 |   803.7 → 801.2 |
+| zellij    | cold  | full          |   8.079 → 7.573 |   7.852 → 7.378 |   815.7 → 819.1 |
+| ripgrep   | warm  | default       |   7.575 → 6.977 |   7.352 → 6.810 |   815.0 → 791.6 |
+| zellij    | warm  | default       |   7.774 → 7.178 |   7.581 → 6.981 |   820.9 → 822.0 |
+| ripgrep   | warm  | full          |   7.976 → 7.875 |   7.746 → 7.679 |   812.7 → 789.3 |
+| zellij    | warm  | full          | 14.995 → 13.978 | 14.742 → 13.718 |   818.5 → 811.5 |
+
+<!-- END:allocation-report:normal -->
+
+### SDK span and audit separation
+
+<!-- BEGIN:allocation-report:sdk -->
+
+Cold/default directory audit wall medians are 1.273 s baseline / 0.782 s candidate; SDK spans are 0.944 → 0.948 s. Whole-family costs include those experimental audits. Their cause and per-span CPU are unmeasured.
+
+SDK span from client connect through task checks and client/server close. Excludes pre/post runtime binding and preflight artifact/oracle loading. Diagnostic spans include inspector and forced GC. CPU is measured for the whole family only; per-span CPU is unmeasured.
+
+| Task      | Cache | Inputs  | SDK span s, baseline → candidate |
+| --------- | ----- | ------- | -------------------------------: |
+| directory | cold  | default |                    0.944 → 0.948 |
+| directory | cold  | full    |                    1.067 → 1.102 |
+| directory | warm  | default |                    0.888 → 0.878 |
+| directory | warm  | full    |                    1.038 → 1.042 |
+| ripgrep   | cold  | default |                    5.778 → 5.752 |
+| zellij    | cold  | default |                    5.998 → 5.991 |
+| ripgrep   | cold  | full    |                    6.077 → 6.119 |
+| zellij    | cold  | full    |                    6.228 → 6.209 |
+| ripgrep   | warm  | default |                    5.743 → 5.656 |
+| zellij    | warm  | default |                    5.965 → 5.788 |
+| ripgrep   | warm  | full    |                    6.100 → 6.492 |
+| zellij    | warm  | full    |                  11.776 → 11.529 |
+
+<!-- END:allocation-report:sdk -->
+
+Full-profile warm Zellij is slower than its cold condition in both roles in this cohort. Cache hit rate and the cause of this observation are unmeasured, and cold/warm groups run sequentially. These timings support neither a general cache speedup nor a causal regression attribution.
+
+## Separate retained-heap diagnostics
+
+The same completed SDK task launches only its owned REA process with `--inspect=127.0.0.1:0`. Four CDP calls verify the owned transport PID, read heap, force GC and read heap again. The endpoint comes from that child’s stderr; the PID is a cross-check of the owned endpoint, not sole ownership proof. The inspector socket closes before MCP shutdown. These V8 values include inspector perturbation and exclude the client; diagnostic wall/CPU/family peaks include inspector and forced-GC overhead and are not normal-task timing results.
+
+<!-- BEGIN:allocation-report:heap -->
+
+| Inputs  | REA V8 retained MiB |  Baseline range | Candidate range | Diagnostic wall s |           CPU s | Family peak MiB |
+| ------- | ------------------: | --------------: | --------------: | ----------------: | --------------: | --------------: |
+| default |   189.835 → 180.242 | 189.823–189.855 | 180.208–180.366 |   15.490 → 14.291 | 15.246 → 14.123 |   814.1 → 786.3 |
+| full    |   191.260 → 181.693 | 191.165–191.304 | 181.588–181.848 |     8.979 → 8.377 |   8.769 → 8.142 |   810.3 → 824.9 |
+
+<!-- END:allocation-report:heap -->
+
+A mismatched PID is rejected; removing only that guard makes the negative oracle fail. Both connections in that check use the same owned REA endpoint, with no foreign-process attachment. Aggregation rejects diagnostic GC in a normal trial. Historical #4424 receipt reaggregation preserves previous metrics and adds the separately reported SDK-span fields; its aggregator source hash changes.
+
+## Context accounting
+
+<!-- BEGIN:allocation-report:context -->
+
+tiktoken==0.14.0/cl100k_base; estimates, not model usage. Actual model usage is unmeasured.
+
+| Profile | Input directory once | Directory task | ripgrep task | Zellij task |
+| ------- | -------------------: | -------------: | -----------: | ----------: |
+| default |               49,670 |         50,840 |       54,029 |      53,949 |
+| full    |              205,744 |        206,914 |      210,103 |     210,023 |
+
+Raw SDK directory costs per list: 756,165/912,436 tokens and 2,935,148/3,587,792 bytes for default/full.
+
+Question, explicit recipe, server instructions, one complete name/description/input-schema directory, every tool argument and text reply, plus prompt directory for discovery. This projection assumes the client retains a single unchanged directory. Raw catalog result costs include every observed tools/list result separately, with output schemas and without JSON-RPC envelopes. SDK initialization/framing, reasoning and actual model usage are unmeasured. The analysis task includes retained-read, rejection, export/oracle and post-materialization directory checks.
+
+<!-- END:allocation-report:context -->
+
+## Validation and reproduction
+
+- Both runtime builds and all six static checks plus architecture guards pass. Before the final main synchronization, 5,972 source/contract/public CLI/MCP tests pass across 323 files; four skip for unavailable/guarded coverage. After synchronization, both builds/static checks repeat successfully, 77 affected producer and CLI/MCP tests pass, and all 974 registered numeric-parameter parser cases match again. Includes real SQLite CLI/MCP record/column selection and JavaScript heap/deadline preservation. A first direct schema-validity invocation lacked generated catalog metadata; the supported focused entry generates it and all 15 cases pass. A later affected-test invocation selected two nonexistent paths; the corrected three-file producer/consumer run is the 77-case result above. Neither setup failure was counted as a passing test, and no production or timeout change was needed.
+- All 84 measured tasks and four warm priming tasks pass independent oracles, canonical refusal, parent/directory identity and owned cleanup checks. This does not verify external Hopper/Ghidra/IDA, Android devices, all providers or foreign OS behavior. The earlier macOS numbers in #4360 describe a different revision/platform and are not combined with these results.
+
+Build the pinned baseline/candidate in separate clean worktrees with the locked toolchain. Use the candidate’s producer scripts for both roles. `measurement_inputs` in the JSON records the complete matrix, questions/recipes, runtime bindings and producer hashes; extract it unchanged as the bindings file. Historical receipts require their matching producer revision. One normal task:
+
+```bash
+NODE_DISABLE_COMPILE_CACHE=1 node experiments/analysis-efficiency/mcp-input-catalog.mjs \
+  --runtime "$CANDIDATE_RUNTIME" --bindings "$MEASUREMENT_INPUTS" --role candidate \
+  --artifact "$RIPGREP_BINARY" --oracle "$RIPGREP_ORACLE" \
+  --output "$NEW_CASE_DIRECTORY" --profile default --phase analysis --cache cold
+```
+
+Run each task through `resource-run.py --observe-payload-exit --` to obtain whole-family counters. For warm runs replace `--cache cold` with `--cache warm --cache-root <role/profile cache>` after one complete priming task. For the separate Zellij diagnostic tasks add `--diagnostic-heap` and use cold cache. Keep their case names/logs aligned with `measurement_inputs`; aggregate both cohorts with:
+
+```bash
+python experiments/analysis-efficiency/mcp-startup-costs.py "$RECEIPT_ROOT" \
+  --output mcp-integer-allocation.json
+```
+
+The aggregator requires the recorded tiktoken version, exact catalog/parent/runtime/producer/guard identities, clean source, successful payload cleanup and matching matrix coverage. Default driver behavior continues without an inspector; the heap flag is confined to the experiment.
+
+Regenerate or verify every numerical section directly from the committed JSON:
+
+```bash
+node experiments/analysis-efficiency/mcp-integer-report.mjs
+node experiments/analysis-efficiency/mcp-integer-report.mjs --check
+```
+
+The documentation conformance gate checks current receipts, rejects stale normal/heap tables, and refuses missing producer markers without writing.

experiments/analysis-efficiency/mcp-integer-report.mjs

@@ -0,0 +1,212 @@
+// One producer for the numerical sections of the committed allocation report.
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+const { values } = parseArgs({
+  options: {
+    data: { type: "string" },
+    markdown: { type: "string" },
+    check: { type: "boolean", default: false },
+  },
+});
+const dataPath =
+  values.data ?? new URL("mcp-integer-allocation.json", import.meta.url);
+const markdownPath =
+  values.markdown ?? new URL("mcp-integer-allocation.md", import.meta.url);
+const data = JSON.parse(await readFile(dataPath, "utf8"));
+assert.equal(data.status, "passed");
+const original = await readFile(markdownPath, "utf8");
+const fixed = (value, digits = 3) => {
+  assert.ok(Number.isFinite(value));
+  return value.toFixed(digits);
+};
+const mib = (value, digits = 1) => fixed(value / 2 ** 20, digits);
+const median = (values) => {
+  assert.ok(values.length > 0);
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2
+    ? sorted[middle]
+    : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const table = (headers, rows, right = []) =>
+  [
+    `| ${headers.join(" | ")} |`,
+    `| ${headers.map((_, index) => (right.includes(index) ? "---:" : "---")).join(" | ")} |`,
+    ...rows.map((row) => `| ${row.join(" | ")} |`),
+  ].join("\n");
+const pair = (item, key, format = fixed) =>
+  `${format(item.baseline[key].median)} → ${format(item.candidate[key].median)}`;
+const heapMetric = "retained_v8_heap_bytes_after_gc";
+const heaps = data.heap_diagnostics.summary;
+const changes = heaps.map(
+  (item) =>
+    (item.baseline[heapMetric].median - item.candidate[heapMetric].median) /
+    2 ** 20,
+);
+const changesText = [...new Set(changes.map((value) => fixed(value, 1)))].join(
+  "–",
+);
+const separated = heaps.every(
+  (item) => item.baseline[heapMetric].min > item.candidate[heapMetric].max,
+);
+const provenance = `Baseline \`main@${data.measurement_inputs.baseline_revision}\`; candidate \`${data.measurement_inputs.candidate_revision}\`. This is a pinned comparison.\n\nIn separate inspector/forced-GC diagnostics, retained REA V8 heap decreases by about ${changesText} MiB. ${separated ? "The three-pair ranges do not overlap in either profile." : "Ranges overlap; inspect the observations below."} Inspector perturbation is included. Normal task timing, CPU and peak memory are reported separately; these observations do not establish a general latency or peak-memory reduction.`;
+const normal = table(
+  [
+    "Task",
+    "Cache",
+    "Input profile",
+    "Wall s",
+    "Family CPU s",
+    "Family peak MiB",
+  ],
+  data.summary.map((item) => [
+    item.artifact ?? "directory",
+    item.cache,
+    item.profile,
+    pair(item, "wall_seconds"),
+    pair(item, "cpu_seconds"),
+    pair(item, "kernel_family_peak_bytes_including_page_cache", mib),
+  ]),
+  [3, 4, 5],
+);
+const discovery = data.summary.find(
+  (item) =>
+    item.phase === "discovery" &&
+    item.cache === "cold" &&
+    item.profile === "default",
+);
+assert.ok(discovery);
+const audit = (role) =>
+  median(
+    data.records
+      .filter(
+        (row) =>
+          row.phase === "discovery" &&
+          row.cache === "cold" &&
+          row.profile === "default" &&
+          row.role === role,
+      )
+      .map(
+        (row) =>
+          (row.runtime_audit_ms.before + row.runtime_audit_ms.after) / 1000,
+      ),
+  );
+const sdk =
+  `Cold/default directory audit wall medians are ${fixed(audit("baseline"))} s baseline / ${fixed(audit("candidate"))} s candidate; SDK spans are ${pair(discovery, "sdk_task_elapsed_seconds")} s. Whole-family costs include those experimental audits. Their cause and per-span CPU are unmeasured.\n\n${data.sdk_task_elapsed_scope}\n\n` +
+  table(
+    ["Task", "Cache", "Inputs", "SDK span s, baseline → candidate"],
+    data.summary.map((item) => [
+      item.artifact ?? "directory",
+      item.cache,
+      item.profile,
+      pair(item, "sdk_task_elapsed_seconds"),
+    ]),
+    [3],
+  );
+const heap = table(
+  [
+    "Inputs",
+    "REA V8 retained MiB",
+    "Baseline range",
+    "Candidate range",
+    "Diagnostic wall s",
+    "CPU s",
+    "Family peak MiB",
+  ],
+  heaps.map((item) => [
+    item.profile,
+    pair(item, heapMetric, (value) => mib(value, 3)),
+    ...["baseline", "candidate"].map(
+      (role) =>
+        `${mib(item[role][heapMetric].min, 3)}–${mib(item[role][heapMetric].max, 3)}`,
+    ),
+    pair(item, "wall_seconds"),
+    pair(item, "cpu_seconds"),
+    pair(item, "kernel_family_peak_bytes_including_page_cache", mib),
+  ]),
+  [1, 2, 3, 4, 5, 6],
+);
+const integer = (value) => new Intl.NumberFormat("en-US").format(value);
+const tokens = (profile, phase, artifact) => {
+  const values = data.records
+    .filter(
+      (row) =>
+        row.profile === profile &&
+        row.phase === phase &&
+        row.artifact === artifact,
+    )
+    .map((row) => row.tokens_estimated.whole_task);
+  assert.ok(values.length > 0);
+  return [...new Set([Math.min(...values), Math.max(...values)])]
+    .map(integer)
+    .join("–");
+};
+const catalogs = data.catalogs;
+const context =
+  `${data.tokenizer}. Actual model usage is unmeasured.\n\n` +
+  table(
+    [
+      "Profile",
+      "Input directory once",
+      "Directory task",
+      "ripgrep task",
+      "Zellij task",
+    ],
+    ["default", "full"].map((profile) => [
+      profile,
+      integer(catalogs[profile].input_catalog_tokens),
+      tokens(profile, "discovery", null),
+      tokens(profile, "analysis", "ripgrep"),
+      tokens(profile, "analysis", "zellij"),
+    ]),
+    [1, 2, 3, 4],
+  ) +
+  `\n\nRaw SDK directory costs per list: ${integer(catalogs.default.raw_catalog_tokens)}/${integer(catalogs.full.raw_catalog_tokens)} tokens and ${integer(catalogs.default.raw_catalog_bytes)}/${integer(catalogs.full.raw_catalog_bytes)} bytes for default/full.\n\n${data.context_scope}`;
+const sections = { provenance, normal, sdk, heap, context };
+// oxfmt may pad table cells and separator dashes; neither changes report facts.
+const normalized = (value) =>
+  value
+    .trim()
+    .replace(/\s+/gu, " ")
+    .replace(/\s*\|\s*/gu, "|")
+    .replace(
+      /(?<=\|)(:)?-{3,}(:)?(?=\|)/gu,
+      (_, left, right) => `${left ?? ""}---${right ?? ""}`,
+    );
+let rendered = original;
+const changed = [];
+for (const [name, content] of Object.entries(sections)) {
+  const begin = `<!-- BEGIN:allocation-report:${name} -->`;
+  const end = `<!-- END:allocation-report:${name} -->`;
+  assert.equal(
+    rendered.split(begin).length,
+    2,
+    `Expected one opening report marker: ${name}`,
+  );
+  assert.equal(
+    rendered.split(end).length,
+    2,
+    `Expected one closing report marker: ${name}`,
+  );
+  const start = rendered.indexOf(begin) + begin.length;
+  const finish = rendered.indexOf(end);
+  assert.ok(finish > start, `Invalid report marker order: ${name}`);
+  if (normalized(rendered.slice(start, finish)) !== normalized(content)) {
+    changed.push(name);
+    rendered =
+      rendered.slice(0, start) + `\n\n${content}\n\n` + rendered.slice(finish);
+  }
+}
+if (values.check) {
+  assert.equal(
+    changed.length,
+    0,
+    `Generated allocation report differs: ${changed.join(", ")}`,
+  );
+  console.log("Allocation report matches committed receipt data");
+} else if (changed.length) {
+  await writeFile(markdownPath, rendered);
+  console.log(`Updated allocation report sections: ${changed.join(", ")}`);
+}

experiments/analysis-efficiency/mcp-retained-heap.mjs

@@ -0,0 +1,107 @@
+// Diagnostic only: inspect the explicitly launched REA process after its task.
+import assert from "node:assert/strict";
+
+export const sampleRetainedHeap = async (endpoint, expectedPid) => {
+  const url = new URL(endpoint);
+  assert.equal(url.protocol, "ws:");
+  assert.equal(url.hostname, "127.0.0.1");
+  assert.ok(Number.isSafeInteger(expectedPid) && expectedPid > 0);
+  const socket = new WebSocket(url);
+  let sequence = 0;
+  const pending = new Map();
+  const closed = new Promise((resolve) => {
+    socket.addEventListener("close", resolve, { once: true });
+  });
+  const rejectPending = (cause) => {
+    for (const request of pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(cause);
+    }
+    pending.clear();
+  };
+  socket.addEventListener("error", () =>
+    rejectPending(new Error("Owned REA inspector connection failed")),
+  );
+  socket.addEventListener("close", () =>
+    rejectPending(new Error("Owned REA inspector connection closed")),
+  );
+  socket.addEventListener("message", (event) => {
+    try {
+      const reply = JSON.parse(event.data);
+      const request = pending.get(reply.id);
+      if (request === undefined) return;
+      pending.delete(reply.id);
+      clearTimeout(request.timer);
+      if (reply.error !== undefined)
+        request.reject(new Error(JSON.stringify(reply.error)));
+      else request.resolve(reply.result);
+    } catch (cause) {
+      rejectPending(cause);
+    }
+  });
+  const withinDeadline = async (promise) => {
+    let timer;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("Owned REA inspector deadline exceeded")),
+            10_000,
+          );
+        }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const call = (method, params = {}) =>
+    new Promise((resolve, reject) => {
+      const id = ++sequence;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Owned REA inspector timed out: ${method}`));
+      }, 10_000);
+      pending.set(id, { resolve, reject, timer });
+      try {
+        socket.send(JSON.stringify({ id, method, params }));
+      } catch (cause) {
+        pending.delete(id);
+        clearTimeout(timer);
+        reject(cause);
+      }
+    });
+  try {
+    await withinDeadline(
+      new Promise((resolve, reject) => {
+        socket.addEventListener("open", resolve, { once: true });
+        socket.addEventListener("error", reject, { once: true });
+        socket.addEventListener("close", reject, { once: true });
+      }),
+    );
+    const identity = await call("Runtime.evaluate", {
+      expression: "process.pid",
+      returnByValue: true,
+    });
+    assert.equal(identity.result.value, expectedPid);
+    const before = await call("Runtime.getHeapUsage");
+    await call("HeapProfiler.collectGarbage");
+    const after = await call("Runtime.getHeapUsage");
+    for (const sample of [before, after]) {
+      assert.ok(Number.isSafeInteger(sample.usedSize) && sample.usedSize >= 0);
+      assert.ok(Number.isSafeInteger(sample.totalSize));
+      assert.ok(sample.totalSize >= sample.usedSize);
+    }
+    return {
+      scope:
+        "Owned REA V8 heap after the complete SDK task; inspector and forced GC are diagnostic overhead",
+      pid_verified: true,
+      before_gc: before,
+      after_gc: after,
+    };
+  } finally {
+    rejectPending(new Error("Owned REA inspector diagnostic finished"));
+    socket.close();
+    await withinDeadline(closed);
+  }
+};

experiments/analysis-efficiency/mcp-startup-costs.py

@@ -0,0 +1,151 @@
+"""Verify paired SDK startup/analysis receipts and account for the whole task."""
+import argparse
+import hashlib
+import importlib.util
+import json
+import math
+import statistics
+from pathlib import Path
+
+import tiktoken
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument('root', type=Path)
+parser.add_argument('--output', type=Path, required=True)
+args = parser.parse_args()
+root = args.root
+input_bytes = (root / 'measurement-inputs.json').read_bytes()
+inputs = json.loads(input_bytes)
+expected = inputs['runtime_bindings']
+sha = lambda value: hashlib.sha256(value).hexdigest()
+compact = lambda value: json.dumps(value, ensure_ascii=False, separators=(',', ':'), allow_nan=False)
+encoding = tiktoken.get_encoding('cl100k_base')
+count = lambda value: len(encoding.encode(value, disallowed_special=()))
+for role in ['baseline', 'candidate']:
+    assert expected[role]['git_revision'] == inputs[f'{role}_revision']
+    assert expected[role]['source_diff_sha256'] == sha(b'')
+    assert expected[role]['untracked_source_sha256'] == sha(b'[]')
+assert expected['baseline']['root'] != expected['candidate']['root']
+assert expected['baseline']['compiled_runtime_sha256'] != expected['candidate']['compiled_runtime_sha256']
+spec = importlib.util.spec_from_file_location('catalog_costs', Path(__file__).with_name('mcp-input-catalog-costs.py'))
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+catalogs = {}
+identities = {}
+rows = []
+heap_rows = []
+for case in inputs['cases'] + inputs.get('diagnostic_cases', []):
+    directory = root / case['case']
+    report = json.loads((directory / 'report.json').read_text())
+    assert report['status'] == 'passed' and report['cleanup_verified']
+    assert report['runtime_binding_verified']
+    assert report['measurement_inputs_sha256'] == sha(input_bytes)
+    for name, producer_digest in report['producer_sources_sha256'].items():
+        assert producer_digest == inputs['harness_sources_sha256'][name]
+    assert report['runtime_binding'] == expected[case['role']]
+    assert type(report['elapsed_ms']) in [int, float] and math.isfinite(report['elapsed_ms']) and report['elapsed_ms'] >= 0
+    for key in ['role', 'cache', 'profile', 'phase']:
+        assert report[key] == case[key]
+    raw = (directory / 'catalog.json').read_bytes()
+    catalog_digest = sha(raw)
+    assert catalog_digest == report['catalog_sha256']
+    profile = case['profile']
+    if profile not in catalogs:
+        catalog = json.loads(raw)
+        definitions = [{key: tool[key] for key in ['name', 'description', 'inputSchema']} for tool in catalog['tools']]
+        catalogs[profile] = {'sha256': catalog_digest, 'tool_count': len(catalog['tools']),
+                             'input_catalog_tokens': count(compact(definitions)),
+                             'raw_catalog_tokens': count(raw.decode()), 'raw_catalog_bytes': len(raw)}
+    assert catalog_digest == catalogs[profile]['sha256'], 'Directory differs across roles or phases'
+    transcript = json.loads((directory / 'transcript.json').read_text())
+    server = json.loads((directory / 'server.json').read_text())
+    tokens = {'question_and_recipe': count(inputs['questions'][case['phase']] + '\n' + inputs['recipes'][case['phase']]),
+              'server_instructions': count(server.get('instructions') or ''),
+              'input_catalog_once': catalogs[profile]['input_catalog_tokens'],
+              'arguments': sum(count(compact({'name': call['name'], 'arguments': call['arguments']})) for call in transcript),
+              'text_replies': sum(count(block['text']) for call in transcript for block in call['reply']['content'] if block['type'] == 'text')}
+    requests = report['protocol_requests']
+    assert requests['initialize'] == 1
+    if case['phase'] == 'analysis':
+        assert len(transcript) == 5 and requests['tools/call'] == 5 and requests['tools/list'] == 2
+        assert report['artifact_sha256'] == inputs['artifacts'][case['artifact']]['sha256']
+        identity = (report['parent_evidence_id'], report['parent_semantic_sha256'], sha(compact(report['answer']).encode()))
+        assert identities.setdefault(case['artifact'], identity) == identity
+        assert sum(call['is_error'] for call in report['calls']) == 1
+    else:
+        assert not transcript and requests.get('tools/call', 0) == 0
+        assert requests['tools/list'] == 1 and requests['prompts/list'] == 1
+        prompts = (directory / 'prompts.json').read_bytes()
+        assert sha(prompts) == report['prompts_sha256']
+        assert identities.setdefault('prompts', report['prompts_sha256']) == report['prompts_sha256']
+        tokens['prompt_directory'] = count(prompts.decode())
+    tokens['whole_task'] = sum(tokens.values())
+    resource = module.resource(directory)
+    for name, guard_digest in resource['guard_sources_sha256'].items():
+        assert guard_digest == inputs['harness_sources_sha256'][name]
+    del resource['guard_sources_sha256']
+    row = {**case, 'runtime_binding_sha256': sha(compact(report['runtime_binding']).encode()), 'runtime_audit_ms': report['runtime_audit_ms'],
+           'sdk_task_elapsed_seconds': report['elapsed_ms'] / 1000,
+           'catalog_sha256': catalog_digest, 'parent_evidence_id': report.get('parent_evidence_id'),
+           'parent_semantic_sha256': report.get('parent_semantic_sha256'),
+           'answer_sha256': sha(compact(report['answer']).encode()), 'tokens_estimated': tokens,
+           'raw_catalog_result_tokens_all_lists': catalogs[profile]['raw_catalog_tokens'] * requests['tools/list'],
+           'raw_catalog_result_bytes_all_lists': catalogs[profile]['raw_catalog_bytes'] * requests['tools/list'],
+           'actual_model_usage': None, 'protocol_era': report['protocol_era'], 'protocol_requests': requests, 'calls': report['calls'],
+           **resource,
+           'receipt_sha256': {name: sha((directory / name).read_bytes()) for name in ['report.json', 'catalog.json', 'server.json', 'transcript.json']}}
+    assert row['catalog_sha256'] == row['receipt_sha256']['catalog.json'] == catalogs[profile]['sha256']
+    heap = report.get('diagnostic_heap')
+    if case.get('diagnostic_heap'):
+        assert case['phase'] == 'analysis' and case['cache'] == 'cold' and case['artifact'] == 'zellij'
+        assert heap is not None and heap['pid_verified'] is True
+        for sample in [heap['before_gc'], heap['after_gc']]:
+            assert type(sample['usedSize']) is int and sample['usedSize'] >= 0
+            assert type(sample['totalSize']) is int and sample['totalSize'] >= sample['usedSize']
+        row['heap_observation'] = heap
+        row['retained_v8_heap_bytes_after_gc'] = heap['after_gc']['usedSize']
+        heap_rows.append(row)
+    else:
+        assert heap is None, 'Diagnostic GC contaminated a normal task trial'
+        rows.append(row)
+assert len(rows) == 72
+summary = []
+for phase in ['discovery', 'analysis']:
+    for cache in ['cold', 'warm']:
+        for profile in ['default', 'full']:
+            for artifact in ([None] if phase == 'discovery' else ['ripgrep', 'zellij']):
+                item = {'phase': phase, 'cache': cache, 'profile': profile, 'artifact': artifact}
+                for role in ['baseline', 'candidate']:
+                    selected = [row for row in rows if all(row[key] == item[key] for key in ['phase', 'cache', 'profile', 'artifact']) and row['role'] == role]
+                    assert len(selected) == 3
+                    item[role] = {metric: {'median': statistics.median(row[metric] for row in selected),
+                                           'min': min(row[metric] for row in selected), 'max': max(row[metric] for row in selected)}
+                                  for metric in ['wall_seconds', 'cpu_seconds', 'kernel_family_peak_bytes_including_page_cache', 'sdk_task_elapsed_seconds']}
+                    item[role]['tokens_estimated'] = [row['tokens_estimated']['whole_task'] for row in selected]
+                summary.append(item)
+result = {'status': 'passed', 'tokenizer': f'tiktoken=={tiktoken.__version__}/cl100k_base; estimates, not model usage',
+          'aggregation_sources_sha256': {path.name: sha(path.read_bytes()) for path in [Path(__file__), Path(spec.origin)]},
+          'context_scope': 'Question, explicit recipe, server instructions, one complete name/description/input-schema directory, every tool argument and text reply, plus prompt directory for discovery. This projection assumes the client retains a single unchanged directory. Raw catalog result costs include every observed tools/list result separately, with output schemas and without JSON-RPC envelopes. SDK initialization/framing, reasoning and actual model usage are unmeasured. The analysis task includes retained-read, rejection, export/oracle and post-materialization directory checks.',
+          'cache_scope': 'Cold disables server Node compile cache. Warm enables a prepopulated role/profile-specific cache after one complete analysis priming run. Fresh server/client processes and HOME each trial. Driver compile cache disabled in both cohorts. Cache hit rate and OS page cache are unmeasured; source/runtime audits warm compiled-file pages before startup.',
+          'resource_scope': 'Whole SDK driver, resource observer and owned REA process family. Includes before/after source-and-all-compiled-JS/JSON binding, SDK schema checks, extra validation calls, bundle export and independent oracle checking. Kernel cgroup peak includes file cache. Build/download/oracle preparation and cache priming excluded. Retained V8 heap and forced-GC diagnostics were not separately measured.',
+          'measurement_inputs': inputs, 'catalogs': catalogs, 'summary': summary, 'records': rows,
+          'sdk_task_elapsed_scope': 'SDK span from client connect through task checks and client/server close. Excludes pre/post runtime binding and preflight artifact/oracle loading. Diagnostic spans include inspector and forced GC. CPU is measured for the whole family only; per-span CPU is unmeasured.',
+          'warmup_receipts': {name: sha((root / name / 'report.json').read_bytes()) for name in [f'warmup-{profile}-{role}' for profile in ['default', 'full'] for role in ['baseline', 'candidate']]}}
+if heap_rows:
+    assert len(heap_rows) == 12
+    heap_summary = []
+    for profile in ['default', 'full']:
+        item = {'profile': profile}
+        for role in ['baseline', 'candidate']:
+            selected = [row for row in heap_rows if row['profile'] == profile and row['role'] == role]
+            assert len(selected) == 3
+            item[role] = {metric: {'median': statistics.median(row[metric] for row in selected),
+                                   'min': min(row[metric] for row in selected), 'max': max(row[metric] for row in selected)}
+                          for metric in ['retained_v8_heap_bytes_after_gc', 'wall_seconds', 'cpu_seconds', 'sdk_task_elapsed_seconds',
+                                         'kernel_family_peak_bytes_including_page_cache']}
+        heap_summary.append(item)
+    result['heap_diagnostics'] = {
+        'scope': 'Separate three-pair Zellij tasks per profile, with an explicitly launched loopback inspector. Four CDP calls verify the owned REA PID, read heap, force GC and read heap again after the completed SDK task. These whole-family costs include inspector and diagnostic GC overhead; they are excluded from the normal timing cohort. Heap values describe REA V8 only, not the client or the whole process family.',
+        'summary': heap_summary, 'records': heap_rows}
+args.output.write_text(json.dumps(result, indent=2) + '\n')
+print(json.dumps(summary, indent=2))

experiments/analysis-efficiency/mcp-startup.md

@@ -0,0 +1,61 @@
+# MCP discovery and complete Rust tasks
+
+Target-free stdio discovery previously constructed the canonical analysis runtime before the client could inspect its directory. The candidate records SDK advertisements at build time for default/explicit compact and explicit full inputs. Its first tool, prompt or completion request materializes canonical validators and handlers on the same SDK server. HTTP, output-schema-off, initial-target and unrecorded source runs retain eager composition.
+
+Pinned baseline: [`main@c465ff5a8`](https://github.com/morluto/rea/commit/c465ff5a814b8e1a386fc547cbcd94df5c35f086). Measured candidate: [`04900abbc`](https://github.com/leeguooooo/rea/commit/04900abbcd3c3438fce4af932ff28400fe744a7d). Both use the same main base and locked dependencies. Before/after source and all compiled JS/JSON bindings identify the exact runtime used in every trial. The input manifest and producer scripts are also hashed and checked.
+
+## Real tasks and independent facts
+
+Official Alpine v3.21 packages supply ripgrep 14.1.1-r0 (3,416,168-byte executable) and Zellij 0.40.0-r0 (17,151,864 bytes). Their download URLs, archive/executable digests and aports revisions are retained in [the measurement data](mcp-startup.json). The independent Python ELF/section/zlib/JSON oracle checks 42 packages and 88 dependency edges for ripgrep, and 422 packages and 1,063 edges for Zellij. Serde versions are 1.0.210 and 1.0.137 respectively; the selected package kind remains explicit unknown (`null`). Verification covers embedded static build metadata; execution and runtime reachability remain unverified.
+
+Each analysis task initializes the actual SDK client, lists and validates the input directory, selects serde name/version/kind, reads the exact retained parent twice, verifies canonical rejection of a negative offset, exports and independently checks the complete package/edge inventory, confirms unchanged advertisements after materialization, then closes. All five tool calls and both directory reads are included in the measured task. Discovery tasks initialize, list tools/prompts, validate the input directory and close without an analysis call.
+
+All 72 paired trials and four priming runs passed. Each artifact has identical answers, parent Evidence IDs and complete semantic hashes across roles, profiles and cache modes. Both profiles retain byte-identical directories across baseline/candidate and before/after canonical materialization. The directory contains 213 tools. Complete Evidence is retained and exported through the existing shared workflow.
+
+## Measured cost
+
+Three alternating pairs per condition; table values are medians. Min/max ranges and individual receipts are in [mcp-startup.json](mcp-startup.json). Each cell is baseline → candidate. Kernel process-family peak includes file cache, SDK driver, observer and REA children.
+
+| Task      | Cache | Inputs            |  Wall seconds | Family CPU seconds | Family peak MiB |
+| --------- | ----- | ----------------- | ------------: | -----------------: | --------------: |
+| Directory | cold  | compact (default) | 5.661 → 2.236 |      5.403 → 2.050 |   559.3 → 248.6 |
+| Directory | cold  | full              | 5.256 → 2.337 |      5.040 → 2.175 |   650.9 → 349.1 |
+| Directory | warm  | compact (default) | 5.056 → 2.236 |      4.800 → 2.015 |   572.8 → 251.4 |
+| Directory | warm  | full              | 4.957 → 2.338 |      4.754 → 2.139 |   672.7 → 349.6 |
+| ripgrep   | cold  | compact (default) | 8.177 → 8.078 |      7.945 → 7.899 |   849.7 → 792.5 |
+| zellij    | cold  | compact (default) | 8.276 → 7.276 |      8.041 → 7.105 |   846.2 → 819.0 |
+| ripgrep   | cold  | full              | 8.180 → 7.483 |      8.000 → 7.312 |   846.5 → 794.4 |
+| zellij    | cold  | full              | 8.484 → 7.776 |      8.284 → 7.514 |   850.4 → 813.1 |
+| ripgrep   | warm  | compact (default) | 7.976 → 6.879 |      7.739 → 6.678 |   826.8 → 802.6 |
+| zellij    | warm  | compact (default) | 8.285 → 7.472 |      8.019 → 7.254 |   882.1 → 811.4 |
+| ripgrep   | warm  | full              | 8.074 → 7.476 |      7.890 → 7.265 |   852.1 → 803.6 |
+| zellij    | warm  | full              | 8.382 → 7.479 |      8.151 → 7.293 |   854.3 → 830.0 |
+
+Discovery improves clearly in this cohort. Completed-task changes depend on the workload: default cold ripgrep is approximately unchanged. Initialization moves into the first actual analysis request; its latency must be assessed with the full workflow.
+
+| Default ripgrep first RPC | Baseline ms | Candidate ms |
+| ------------------------- | ----------: | -----------: |
+| cold                      |       231.5 |       2532.1 |
+| warm                      |       227.1 |       2118.2 |
+
+Within each profile, advertised context remains identical. Input-directory estimates are 49,670 tokens for default compact and 205,744 for full. Whole-task estimates include the supplied question/recipe, server instructions, directory once, every tool argument and text reply, and the prompt directory in discovery tasks. This projection assumes the client retains one unchanged directory; raw catalog result costs count every observed list result separately, including output schemas. These use tiktoken 0.14.0/cl100k_base; actual model usage, reasoning and SDK initialization/framing are unmeasured.
+
+Linux x64 / AMD EPYC 7B12 / kernel 6.1.0-54-cloud-amd64 / Node 24.18.0, npm 11.16.0. Timed SDK tasks negotiated the legacy protocol era; auto/modern correctness is covered separately by compiled boundary tests. Trials run serially under a 1-CPU quota pinned to CPU 15, 4 GiB hard memory / 3 GiB early stop, no swap and 192 tasks. No resource stop, OOM or remaining payload process was observed. Cold disables server Node compile cache; warm uses a role/profile-specific cache populated by one complete task. Fresh processes and HOME are used each trial. Cache hit rate and OS page cache are unmeasured. Runtime audits warm compiled-file pages and are included in whole-task costs. Builds, downloads, oracle generation and cache priming are preparation outside those costs. Retained V8 heap and forced-GC measurements were not separately collected.
+
+## Ownership and validation
+
+`OwnedMcpServers` seals publication before taking its close snapshot, keeps failed exact close capabilities for retry and serves both eager and deferred paths. Deferred startup still joins servers published before an asynchronous serving handle settles. Post-snapshot and post-close factory calls are refused before allocation. Both production-boundary regressions fail with only the shared guard removed and pass restored.
+
+The moved transport/delivery implementation preserves current complete-error retention, escaped-preview fitting, response/string-limit recovery, target-content provenance and native Evidence continuations. Canonical parsers remain authoritative after lazy binding. Both protocol eras, input/output profile choices, invalid input/output, completion cancellation, partial startup and cleanup retry are exercised.
+
+Aggregation keeps catalog, producer-script and guard-script digests in distinct variables. Before publishing a trial it verifies that the catalog digest matches both its catalog-file receipt and the shared profile identity. Deliberately selecting the guard digest for that field is rejected. Regeneration preserves all measured timing, CPU, memory, context and parent-Evidence values.
+
+Executed local gates: 125 focused tests across 14 files; a repeated 22-case schema/profile subset after the pinned main merge; all six static-check tasks plus architecture guards; builds for both pinned runtimes; six documentation checks and five README consistency tests. HTTP coverage includes the real compiled CLI session/replacement/Host tests. Runtime-binding admission rejects a mismatched compiled graph before MCP launch; aggregation rejects a tampered trial binding. The raw receipts remain in `/tmp/rea-perf-mcp-startup-20261022`, identified by hashes in the data. Real initial-target providers, foreign OS runtime behavior and other providers remain outside this measurement.
+
+## Reproduction
+
+Use the pinned Node/npm toolchain and separate clean baseline/candidate checkouts. Build each with `npm ci` and `npm run build:cached` (the measured workspace shared one locked dependency installation). Acquire and verify the official packages listed in the data, extract the named executables and generate independent oracles with `mcp-input-catalog-oracle.py`.
+
+Capture each checkout with `node experiments/analysis-efficiency/managed-cli-runtime.mjs CHECKOUT mcp`. Construct `measurement-inputs.json` using the recorded schema, updating absolute checkout/artifact/oracle paths and their independently verified bindings. Keep it immutable through a cohort; producer source digests cover `mcp-input-catalog.mjs`, `managed-cli-runtime.mjs`, `resource-run.py` and `resource_payload.py`.
+
+Run `mcp-input-catalog.mjs` through `resource-run.py --observe-payload-exit` with `--runtime`, `--output`, `--bindings`, `--role baseline|candidate`, `--profile default|full`, `--phase discovery|analysis` and `--cache cold|warm`. Analysis also takes `--artifact` and `--oracle`; warm requires a role/profile-specific `--cache-root`. Disable the driver compile cache for both cohorts. Prime each warm role/profile once with the complete ripgrep task. Follow the 72-case order in the data, reversing role order in every second pair. Aggregate with `python mcp-startup-costs.py LAB --output mcp-startup.json` using tiktoken 0.14.0. The aggregator verifies every input/runtime/guard binding and completed receipt before producing summaries.

package.json

@@ -305,8 +305,8 @@
     "verify:solidity:metadata": "npm run build:cached && node scripts/verify-solidity-metadata.mjs",
     "verify:recorded:crash": "npm run build:cached && node scripts/verify-recorded-crash.mjs",
     "mcp-catalog:check:built": "node scripts/generate-mcp-tool-catalog.mjs --check",
-    "compile": "node scripts/clean-build-output.mjs && node scripts/run-typescript.mjs -p tsconfig.build.json && node scripts/record-catalog-digests.mjs && node scripts/bundle-runtime.mjs",
-    "compile:termux": "node scripts/clean-build-output.mjs && node --max-old-space-size=3072 node_modules/typescript-termux/lib/tsc.js -p tsconfig.build.json && node scripts/record-catalog-digests.mjs && node scripts/bundle-runtime.mjs",
+    "compile": "node scripts/clean-build-output.mjs && node scripts/run-typescript.mjs -p tsconfig.build.json && node scripts/record-catalog-digests.mjs && node scripts/record-mcp-catalog.mjs && node scripts/bundle-runtime.mjs",
+    "compile:termux": "node scripts/clean-build-output.mjs && node --max-old-space-size=3072 node_modules/typescript-termux/lib/tsc.js -p tsconfig.build.json && node scripts/record-catalog-digests.mjs && node scripts/record-mcp-catalog.mjs && node scripts/bundle-runtime.mjs",
     "artifacts:mcp-catalog": "node scripts/generate-mcp-tool-catalog.mjs",
     "artifacts:skills": "node scripts/generate-skill-metadata.mjs",
     "artifacts:product-catalog": "node scripts/generate-product-catalog.mjs",

scripts/ci/artifacts.d.mts

@@ -1,6 +1,31 @@
 import type { NormalizedWorkflowRun } from "./workflow-run.mjs";
 import type { StaticTaskContext } from "./static-task-context.mjs";
-export type { StaticTaskContext } from "./static-task-context.mjs";
+
+export interface CiRun {
+  readonly id?: string | number;
+  readonly run_attempt?: number;
+  readonly status?: string;
+  readonly conclusion?: string | null;
+  readonly event?: string;
+  readonly path?: string;
+  readonly head_sha?: string;
+  readonly head_branch?: string;
+  readonly repository?: { readonly full_name?: string };
+  readonly pull_requests?: readonly {
+    readonly base?: {
+      readonly sha?: string;
+      readonly repo?: { readonly full_name?: string };
+    };
+  }[];
+}
+
+export interface CiJob {
+  readonly name?: string;
+  readonly status?: string;
+  readonly conclusion?: string | null;
+  readonly run_id?: number;
+  readonly run_attempt?: number;
+}
 
 export interface StaticDiagnostic {
   readonly kind: "lint" | "jscpd";
@@ -11,15 +36,20 @@ export interface StaticDiagnostic {
   readonly severity?: string;
 }
 
+export interface StaticEvidence {
+  readonly context: StaticTaskContext;
+  readonly diagnostics: readonly StaticDiagnostic[];
+}
+
 export function classifyFailure(input: {
   repository: string;
   defaultBranch: string;
-  run: Record<string, unknown> & NormalizedWorkflowRun;
-  job: Record<string, unknown>;
+  run: CiRun & NormalizedWorkflowRun;
+  job: CiJob;
   diagnostics: readonly StaticDiagnostic[];
   context: StaticTaskContext;
-  mainRun: Record<string, unknown> & NormalizedWorkflowRun;
-  mainJob: Record<string, unknown>;
+  mainRun: CiRun & NormalizedWorkflowRun;
+  mainJob: CiJob;
   mainDiagnostics: readonly StaticDiagnostic[];
   mainContext: StaticTaskContext;
   executionSourcesVerified: boolean;
@@ -47,7 +77,7 @@ export function safeSha(value: unknown): string | null;
 export function validRepoPath(value: unknown): value is string;
 export function selectStaticCheckArtifact(
   page: unknown,
-  run: { id?: string | number; head_sha?: string },
+  run: Pick<CiRun, "id" | "head_sha">,
   runAttempt: number,
   name?: string,
 ): unknown | null;
@@ -57,12 +87,8 @@ export function readStaticCheckArtifact(options: {
   artifactId: number | string;
   token: string;
   fetchImpl?: typeof fetch;
-}): Promise<{
-  context: StaticTaskContext;
-  diagnostics: readonly StaticDiagnostic[];
-}>;
+}): Promise<StaticEvidence>;
 
-export function parseStaticArchive(archivePath: string): Promise<{
-  context: StaticTaskContext;
-  diagnostics: readonly StaticDiagnostic[];
-}>;
+export function parseStaticArchive(
+  archivePath: string,
+): Promise<StaticEvidence>;

scripts/ci/failure-report.d.mts

@@ -1,38 +1,5 @@
-import type { NormalizedWorkflowRun } from "./workflow-run.mjs";
-import type { StaticDiagnostic } from "./artifacts.mjs";
-export type { StaticDiagnostic } from "./artifacts.mjs";
+import type { CiRun, CiJob, StaticEvidence } from "./artifacts.mjs";
 import type { StaticTaskContext } from "./static-task-context.mjs";
-export type { StaticTaskContext } from "./static-task-context.mjs";
-export interface CiRun {
-  readonly id?: string | number;
-  readonly run_attempt?: number;
-  readonly status?: string;
-  readonly conclusion?: string | null;
-  readonly event?: string;
-  readonly path?: string;
-  readonly head_sha?: string;
-  readonly head_branch?: string;
-  readonly repository?: { readonly full_name?: string };
-  readonly pull_requests?: readonly {
-    readonly base?: {
-      readonly sha?: string;
-      readonly repo?: { readonly full_name?: string };
-    };
-  }[];
-}
-
-export interface CiJob {
-  readonly name?: string;
-  readonly status?: string;
-  readonly conclusion?: string | null;
-  readonly run_id?: number;
-  readonly run_attempt?: number;
-}
-
-export interface StaticEvidence {
-  readonly context: StaticTaskContext;
-  readonly diagnostics: readonly StaticDiagnostic[];
-}
 
 export interface CiFailureReport {
   readonly version: 1;
@@ -99,25 +66,6 @@ export interface FailureReportApi {
   ): Promise<Readonly<Record<string, boolean>>>;
 }
 
-export function classifyFailure(input: {
-  repository: string;
-  defaultBranch: string;
-  run: CiRun & NormalizedWorkflowRun;
-  job: CiJob;
-  diagnostics: readonly StaticDiagnostic[];
-  context: StaticTaskContext;
-  mainRun: CiRun & NormalizedWorkflowRun;
-  mainJob: CiJob;
-  mainDiagnostics: readonly StaticDiagnostic[];
-  mainContext: StaticTaskContext;
-  executionSourcesVerified: boolean;
-  ancestry: { status: string; mergeBaseSha: string | null };
-  blobs: Readonly<Record<string, boolean>>;
-}): {
-  classification: "matching-main-diagnostics" | "unknown";
-  reason: string;
-};
-
 export function reportCiFailures(options: {
   repository: string;
   defaultBranch: string;

scripts/ci/failure-report.mjs

@@ -26,8 +26,6 @@ const MAX_MAIN_RUN_LOOKUPS = 100;
 const MAX_PATHS_PER_COMPARISON = 50;
 const MAX_API_REQUESTS = 250;
 
-export { classifyFailure } from "./artifacts.mjs";
-
 /** Uses only failed CI candidates present in the supplied bounded timing manifest. */
 export async function reportCiFailures({
   repository,

scripts/lib/browser-scenario-service-worker-setup-e2e.mjs

@@ -142,6 +142,9 @@ export const verifyScenarioPolicySetup = async (
   page,
 ) => {
   const result = {};
+  // Exercise a caller-selected handshake deadline within the existing teardown
+  // guard; the default command deadline may legitimately outlast that guard.
+  const setupCommandTimeoutMs = 2_000;
   for (const mode of ["http-websocket", "http-discovery", "deadline"]) {
     const proxy = await startProxy(endpoint, mode);
     const provider = createBrowserScenarioProvider(process.env);
@@ -152,6 +155,9 @@ export const verifyScenarioPolicySetup = async (
         target_id: targetId,
       },
       start_url: { url: origin },
+      ...(mode === "deadline"
+        ? { command_timeout_ms: setupCommandTimeoutMs }
+        : {}),
       environment: { service_workers: "block" },
       actions: [
         { step_id: "settle", action: "wait_for_timeout", duration_ms: 1 },
@@ -189,7 +195,9 @@ export const verifyScenarioPolicySetup = async (
       if (!next.ok) throw next.error;
       assert.equal(next.value.browser.cleanup, "disconnected-external");
       result[mode] = {
-        ...(mode === "deadline" ? { timed_out: true } : { cancelled: true }),
+        ...(mode === "deadline"
+          ? { timed_out: true, command_timeout_ms: setupCommandTimeoutMs }
+          : { cancelled: true }),
         socket_closed: true,
         target_reused: true,
       };

scripts/lib/catalog-builders.mjs

@@ -238,7 +238,9 @@ export const providerCatalog = (sources) => {
       identity: sources.pwntoolsProvider.PWNTOOLS_PROVIDER_IDENTITY,
       contracts:
         sources.binaryDiagnosticsContracts.BINARY_DIAGNOSTICS_TOOL_CONTRACTS.filter(
-          ({ name }) => name !== "inspect_pe_resources",
+          ({ name }) =>
+            name !== "inspect_pe_resources" &&
+            name !== "inspect_pe_certificates",
         ),
     },
     {
@@ -248,6 +250,13 @@ export const providerCatalog = (sources) => {
           ({ name }) => name === "inspect_pe_resources",
         ),
     },
+    {
+      identity: sources.artifactProviders.PE_CERTIFICATES_PROVIDER,
+      contracts:
+        sources.binaryDiagnosticsContracts.BINARY_DIAGNOSTICS_TOOL_CONTRACTS.filter(
+          ({ name }) => name === "inspect_pe_certificates",
+        ),
+    },
     {
       identity: sources.captureProvider.TSHARK_PROVIDER_IDENTITY,
       contracts: sources.captureContracts.CAPTURE_TOOL_CONTRACTS,

scripts/lib/development-tests.mjs

@@ -39,6 +39,7 @@ export const parseDevelopmentTestRequest = (mode, arguments_) => {
 // runtime or typecheck prerequisites. Add a consumer here when it reads one.
 const artifactConsumers = {
   "artifacts:mcp-catalog": [
+    "tests/boundary/mcp/deferredRuntime.test.ts",
     "tests/boundary/mcp/contractPresentation.test.ts",
     "tests/boundary/mcp/toolSchemaValidity.test.ts",
   ],

scripts/lib/mcp-startup-probe.d.mts

@@ -47,6 +47,13 @@ export function profileMcpModuleLoading(
 /** Parse Linux procfs VmRSS text into bytes. */
 export function parseLinuxVmRssBytes(status: string): number | null;
 
+/** Name a fixed MCP startup phase budget. Mirrors `fixedMcpPhaseBudgetRecovery`. */
+export function fixedMcpStartupPhaseBudgetRecovery(
+  phase: string,
+  value: number,
+  unit: "ms" | "bytes",
+): string;
+
 /** Collect unique file-backed ESM module URLs from Node diagnostics. */
 export function createEsmModuleProfileCollector(packageName?: string): {
   append(chunk: string): void;

scripts/lib/mcp-startup-probe.mjs

@@ -35,11 +35,22 @@ export async function measureMcpStartup({
   const startedAt = performance.now();
   rss.start();
   try {
-    await client.connect(transport, { timeout: policy.initializeBudgetMs });
+    await withFixedPhaseBudget(
+      "MCP initialize phase budget",
+      policy.initializeBudgetMs,
+      "ms",
+      () => client.connect(transport, { timeout: policy.initializeBudgetMs }),
+    );
     const initializedAt = performance.now();
-    const tools = await client.listTools(undefined, {
-      timeout: policy.toolsListBudgetMs,
-    });
+    const tools = await withFixedPhaseBudget(
+      "MCP tools/list phase budget",
+      policy.toolsListBudgetMs,
+      "ms",
+      () =>
+        client.listTools(undefined, {
+          timeout: policy.toolsListBudgetMs,
+        }),
+    );
     const listedAt = performance.now();
     rss.stop();
     const measurement = {
@@ -52,7 +63,11 @@ export async function measureMcpStartup({
     assertStartupBudgets(measurement, policy);
     return measurement;
   } catch (cause) {
-    throw new Error(`packaged MCP startup probe failed: ${stderr}`, { cause });
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(
+      `packaged MCP startup probe failed: ${detail}${stderr.length === 0 ? "" : `\n${stderr}`}`,
+      { cause },
+    );
   } finally {
     rss.stop();
     await Promise.allSettled([client.close(), transport.close()]);
@@ -82,12 +97,24 @@ export async function profileMcpModuleLoading({
     version: "1.0.0",
   });
   try {
-    await client.connect(transport, {
-      timeout: policy.doctorDeadlineMs,
-    });
-    await client.listTools(undefined, {
-      timeout: policy.toolsListBudgetMs,
-    });
+    await withFixedPhaseBudget(
+      "MCP doctor startup deadline",
+      policy.doctorDeadlineMs,
+      "ms",
+      () =>
+        client.connect(transport, {
+          timeout: policy.doctorDeadlineMs,
+        }),
+    );
+    await withFixedPhaseBudget(
+      "MCP tools/list phase budget",
+      policy.toolsListBudgetMs,
+      "ms",
+      () =>
+        client.listTools(undefined, {
+          timeout: policy.toolsListBudgetMs,
+        }),
+    );
     return profile.result();
   } finally {
     await Promise.allSettled([client.close(), transport.close()]);
@@ -197,16 +224,46 @@ const createLinuxRssSampler = (pid) => {
   };
 };
 
+/** Same sentence as `fixedMcpPhaseBudgetRecovery`; this script cannot import that TypeScript module. */
+export const fixedMcpStartupPhaseBudgetRecovery = (phase, value, unit) =>
+  `REA's fixed ${phase} is ${String(value)} ${unit} and this release has no runtime override.`;
+
+const phaseTimeout = (cause) => {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return (
+    message.includes("Request timed out") ||
+    message.includes("Maximum total timeout exceeded") ||
+    message.includes("timed out")
+  );
+};
+
+const withFixedPhaseBudget = async (phase, value, unit, operation) => {
+  try {
+    return await operation();
+  } catch (cause) {
+    if (!phaseTimeout(cause)) throw cause;
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(
+      `${detail} ${fixedMcpStartupPhaseBudgetRecovery(phase, value, unit)}`,
+      { cause },
+    );
+  }
+};
+
 const assertStartupBudgets = (measurement, policy) => {
   if (measurement.process_started_to_initialized_ms > policy.initializeBudgetMs)
-    throw new Error("packaged MCP exceeded the initialize regression budget");
+    throw new Error(
+      `packaged MCP exceeded the initialize phase budget. ${fixedMcpStartupPhaseBudgetRecovery("MCP initialize phase budget", policy.initializeBudgetMs, "ms")}`,
+    );
   if (measurement.initialized_to_tools_list_ms > policy.toolsListBudgetMs)
-    throw new Error("packaged MCP exceeded the tools/list regression budget");
+    throw new Error(
+      `packaged MCP exceeded the tools/list phase budget. ${fixedMcpStartupPhaseBudgetRecovery("MCP tools/list phase budget", policy.toolsListBudgetMs, "ms")}`,
+    );
   if (
     measurement.process_started_to_tools_list_ms > policy.firstCatalogBudgetMs
   )
     throw new Error(
-      "packaged MCP exceeded the first-catalog regression budget",
+      `packaged MCP exceeded the first-catalog phase budget. ${fixedMcpStartupPhaseBudgetRecovery("MCP first-catalog phase budget", policy.firstCatalogBudgetMs, "ms")}`,
     );
 };
 

scripts/record-mcp-catalog.mjs

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+
+// Runtime discovery is generated from the same canonical registrations, after
+// default identity has been recorded and before bundling. Test catalogs stay separate.
+const compiled = resolve(dirname(fileURLToPath(import.meta.url)), "../dist");
+const read = (name) => import(pathToFileURL(join(compiled, name)).href);
+const [
+  { createServer },
+  { createBinarySession },
+  { parseConfig },
+  { silentLogger },
+  { PROMPT_CONTRACTS },
+] = await Promise.all([
+  read("server/createServer.js"),
+  read("composition/binary.js"),
+  read("config/parseConfig.js"),
+  read("logger.js"),
+  read("contracts/promptContracts.js"),
+]);
+const recordCatalog = async (profile) => {
+  // Catalog generation is independent of the host account and user configuration.
+  const home = await mkdtemp(join(tmpdir(), "rea-mcp-catalog-"));
+  const environment = {
+    REA_MCP_INPUT_SCHEMA_PROFILE: profile,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: join(home, "config"),
+    XDG_CACHE_HOME: join(home, "cache"),
+    XDG_STATE_HOME: join(home, "state"),
+  };
+  const cleanup = [];
+  let producerFailure;
+  try {
+    const config = parseConfig(environment);
+    if (!config.ok) throw config.error;
+    const session = createBinarySession(
+      config.value,
+      silentLogger,
+      environment,
+    );
+    cleanup.push(async () => {
+      const closed = await session.close({ retainProviderDocuments: true });
+      if (!closed.ok) throw closed.error;
+    });
+    const server = createServer({ kind: "session", session }, { environment });
+    cleanup.push(() => server.close());
+    const client = new Client({ name: "rea-catalog-recorder", version: "1" });
+    cleanup.push(() => client.close());
+    const [clientTransport, serverTransport] =
+      InMemoryTransport.createLinkedPair();
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+    const tools = (await client.listTools()).tools;
+    const prompts = (await client.listPrompts()).prompts.map((prompt) => {
+      const contract = PROMPT_CONTRACTS.find(
+        (candidate) => candidate.name === prompt.name,
+      );
+      if (contract === undefined)
+        throw new Error(`Missing prompt ${prompt.name}`);
+      return { ...prompt, parameters: contract.arguments };
+    });
+    const catalog = {
+      version: 1,
+      info: client.getServerVersion(),
+      capabilities: client.getServerCapabilities(),
+      instructions: client.getInstructions(),
+      identity: server.catalogIdentity,
+      tools,
+      prompts,
+    };
+    const encoded = JSON.stringify(catalog);
+    const digest = createHash("sha256").update(encoded).digest("hex");
+    await writeFile(
+      join(
+        compiled,
+        profile === "full" ? "mcp-catalog-full.json" : "mcp-catalog.json",
+      ),
+      encoded,
+    );
+    return digest;
+  } catch (cause) {
+    producerFailure = { cause };
+    throw cause;
+  } finally {
+    const results = await Promise.allSettled(
+      cleanup.reverse().map((close) => Promise.resolve().then(close)),
+    );
+    const failures = results.flatMap((result) =>
+      result.status === "rejected" ? [result.reason] : [],
+    );
+    if (failures.length === 0) {
+      try {
+        await rm(home, { recursive: true, force: true });
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    if (failures.length > 0)
+      throw new AggregateError(
+        producerFailure === undefined
+          ? failures
+          : [producerFailure.cause, ...failures],
+        `Catalog cleanup failed; temporary home retained at ${home}`,
+      );
+  }
+};
+
+const digests = {};
+for (const profile of ["compact", "full"])
+  digests[profile] = await recordCatalog(profile);
+await writeFile(
+  join(compiled, "recordedMcpCatalog.js"),
+  `/** Recorded from the compiled runtime; do not edit. */\nexport const RECORDED_MCP_CATALOG_SHA256 = ${JSON.stringify(digests)};\n`,
+);

scripts/verify-repository-skill.mjs

@@ -3,6 +3,26 @@ import { dirname, join, relative } from "node:path";
 
 import { exec, execNpm, pathExists } from "./lib/verify-package-core.mjs";
 
+/** Install the separately locked Skills CLI so verification resolves no registry metadata. */
+const lockedSkillsCli = async (root, workspace) => {
+  const tool = join(workspace, "skills-cli");
+  await mkdir(tool, { recursive: true });
+  for (const file of ["package.json", "package-lock.json"])
+    await cp(join(root, "scripts/verify-tools/skills", file), join(tool, file));
+  await execNpm(
+    ["ci", "--prefer-offline", "--ignore-scripts", "--no-audit", "--no-fund"],
+    { cwd: tool, timeout: 120_000 },
+  );
+  const installed = join(tool, "node_modules/skills");
+  const manifest = JSON.parse(
+    await readFile(join(installed, "package.json"), "utf8"),
+  );
+  return {
+    version: manifest.version,
+    entry: join(installed, manifest.bin.skills),
+  };
+};
+
 /** Exercise Skills' default root discovery without ignored build outputs. */
 export async function verifyRepositorySkill({ root, workspace }) {
   const snapshot = join(workspace, "repository");
@@ -33,15 +53,14 @@ export async function verifyRepositorySkill({ root, workspace }) {
     throw new Error("repository skill check must run without generated skills");
   await mkdir(consumer, { recursive: true });
   await mkdir(home, { recursive: true });
-  const skillsVersion = "1.7.2";
-  await execNpm(
+  const { version: skillsVersion, entry } = await lockedSkillsCli(
+    root,
+    workspace,
+  );
+  await exec(
+    process.execPath,
     [
-      "exec",
-      "--yes",
-      "--package",
-      `skills@${skillsVersion}`,
-      "--",
-      "skills",
+      entry,
       "add",
       snapshot,
       "--skill",

scripts/verify-tools/skills/package-lock.json

@@ -0,0 +1,112 @@
+{
+  "name": "rea-verify-skills-cli",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "rea-verify-skills-cli",
+      "dependencies": {
+        "skills": "1.7.2"
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/skills": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/skills/-/skills-1.7.2.tgz",
+      "integrity": "sha512-j+GzyF/oNahsjjjup6y3lJpFkC1lQjIkf4kAMXICA1hboBqi0fAGXAGoE4x9FRZiP1br/YE9+L3/Tqq6PIAe0A==",
+      "license": "MIT",
+      "dependencies": {
+        "tar": "^7.5.20",
+        "yaml": "^2.8.3"
+      },
+      "bin": {
+        "add-skill": "bin/cli.mjs",
+        "skills": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": ">=22.20.0"
+      }
+    },
+    "node_modules/tar": {
+      "version": "7.5.22",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.22.tgz",
+      "integrity": "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.1.0",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/yaml": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.1.tgz",
+      "integrity": "sha512-3NxN8+78OdzbT7C/WjGsyfPAtJaN3FNDsWxv7Y7mcDsT/oOmgW8BpyQQFFBnvZE3j9Y2Sdz1ULFLezL7Eb2yFw==",
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    }
+  }
+}

scripts/verify-tools/skills/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "rea-verify-skills-cli",
+  "private": true,
+  "description": "Lockfile-pinned Skills CLI for the repository skill check in verify:package.",
+  "dependencies": {
+    "skills": "1.7.2"
+  }
+}

src/adb/AdbProvider.test.ts

@@ -784,6 +784,33 @@ it("projects package details from dumpsys package output", async () => {
   });
 });
 
+// Package Manager prints an absent installer as the text "null"; the
+// normalized result must report the absence, not a package named "null"
+// (morluto/rea#3943).
+it("reports a null installer declaration as an absent installer", async () => {
+  const { binary } = await writeAdbStub(
+    shellStub({
+      "dumpsys:package": `Packages:
+  Package [com.example] (abcdef):
+    versionName=1.2.3
+    installerPackageName=null
+    requested permissions:
+      android.permission.INTERNET
+`,
+    }),
+  );
+  const result = await evidenceResult(providerOver(binary), {
+    operation: "inspect_adb_package",
+    input: { serial: "emulator-5554", package: "com.example" },
+  });
+  expect(result).toMatchObject({
+    version_name: "1.2.3",
+    installer_package_name: null,
+    requested_permissions_count: 1,
+    coverage: "complete",
+  });
+});
+
 // PackageInfo.getLongVersionCode() combines versionCodeMajor and versionCode
 // into a signed 64-bit long, which JSON numbers cannot hold exactly.
 it.each(["9007199254740993", "-4294967296"])(

src/adb/AdbShellOutput.test.ts

@@ -7,6 +7,52 @@ import {
   parseWindowFocusOutput,
 } from "./AdbShellOutput.js";
 
+const packageDump = (installerLine: string | undefined): string =>
+  [
+    "Packages:",
+    "  Package [com.example] (abcdef):",
+    "    versionName=1.2.3",
+    ...(installerLine === undefined ? [] : [`    ${installerLine}`]),
+    "    pkgFlags=[ HAS_CODE ]",
+    "",
+  ].join("\n");
+
+describe("parseDumpsysPackageOutput", () => {
+  it("keeps a reported installer package name", () => {
+    expect(
+      parseDumpsysPackageOutput(
+        packageDump("installerPackageName=com.android.vending"),
+      ).installerPackageName,
+    ).toBe("com.android.vending");
+  });
+
+  // Package Manager prints an absent String field as the text "null"; a
+  // missing or empty declaration means the same absence (morluto/rea#3943).
+  it.each([
+    ["the literal null sentinel", "installerPackageName=null"],
+    ["an empty value", "installerPackageName="],
+    ["a missing line", undefined],
+  ])("reports an absent installer as null for %s", (_case, line) => {
+    expect(parseDumpsysPackageOutput(packageDump(line))).toMatchObject({
+      versionName: "1.2.3",
+      installerPackageName: null,
+    });
+  });
+
+  // A manifest may declare the literal string "null" as its version name and
+  // dumpsys prints it the same way as an absent one, so the text is kept.
+  it("keeps a version name printed as the text null", () => {
+    expect(
+      parseDumpsysPackageOutput(
+        packageDump("installerPackageName=null").replace(
+          "versionName=1.2.3",
+          "versionName=null",
+        ),
+      ).versionName,
+    ).toBe("null");
+  });
+});
+
 describe("parseWindowFocusOutput display contexts", () => {
   it.each([false, true])(
     "retains both display owners independent of block order: %s",

src/adb/AdbShellOutput.ts

@@ -275,6 +275,17 @@ export interface AdbPackageDetails {
 
 const DETAIL_LINE = /^\s+([A-Za-z][A-Za-z0-9_]*)=(.*)$/u;
 
+/**
+ * Package Manager prints its `String` fields by concatenation, so an absent
+ * `installerPackageName` appears as the literal text `null`
+ * (morluto/rea#3943). No installer can be named "null", so an empty value or
+ * that sentinel is the absence of the fact and becomes the nullable result's
+ * null. `versionName` keeps the printed text: a manifest may declare the
+ * string "null" on purpose, and the parser cannot tell the two apart.
+ */
+const absentInstallerOrName = (value: string): string | null =>
+  value === "" || value === "null" ? null : value;
+
 /**
  * Project `dumpsys package PACKAGE` output. Only the listed fields are
  * extracted; the input is version-dependent and everything else is ignored
@@ -340,7 +351,7 @@ export const parseDumpsysPackageOutput = (
       key === "installerPackageName" &&
       details.installerPackageName === null
     )
-      details.installerPackageName = value === "" ? null : value;
+      details.installerPackageName = absentInstallerOrName(value);
     else if (key === "userId" && details.userId === null) {
       const parsed = /^(\d+)/u.exec(value);
       if (parsed !== null) details.userId = Number(parsed[1]!);

src/android/JadxProtocol.ts

@@ -4,14 +4,14 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import type { AndroidOperation } from "../domain/android/androidAnalysis.js";
 import { dexDescriptorSchema } from "../domain/android/androidAnalysis.js";
 
-const count = z.number().int().nonnegative();
+const count = z.int().nonnegative();
 /** Typed allocation failures authored before upstream erases the JVM exception. */
 const jadxMemoryFailureSchema = z.strictObject({
   kind: z.literal("jvm-memory-failure"),
   memory_area: z.enum(["heap", "unknown"]),
   exception_type: z.literal("java.lang.OutOfMemoryError"),
   message: z.string().optional(),
-  max_heap_bytes: z.number().int().positive().safe(),
+  max_heap_bytes: z.int().positive().safe(),
 });
 /** Selector failures authored by REA's bridge, separate from arbitrary engine errors. */
 const jadxInputFailureSchema = z.strictObject({
@@ -40,8 +40,8 @@ export const parseJadxFailure = (
 /** Values observed inside the exact JVM producing the analysis. */
 export const jadxRuntimeSchema = z.object({
   engine_reported_version: z.string().min(1),
-  max_heap_bytes: z.number().int().positive().safe(),
-  available_processors: z.number().int().positive(),
+  max_heap_bytes: z.int().positive().safe(),
+  available_processors: z.int().positive(),
   java_version: z.string().min(1),
   metadata_scope: z.literal("parsed_members"),
 });
@@ -81,11 +81,11 @@ export const jadxClassSchema = z.object({
       signature: z.string(),
       dex_descriptor: dexDescriptorSchema,
       is_constructor: z.boolean(),
-      def_pos: z.number().int(),
+      def_pos: z.int(),
     }),
   ),
   fields: z.array(
-    z.object({ name: z.string(), type: z.string(), def_pos: z.number().int() }),
+    z.object({ name: z.string(), type: z.string(), def_pos: z.int() }),
   ),
   inner_classes: z.array(z.string()),
 });
@@ -115,7 +115,7 @@ export const jadxXrefsSchema = z.object({
       full_name: z.string(),
       containing_class: z.string(),
       top_class: z.string(),
-      def_pos: z.number().int(),
+      def_pos: z.int(),
       direct_invokes_exhaustive: z.boolean().optional(),
       direct_invokes: z
         .array(

src/android/JadxWorkspaceRoot.test.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from "node:events";
+import { win32 } from "node:path";
+import { PassThrough } from "node:stream";
+
+import { afterEach, expect, it, vi } from "vitest";
+
+const { spawnMock, tmpdirMock, lstatMock } = vi.hoisted(() => ({
+  spawnMock: vi.fn(),
+  tmpdirMock: vi.fn(),
+  lstatMock: vi.fn(),
+}));
+
+vi.mock("node:child_process", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("node:child_process")>()),
+  spawn: spawnMock,
+}));
+vi.mock("node:os", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("node:os")>()),
+  tmpdir: tmpdirMock,
+}));
+vi.mock("node:fs/promises", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("node:fs/promises")>()),
+  lstat: lstatMock,
+}));
+
+import { createJadxWorkspaceRoot } from "./JadxWorkspaceRoot.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+});
+
+it("decodes a Windows guardian path across split UTF-8 stdout writes", async () => {
+  const previousPlatform = process.platform;
+  Object.defineProperty(process, "platform", {
+    configurable: true,
+    value: "win32",
+  });
+  const parent = "C:\\Users\\研究者\\AppData\\Local\\Temp";
+  const path = win32.join(parent, `rea-android-${"a".repeat(32)}`);
+  const child = Object.assign(new EventEmitter(), {
+    stdin: new PassThrough(),
+    stdout: new PassThrough(),
+    stderr: new PassThrough(),
+    unref: vi.fn(),
+  });
+  child.stdin.once("finish", () => {
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 0, null);
+  });
+  tmpdirMock.mockReturnValue(parent);
+  const missingPath = Object.assign(new Error("missing after cleanup"), {
+    code: "ENOENT",
+  });
+  lstatMock.mockRejectedValue(missingPath);
+  spawnMock.mockReturnValue(child);
+  const ready = Buffer.from(
+    `${JSON.stringify({
+      path,
+      volumeSerial: "0123456789abcdef",
+      fileId: "0123456789abcdef0123456789abcdef",
+      privateDacl: true,
+    })}\n`,
+  );
+  const split = ready.indexOf(Buffer.from("研")) + 1;
+
+  try {
+    const start = createJadxWorkspaceRoot();
+    setImmediate(() => {
+      child.stdout.write(ready.subarray(0, split), () => {
+        setImmediate(() => child.stdout.write(ready.subarray(split)));
+      });
+    });
+
+    const root = await start;
+    try {
+      expect(root.path).toBe(path);
+    } finally {
+      await expect(root.close()).resolves.toBeUndefined();
+    }
+    expect(lstatMock).toHaveBeenCalledWith(path);
+  } finally {
+    Object.defineProperty(process, "platform", {
+      configurable: true,
+      value: previousPlatform,
+    });
+  }
+});

src/android/JadxWorkspaceRoot.ts

@@ -105,8 +105,9 @@ class WindowsJadxWorkspaceRoot implements JadxWorkspaceRoot {
       },
     });
     let diagnostics = "";
-    child.stderr.on("data", (chunk: Buffer) => {
-      diagnostics = (diagnostics + chunk.toString()).slice(-8192);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk: string) => {
+      diagnostics = (diagnostics + chunk).slice(-8192);
     });
     const exit = new Promise<GuardianExit>((resolve) => {
       child.once("error", (error: Error) =>
@@ -116,8 +117,9 @@ class WindowsJadxWorkspaceRoot implements JadxWorkspaceRoot {
     });
     const ready = new Promise<string>((resolve, reject) => {
       let frame = "";
-      child.stdout.on("data", (chunk: Buffer) => {
-        frame += chunk.toString();
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk: string) => {
+        frame += chunk;
         if (frame.length > 4096) {
           reject(
             new Error("Android workspace guardian readiness exceeded 4 KiB"),

src/application/AnalysisProvider.ts

@@ -1,3 +1,4 @@
+import type { EvidenceCreationOptions } from "../domain/evidence.js";
 import type { ProviderInspectionScope } from "../providers/ProviderInspectionScope.js";
 import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
 import type { OfficialToolName } from "../contracts/officialToolContracts.js";
@@ -146,6 +147,7 @@ export const createAnalysisExecutionEvidence = (
   input: unknown,
   execution: AnalysisExecution,
   confidence: "observed" | "derived",
+  options?: EvidenceCreationOptions,
 ): Evidence =>
   createEvidence(
     execution.subject === undefined
@@ -167,6 +169,7 @@ export const createAnalysisExecutionEvidence = (
       locations: execution.locations,
       confidence,
     },
+    options,
   );
 
 /** Provider-neutral application capability for one analysis operation. */

src/application/BrowserEvidence.ts

@@ -138,6 +138,9 @@ const browserParameters = (
         : "target_id" in input && observedOrigin !== undefined
           ? [observedOrigin]
           : [],
+    ...("command_timeout_ms" in input && input.command_timeout_ms !== undefined
+      ? { command_timeout_ms: input.command_timeout_ms }
+      : {}),
   };
   if (!("target_id" in input)) return scope;
   return {
@@ -171,6 +174,11 @@ const browserParameters = (
           ...(input.total_analysis_timeout_ms === undefined
             ? {}
             : { total_analysis_timeout_ms: input.total_analysis_timeout_ms }),
+          ...(input.source_map_fetch_timeout_ms === undefined
+            ? {}
+            : {
+                source_map_fetch_timeout_ms: input.source_map_fetch_timeout_ms,
+              }),
         }
       : {}),
   };

src/application/CapabilityInventory.ts

@@ -499,6 +499,8 @@ const workflowAvailabilityFor = ({
         };
   if (name === "inspect_pe_resources")
     return { reason: "available", remediation: null };
+  if (name === "inspect_pe_certificates")
+    return { reason: "available", remediation: null };
   if (name === "inspect_evm_interface") {
     if (policy.evmInterfaceEnabled !== true)
       return {

src/application/DirectAnalysis.ts

@@ -1,4 +1,5 @@
 import type { ExecutableFormatHint } from "../domain/dosCom.js";
+import { dispatchQueuedInterrupts } from "../process/queuedInterrupts.js";
 import type { BinaryArchitecture } from "../domain/binaryTargetTypes.js";
 import type { JsonValue } from "../domain/jsonValue.js";
 import type { DirectAnalysisDependencies } from "./DirectAnalysisDependencies.js";
@@ -59,7 +60,11 @@ import {
 import type { AnalysisProviderSelector } from "../contracts/providerSelection.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 import { resolveXrefsAddress } from "./XrefsAddressResolution.js";
-import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import {
+  AnalysisCancelledError,
+  AnalysisInputError,
+} from "../domain/analysisErrorCore.js";
+import { deliverAnalysisEvidence } from "./EvidenceBundleCommands.js";
 import type { BinaryTargetError } from "../domain/configurationErrors.js";
 import {
   directAnalysisCleanupFailure,
@@ -146,24 +151,81 @@ export const runDirectAnalysis = async (
 /** Execute one provider-native semantic operation with atomic provenance. */
 export const runProviderAnalysis = async (
   dependencies: DirectAnalysisDependencies,
-  ...[path, tool, arguments_, logger = silentLogger, signal]: readonly [
-    path: string,
-    tool: NativeToolName | ArtifactAnalysisOperation | ManagedToolName,
-    arguments_: Readonly<Record<string, JsonValue>>,
-    logger?: Logger,
-    signal?: AbortSignal,
-  ]
+  ...[path, tool, arguments_, logger = silentLogger, signal, delivery]:
+    | readonly [
+        path: string,
+        tool: NativeToolName | ArtifactAnalysisOperation | ManagedToolName,
+        arguments_: Readonly<Record<string, JsonValue>>,
+        logger?: Logger | undefined,
+        signal?: AbortSignal | undefined,
+      ]
+    | readonly [
+        path: string,
+        tool: "inspect_managed_members",
+        arguments_: Readonly<Record<string, JsonValue>>,
+        logger: Logger | undefined,
+        signal: AbortSignal | undefined,
+        delivery: {
+          readonly detail?: "complete" | "summary";
+          readonly evidenceBundlePath?: string;
+        },
+      ]
 ): Promise<JsonValue> => {
-  if (isManagedToolName(tool))
-    return runManagedProviderAnalysis(
-      dependencies,
-      path,
-      tool,
-      arguments_,
-      signal,
+  if (delivery !== undefined && tool !== "inspect_managed_members")
+    return cliError(
+      new AnalysisInputError(tool, undefined, [
+        {
+          path: ["delivery"],
+          reason: "invalid_value",
+          message:
+            "Evidence delivery options are only supported by inspect_managed_members",
+        },
+      ]),
     );
-  return withProcessCancellation(signal, (operationSignal) =>
-    runAnalysis(dependencies, path, tool, arguments_, {
+  if (
+    delivery?.detail === "summary" &&
+    delivery.evidenceBundlePath === undefined
+  )
+    return cliError(
+      new AnalysisInputError(tool, undefined, [
+        {
+          path: ["evidence_bundle"],
+          reason: "missing_argument",
+          message:
+            "summary detail requires --evidence-bundle so complete Evidence remains available to later CLI commands",
+        },
+      ]),
+    );
+  return withProcessCancellation(signal, async (operationSignal) => {
+    if (isManagedToolName(tool)) {
+      const original = await runManagedProviderAnalysis(
+        dependencies,
+        path,
+        tool,
+        arguments_,
+        operationSignal,
+      );
+      await dispatchQueuedInterrupts();
+      if (!original.ok) return cliError(original.error);
+      if (operationSignal.aborted)
+        return cliError(
+          new AnalysisCancelledError(tool, {
+            cause: operationSignal.reason,
+            partialObservation: original.value,
+          }),
+        );
+      const result =
+        delivery?.evidenceBundlePath === undefined
+          ? original
+          : await deliverAnalysisEvidence(
+              original.value,
+              delivery.evidenceBundlePath,
+              delivery.detail,
+              operationSignal,
+            );
+      return result.ok ? result.value : cliError(result.error);
+    }
+    return runAnalysis(dependencies, path, tool, arguments_, {
       logger,
       snapshotPath: undefined,
       signal: operationSignal,
@@ -172,8 +234,8 @@ export const runProviderAnalysis = async (
         : NATIVE_INSPECTION_OPERATIONS.has(tool)
           ? { createSession: dependencies.createNativeBinarySession }
           : {}),
-    }),
-  );
+    });
+  });
 };
 
 /** Execute managed metadata inspection in an isolated managed-only session. */
@@ -199,13 +261,14 @@ export const runManagedProviderExecution = async (
     );
   });
 
+/** Preserve typed managed Evidence before selecting its CLI delivery. */
 const runManagedProviderAnalysis = async (
-  dependencies: DirectAnalysisDependencies,
+  dependencies: Pick<DirectAnalysisDependencies, "createManagedBinarySession">,
   path: string,
   tool: ManagedToolName,
   arguments_: Readonly<Record<string, JsonValue>>,
   signal?: AbortSignal,
-): Promise<JsonValue> => {
+): Promise<Result<Evidence, AnalysisError>> => {
   const execution = await runManagedProviderExecution(
     dependencies,
     path,
@@ -213,9 +276,13 @@ const runManagedProviderAnalysis = async (
     signal,
     arguments_,
   );
-  if (!execution.ok) return cliError(execution.error);
+  if (!execution.ok) return execution;
   const value = execution.value;
-  return createAnalysisExecutionEvidence(tool, arguments_, value, "observed");
+  return ok(
+    createAnalysisExecutionEvidence(tool, arguments_, value, "observed", {
+      immutable: true,
+    }),
+  );
 };
 
 const runAnalysis = async (

src/application/EnhancedTools.ts

@@ -198,12 +198,13 @@ export class EnhancedTools {
   ): EnhancedResult {
     switch (call.name) {
       case "inspect_native_dispatch_metadata":
-        return this.#inspectNativeDispatchMetadata(
-          call.input.max_records,
+        return inspectNativeDispatch(this.analysis, call.input.max_records, {
           signal,
-          call.input.objc_class_import_addresses,
-          call.input.objc_class_import_addresses_complete,
-        );
+          objcClassImportAddresses: call.input.objc_class_import_addresses,
+          objcClassImportAddressesComplete:
+            call.input.objc_class_import_addresses_complete,
+          maxInputBytes: call.input.max_input_bytes,
+        });
       case "get_objc_classes":
         return this.#objcClasses(call.input.pattern, signal);
       case "get_objc_protocols":
@@ -420,21 +421,6 @@ export class EnhancedTools {
     );
   }
 
-  #inspectNativeDispatchMetadata(
-    maxRecords: number,
-    signal?: AbortSignal,
-    objcClassImportAddresses?: readonly string[],
-    objcClassImportAddressesComplete?: boolean,
-  ): EnhancedResult {
-    return inspectNativeDispatch(
-      this.analysis,
-      maxRecords,
-      signal,
-      objcClassImportAddresses,
-      objcClassImportAddressesComplete,
-    );
-  }
-
   async #objcProtocols(signal?: AbortSignal): EnhancedResult {
     const names = await this.#allAddressed("list_names", signal);
     return names.ok ? ok(discoverObjcProtocols(names.value)) : names;

src/application/EvidenceBundleCommands.ts

@@ -1,9 +1,23 @@
+import { dispatchQueuedInterrupts } from "../process/queuedInterrupts.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
+import { requireAuthenticationHeadroom } from "./JsonAuthenticationHeadroom.js";
+
 import {
   EvidenceFileError,
   EvidenceIntegrityError,
+  type PublishedEvidenceFile,
 } from "../domain/evidenceErrors.js";
 import type { AnalysisError } from "../domain/analysisErrorBase.js";
-import type { EvidenceBundle } from "../domain/evidenceBundle.js";
+import {
+  AnalysisCancelledError,
+  AnalysisInputError,
+} from "../domain/analysisErrorCore.js";
+import type { Evidence } from "../domain/evidence.js";
+import {
+  createImmutableEvidenceBundle,
+  type EvidenceBundle,
+} from "../domain/evidenceBundle.js";
+import type { InspectAnalysisViewInput } from "../domain/analysisView/analysisView.js";
 import type { JsonValue } from "../domain/jsonValue.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok, type Result } from "../domain/result.js";
@@ -14,12 +28,18 @@ import {
   readImmutableEvidenceBundle,
   writeEvidenceBundle,
 } from "./EvidenceBundleFiles.js";
+import { inspectAnalysisViewValidated } from "./analysisView/AnalysisViewService.js";
 
 /** Validate a standalone bundle and report its complete record/revision counts. */
 export const importEvidenceBundleCommand = async (
   path: string,
 ): Promise<Result<JsonValue, AnalysisError>> => {
-  const loaded = await readEvidenceBundle(path);
+  const loaded = await readEvidenceBundle(
+    path,
+    undefined,
+    undefined,
+    "import_evidence_bundle",
+  );
   if (!loaded.ok) return loaded;
   return ok({
     imported: loaded.value.records.length,
@@ -35,16 +55,170 @@ export const exportEvidenceBundleCommand = async (
   overwrite: boolean,
 ): Promise<Result<JsonValue, AnalysisError>> => {
   // The sealed snapshot lets the writer reuse this authentication.
-  const loaded = await readImmutableEvidenceBundle(sourcePath);
+  const loaded = await readImmutableEvidenceBundle(
+    sourcePath,
+    undefined,
+    undefined,
+    "export_evidence_bundle",
+  );
   if (!loaded.ok) return loaded;
+  return projectWrite(
+    loaded.value,
+    await persistEvidenceBundleCommand(loaded.value, outputPath, overwrite),
+  );
+};
+
+/** Publish complete parent Evidence before delivering it or its linked summary. */
+export const deliverAnalysisEvidence = async (
+  evidence: Evidence,
+  outputPath: string,
+  detail: "complete" | "summary" = "complete",
+  signal?: AbortSignal,
+): Promise<Result<Evidence, AnalysisError>> => {
+  const headroom = requireAuthenticationHeadroom(evidence, {
+    operation: evidence.operation,
+    path: absoluteCallerPath(outputPath),
+    description:
+      "Insufficient heap headroom to authenticate the complete parent Evidence",
+  });
+  if (!headroom.ok)
+    return err(headroom.error.retainPartialObservation(evidence));
+  const bundle = createImmutableEvidenceBundle([evidence]);
+  const delivered =
+    detail === "summary"
+      ? inspectAnalysisViewValidated(
+          {
+            source: {
+              kind: "retained-evidence",
+              evidence_id: evidence.evidence_id,
+            },
+            view: { kind: "summary" },
+          },
+          (id) => bundle.records.find((record) => record.evidence_id === id),
+        )
+      : ok(evidence);
+  if (!delivered.ok) return delivered;
+  const published = await publishEvidenceDelivery({
+    bundle,
+    complete: evidence,
+    delivered: delivered.value,
+    outputPath,
+    operation: evidence.operation,
+    signal,
+  });
+  return published.ok ? ok(published.value.delivered) : published;
+};
+
+/** Selected Evidence delivered after its complete bundle was committed. */
+export interface PublishedEvidenceDelivery {
+  readonly delivered: Evidence;
+  readonly evidenceBundle: PublishedEvidenceFile;
+}
+
+/**
+ * Publish a complete bundle, then deliver Evidence already projected from it.
+ * Cancellation observed before commit leaves no output and retains the
+ * complete Evidence. A committed publication wins a later cancellation race;
+ * its receipt stays in the typed cancellation as diagnostics.evidence_bundle,
+ * and a cleanup failure after commit keeps its own published receipt.
+ */
+export const publishEvidenceDelivery = async (input: {
+  readonly bundle: EvidenceBundle;
+  readonly complete: Evidence;
+  readonly delivered: Evidence;
+  readonly outputPath: string;
+  readonly operation: string;
+  readonly signal?: AbortSignal | undefined;
+}): Promise<Result<PublishedEvidenceDelivery, AnalysisError>> => {
+  const { signal, operation } = input;
+  const written = await persistEvidenceBundleCommand(
+    input.bundle,
+    input.outputPath,
+    false,
+    signal,
+    operation,
+  );
+  // Deliver interrupts queued during final publication cleanup before the
+  // command's signal owner accepts completion and removes its listeners.
+  await dispatchQueuedInterrupts();
+  if (!written.ok)
+    return err(written.error.retainPartialObservation(input.complete));
+  if (signal?.aborted)
+    return err(
+      new AnalysisCancelledError(operation, {
+        cause: signal.reason,
+        partialObservation: input.delivered,
+        diagnostics: { evidence_bundle: { ...written.value } },
+      }),
+    );
+  return ok({ delivered: input.delivered, evidenceBundle: written.value });
+};
+
+/** Resolve the caller's exact retained parent from an authenticated portable bundle. */
+export const inspectAnalysisViewFromBundle = async (
+  input: InspectAnalysisViewInput,
+  bundlePath: string,
+  resources: ArtifactResourceScope,
+  signal?: AbortSignal,
+): Promise<Result<Evidence, AnalysisError>> => {
+  if (input.source.kind !== "retained-evidence")
+    return err(
+      new AnalysisInputError("inspect_analysis_view", undefined, [
+        {
+          path: ["source", "kind"],
+          reason: "invalid_value",
+          message:
+            "--evidence-bundle requires a retained-evidence source with the exact parent evidence_id; inline Evidence already supplies its source",
+        },
+      ]),
+    );
+  const loaded = await readImmutableEvidenceBundle(
+    bundlePath,
+    signal,
+    resources,
+    "inspect_analysis_view",
+  );
+  // Authentication and projection are synchronous; dispatch queued interrupts before accepting either result.
+  await dispatchQueuedInterrupts();
+  if (!loaded.ok) return loaded;
+  if (signal?.aborted)
+    return err(
+      new AnalysisCancelledError("inspect_analysis_view", {
+        cause: signal.reason,
+      }),
+    );
+  const projected = inspectAnalysisViewValidated(input, (id) =>
+    loaded.value.records.find((record) => record.evidence_id === id),
+  );
+  await dispatchQueuedInterrupts();
+  if (projected.ok && signal?.aborted)
+    return err(
+      new AnalysisCancelledError("inspect_analysis_view", {
+        cause: signal.reason,
+        partialObservation: projected.value,
+      }),
+    );
+  return projected;
+};
+
+/** Publish a completed bundle and retry its exact staged-output cleanup owner. */
+const persistEvidenceBundleCommand = async (
+  bundle: EvidenceBundle,
+  outputPath: string,
+  overwrite: boolean,
+  signal?: AbortSignal,
+  operation?: string,
+): Promise<Result<PublishedEvidenceFile, AnalysisError>> => {
   const resources = new ArtifactResourceScope();
   const written = await writeEvidenceBundle(
-    loaded.value,
+    bundle,
     outputPath,
     overwrite,
     resources,
+    signal,
+    operation,
   );
-  if (written.ok) return projectWrite(loaded.value, written);
+  if (written.ok) return written;
 
   // Confirmed release resolves the bound error to its primary outcome; a
   // failed retry leaves that error incomplete with its exact retained owner.
@@ -54,10 +228,7 @@ export const exportEvidenceBundleCommand = async (
     written.error instanceof EvidenceFileError &&
     written.error.published
   ) {
-    return projectWrite(loaded.value, {
-      ok: true,
-      value: written.error.published,
-    });
+    return ok(written.error.published);
   }
   return written;
 };
@@ -70,8 +241,18 @@ export const compareEvidenceBundlesCommand = async (input: {
   // Sealed snapshots let comparison and its bundle digests reuse this
   // authentication instead of re-validating every record twice more.
   const [left, right] = await Promise.all([
-    readImmutableEvidenceBundle(input.leftPath),
-    readImmutableEvidenceBundle(input.rightPath),
+    readImmutableEvidenceBundle(
+      input.leftPath,
+      undefined,
+      undefined,
+      "compare_bundles",
+    ),
+    readImmutableEvidenceBundle(
+      input.rightPath,
+      undefined,
+      undefined,
+      "compare_bundles",
+    ),
   ]);
   if (!left.ok) return left;
   if (!right.ok) return right;
@@ -88,7 +269,7 @@ export const compareEvidenceBundlesCommand = async (input: {
 
 const projectWrite = (
   bundle: EvidenceBundle,
-  written: Awaited<ReturnType<typeof writeEvidenceBundle>>,
+  written: Result<PublishedEvidenceFile, AnalysisError>,
 ): Result<JsonValue, AnalysisError> =>
   written.ok
     ? ok({

src/application/EvidenceBundleFiles.ts

@@ -1,3 +1,4 @@
+import { requireAuthenticationHeadroom } from "./JsonAuthenticationHeadroom.js";
 import { absoluteCallerPath } from "../filesystem/callerPath.js";
 
 import {
@@ -39,45 +40,47 @@ export const readEvidenceBundle = (
   path: string,
   signal?: AbortSignal,
   resources?: ArtifactResourceScope,
+  operation = "import_evidence_bundle",
 ): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
-  readBundle(path, parseEvidenceBundle, signal, resources);
+  readBundle(path, parseEvidenceBundle, signal, resources, operation);
 
 /** Read an authenticated immutable snapshot for a subsequent session import. */
 export const readImmutableEvidenceBundle = (
   path: string,
   signal?: AbortSignal,
   resources?: ArtifactResourceScope,
+  operation = "import_evidence_bundle",
 ): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
-  readBundle(path, parseImmutableEvidenceBundle, signal, resources);
+  readBundle(path, parseImmutableEvidenceBundle, signal, resources, operation);
 
 const readBundle = async (
   path: string,
   parseBundle: (input: unknown) => EvidenceBundle,
   signal?: AbortSignal,
   resources?: ArtifactResourceScope,
+  operation = "import_evidence_bundle",
 ): Promise<Result<EvidenceBundle, EvidenceReadFailure>> => {
   if (signal?.aborted)
     return err(
-      new AnalysisCancelledError("import_evidence_bundle", {
+      new AnalysisCancelledError(operation, {
         cause: signal.reason,
       }),
     );
-  const loaded = await readJsonFile(path, signal, resources);
-  if (!loaded.ok) {
-    if (loaded.error instanceof AnalysisCancelledError)
-      return err(
-        new AnalysisCancelledError("import_evidence_bundle", {
-          cause: loaded.error.cause,
-        }),
-      );
-    return loaded;
-  }
+  const loaded = await readJsonFile(path, signal, resources, operation);
+  if (!loaded.ok) return loaded;
   if (signal?.aborted)
     return err(
-      new AnalysisCancelledError("import_evidence_bundle", {
+      new AnalysisCancelledError(operation, {
         cause: signal.reason,
       }),
     );
+  const headroom = requireAuthenticationHeadroom(loaded.value, {
+    operation,
+    path: absoluteCallerPath(path),
+    description:
+      "Insufficient heap headroom to authenticate the Evidence bundle",
+  });
+  if (!headroom.ok) return headroom;
   let bundle: EvidenceBundle;
   try {
     bundle = parseBundle(loaded.value);
@@ -121,6 +124,7 @@ export const writeEvidenceBundle = async (
   overwrite: boolean,
   resources: ArtifactResourceScope,
   signal?: AbortSignal,
+  operation = "export_evidence_bundle",
 ): Promise<
   Result<
     { readonly path: string; readonly bytes: number },
@@ -128,7 +132,11 @@ export const writeEvidenceBundle = async (
   >
 > => {
   if (signal?.aborted === true)
-    return err(new AnalysisCancelledError("export_evidence_bundle"));
+    return err(
+      new AnalysisCancelledError(operation, {
+        cause: signal.reason,
+      }),
+    );
   let checked: EvidenceBundle;
   try {
     checked = parseEvidenceBundle(bundle);
@@ -144,8 +152,6 @@ export const writeEvidenceBundle = async (
     path,
     overwrite,
     resources,
-    signal === undefined
-      ? undefined
-      : { signal, operation: "export_evidence_bundle" },
+    signal === undefined ? undefined : { signal, operation },
   );
 };

src/application/EvidenceInputResolver.test.ts

@@ -22,7 +22,9 @@ describe("exact Evidence input resolution", () => {
           actual: null,
         },
       });
-      expect(projected.message).toContain("not retained in this session");
+      expect(projected.message).toContain(
+        "not available from the selected source",
+      );
       expect(projected.remediation.action).toContain(
         "complete inline Evidence",
       );

src/application/EvidenceInputResolver.ts

@@ -1,4 +1,4 @@
-import type { EvidenceInput } from "../contracts/evidenceInputContracts.js";
+import type { EvidenceInput } from "../domain/evidenceReference.js";
 import type { Evidence } from "../domain/evidence.js";
 import { EvidenceReferenceError } from "../domain/evidenceErrors.js";
 import { err, ok, type Result } from "../domain/result.js";
@@ -18,7 +18,7 @@ export const resolveEvidenceInput = (
       new EvidenceReferenceError(
         input.evidence_id,
         "missing",
-        "Evidence retained in this session",
+        "Evidence available to the selected source",
         null,
       ),
     );

src/application/InventoryProjectionEvidence.ts

@@ -9,6 +9,7 @@ import {
   type EvidenceSubjectTarget,
 } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
+import type { MobileApplicationProjectionWithSources } from "../domain/mobileApplicationGraphProjection.js";
 import { err, ok, type Result } from "../domain/result.js";
 import { requestInputError, workflowInputError } from "./workflowInputError.js";
 
@@ -23,13 +24,20 @@ interface InventoryProjectionResult {
   readonly limitations: readonly string[];
 }
 
+export interface InventoryProjectionEvidenceResult {
+  readonly evidence: Evidence;
+  readonly sources: readonly Evidence[];
+}
+
 interface InventoryProjectionOptions<
   Input extends InventoryProjectionInput,
   Output extends InventoryProjectionResult,
 > {
   readonly rawInput: unknown;
   readonly schema: z.ZodType<Input>;
-  readonly project: (input: Input) => Output;
+  readonly project: (
+    input: Input,
+  ) => MobileApplicationProjectionWithSources<Output>;
   readonly operation: string;
   readonly predicateType: string;
   readonly provider: EvidenceProvider;
@@ -43,17 +51,18 @@ export const projectInventoryEvidence = <
   Output extends InventoryProjectionResult,
 >(
   options: InventoryProjectionOptions<Input, Output>,
-): Result<Evidence, AnalysisError> => {
+): Result<InventoryProjectionEvidenceResult, AnalysisError> => {
   const parsed = options.schema.safeParse(options.rawInput);
   if (!parsed.success)
     return err(
       requestInputError(options.operation, parsed.error, options.rawInput),
     );
   try {
-    const result = options.project(parsed.data);
-    const first = parsed.data.inventory_evidence[0];
-    return ok(
-      createEvidence(
+    const projected = options.project(parsed.data);
+    const result = projected.projection;
+    const first = projected.sources[0];
+    return ok({
+      evidence: createEvidence(
         first?.subject === null || first?.subject === undefined
           ? undefined
           : {
@@ -80,7 +89,8 @@ export const projectInventoryEvidence = <
           evidenceLinks: result.source_evidence_ids,
         },
       ),
-    );
+      sources: projected.sources,
+    });
   } catch (cause: unknown) {
     return err(
       cause instanceof TypeError || cause instanceof z.ZodError

src/application/InvestigationProviders.ts

@@ -3,7 +3,6 @@ import {
   createAnalysisProfile,
   type AnalysisProfileCommitment,
 } from "../domain/analysisProfile.js";
-
 /** Provider identity for deterministic composed analysis workflows. */
 export const REA_WORKFLOW_PROVIDER = {
   id: "rea-workflow",
@@ -49,6 +48,13 @@ export const PE_RESOURCES_PROVIDER = Object.freeze({
   version: "1",
 } as const);
 
+/** Provider identity for portable, execution-free PE Authenticode table decoding. */
+export const PE_CERTIFICATES_PROVIDER = Object.freeze({
+  id: "rea-pe-certificates",
+  name: "REA PE certificate parser",
+  version: "1",
+} as const);
+
 /** Provider identity for deterministic managed-code comparison workflows. */
 export const MANAGED_WORKFLOW_PROVIDER = {
   id: "rea-dotnet-workflows",
@@ -112,20 +118,6 @@ export const JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER = {
   version: "1",
 } as const;
 
-/** Provider identity for deterministic cross-artifact comparisons. */
-export const ARTIFACT_COMPARISON_PROVIDER = {
-  id: "rea-artifact-comparison",
-  name: "REA artifact comparison",
-  version: "1",
-} as const;
-
-/** Provider identity for deterministic cross-function comparisons. */
-export const FUNCTION_COMPARISON_PROVIDER = {
-  id: "rea-function-comparison",
-  name: "REA function comparison",
-  version: "1",
-} as const;
-
 /** Provider identity for deterministic Evidence bundle comparisons. */
 export const BUNDLE_COMPARISON_PROVIDER = {
   id: "rea-bundle-comparison",

src/application/JsonAuthenticationHeadroom.test.ts

@@ -4,6 +4,50 @@ import {
   requireAuthenticationHeadroom,
 } from "./JsonAuthenticationHeadroom.js";
 describe("JSON authentication headroom", () => {
+  it("does not queue every row while deciding whether a wide report can fit", () => {
+    let pending = 0;
+    let peak = 0;
+    const rows: { admission_probe: boolean }[] = [];
+    for (let index = 0; index < 512; index++) {
+      const row = {
+        get admission_probe() {
+          pending--;
+          return true;
+        },
+      };
+      // Observe reading a row separately from examining its scalar. A width
+      // queue reads every row first; an iterator finishes each row before advancing.
+      Object.defineProperty(rows, index, {
+        enumerable: true,
+        get: () => {
+          peak = Math.max(peak, ++pending);
+          if (pending > 32)
+            throw new Error(
+              "Admission queued report rows before refusing their allocation",
+            );
+          return row;
+        },
+      });
+    }
+    const value = { rows };
+    const result = requireAuthenticationHeadroom(value, {
+      operation: "inspect_managed_members",
+      path: "/tmp/parent.json",
+      description: "Cannot authenticate",
+      availableBytes: 0,
+    });
+    expect(pending).toBe(0);
+    expect(peak).toBe(1);
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        _tag: "AnalysisResourceConstraintError",
+        reportedLimits: {
+          serialized_json_utf16_bytes: JSON.stringify(value).length * 2,
+        },
+      },
+    });
+  });
   it("estimates parsed JSON at no less than its UTF-16 text", () => {
     const text = "x".repeat(1000);
     expect(estimateJsonValueBytes(text)).toBeGreaterThanOrEqual(2000);
@@ -42,3 +86,28 @@ describe("JSON authentication headroom", () => {
     ).toEqual({ ok: true, value: undefined });
   });
 });
+
+it.each([
+  ["control characters", { text: "\u0000\u0001\b\t\n\f\r".repeat(2000) }],
+  [
+    "escaped keys",
+    { ['\u0000\\"'.repeat(2000)]: [true, false, null, -0, 1e30] },
+  ],
+  ["surrogate boundaries", { text: "😀\ud800x\udfff".repeat(2000) }],
+])("reserves actual escaped JSON storage for %s", (_label, value) => {
+  const result = requireAuthenticationHeadroom(value, {
+    operation: "inspect_analysis_view",
+    path: "/tmp/bundle.json",
+    description: "Cannot authenticate bundle",
+    availableBytes: estimateJsonValueBytes(value) * 2 + 1,
+  });
+  expect(result).toMatchObject({
+    ok: false,
+    error: {
+      _tag: "AnalysisResourceConstraintError",
+      reportedLimits: {
+        serialized_json_utf16_bytes: JSON.stringify(value).length * 2,
+      },
+    },
+  });
+});

src/application/JsonAuthenticationHeadroom.ts

@@ -1,32 +1,66 @@
+import { jsonStringCodeUnits } from "../domain/jsonSerialization.js";
 import { getHeapStatistics } from "node:v8";
 import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
-import type { AnalysisError } from "../domain/analysisErrorBase.js";
 import { err, ok, type Result } from "../domain/result.js";
 
 /** Authentication clones parsed JSON and hashes its canonical commitment. */
 const AUTHENTICATION_COPIES = 2;
 
-/** Conservative bytes a parsed JSON value occupies: UTF-16 text plus container and slot overhead. */
-export const estimateJsonValueBytes = (value: unknown): number => {
-  let bytes = 0;
-  const stack: unknown[] = [value];
+/** Parsed working copies and conservative UTF-16 storage for escaped JSON. */
+const estimateJsonStorage = (
+  value: unknown,
+): { valueBytes: number; serializedUtf16Bytes: number } => {
+  let valueBytes = 0;
+  let serializedCharacters = 0;
+  const stack: Iterator<unknown>[] = [[value][Symbol.iterator]()];
   while (stack.length > 0) {
-    const item = stack.pop();
-    if (typeof item === "string") bytes += 64 + item.length * 2;
-    else if (Array.isArray(item)) {
-      bytes += 128 + item.length * 16;
-      for (const entry of item) stack.push(entry);
+    const next = stack[stack.length - 1]!.next();
+    if (next.done) {
+      stack.pop();
+      continue;
+    }
+    const item = next.value;
+    if (typeof item === "string") {
+      valueBytes += 64 + item.length * 2;
+      serializedCharacters += jsonStringCodeUnits(item);
+    } else if (Array.isArray(item)) {
+      valueBytes += 128 + item.length * 16;
+      serializedCharacters += 2 + Math.max(0, item.length - 1);
+      stack.push(item.values());
     } else if (typeof item === "object" && item !== null) {
-      bytes += 128;
-      for (const [key, entry] of Object.entries(item)) {
-        bytes += 64 + key.length * 2;
-        stack.push(entry);
-      }
-    } else bytes += 16;
+      valueBytes += 128;
+      serializedCharacters += 2;
+      stack.push(
+        (function* () {
+          let count = 0;
+          for (const key in item) {
+            if (!Object.hasOwn(item, key)) continue;
+            valueBytes += 64 + key.length * 2;
+            serializedCharacters +=
+              jsonStringCodeUnits(key) + 1 + (count++ === 0 ? 0 : 1);
+            yield (item as Record<string, unknown>)[key];
+          }
+        })(),
+      );
+    } else {
+      valueBytes += 16;
+      serializedCharacters +=
+        typeof item === "number"
+          ? String(item).length
+          : item === true
+            ? 4
+            : item === false
+              ? 5
+              : 4;
+    }
   }
-  return bytes;
+  return { valueBytes, serializedUtf16Bytes: serializedCharacters * 2 };
 };
 
+/** Conservative parsed JSON bytes, independent of its escaped representation. */
+export const estimateJsonValueBytes = (value: unknown): number =>
+  estimateJsonStorage(value).valueBytes;
+
 /** Refuse before authentication when live heap headroom cannot hold its validation and commitment working copies. */
 export const requireAuthenticationHeadroom = (
   value: unknown,
@@ -36,11 +70,14 @@ export const requireAuthenticationHeadroom = (
     readonly description: string;
     readonly availableBytes?: number;
   },
-): Result<void, AnalysisError> => {
+): Result<void, AnalysisResourceConstraintError> => {
   const availableBytes =
     options.availableBytes ?? getHeapStatistics().total_available_size;
-  const valueBytes = estimateJsonValueBytes(value);
-  const requiredBytes = valueBytes * AUTHENTICATION_COPIES;
+  const { valueBytes, serializedUtf16Bytes } = estimateJsonStorage(value);
+  // Canonical hashing and manifest normalization can still encode scalars or
+  // metadata; account for their escaped representations before allocating them.
+  const requiredBytes =
+    (valueBytes + serializedUtf16Bytes) * AUTHENTICATION_COPIES;
   if (requiredBytes <= availableBytes) return ok(undefined);
   return err(
     new AnalysisResourceConstraintError(
@@ -50,6 +87,7 @@ export const requireAuthenticationHeadroom = (
       {
         input_path: options.path,
         projected_value_bytes: valueBytes,
+        serialized_json_utf16_bytes: serializedUtf16Bytes,
         authentication_bytes: requiredBytes,
         available_heap_bytes: availableBytes,
       },

src/application/JsonFiles.ts

@@ -52,13 +52,14 @@ export const readJsonFile = async (
   path: string,
   signal?: AbortSignal,
   resources?: ArtifactResourceScope,
+  operation = "read_evidence_file",
 ): Promise<
   Result<
     unknown,
     EvidenceFileError | AnalysisResourceConstraintError | AnalysisCancelledError
   >
 > => {
-  const read = await readJsonFileWithSource(path, signal, resources);
+  const read = await readJsonFileWithSource(path, signal, resources, operation);
   return read.ok ? ok(read.value.data) : read;
 };
 
@@ -67,6 +68,7 @@ export const readJsonFileWithSource = (
   path: string,
   signal?: AbortSignal,
   resources?: ArtifactResourceScope,
+  operation = "read_evidence_file",
 ): Promise<
   Result<
     { readonly data: unknown; readonly path: string },
@@ -78,13 +80,14 @@ export const readJsonFileWithSource = (
     async (selected) => {
       const read = await readJsonInputFile(
         selected,
-        "read_evidence_file",
+        operation,
         signal,
         resources,
       );
       return read.ok ? ok({ data: read.value, path: selected }) : read;
     },
     signal,
+    operation,
   );
 
 /** Read selected JSON members through the same regular-file error boundary. */
@@ -124,6 +127,7 @@ const readJsonFileInput = async <Value>(
     >
   >,
   signal?: AbortSignal,
+  operation = "read_evidence_file",
 ): Promise<
   Result<
     Value,
@@ -153,7 +157,7 @@ const readJsonFileInput = async <Value>(
     if (cause instanceof AnalysisResourceConstraintError) return err(cause);
     if (cause instanceof JsonInputCancellationFailure)
       return err(
-        new AnalysisCancelledError("read_evidence_file", {
+        new AnalysisCancelledError(operation, {
           cause: cause.reason,
         }),
       );
@@ -166,7 +170,7 @@ const readJsonFileInput = async <Value>(
       );
     if (isJsonReadCancellation(cause, signal))
       return err(
-        new AnalysisCancelledError("read_evidence_file", {
+        new AnalysisCancelledError(operation, {
           cause: signal?.reason,
         }),
       );

src/application/ReconstructionObligationCandidates.test.ts

@@ -35,7 +35,13 @@ import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
 import { createProcessCaptureEvidence } from "./process/ProcessEvidence.js";
 import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
 
-const applicationWithUnknowns = (keys: readonly string[]) => {
+const applicationWithUnknowns = (
+  keys: readonly string[],
+  {
+    kind = "unknown",
+    label = "Unclassified application boundary",
+  }: { kind?: "unknown" | "package"; label?: string } = {},
+) => {
   const source = createEvidence(
     undefined,
     { id: "fixture-source", name: "Fixture source", version: "1" },
@@ -50,7 +56,7 @@ const applicationWithUnknowns = (keys: readonly string[]) => {
   const base = buildSyntheticJavaScriptApplicationGraph();
   const unknownNodes = keys.map((key) =>
     createJavaScriptApplicationNode({
-      kind: "unknown",
+      kind,
       identity: {
         strategy: "artifact-local-key",
         stability: "artifact-version",
@@ -60,7 +66,7 @@ const applicationWithUnknowns = (keys: readonly string[]) => {
       },
       observations: [
         {
-          label: "Unclassified application boundary",
+          label,
           properties: {},
           evidence: artifactEvidence(
             APPLICATION_GRAPH_DIGESTS.asar,
@@ -144,6 +150,22 @@ describe("reconstruction obligation candidates", () => {
       ).toBe(false);
   });
 
+  it("falls back to a kind-based title when an application node label is blank", () => {
+    const {
+      unknownNodes: [node],
+      generated,
+    } = applicationWithUnknowns(["blank-label"], {
+      kind: "package",
+      label: " ",
+    });
+
+    expect(
+      generated.candidates.find(
+        ({ target }) => target.application_node_id === node?.node_id,
+      )?.title,
+    ).toBe("package boundary");
+  });
+
   it("does not bind an unknown process image to a packaged artifact obligation", () => {
     const scenario = parseProcessScenario({
       executable: "/path/whose-launch-identity-is-unknown",
@@ -327,3 +349,87 @@ it("keeps each semantic candidate bound to its own file and authority context",
     });
   }
 });
+
+it("falls back to a kind-based title when a semantic node label is blank", () => {
+  const contexts = new JavaScriptSemanticEvidenceContextRegistry();
+  const base = javascriptApplicationAnalysisResultSchema.parse(
+    JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.normalized_result,
+  );
+  const source = proofEvidence("blank-label-file");
+  const module = createJavaScriptSemanticGraphNode(
+    {
+      kind: "module",
+      identity: {
+        artifact_sha256: base.root_artifact_sha256,
+        module_path: "app.js",
+        source_range: null,
+        role_key: "module",
+      },
+      function_node_id: null,
+      application_node_ids: [],
+      label: "app.js",
+      properties: {},
+      evidence: artifactEvidence(base.root_artifact_sha256, "app.js"),
+    },
+    contexts,
+  );
+  const sha256 = "4".repeat(64);
+  const request = createJavaScriptSemanticGraphNode(
+    {
+      kind: "request",
+      identity: {
+        artifact_sha256: sha256,
+        module_path: "file.js",
+        source_range: {
+          start: { line: 1, column: 0 },
+          end: { line: 1, column: 8 },
+        },
+        role_key: "request-1",
+      },
+      function_node_id: null,
+      application_node_ids: [],
+      label: " ",
+      properties: {},
+      evidence: {
+        ...artifactEvidence(sha256, "file.js", "ast-static-analysis"),
+        evidence_ids: [source.evidence_id],
+      },
+    },
+    contexts,
+  );
+  const { graph_id: _graphId, ...semantic } = base.semantic_graph;
+  const semanticGraph = createJavaScriptSemanticGraph({
+    ...semantic,
+    root_node_ids: [module.node_id],
+    nodes: [module, request],
+    evidence_contexts: contexts.contexts,
+  });
+  const example = JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE;
+  const application = createEvidence(
+    {
+      path: base.input_path,
+      sha256: base.root_artifact_sha256,
+      format: base.format,
+    },
+    example.provider,
+    {
+      predicateType: example.predicate_type,
+      operation: example.operation,
+      parameters: example.parameters,
+      result: jsonValueSchema.parse({ ...base, semantic_graph: semanticGraph }),
+      confidence: "derived",
+      authority: "shipped-artifact",
+      evidenceLinks: [source.evidence_id],
+    },
+  );
+  const generated = deriveReconstructionObligationCandidates(
+    createEvidenceBundle([source, application]),
+    [],
+  );
+
+  expect(
+    generated.candidates.find(
+      ({ target }) => target.semantic_node_id === request.node_id,
+    )?.title,
+  ).toBe("request semantic boundary");
+});

src/application/ReconstructionObligationCandidates.ts

@@ -114,7 +114,7 @@ const deriveApplicationCandidates = (
         candidates,
         generatedCandidate({
           key: `application:${node.node_id}:${candidatePolicy.family}`,
-          title: node.observations[0]?.label ?? `${node.kind} boundary`,
+          title: node.observations[0]?.label?.trim() || `${node.kind} boundary`,
           policy: candidatePolicy,
           artifactSha256: source.rootArtifactSha256,
           applicationNodeId: node.node_id,
@@ -143,7 +143,7 @@ const deriveApplicationCandidates = (
           candidates,
           generatedCandidate({
             key: `semantic:${node.node_id}:${candidatePolicy.family}`,
-            title: node.label ?? `${node.kind} semantic boundary`,
+            title: node.label?.trim() || `${node.kind} semantic boundary`,
             policy: candidatePolicy,
             artifactSha256: node.identity.artifact_sha256,
             applicationNodeId: node.application_node_ids[0] ?? null,