docs(javascript): state that duplicate unmapped content stays ambiguous

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.agents/skills/reverse-engineer-anything/references/evidence-workflows.md

@@ -93,14 +93,10 @@ Use `view: {kind: "environment-state"}` with the manifest's `template_rules` to
 extract the data those reads observed instead: entity types and identity
 fields, entities with recorded values, documents, and per-tool render plans
 checked against the recordings. The state comes only from reads before the
-first related write; types, identity and list membership are inferences. The
-view also gives each state-changing tool a write plan, served only when a later
-recorded read confirms its effect and none contradicts it.
+first related write; types, identity and list membership are inferences.
 `rea environment-serve manifest.json --evidence capture.json` derives that
-state at startup, answers read tools from it, serves the write tools whose plan
-is served, each applying its effect to that state, and serves `data/reset`,
-`data/add` and `data/get` on `/agentenv`; other write tools are not served, and
-each plan states why in its `reason`. It replays the capture instead with
-`--replay-only` or when the state is unavailable (not derivable, or a catalog
-over the discovery budget), and its stopped document's `state` says which
-applied.
+state at startup, answers read tools from it and serves `data/reset`,
+`data/add` and `data/get` on `/agentenv`; write tools are not served. It
+replays the capture instead with `--replay-only` or when the state is
+unavailable (not derivable, or a catalog over the discovery budget), and its
+stopped document's `state` says which applied.

.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 is fixed at 16 MiB / 16777216 bytes for this
+release and has no runtime override. `source_paths`, `detail`, and
+`max_heap_mb` do not bypass or raise it. Analyze an extracted directory, or
+supply an archive whose header fits.
+
 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

docs/agent-environments.md

@@ -5,8 +5,7 @@ environment: an MCP server whose tools answer from what one retained web
 network capture observed, plus the environment card the agentenv framework
 reads to discover it. By default the server derives the
 [state the capture observed](#the-state-a-capture-observed) at startup and
-answers read tools from it, and the write tools whose effect the capture
-confirmed by changing it; `--replay-only` replays the capture's records
+answers read tools from it; `--replay-only` replays the capture's records
 instead. Nothing is fetched from the recorded application; every answer comes
 from retained Evidence. `rea environment-export` writes the same pair as a
 bundle folder `agent-env run` builds and runs; see
@@ -272,11 +271,11 @@ document, with the same signal exit status.
 
 Three routes are served:
 
-| Route                             | Answer                                                                                                                                                                                                                                              |
-| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `POST /mcp`                       | The MCP server: from the state, one tool per read tool, answering from the state where it backs them, and one per write tool whose effect the capture confirmed, applying it to the state; in replay, one tool per manifest tool, replaying records |
-| `GET /.well-known/agent-env.json` | The environment card                                                                                                                                                                                                                                |
-| `POST /agentenv`                  | From the state, `data/reset`, `data/add` and `data/get`; in replay, JSON-RPC `-32601 method not found: <method>` for every method                                                                                                                   |
+| Route                             | Answer                                                                                                                                                         |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `POST /mcp`                       | The MCP server: from the state, one tool per read tool, answering from the state where it backs them; in replay, one tool per manifest tool, replaying records |
+| `GET /.well-known/agent-env.json` | The environment card                                                                                                                                           |
+| `POST /agentenv`                  | From the state, `data/reset`, `data/add` and `data/get`; in replay, JSON-RPC `-32601 method not found: <method>` for every method                              |
 
 Numeric JSON-RPC IDs outside JavaScript's safe range or whose precision would
 be lost are refused as invalid requests with a null ID. They are never echoed
@@ -377,11 +376,8 @@ In replay, `extensions`, `operations` and `children_environments` are fixed to
 `null`, `[]` and `null`: a replay environment declares no extensions, no
 data-plane operations and no children. Served
 [from the state](#serve-from-the-state), the card declares the three data-plane
-operations and one intake extension instead, and the catalog holds the read
-tools and only the write tools whose effect the capture confirmed: a read tool
-is described as answering from the state where the state backs it, and a
-served write tool by the effect it applies to the state and the body members it
-accepts.
+operations and one intake extension instead, leaves write tools out and
+describes each tool as answering from the state where the state backs it.
 
 ## Serve from the state
 
@@ -404,8 +400,7 @@ A state that is unavailable does not stop the server: it logs a warning naming
 the error `code` and message before it binds, then serves replay. The state is
 unavailable when it cannot be derived, such as from a
 `capture_browser_scenario` capture that selected header values but no response
-bodies or over the view's budget, when `data/get` would write it past the 32 MiB
-`data/add` intake limit, and when its catalog under the served name
+bodies or over the view's budget, and when its catalog under the served name
 exceeds the [discovery reservation](#what-a-manifest-is). That check runs
 first, so no state is derived for it, and replay is then admitted exactly as
 with `--replay-only`. `--replay-only`
@@ -422,53 +417,26 @@ member reports which applied:
 
 Each read tool answers according to its view in the state:
 
-| View       | Answer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `item`     | The entity the path arguments name, rendered into the recorded envelope of `envelope_ordinal`. Arguments match as replay matches them: each collection segment equals the held collection's segment as written or after percent-decoding, and the identity is the last argument percent-decoded, then as written; values are never re-split on `/`. Any entity the state holds answers, including one `data/add` loaded; query arguments only decide `replay.exact_match`. An entity the state does not hold answers the tool's latest recorded 400, 404 or 410 response with `state.view` `missing`, or is a tool error when none was recorded; one lacking a field every recording carried is a tool error; a body is never invented. |
-| `list`     | When the arguments name one of the lines the view checked exactly (its latest recordings before the first related write; every path and query value equal to the recording's, and every recorded query parameter supplied), that recorded envelope with its array rendered from the state: every entity of the collection in state order for `membership: "all"`, or the recorded members still held. A call with no query argument to a `membership: "all"` view answers from a checked line of the collection its path arguments name that only pages its list, with `replay.exact_match` false. A member lacking a field every recording carried makes the call a tool error rather than a partial list.                             |
-| `document` | When the arguments name the document's checked line exactly, the state's value for it; a tool error when the state holds none.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `recorded` | The recording, as replay answers it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| View       | Answer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `item`     | The entity the path arguments name, rendered into the recorded envelope of `envelope_ordinal`. Arguments match as replay matches them: each collection segment equals the held collection's segment as written or after percent-decoding, and the identity is the last argument percent-decoded, then as written; values are never re-split on `/`. Any entity the state holds answers, including one `data/add` loaded; query arguments only decide `replay.exact_match`. An entity the state does not hold, or one lacking a field every recording carried, is a tool error; a body is never invented. |
+| `list`     | When the arguments name one of the lines the view checked exactly (its latest recordings before the first related write; every path and query value equal to the recording's, and every recorded query parameter supplied), that recorded envelope with its array rendered from the state: every entity of the collection in state order for `membership: "all"`, or the recorded members still held. A member lacking a field every recording carried makes the call a tool error rather than a partial list.                                                                                           |
+| `document` | When the arguments name the document's checked line exactly, the state's value for it; a tool error when the state holds none.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `recorded` | The recording, as replay answers it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 
 A list or document call that names no checked line, including a line recorded
 after a write or with other query values, answers from the recording. Every
 answer has the replay shape plus `state`: `{"source": "state", "view": …}`
 naming the entity, collection or document path, or `{"source": "recording",
-"reason": …}` with the view's reason, `no-view`, `unrecorded-request` or `page-exceeded` (a call naming a page of a whole list that the collection has outgrown). A
+"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. Query `POST`s
-stay served and answer from their recordings with the reason `query-body`.
-
-`POST`, `PUT`, `PATCH` and `DELETE` tools are served only when the state's
-[write plan](web-network-captures.md#environment-state) for them is served:
-the capture's later reads confirmed the effect the plan models. Other write
-tools are not served, so no call claims a change it does not make; each one's
-plan states why in its `reason`. A served write changes the live state, which
-every MCP session and `data/get` then see:
-
-| Effect     | Call                                                                                                                                                                                                                                 |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `create`   | Adds an entity to the collection the path names, built from the observed entity with each ruled field taken from the call or generated, at the plan's `insert` position. A plan tied to its exemplar's collection writes only there. |
-| `update`   | Sets the sent members on the entity the path names, constants for members accepted only with their recorded value, and the clock, increment and slug changes the plan models.                                                        |
-| `delete`   | Removes the entity the path names.                                                                                                                                                                                                   |
-| `document` | Merges the body into the plan's document object, or replaces it for `PUT`.                                                                                                                                                           |
-
-Its answer has the status and content type of the plan's recorded response,
-with the written entity or its identity rendered in, no body, or the recorded
-body. A call whose body is not an object, sends a member the capture did not
-show stored, sends a fixed member with another value or a member of another
-JSON type, or lacks a required member is a tool error naming the accepted
-members; so is a rendered answer missing a field the recorded response
-carried, and an update or delete of an entity the state does not hold answers
-the recorded 400, 404 or 410 of the tool or of an item view of the type, if
-any. A refused call leaves the state unchanged. Values a write generates are
-deterministic: the clock starts at `write_clock` and advances one second per
-served write, sequences take one past both the largest held value and the
-largest they generated, and UUIDs and tokens derive from the state Evidence
-id, tool, field and write count, skipping held values. `data/reset` and
-`data/add` restart the clock, counter and sequences, so the same calls after a
-reset give the same state. Answers carry `state: {"source": "state", "view":
-"create" | "update" | "delete", …}` or `"document-write"`.
+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`.
 
 The data plane serves three JSON-RPC methods:
 
@@ -508,6 +476,12 @@ are answered `-32000` with `error.data.reason` `cancelled` without running. A
 cancelled call leaves the state unchanged, and shutdown never waits for a
 download.
 
+A `file://` state file whose close fails stays owned by the server, and
+the `data/add` gets `-32000`. The next `file://` load retries that close first
+and, while it still fails, answers `-32000` without reading another file;
+inline and `https://` documents still load. Closing the server retries it once
+more and fails with the unfinished close rather than dropping the descriptor.
+
 One `/agentenv` response carries at most 64 MiB of replies, twice the 32 MiB
 a loaded document may hold: room for a `data/get` of a loaded state, while a
 batch of reads cannot multiply a large state into one body. Replies are
@@ -591,17 +565,14 @@ The card declares the operations and what `data/add` accepts:
 }
 ```
 
-The state starts as a projection of recorded reads and changes only through
-served write tools and the data plane. List and document calls answer from the
-state only for the lines their views checked, and every recorded view answers
-from recordings; item calls answer for any held entity but render only the
-envelope one recording carried. Values copied outside entity objects, derived
-values and counters other than those that count a list stay as recorded, and a
-served write changes only the one entity or document it writes: side effects
-on counters, relations and copies of entities in other collections, reordering
-after an update and referential rules on delete are not modelled. An exported
-bundle carries no state file: its server derives the state at startup, as the
-export does to predict what it serves.
+The state is a projection of recorded reads. List and document calls answer
+from the state only for the lines their views checked, and every recorded view
+answers from recordings; item calls answer for any held entity but render only
+the envelope one recording carried. Values copied outside entity objects,
+derived values and counters other than those that count a list stay as
+recorded; no write has an effect. An exported bundle carries no state file:
+its server derives the state at startup, as the export does to predict what it
+serves.
 
 ## Export a bundle
 
@@ -669,8 +640,8 @@ name from Python sources the image does not have.
 
 `verify.py` is the framework's `async def verify(mcp_url)` shape over its
 Python MCP client: it lists the tools and checks the count equals the number
-the bundle serves (from the state, the manifest's read tools and the write
-tools whose effect the capture confirmed; every manifest tool in replay), calls one tool with no arguments and checks the call did not
+the bundle serves (the manifest's read tools from the state, every manifest
+tool in replay), calls one tool with no arguments and checks the call did not
 fail and its `status` is the expected one, and returns one `serve` result
 whose description reports both checks. The tool is the first served `GET` tool
 without path parameters whose answer to no arguments is not an error, and the
@@ -688,9 +659,8 @@ The README written into the bundle records the capture artifact's SHA-256, the
 capture and manifest Evidence ids, the manifest view digest, the served tool
 count, the derived state's Evidence id or that no state is served, and the
 package source. It says what the environment serves: read tools from the state
-the capture observed, the `/agentenv` data plane on it and the write tools
-whose effect the capture's later reads confirmed, replay when the state is
-unavailable, and `--replay-only` for pure replay; it
+the capture observed, the `/agentenv` data plane on it and no write tools yet,
+replay when the state is unavailable, and `--replay-only` for pure replay; it
 says which applies to this bundle, with the error code and message when the
 state is unavailable, and that neither is emulation and served
 content is untrusted data. It states that the recorded content belongs to the

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
@@ -279,7 +289,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
 
@@ -399,8 +414,7 @@ evidence file's `evidence_id`; otherwise the command refuses with
 `invalid_request` before binding. Before binding it derives the
 `environment-state` view of the capture with the manifest's `template_rules`,
 as `inspect-analysis-view` would, and serves from it: read tools whose views
-are state-backed answer from a live state, write tools are served only where
-the capture's later reads confirmed their effect, and
+are state-backed answer from a live state, write tools are not served, and
 `/agentenv` serves `data/reset`, `data/add` and `data/get`. When the state
 cannot be derived, or its catalog exceeds the discovery reservation, it logs a
 warning with the error code and message and serves replay; `--replay-only` serves replay without deriving. In replay every

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
+fixed 16 MiB / 16777216 byte budget used by static ASAR reads. This release has
+no runtime override. 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 16 MiB of already-admitted encoded headers across
+eight archives. Evicting that cache does not raise admission.

docs/javascript-artifact-reconstruction.md

@@ -106,6 +106,15 @@ 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 is a fixed 16 MiB / 16777216 bytes for this
+release. There is no runtime override. 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 that allowance, the failure names this budget.
+Analyze an extracted application directory, which does not admit an ASAR
+header, or supply an archive whose header fits. Repeating the unchanged
+request fails the same way.
+
 ## Read the analysis
 
 `analyze_javascript_application` returns the complete analysis Evidence by
@@ -172,7 +181,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
 

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
 

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

@@ -18,10 +18,13 @@ tool, view kind, provider, network activity or write effect.
   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`. 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`
-  or `body-unusable`, the unreachable `not-entity` reason leaves the result
+  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
@@ -80,8 +83,10 @@ 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, non-JSON bodies
-and the catalog budget; the in-process and compiled MCP servers advertise the
+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

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

@@ -110,3 +110,14 @@ 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/specs/agent-environments/state-serve/spec.md

@@ -90,6 +90,10 @@ this increment: write tools are not served from the state.
   download in progress ends with reason `cancelled`, queued calls are answered
   `-32000` with reason `cancelled` without running, and a `data/add` whose
   file read finished after the cancellation does not replace the state.
+- A `file://` read whose descriptor close fails answers `-32000` and keeps the
+  descriptor in a server-lifetime owner. The next file read retries the close
+  first and, while it still fails, answers `-32000` without opening the file.
+  `close` retries it again and rejects while it is still open.
 - Bound one `/agentenv` response to 64 MiB of replies (twice the intake
   limit). Each reply is measured in bounded JSON parts as it is produced, in
   message order, and assembled only when it fits, so a reply past the budget is
@@ -172,7 +176,8 @@ host or a UNC path, injected https downloads (status, declared and streamed
 size, the timeout whether or not the fetcher honours its signal), the default
 fetch's refused redirects, arrival-order application across requests, a batch
 another request's reset cannot split, cancellation by the server's stop and by
-a departed caller, a server that closes while a download is stalled, the
+a departed caller, a server that closes while a download is stalled, a
+retained state-file close that the next file read and `close` retry, the
 response budget, batches and notifications, the card declaration, absent write
 tools, a served query `POST`, the per-mode discovery reservation and a
 `data/add` that changes the next tool answer over MCP. The mcp-boundary tests serve the state the

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

@@ -44,6 +44,13 @@ The review fixes are covered by these tests, all passing in the runs above:
   unchanged. Over loopback HTTP, `close()` of a served state returned while a
   download that never answers was in progress, and that download's signal was
   aborted.
+- File closes: with an injected close failure, `data/add` of a `file://` uri
+  answered `-32000` without echoing the uri. The descriptor stayed open, and
+  the next file load closed it before loading. While the close kept failing,
+  over loopback HTTP the next file load answered `-32000` ("still open") and
+  an inline `data` part still loaded. `close()` rejected with the unfinished
+  close, then resolved and closed the descriptor once the close succeeded.
+  Both tests fail on the previous head, which dropped the descriptor.
 - File hosts: `file://remote.example.test/...` and
   `file:////remote.example.test/...` are refused with the network-share
   message and no failure category; a `file://localhost/...` uri loads.

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

@@ -1,45 +0,0 @@
-# Implementation plan
-
-The branch builds on the state-serving and coverage branches (merged into it).
-
-1. **Write plan types and request bodies.** Add the plan, rule and reason types
-   beside the state rules, and have the state accumulator lend extraction
-   parsed request bodies under the same budget, admitted like response bodies.
-2. **Field rules.** Add a module that explains an observed entity against the
-   call that wrote it (echo, copy, path, slug, clock, sequence, unique,
-   template and constant) and that recognises and formats clock values,
-   UUIDs and tokens.
-3. **Effects.** Add one apply module that both the gate and the server use. It
-   applies a create, update, delete or document write to a writable state
-   interface from a plan, a call and a value source: the recorded values in
-   the gate, the store's generators when served.
-4. **Gate.** Add a simulation that:
-   - classifies every write tool;
-   - builds each plan from its exemplar;
-   - walks the timeline over a copy of the initial state;
-   - checks state-answered reads;
-   - attributes passes and mismatches;
-   - learns the insert rule;
-   - records verdicts.
-
-   Extraction runs it after the read gate and returns `writes` and
-   `write_clock`; the view schema and its unknowns state the write model.
-
-5. **Serving.**
-   - The loaded state carries the plans and the clock.
-   - The store gains atomic mutations, the clock and the counter (all reset by
-     `data/reset` and `data/add`).
-   - A write answer module validates the body, applies the effect and renders
-     the response.
-   - Item reads of missing entities answer recorded 404s.
-   - The served catalog adds served write tools, with descriptions charged to
-     the discovery budget.
-6. **Export.** Count served write tools in the bundle plan and README.
-7. **Tests.** Domain, services, adapters and MCP-boundary coverage as the
-   spec's acceptance lists.
-8. **Documentation.** Document the write model in the environment-state and
-   serving sections, and record the real-capture results, the AgentEnv run
-   and the live comparison in `verification.md`.
-
-There are no dependency, provider or REA tool contract changes beyond the
-`environment-state` result members, and no new network activity.

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

@@ -1,406 +0,0 @@
-# Apply write effects to the served state
-
-Issue: https://github.com/morluto/rea/issues/4933
-
-## Outcome
-
-An environment served from its state also serves the write tools whose effects
-the capture itself confirms:
-
-- a create adds an entity;
-- an update changes the fields the call sends;
-- a delete removes the entity;
-- a document write changes a document.
-
-Later reads, list membership and `data/get` show the change, and `data/reset`
-undoes it.
-
-The `environment-state` view decides which write tools are served. It replays
-the capture's own timeline on the extracted initial state: each recorded write
-applies its modelled effect, and each later read that the state answers is
-rendered and compared with the recorded response. A write tool is served only
-when at least one later read reproduces after its effect and none contradicts
-it. Every other write tool stays unserved, listed with the reason.
-
-Values the application generates are deterministic: identities, sequences and
-clock values follow the formats the capture recorded, so the same calls after
-a reset give the same state.
-
-## Write plans
-
-The view adds two members to its result:
-
-- `writes`: one plan per manifest tool whose method may change state
-  (`changesState`);
-- `write_clock`: the instant the served clock starts from.
-
-**Effects.** Each plan classifies its tool:
-
-| Effect     | Tool                                                                  | Target                    |
-| ---------- | --------------------------------------------------------------------- | ------------------------- |
-| `create`   | `POST` to a state type's `collection_template`                        | an entity of that type    |
-| `update`   | `PUT`, `PATCH` or `POST` to that template plus one trailing parameter | the entity the path names |
-| `delete`   | `DELETE` to that same item template                                   | the entity the path names |
-| `document` | `PUT`, `PATCH` or `POST` to a document view's path                    | that document             |
-| `none`     | anything else                                                         | reason `no-state-target`  |
-
-**Exemplar.** A plan is built from its first successful (2xx) recorded call,
-the exemplar.
-
-- **Request body.** The exemplar's request body must be a JSON object that
-  could enter the state: a JSON-like media type, complete UTF-8 text within
-  256 KiB, exact numbers, no `__proto__` member. Otherwise the reason is
-  `body-unusable`. A `DELETE` takes no body.
-- **The written entity.** The entity is observed in the exemplar's response,
-  located by its identity value at the root, in one member, or in a
-  one-element array, as item views locate it. When the response does not carry
-  it, the entity is observed in the first later read that shows it: an item
-  read of that entity, or for a create, the one entity a collection read newly
-  lists. A create whose response names its id alone (a scalar, the identity
-  field, or one member) is observed only through a read of that id. With
-  neither, the reason is `no-observation`.
-
-**Field rules for creates.** Each field of the observed entity gets the first
-rule that explains its value. Rules that read the call come first, so an
-identity the client sends is an echo:
-
-1. **Echo.** A body member of the same name with an equal value.
-2. **Copy.** A body string of 8 or more characters, found at a JSON pointer of
-   the body (the shallowest match).
-3. **Path.** The value of a path parameter of the call, percent-decoded.
-   Serving decodes it from the collection the call names, whichever spelling
-   the call uses.
-4. **Slug.** The slug of a body string member: lower case, runs of other
-   characters joined by `-`.
-5. **Identity.** The type's `id_field` is generated. A sequence when it is an
-   integer (or a string of digits); otherwise a UUID when it has the
-   `8-4-4-4-12` hex shape; otherwise a token of the same length and character
-   classes.
-6. **Clock.** A timestamp within 10 minutes of the exemplar's start time. The
-   format is kept: ISO-8601 with its separator, fraction digits and zone, or
-   epoch seconds or milliseconds.
-7. **Sequence.** An integer one greater than the largest value of the field in
-   the collection, else in the type.
-8. **Unique.** A UUID-shaped string that no other entity of the type shares.
-9. **Template.** A string containing a generated value as a delimited token
-   (for example a URL that ends in the new id). It is rebuilt around the new
-   value.
-10. **Constant.** Otherwise the exemplar's value.
-
-When a constant, or the text a template keeps, contains a path value of the
-exemplar's call as a delimited token, the create is served only for calls
-naming the exemplar's collection.
-
-**Body members of a create.** A member is either accepted or not:
-
-- **Accepted.** An echoed member, or the identity field's value. Every member
-  the exemplar sent is required.
-- **Not accepted.** A member the application stored with a different value
-  (transformed), or one it did not show. A call that sends such a member is a
-  tool error naming the accepted members.
-
-**Updates.** Body members follow the same accepted and not-accepted rules,
-except that a member the application stored differently is accepted only with
-the value a recorded call sent it with, and then stores the value that call
-recorded (its `constant` rule carries it). The type's identity field never
-takes a rule: sent as the path's id it is the identity member, sent as another
-value the application ignored it is accepted with that value and stores
-nothing, and a stored id that changed is `unexplained-change`. A plan whose
-calls use a member both as the identity and as a fixed member, or fix it at
-different values, is `unexplained-change`, as serving could not take every
-recorded call. So is an update a later read shows dropped a field the
-entity held, since serving keeps every field an update does not write; a write's
-own response may leave fields out.
-`PUT` requires every member the exemplar sent; `PATCH` and `POST` require at
-least one. A field the exemplar's update changed without sending it is
-explained as one of:
-
-- clock;
-- an increment by one;
-- a slug of an echoed member.
-
-Any other change is `unexplained-change`. An increment or a slug applies to
-every call that could take it, so the plan is also `unexplained-change` when
-such a rule would give a call of the tool another value than the one it
-recorded, or when a later call treats a member otherwise than the plan: one
-call echoes it and another stores something else, or the two rule it
-differently.
-
-**Deletes.** A delete removes the entity. Its response is the exemplar's
-response, with the entity re-rendered when the response carries it.
-
-**Documents.** A document write merges the body's members (replaces them, for
-`PUT`) into the document object that holds most of them: the root or one
-member. Later calls write at the exemplar's object. Document reads answer only on their recorded line, so a write is
-served only at the path the state holds the document at, and the gate treats a
-recorded write at another path as an unmodelled write. A recorded write whose
-body serving would refuse (a member of another JSON type than the document
-holds) is `unexplained-change`.
-
-**Responses.** A write answers with the status and content type of one
-recorded response:
-
-| Response   | Body                                                                                                      |
-| ---------- | --------------------------------------------------------------------------------------------------------- |
-| `entity`   | the written entity, rendered into the recorded envelope at the plan's pointer through the recorded fields |
-| `identity` | the recorded body with the new identity at the plan's pointer                                             |
-| `empty`    | no body                                                                                                   |
-| `recorded` | the recorded body                                                                                         |
-
-A rendered body missing a field the recorded response carried is a tool error,
-and the state is left unchanged.
-
-**List position.** A create's `insert` rule places the new entity in its
-collection's order: sorted by the identity field or a clock field (ascending
-or descending), `first` or `last`. The rule is the first candidate consistent
-with both the initial `all`-membership recordings and the position a later
-recorded list shows. With no evidence, the rule is `last`.
-
-## The gate
-
-The view replays every primary-origin record in timeline order on a copy of
-the initial state.
-
-**Writes.** Only a 2xx write is modelled. A modelled write applies its effect, using the values it recorded
-for generated fields and the stored values for fields it transformed. A
-modelled write whose call the plan does not explain brings its entity to the
-recorded outcome instead, without attribution. A later create whose generated
-values take another form than serving gives them (a sequence value out of
-order, a clock in another format, a non-UUID unique value) makes the plan
-`unexplained-change`; integer identities are left to the id mapping. An update or
-delete names its entity as an item read does (below).
-
-Any other write that may have changed state, including a redirected or
-unanswered one, is unmodelled, and what it may have changed
-depends on where its path lies relative to each type's collection paths
-(segment-prefix related, parameters matching any segment):
-
-- **Below an item path:** the named entity is unknown until a read shows it
-  again. When the path names no held entity, every entity of that collection
-  is unknown.
-- **At a collection path:** that collection is not checked again.
-- **Above collection paths:** everything under the path is not checked again.
-
-An item read of an unknown entity shows it again: the copy takes its recorded
-values. Writes that changed it since its last check are checked only on the
-members they sent.
-
-**Reads.** A read is checked when the served environment would answer it
-from the state:
-
-- an item read of a state-backed item view, of the entity serving would name:
-  in a held collection the read's path matches, each segment verbatim or once
-  percent-decoded and verbatim spellings first, the id percent-decoded once,
-  then as written;
-- a list or document read on one of its view's checked request lines,
-  chosen as replay chooses the line for the read's call: each path parameter
-  the read's value verbatim or once percent-decoded, preferring verbatim
-  spellings, then recorded order, and the query values decoded, in any order.
-  A read with no query on a whole list falls back, as serving does, on a
-  checked line that only pages it. A line whose query repeats a name with
-  different values is never chosen, since no call's arguments can name it; one
-  repeating a name with one value is, as a call naming it matches both. A list
-  is compared as served from the collection of that line. A read on a page
-  (`limit`, `size`, `per_page` and the like, or a `_start`–`_end` range; a size
-  of zero is no bound on a line whose recording listed items under it, while its
-  other sizes and range still bound the page) of a
-  whole list checks nothing once the collection holds more entities than the
-  page, which serving then answers from its recording.
-- A read made while a modelled write to its entity or collection was still
-  running, starting before that write ended, checks nothing: it may show the
-  state before or after the write. Nor does such a read show an unknown entity
-  again.
-- A read a write's effect was learned from checks nothing of that write, but
-  still contradicts the other writes it exercises.
-
-**Comparison.** The read's answer is the full response serving would give from
-the copy: an item read's entity rendered into its item view's base recording,
-or a list read's members as serving would list them (so a member the copy no
-longer holds fails the check) rendered into its line's base recording. It is
-compared with the recording, as the read gate compares, with volatile fields taking the
-observed values. A recorded 400, 404 or 410, or a 2xx with a JSON `null`
-body, for an entity the copy does not hold agrees with it. A successful read
-whose usable body no longer holds the entity or the list fails, as does one of
-an entity lacking a field every recording of its view carried, which serving
-refuses to answer with.
-
-**Attribution.**
-
-- A check exercises the write tools that changed its entity or collection
-  since the previous check of it, less those whose effect later writes erased.
-  An update's effect is the fields it sent or changed, derived ones included.
-  A later update overwrites the fields it sets (an increment adds to its field
-  instead), a recorded outcome every field, and a create or delete the whole
-  entity. A document write's effect is the members it merged at its
-  object, or everything under the object it replaces, the whole document at the
-  root; an entity's fields match by name only, whatever their names look like. A write with nothing left on an entity no
-  longer counts there, nor in a collection where no entity it changed keeps any
-  of its effect. A mismatch contradicts them. A pass confirms those it shows
-  something of: a create's or delete's membership, or a changed field the
-  read's view shows and does not treat as volatile; a read that shows none of
-  an update's changes confirms nothing of it, and leaves it for a later check
-  of that entity or collection.
-- A mismatch contradicts each exercised write that no unmodelled write came
-  after its latest call on any of the read's entities or collections where its
-  effect survives, whatever earlier write is still pending. An item read checks the writes an unmodelled
-  write did follow only on the members they sent, and a list with such a write
-  is not checked again: the unmodelled write may explain the rest.
-- A mismatch on an entity or collection that no write changed contradicts,
-  as `side-effect`, the modelled writes since that previous check whose paths
-  are segment-prefix related to the read's path.
-- After a failed item check, the copy takes the read's recorded values (or
-  drops the entity on a recorded absence). A list whose check failed is not
-  checked again.
-- A list that fails only for where one create placed its entity passes when
-  another of that create's insert candidates reproduces it, which then
-  becomes the plan's rule, unless an earlier list check relied on the rule
-  (an item read's confirmation does not fix it).
-- The read that supplied a create's or update's observation does not check
-  it, but checks the other writes it exercises.
-
-**Verdicts.** A plan is served when at least one check confirms it and none
-contradicts it. Otherwise the reason, in this precedence, is:
-
-1. the first build reason;
-2. `contradicted`, with `contradicted_by` naming the first contradicting read;
-3. `side-effect`;
-4. `unconfirmed`;
-5. `incomplete-entities`: an update or delete that answers with the entity,
-   when no initial entity holds every field its recorded answer shows (for
-   example a delete that answers with an edit view of the entity the reads
-   never showed), so it could answer only for entities the environment itself
-   created.
-
-`checked_record_ordinals` lists the confirming reads.
-
-## Serving
-
-**Catalog.** In state mode, the catalog adds the write tools whose plan is
-served. Their descriptions say the tool:
-
-- applies its effect to the served state;
-- names its target type;
-- lists its required and accepted body members.
-
-The discovery budget charges them. `--replay-only` and the replay fallback are
-unchanged.
-
-**Calls.** A served write answers synchronously against the live store and
-changes it atomically, so every MCP session and `data/get` see one state.
-
-**Refusals.** These are tool errors that leave the state unchanged:
-
-- a body that is not an object;
-- a missing required member;
-- a member that is not accepted;
-- a value of another JSON type than the exemplar's, for documents as well as
-  entities;
-- an update or delete of an entity the state does not hold;
-- a create in another collection when the plan is tied to its own;
-- a document write at a path other than the one the state holds it at;
-- a body member or a resulting value `data/add` would refuse (a number not
-  exact as `data/get` writes it, a `__proto__` member, nesting past the
-  limit), increments included, so `data/get` always loads back;
-- a create, update or document write that would take what `data/get` reports
-  past the 32 MiB `data/add` intake limit, as a `resource_constraint` error;
-- a rendered response missing a recorded field.
-
-When the tool, or else an item view of the type, recorded a 400, 404 or 410
-response, an update or delete of a missing entity answers with the latest such
-recording instead.
-
-A create in a collection held under more than one spelling (`acme1` and
-`%61cme1`) goes to the one the call spells verbatim, as item calls choose their
-entity; a collection keeps its spelling after its last entity is deleted. A
-reset or load knows the spellings of the Evidence's state, of the state it
-installs and of the type's checked list lines (so a collection the capture
-listed empty keeps its spelling), never those of a state it replaced. When two
-spellings fit a call equally, the one holding entities wins. `data/add` refuses a document that `data/get` would write back past the
-32 MiB intake limit once it adds the members a document may omit, such as
-`types` and the state Evidence id. A derived state `data/get` would write
-past that limit is not served: the environment serves replay and reports the
-state `unavailable`.
-
-**Clock and generators.** The store's clock starts at `write_clock` and
-advances one second before each served write; clock fields take its value in
-their recorded format.
-
-- **Sequences:** one more than the largest current value in their scope, the
-  largest the state started with at its last reset or load, and the largest
-  value they generated, so a deleted entity's value is not reused, as database
-  sequences do not reuse values.
-- **UUIDs and tokens:** derived from a SHA-256 of the state Evidence id, the
-  tool, the field and a write counter, skipping values the type already holds.
-
-`data/reset` and `data/add` restart the clock, the counter and the
-sequences.
-
-**Missing entities.** An item read of an entity the state does not hold
-answers with the tool's latest recorded 400, 404 or 410 response, or 2xx JSON
-`null` response, the absences the gate accepts, when it has one, labelled
-`state.view: "missing"`. Otherwise it stays a tool error.
-
-**Lists of a whole collection.** Written entities matter only if lists show
-them, so the read gate's `membership: "all"` also covers a line that only pages
-its list (`limit`, `offset`, `page`, `per_page`, `perpage`, `page_size`,
-`pagesize`, `size`, `start`, `_start`, `_end`) when its recording listed the
-whole collection. A list call with no query argument answers from such a line
-of an `all` view of the collection its path arguments name, with
-`replay.exact_match` false; a collection with no such line answers from its
-recording. A call that asks for a page
-still answers from its recording.
-
-**Provenance.** Write answers carry `state: {source: "state", view: "create" |
-"update" | "delete", type, collection, id}`, or `{source: "state", view:
-"document-write", path}`.
-
-**Data plane and export.**
-
-- `data/get` reports written entities without record citations; they load
-  back through `data/add` unchanged.
-- `environment-export` counts served write tools in the bundle's tool count
-  and README. Its check stays a read tool.
-
-## Not modelled
-
-These stay unserved, or are labelled in the description:
-
-- side effects on counters, relations and copies of entities in other
-  collections;
-- inputs the application transforms;
-- members the capture never sent;
-- reordering after an update;
-- membership of filtered or paged lists, which answer their recorded members;
-- write paths the manifest left literal;
-- writes whose request body the capture did not retain;
-- referential rules on delete: a delete removes the entity alone, so an
-  application that refuses to delete a referenced entity, or deletes its
-  dependents with it, is not modelled;
-- authorization.
-
-## Acceptance
-
-- **Domain tests:** classification, every field rule, request-body admission,
-  observation from a later read, the insert rules, every verdict and reason,
-  attribution and resynchronisation, and taint by an unmodelled write.
-- **Services tests:**
-  - store mutations and their atomicity;
-  - every refusal;
-  - generated values and their determinism across reset;
-  - `data/get` round trips of written entities;
-  - the recorded 404 for missing entities;
-  - the catalog and descriptions in each mode.
-- **Boundary test:** a write tool changes the next read over MCP.
-
-**Real captures.**
-
-- The view runs over every showcase capture within its budget, and the
-  verification reports, per capture, the write tools served and the reasons
-  for the rest.
-- One environment, chosen at random among those serving a write tool, is
-  exported, run in the AgentEnv framework, and graded from `data/get` after an
-  agent's create, update and delete.
-- The served model is compared with that application running live on the same
-  calls.
-
-No test reaches an external network.

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

@@ -1,22 +0,0 @@
-# Tasks
-
-- [x] Record the write model, the gate and the serving contract.
-- [x] Admit request bodies and add the plan types.
-- [x] Explain created and updated entities with field rules.
-- [x] Apply create, update, delete and document effects in one shared module.
-- [x] Simulate the capture's timeline and decide each plan's verdict.
-- [x] Leave entities below an unmodelled write unknown until a read shows them
-      again, and check writes such a write follows only on the members they
-      sent.
-- [x] Serve gated write tools from the live store with deterministic values.
-- [x] Answer recorded 400, 404 and 410 responses for missing entities.
-- [x] Let lines that only page a whole collection back `membership: "all"`,
-      and answer argument-less list calls from them.
-- [x] Count served write tools in exports and describe them in bundle READMEs.
-- [x] Add domain, services, adapters and boundary coverage.
-- [x] Document the write model and serving.
-- [x] Run the view over every showcase capture and report per-capture verdicts.
-- [x] Export one randomly chosen environment, run write tasks in the AgentEnv
-      framework and grade them from `data/get`.
-- [x] Compare the served model with the live application on the same calls.
-- [x] Run static, formatting, duplication, documentation and test gates.

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

@@ -1,360 +0,0 @@
-# Verification
-
-Verified base: cbb7b613 (this branch before this file). Executed on macOS with
-Node v22.23.1 (the repository pins 24.18.0 in `.nvmrc`, which was not
-installed); the AgentEnv runs and the live comparison ran on a disposable Linux
-VM. Every check below ran as written after the last source change.
-
-## Gates
-
-- `npm run build:cached`, `npm run check:fast` (typecheck and lint),
-  `npm run format:check`, `npx knip`, `npm run scan:todos`, `npm run docs:check`
-  and `npm run verify:test-discovery`: passed.
-- `npm run jscpd`: 3.43% duplicated lines over 3538 files, under the 3.5% gate.
-- `npx vitest run --project domain --project services`: 7407 passed, 5
-  pre-existing skips.
-- `npm run test:prepare`, then `npm run test:focused --` the new write MCP
-  boundary, the serve MCP, CLI and process boundaries, the export CLI
-  boundary, the analysis-view CLI and MCP boundaries, the compact input schema
-  boundary and the contract description tests: 10 files, 72 passed.
-- `npm run mcp-catalog:check`: passed.
-
-New tests: `environmentStateWriteValues` (94), `environmentStateWriteExplain`
-(101), `environmentStateWriteApply` (52), `environmentStateWrites` (16, the gate
-through the view), `environmentStateWriteAnswer` (14, serving) and
-`environmentServeWritesMcp` (1, the built CLI over MCP). The replay card pinned
-by the serve MCP boundary changed with the response summaries tool descriptions
-carry; its digest now matches the combined branch.
-
-## Real captures
-
-The `environment-state` view ran over the 50 showcase captures (45 HAR
-inspections and 5 `capture_browser_scenario` captures), each within its budget in
-8–110 ms. It served 33 write tools in 16 captures (11 creates, 12 updates, 10
-deletes). Of the other 150 state-changing tools, 102 name no state type or
-document (most write to literal single-entity paths the manifest left
-untemplated, or to collections whose reads are not state-backed), and 48 are
-modelled but not served:
-
-- 15 unconfirmed (no later read checked them);
-- 13 no-observation;
-- 8 contradicted, for example a deleted Airbyte source and EspoCRM task still
-  readable, Immich and BookStack item reads showing fields the create
-  response lacked, and Sonarr's tag list ordering;
-- 7 unexplained-change, such as BookStack's description_html and Paperless's
-  derived text colour;
-- 4 side-effect, for example a Sonarr tag also listed by `/tag/detail`;
-- 1 incomplete-entities: WordPress answers a delete with the post in its edit
-  context, which the reads never showed for seeded posts.
-
-| Capture          | Served (create / update / delete) | Not served                                                                                      |
-| ---------------- | --------------------------------- | ----------------------------------------------------------------------------------------------- |
-| airbyte          | 2 / 2 / 0                         | create contradicted, delete contradicted, delete unconfirmed                                    |
-| baserow          | none                              | no-state-target ×3                                                                              |
-| bookstack        | 0 / 0 / 1                         | create contradicted, create side-effect, update unexplained-change                              |
-| directus         | none                              | no-state-target ×2                                                                              |
-| espocrm          | none                              | create unconfirmed, delete contradicted, update unexplained-change                              |
-| ghost            | none                              | no-state-target ×2                                                                              |
-| gitea            | 1 / 1 / 0                         | no-state-target ×2                                                                              |
-| grafana          | none                              | create unconfirmed, no-state-target ×5                                                          |
-| grist            | none                              | create no-observation, no-state-target ×5                                                       |
-| grocy            | none                              | create no-observation, delete no-observation, update no-observation, no-state-target ×2         |
-| healthchecks     | none                              | create no-observation, delete no-observation, update no-observation, no-state-target ×2         |
-| homebox          | none                              | document no-observation, no-state-target ×3                                                     |
-| immich           | 0 / 0 / 1                         | create contradicted, update contradicted                                                        |
-| jellyfin         | none                              | no-state-target ×2                                                                              |
-| keycloak         | none                              | no-state-target ×1                                                                              |
-| komga            | none                              | create unconfirmed ×2, no-state-target ×4                                                       |
-| linkding         | 2 / 2 / 2                         | create unconfirmed, delete unconfirmed, update unconfirmed, no-state-target ×2                  |
-| listmonk         | 1 / 1 / 1                         | —                                                                                               |
-| lychee           | none                              | no-state-target ×4                                                                              |
-| mailpit          | none                              | document no-observation, no-state-target ×5                                                     |
-| mattermost       | 1 / 1 / 1                         | no-state-target ×3                                                                              |
-| mealie           | none                              | create no-observation, no-state-target ×2                                                       |
-| memos            | none                              | no-state-target ×3                                                                              |
-| metabase         | 0 / 0 / 1                         | create side-effect, update unexplained-change                                                   |
-| miniflux         | 0 / 1 / 0                         | no-state-target ×3                                                                              |
-| n8n              | none                              | create unconfirmed, no-state-target ×6                                                          |
-| navidrome        | none                              | create no-observation, no-state-target ×2                                                       |
-| netbox           | 1 / 1 / 1                         | —                                                                                               |
-| nocodb           | none                              | create no-observation, no-state-target ×4                                                       |
-| nomad            | none                              | no-state-target ×4                                                                              |
-| paperless        | 0 / 0 / 1                         | create unconfirmed, update unexplained-change, no-state-target ×3                               |
-| photoprism       | 1 / 1 / 0                         | delete unconfirmed                                                                              |
-| pinry            | none                              | create unconfirmed, delete unconfirmed, update unexplained-change                               |
-| pocketbase       | none                              | no-state-target ×4                                                                              |
-| redpanda-console | none                              | document no-observation, no-state-target ×5                                                     |
-| sentry           | 1 / 0 / 0                         | update unexplained-change, no-state-target ×3                                                   |
-| shlink           | none                              | create unconfirmed, no-state-target ×1                                                          |
-| sonarr           | 0 / 1 / 0                         | create contradicted, create side-effect, update contradicted                                    |
-| tandoor          | none                              | no-state-target ×4                                                                              |
-| umami            | 1 / 1 / 1                         | —                                                                                               |
-| vault            | none                              | no-state-target ×7                                                                              |
-| vikunja          | none                              | no-state-target ×4                                                                              |
-| wordpress        | none                              | create side-effect, delete incomplete-entities, document unconfirmed, update unexplained-change |
-
-An in-process smoke derived each capture's served state and called every served
-write tool once with a varied body: all 33 applied (status equal to the
-recording), and every created or updated entity read back from the state;
-deleted entities answered the recorded 400 or 404 where one was recorded. Eight
-older published manifests no longer match the tool names the current view
-derives, so their state is unavailable and they serve replay, as designed;
-none of them has a served write tool.
-
-## End to end on a published environment
-
-Five published environments serve a create, an update and a delete (Linkding,
-Listmonk, Mattermost, NetBox, Umami); `random.SystemRandom().choice` picked
-NetBox (NetBoxEnv-REA, NetBox 4.7.3).
-
-- `rea environment-export` (packed from this branch) wrote the bundle; its
-  smoke task passed in AgentEnv framework 0.9.1334 with 42 served tools (39
-  reads and `post_dcim_sites`, `patch_dcim_sites_by_id`,
-  `delete_dcim_sites_by_id`).
-- Four write tasks, each graded by an `env_outcome_verifier` that reads the
-  environment's state through `/agentenv` `data/get` (not the agent's reply),
-  with the replay-qa agent over the Hugging Face router, one run per task and
-  model:
-
-| Task                                            | gpt-oss-120b | GLM-5.3-Flash | Tool calls (gpt-oss)                                         |
-| ----------------------------------------------- | ------------ | ------------- | ------------------------------------------------------------ |
-| Create a site in the Copper Valley region       | 1.0          | 1.0           | get_dcim_regions, post_dcim_sites                            |
-| Update a seeded site's facility and description | 1.0          | 1.0           | get_dcim_sites, patch_dcim_sites_by_id                       |
-| Delete one seeded site and only it              | 1.0          | 1.0           | get_dcim_sites, delete_dcim_sites_by_id                      |
-| Create a site, then set its facility            | 1.0          | 1.0           | get_dcim_regions, post_dcim_sites, patch_dcim_sites_by_id ×2 |
-
-- The bundle's 12 retrieval tasks (one per seeded object) passed 12/12 for both
-  models, as they did on the published replay bundle.
-
-## The served model against the live application
-
-The same NetBox 4.7.3 image ran on the VM, seeded by the capture's own seed
-script (the same ids), and one scenario ran against both the live API and the
-environment served from the capture. Only `created` and `last_updated` were
-normalised; every other member had to be equal:
-
-| Step                                      | Live | Environment | Equal                        |
-| ----------------------------------------- | ---- | ----------- | ---------------------------- |
-| List sites                                | 200  | 200         | yes                          |
-| Create Tide Gauge Annex (id 5)            | 201  | 201         | yes                          |
-| Read it                                   | 200  | 200         | yes                          |
-| List after the create (sorted by name)    | 200  | 200         | yes                          |
-| Patch its description and facility        | 200  | 200         | yes                          |
-| Read after the patch                      | 200  | 200         | yes                          |
-| Create Granite Spur (id 6)                | 201  | 201         | yes                          |
-| Patch a seeded site                       | 200  | 200         | yes                          |
-| Delete Tide Gauge Annex                   | 204  | 204         | yes                          |
-| Read the deleted site                     | 404  | 404         | yes                          |
-| Create Ledger Point (id 7, not reusing 5) | 201  | 201         | yes                          |
-| Delete a seeded site with devices         | 409  | 204         | no                           |
-| Final list                                | 200  | 200         | no (follows from the delete) |
-
-11 of 13 steps were equal. The difference is NetBox's referential protection:
-it refuses to delete a site that devices reference, while the environment's
-delete removes the entity alone. The capture only deleted a scratch site with
-no dependents, so the gate could not see the rule; it is listed under what is
-not modelled.
-
-## Not covered
-
-- A run of the hosted `real-agentenv` lane in CI (the AgentEnv runs here used
-  the published framework release on a VM).
-- Document writes on a real capture: the four modelled ones are unserved.
-- Collections tied to a create's own collection on a real capture, and UUID
-  or token identities through an AgentEnv run (both are covered by tests).
-- Agent token usage and cost.
-
-## After merging the base branches and main
-
-The branch then merged the serving branch at 5a61853a, the coverage branch at
-b4b7ebc7 (their review fixes) and main at edbd291a, then main at 17f581ff
-(the analysis-view tool description string, which main changes often). The gates above ran again
-and passed: `npm run jscpd` 3.44% over 3579 files; domain and services 7442
-passed with 5 pre-existing skips; the focused boundary set 72 passed. The
-write verdicts over the 50 captures were unchanged plan by plan, and the
-in-process smoke again applied all 33 served write tools. The AgentEnv runs
-and the live comparison above ran on cbb7b613, before these merges.
-After the second main merge: `npm run check:fast`, `npm run format:check`,
-`npm run docs:check` and `npm run mcp-catalog:check` passed; the contracts,
-analysis-view and environment tests 857 passed with 3 pre-existing skips; the
-analysis-view and environment MCP and CLI boundaries 53 passed.
-
-## After the review round
-
-The branch then merged the serving branch at c00fde41, the coverage branch at
-f6c756aa and main at 1629266e, and took the review fixes (82556cd5, 138ea4b1,
-6d21b62e). The coverage branch quotes field names in response summaries, so the
-replay card pinned by the serve MCP boundary is now 12,818 bytes; removing
-those quotes gives back the previous 12,618-byte digest exactly. The gates ran
-again and passed: `npm run check:fast`, `npm run format:check`, `npx knip`,
-`npm run scan:todos`, `npm run docs:check`, `npm run verify:test-discovery`,
-`npm run verify:module-boundaries` and `npm run mcp-catalog:check`;
-`npm run jscpd` 3.47% over 3601 files; domain and services 7463 passed with 5
-pre-existing skips; the focused boundary set 75 passed; conformance 279
-passed. The gate is stricter, but the write verdicts over the 50 captures were
-unchanged plan by plan, and the in-process smoke again applied all 33 served
-write tools. The AgentEnv runs and the live comparison above ran on cbb7b613,
-before these merges and fixes.
-
-A second review round then made the gate and serving agree in five more places
-(reads matched to checked lines as serving matches calls, increments and slugs
-held for every call, insert rules still learned after an item read, the
-document body check in the gate, and decoded parent path values). Each new test
-fails on the previous head and passes here. The same gates passed again
-(domain and services 7468 passed with 5 pre-existing skips, the focused
-boundary set 75, conformance 279, `jscpd` 3.47%), the write verdicts over the 50
-captures were again unchanged plan by plan, and the smoke applied all 33 served
-write tools.
-
-A third round kept a checked line's path spelling (replay prefers a verbatim
-one, so two spellings of one parent stay separate lines) and compared a later
-slug rule with the values earlier calls recorded rather than only their member
-names; both new tests fail on the previous head. A fourth round chose a read's
-line as replay does, so a read spelled plainly is checked against the encoded
-line that answers it, and its list against that line's collection; its test
-fails on the previous head.
-
-A review of the fidelity branch built on this one found four more places: a
-document write at another path is now unmodelled in the gate, a create picks
-the collection the call spells verbatim, a missing entity is answered with a
-recorded 2xx `null` the gate accepted as an absence, and `data/add` refuses a
-document whose `data/get` form would exceed the intake limit. Each new test
-fails on the previous head. The gates passed again (domain and services 7475
-with 5 pre-existing skips, boundaries 75, conformance, `jscpd` 3.46%), the
-verdicts over the 50 captures were unchanged plan by plan, and the smoke
-applied all 33 served write tools.
-
-A sixth round, after merging the serving and coverage branches and main
-335c042d, settled five more findings: a read whose usable body no longer holds
-the entity or list fails its check, an entity lacking a field its view always
-carried confirms nothing, a write a later write replaced is not confirmed by
-reads of the replacement, sequences never reuse a value the state started
-with, and a collection keeps its spelling after it empties. Each new test fails
-on the previous head. Over the 50 captures one capture's verdicts change:
-Linkding's bundle create and patch, confirmed only by a list read after the
-same bundle was deleted, are now unconfirmed, so 31 write tools are served (10
-creates, 11 updates, 10 deletes) and the in-process smoke applies all 31. The
-gates passed again (domain and services, boundaries, conformance and `jscpd`).
-
-A seventh round settled two more findings. An update keeps its confirmation
-when a later write overwrites only part of what it changed: a derived change,
-such as an incremented version, counts as part of the update's effect, and a
-later increment adds to the field rather than replacing it. A reset or load
-forgets the collection spellings of the state it replaced. Both new tests fail
-on the previous head. The verdicts over the 50 captures are unchanged plan by
-plan, the in-process smoke applies all 31 served write tools, and the gates
-passed again.
-
-An eighth round settled three more. A later write erases the fields of an
-earlier effect it overwrites, so two writes that together overwrite all of an
-update's changes leave it nothing to be confirmed by. A recorded outcome erases
-what earlier writes changed on its entity. A load keeps the Evidence's own
-collection spellings, so a create in a collection the loaded state does not
-hold keeps its recorded spelling. Each new test fails on the previous head. The
-verdicts over the 50 captures are unchanged plan by plan, the smoke applies all
-31 served write tools, and the gates passed again.
-
-A ninth round made a create prefer a collection the state holds over an equally
-fitting spelling known only from the Evidence, so a create after a load lands in
-the loaded collection and reads back. Its test fails on the previous head; the
-verdicts and the smoke are unchanged and the gates passed again.
-
-A tenth round settled six findings Greptile raised on the list-lines branch
-against this branch's code:
-
-- a read with no query on a whole list is checked on the paging line serving
-  answers it from, and a line whose query repeats a name is never checked;
-- a read made while a write to its targets was still running checks nothing;
-- a later call that stores a member otherwise than the plan refuses the plan;
-- a create keeps the spelling of a collection the capture listed empty;
-- a wide array no longer overflows the stack while checking path-dependent
-  values;
-- the guide counts served write tools among the catalog's.
-
-Each new test fails on the previous head. The verdicts over the 50 captures
-are unchanged plan by plan, the smoke applies all 31 served write tools, and
-the gates passed again.
-
-An eleventh round settled six more findings, five raised on this branch and one on the fidelity branch:
-
-- a passing read confirms only the writes it shows something of;
-- an item read names its entity as serving does, percent-decoded spellings included;
-- a read a write's effect was learned from still contradicts the other writes;
-- a line repeating a query name with one value stays checkable;
-- document writes join the effect tracking, so a replacement overwrites an earlier merge;
-- a call naming a page that the collection has outgrown answers from its recording (`page-exceeded`), and the gate does not check such reads.
-
-Each new test fails on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke
-applies all 31 served write tools, and the gates passed again.
-
-A twelfth round settled four findings Greptile raised on the list-lines branch against this branch's code:
-
-- a create that answers with its id alone is observed only through a read of that id;
-- a later call that is the first to send the path's id in its body adds the identity member to the plan;
-- the copy search walks a request body with an index, so a wide body no longer takes quadratic time (500,000 zeros: 63 s
-  before, 74 ms after);
-- the sent values of fixed members a plan keeps are counted against the view's allowance.
-
-Each new test fails on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke
-applies all 31 served write tools, and the gates passed again.
-
-A thirteenth round settled seven findings Greptile raised on this branch, the fidelity branch and the list-lines branch:
-
-- a passing read that shows nothing of a write leaves it for a later check, instead of clearing it;
-- a read begun while a write to an unknown entity still ran neither checks nor shows the entity again;
-- a later create whose sequence fields do not follow the learned sequence refuses the plan;
-- a document replacement below the root overwrites only what it replaced;
-- a built document plan writes later calls at its own object, even one sharing no member with the document;
-- an update or delete finds its entity as an item read does, percent-decoded spellings included;
-- a `_start`–`_end` range bounds a page as `limit` does, in serving and in the gate.
-
-Each new test fails on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke
-applies all 31 served write tools, and the gates passed again.
-
-A fourteenth round settled two findings Greptile raised on the list-queries branch against this branch's code:
-
-- the type's identity field never becomes a constant: an update whose id member the application ignored no longer
-  writes the exemplar's id into the entity another call names;
-- a page size of zero bounds nothing, so a whole line recorded with `limit=0` answers from the state.
-
-Both tests fail on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke applies
-all 31 served write tools, and the gates passed again.
-
-A fifteenth round settled nine findings Greptile raised on this branch, the fidelity branch and the list-lines branch,
-five of them on the previous rounds' own changes:
-
-- an entity field whose name looks like a pointer is matched by name; only a document's pointers cover the members
-  under them;
-- a failed read contradicts each exercised write no unmodelled write came after, rather than skipping all of them
-  when the oldest pending write came before one;
-- an item read, update or delete names its entity as serving does, decoding the id once, so `book%2531` no longer
-  reaches `book1`;
-- a plan whose calls use a member both as the identity and as a fixed member, or fix it at different values, is
-  refused;
-- a size of zero bounds nothing only on a line whose recording listed items under it;
-- an update whose observation drops a field the entity held is refused;
-- a later create whose clock takes another format, or whose unique value is not a UUID, is refused;
-- a derived state `data/get` would write past 32 MiB is not served.
-
-Each new test fails on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke
-applies all 31 served write tools, and the gates passed again.
-
-A sixteenth round settled four findings Greptile raised on the fifteenth round's changes, here and on the fidelity,
-list-lines and list-queries branches:
-
-- a size of zero is no bound only by itself: a range or another size on the same line still bounds the page;
-- an update is refused for a dropped field only when a later read shows it dropped, since a write's own response may
-  leave fields out;
-- interference is weighed against a tool's latest call on the read's entity or collection, not its latest call
-  anywhere.
-
-Each new test fails on the previous head. The verdicts over the 50 captures are unchanged plan by plan, the smoke
-applies all 31 served write tools, and the gates passed again.
-
-A seventeenth round settled two more findings Greptile raised on the list-queries branch against this branch's
-interference rule: an unmodelled write counts against a tool when it followed the tool's call on any target the read
-covers, so a later call on another entity does not hide it; and a failed item read contradicts the writes no
-unmodelled write followed, checking only the others on their members. Both tests fail on the previous head. The
-verdicts over the 50 captures are unchanged plan by plan, the smoke applies all 31 served write tools, and the gates
-passed again. A follow-up weighs interference only on targets where the tool's effect survives, so a call
-whose effect a later write overwrote no longer excuses a later mismatch; its test fails on the previous head.

docs/testing.md

@@ -1806,7 +1806,7 @@ the built CLI, packs the checkout with `npm pack`, exports the bundle with
 registry package, and runs `agent-env run` on the bundle. It checks that the
 export reports the planned file set with the inputs copied byte-exact and a
 bundle served from the derived state, which serves fewer tools than the
-manifest because write tools the capture did not confirm are not served, that the runner exits `0` with
+manifest because write tools are not served, that the runner exits `0` with
 `tasks/smoke.json` reported as passed and the verifier's description naming
 that served tool count, and that no container exists
 after the run that did not exist before; the container inventory runs even when

docs/web-network-captures.md

@@ -120,6 +120,8 @@ HTTP fields and ordered duplicate headers are retained, with stored body bytes
 in binary sidecars. Bodies are not dechunked or decompressed. Metadata is an
 XML node tree; optional `_w.txt` and `_g.txt` files retain opaque WebSocket and
 gRPC message bytes. Missing members remain null, distinct from empty bodies.
+A zero-byte `_c.txt` or `_s.txt` member, which Fiddler writes for a session
+without that message, is also null and adds a record limitation.
 See Telerik's [SAZ format reference](https://www.telerik.com/fiddler/fiddler-everywhere/documentation/knowledge-base/fiddler-archives).
 
 ## Protobuf and gRPC bodies
@@ -593,12 +595,12 @@ Every entity cites its `record_ordinals`.
 
 `views` lists one plan per read tool in tool order:
 
-| Shape      | Plan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `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 or only paging parameters (`limit`, `offset`, `page`, `per_page`, `perpage`, `page_size`, `pagesize`, `size`, `start`, `_start`, `_end`), 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 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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| Shape      | Plan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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 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
 recording of each request line from the state, comparing JSON values without
@@ -608,84 +610,41 @@ with reason `envelope-varies`, `fields-differ` or `list-differs`; the other
 reasons are `query-body` (a query `POST`), `no-init-recording`,
 `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) and `query-varies` (another read of one path under
-more than one query). A document holds the value of its one `path`, so for such
+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__`.
 
-`writes` lists one plan per tool whose request may change state, in tool
-order. Its `effect` is `create` for a `POST` to a type's
-`collection_template`, `update` for a `PUT`, `PATCH` or `POST` to that template
-plus one trailing parameter, `delete` for a `DELETE` to it, `document` for a
-`PUT`, `PATCH` or `POST` to a document's path, and otherwise `none` with reason
-`no-state-target`. A plan is built from the tool's first successful call: its
-request body must be a usable JSON object (as response bodies are usable), and
-the written entity must show in that call's response or in a later read before
-the next write. Each field of a created entity gets the first rule that
-explains it: generated `identity` (a sequence, UUID or token, by the recorded
-value's shape), `echo` of a body member, `copy` of a body string of 8 or more
-characters, a `path` value, a `slug` of a body member, a `clock` value within 10
-minutes of the request in its recorded format, a `sequence` one past the
-largest value of its collection or type, a `unique` UUID, or a `template` around
-a generated value; other fields keep the observed value. An update's members
-echo when stored as sent; a member stored differently is accepted only with its
-recorded value (`body.fixed`) and stores the value the call that showed it
-recorded (the `value` of its `constant` rule), and a field it changed without
-sending must be a clock, an increment or a slug, or the plan is
-`unexplained-change`; an increment or slug must hold for every call of the
-tool. Every member the first call sent is required, except by `PATCH` and
-`POST` updates.
-
-The view then replays the timeline on a copy of the initial state. Modelled
-writes apply their effect; only a `2xx` write is modelled or an example, and
-any other write (a redirect, an unanswered or unmodelled one) leaves the entity
-below whose item path it wrote unknown until a read shows it again (a whole
-collection when the path names no held entity), and taints what it wrote at or
-above. A read the served environment would answer from the state is compared
-with its recording as the read plans are, as the whole response it would serve:
-the entity or list rendered into the envelope of the item view's or the line's
-base recording, with the members the state still holds. A 400, 404 or 410 (or a
-`null` body) agrees with an entity the copy does not hold. A match confirms
-the writes that changed its entity or collection since it was last read; a
-mismatch contradicts them, or, when an unmodelled write came after them, is
-checked only on the members they sent; a mismatch no write explains marks the related writes since as
-`side-effect`. A plan is `served` when a read confirmed it and none
-contradicted it; otherwise its `reason` is the first of its build reason
-(`no-call`, `body-unusable`, `no-observation`, `unexplained-change`),
-`contradicted` (with `contradicted_by`), `side-effect`, `unconfirmed` and `incomplete-entities` (an update or delete that answers with the entity, when no initial entity holds every field its recorded answer shows, so it could answer only for entities the environment created).
-`checked_record_ordinals` lists the confirming reads, `insert` places created
-entities (sorted by a field the collection's recorded order shows, else last),
-and `write_clock` is the end of the last timed record, to the next second.
-
 Values in the state are recorded data, so the view refuses the same parents as
 the manifest, including those inspected with `sensitive_values`, and a
 `capture_browser_scenario` parent must have selected response bodies. Types and
 identity are inferences, so the Evidence is always inferred. `unknowns` states
 that the state establishes no authorization model, no way the application
-computes responses or derived values, and write effects only as modelled from
-recorded calls. The state
+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. Documents hold whole recorded response
-values of up to 256 KiB each, 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 and the served write plans from it and loads replacement
-states through the AgentEnv data plane, as
+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
 [serve from the state](agent-environments.md#serve-from-the-state) describes.
 
 ## 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,87 @@
+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 the compiled CLI actually launched. */
+export const captureRuntimeBinding = async (runtime) => {
+  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));
+    }
+  };
+  await visit(join(root, "dist/cli-runtime"));
+  assert.ok(
+    files.includes(join("dist", "cli-runtime", "cli.js")),
+    "Missing compiled CLI 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: 1,
+    root,
+    node: process.version,
+    git_revision: gitRevision,
+    source_diff_sha256: sha(sourceDiff),
+    untracked_source_sha256: sha(JSON.stringify(untrackedEntries)),
+    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]), 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.

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/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")}`,
     );
 };
 

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/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/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/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,136 @@ 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 written = await persistEvidenceBundleCommand(
+    bundle,
+    outputPath,
+    false,
+    signal,
+    evidence.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(evidence));
+  if (signal?.aborted)
+    return err(
+      new AnalysisCancelledError(evidence.operation, {
+        cause: signal.reason,
+        partialObservation: delivered.value,
+        diagnostics: { evidence_bundle: { ...written.value } },
+      }),
+    );
+  return delivered;
+};
+
+/** 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 +194,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 +207,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 +235,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",
@@ -112,20 +111,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,

src/application/ReferenceSourceImport.ts

@@ -1,9 +1,11 @@
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import {
   createHistoricalSourceGraph,
+  historicalSourceInventoryHasPartialFacts,
   historicalSourceLanguages,
   historicalSourceManifests,
   historicalSourceParseFailureKey,
+  historicalSourceRelationshipKey,
   type HistoricalSourceGraph,
   type HistoricalSourceGraphInput,
 } from "../domain/referenceSourceGraph.js";
@@ -45,18 +47,13 @@ const cancelled = (
 
 const isAborted = (signal?: AbortSignal): boolean => signal?.aborted === true;
 
-const relationshipKey = (
-  relationship: HistoricalSourceGraphInput["relationships"][number],
-): string =>
-  `${relationship.from_path}\u0000${relationship.to}\u0000${relationship.kind}\u0000${relationship.resolution}\u0000${relationship.parse_state}`;
-
 const deduplicateRelationships = (
   relationships: HistoricalSourceGraphInput["relationships"],
 ): HistoricalSourceGraphInput["relationships"] => {
   const seen = new Set<string>();
   const result: HistoricalSourceGraphInput["relationships"] = [];
   for (const relationship of relationships) {
-    const key = relationshipKey(relationship);
+    const key = historicalSourceRelationshipKey(relationship);
     if (seen.has(key)) continue;
     seen.add(key);
     result.push(relationship);
@@ -93,37 +90,6 @@ const buildProvenance = (
   caller: options.caller,
 });
 
-const deriveInventoryState = (
-  input: Pick<
-    HistoricalSourceGraphInput,
-    | "entries"
-    | "relationships"
-    | "parse_failures"
-    | "exclusions"
-    | "limitations"
-  >,
-): "complete" | "partial" | "unknown" => {
-  if (input.limitations.length > 0) return "partial";
-  if (input.exclusions.length > 0) return "partial";
-  if (input.parse_failures.length > 0) return "partial";
-  const partialEntry = input.entries.some(
-    (entry) =>
-      entry.limitations.length > 0 ||
-      (entry.kind === "file" && entry.content_state !== "hashed") ||
-      (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-      (entry.kind === "symlink" && entry.target_state !== "internal") ||
-      entry.kind === "unknown",
-  );
-  if (partialEntry) return "partial";
-  const partialRelationship = input.relationships.some(
-    ({ parse_state, resolution }) =>
-      parse_state !== "parsed" ||
-      ["unresolved", "unknown"].includes(resolution),
-  );
-  if (partialRelationship) return "partial";
-  return "complete";
-};
-
 const sortExclusions = (
   exclusions: HistoricalSourceGraphInput["exclusions"],
 ): HistoricalSourceGraphInput["exclusions"] =>
@@ -261,16 +227,21 @@ export const importReferenceSource = async (
     schema: "HistoricalSourceGraph",
     authority: "historical-reference",
     root_alias: "$REFERENCE_ROOT",
-    inventory_state: deriveInventoryState({
+    inventory_state: historicalSourceInventoryHasPartialFacts({
       entries: sortedEntries,
       relationships: uniqueRelationships,
       parse_failures: uniqueFailures,
       exclusions: sortedExclusions,
       limitations: sortedLimitations,
-    }),
+    })
+      ? "partial"
+      : "complete",
     entries: sortedEntries,
     relationships: uniqueRelationships.sort((left, right) =>
-      compareUnicodeCodePoints(relationshipKey(left), relationshipKey(right)),
+      compareUnicodeCodePoints(
+        historicalSourceRelationshipKey(left),
+        historicalSourceRelationshipKey(right),
+      ),
     ),
     parse_failures: uniqueFailures,
     exclusions: sortedExclusions,

src/application/SetupClientConfiguration.ts

@@ -405,36 +405,20 @@ export const clientConfigurationAligned = async (
     }
     const original = await readRegularFileText(client.configPath);
     const parsed = parseClientConfiguration(original, client.format);
-    const policy = await readClientPolicyBlock(
+    const desired = await clientConfigurationDesired(
       client,
+      providerEnvironment,
+      command,
       parsed,
-      await clientConfigurationDesired(
-        client,
-        providerEnvironment,
-        command,
-        parsed,
-        files.value,
-        resolveProviderRequestBudget,
-      ),
+      files.value,
+      resolveProviderRequestBudget,
     );
+    const policy = await readClientPolicyBlock(client, parsed, desired);
     if (!policy.ok) {
       throwCleanupFailure(policy.error);
       return false;
     }
-    return (
-      policy.value === undefined &&
-      registrationCurrent(
-        parsed,
-        await clientConfigurationDesired(
-          client,
-          providerEnvironment,
-          command,
-          parsed,
-          files.value,
-          resolveProviderRequestBudget,
-        ),
-      )
-    );
+    return policy.value === undefined && registrationCurrent(parsed, desired);
   } catch (cause: unknown) {
     if (cause instanceof RegularFileCleanupFailure) throw cause;
     // Unreadable configuration is treated as not aligned so setup repairs it.
@@ -544,18 +528,15 @@ const inspectClientDocument = async (
   }
   try {
     const parsed = parseClientConfiguration(original, client.format);
-    const policy = await readClientPolicyBlock(
+    const desired = await clientConfigurationDesired(
       client,
+      providerEnvironment,
+      command,
       parsed,
-      await clientConfigurationDesired(
-        client,
-        providerEnvironment,
-        command,
-        parsed,
-        files.value,
-        resolveProviderRequestBudget,
-      ),
+      files.value,
+      resolveProviderRequestBudget,
     );
+    const policy = await readClientPolicyBlock(client, parsed, desired);
     if (!policy.ok) {
       throwCleanupFailure(policy.error);
       return {
@@ -565,14 +546,6 @@ const inspectClientDocument = async (
     }
     if (policy.value !== undefined)
       return { status: "invalid", remediation: policy.value };
-    const desired = await clientConfigurationDesired(
-      client,
-      providerEnvironment,
-      command,
-      parsed,
-      files.value,
-      resolveProviderRequestBudget,
-    );
     if (registrationCurrent(parsed, desired))
       return { status: "already_current" };
     const fallback = await readZcodeFallbackServers(client, parsed);

src/application/Uninstall.ts

@@ -53,7 +53,6 @@ import {
   redirectedWriteBlocker,
   type MsixPackageView,
 } from "./MsixPackageStorage.js";
-export { isUninstallFailure } from "./UninstallFailure.js";
 
 interface ManagedPathStats {
   readonly uid?: number;

src/application/Update.ts

@@ -3,7 +3,6 @@ import { gt, valid } from "semver";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import type { Result } from "../domain/result.js";
 import type { IntegrationMaintenance } from "./UpdateMaintenance.js";
-export { isUpdateFailure } from "./UpdateFailure.js";
 
 /** Global npm installation that owns the running package and its entry point. */
 export interface NpmInstallation {

src/application/WebModuleTraceService.ts

@@ -1,6 +1,5 @@
 import { closeOwnedWebResources } from "./closeOwnedWebResources.js";
 import { isDeepStrictEqual } from "node:util";
-import { isAbsolute } from "node:path";
 import { z } from "zod";
 import type { AnalysisError } from "../domain/analysisErrorBase.js";
 import {
@@ -94,15 +93,6 @@ export class WebModuleTraceService {
         }),
       );
     const input = parsed.data;
-    for (const [path, value] of [
-      ["manifest_path", input.manifest_path],
-      ["import_map.path", input.import_map?.path],
-    ] as const)
-      if (value !== undefined && !isAbsolute(value))
-        return invalid(
-          path.split("."),
-          "Expected an absolute filesystem path on this host.",
-        );
     for (const [path, value] of [
       ["importer_url", input.importer_url],
       ["import_map.base_url", input.import_map?.base_url],

src/application/WebNetworkCaptureService.test.ts

@@ -43,6 +43,30 @@ it.each(["REDACTED", "[", "]", "/capture.har"])(
   },
 );
 
+it("records an explicit capture deadline and omits the default", async () => {
+  const seen: Array<number | undefined> = [];
+  const service = new WebNetworkCaptureService({
+    inspect: (input) => {
+      seen.push(input.capture_timeout_ms);
+      return Promise.resolve(ok(fixture()));
+    },
+  });
+  const explicit = await service.inspect({
+    capture_path: "/capture.har",
+    format: "har",
+    capture_timeout_ms: 250,
+  });
+  if (!explicit.ok) throw explicit.error;
+  expect(explicit.value.parameters.capture_timeout_ms).toBe(250);
+  const omitted = await service.inspect({
+    capture_path: "/capture.har",
+    format: "har",
+  });
+  if (!omitted.ok) throw omitted.error;
+  expect(omitted.value.parameters).not.toHaveProperty("capture_timeout_ms");
+  expect(seen).toEqual([250, undefined]);
+});
+
 it("keeps observed artifact identity when the entire sensitive path is excluded", async () => {
   const result = await new WebNetworkCaptureService({
     inspect: () => Promise.resolve(ok(fixture())),

src/application/WebNetworkCaptureService.ts

@@ -1,7 +1,6 @@
 import { redactExplicitFailure } from "../domain/explicitSensitiveFailure.js";
 import { excludeCaptureCoordinates } from "../domain/webNetworkCaptureCoordinates.js";
 import { redactExplicitText } from "../domain/explicitSensitiveValues.js";
-import { isAbsolute } from "node:path";
 import type { ExecutionOptions } from "./AnalysisProvider.js";
 import type { WebNetworkCapturePort } from "./WebNetworkCapturePort.js";
 import type { AnalysisError } from "../domain/analysisErrorBase.js";
@@ -57,16 +56,6 @@ export class WebNetworkCaptureService {
         }),
       );
     const input = parsed.data;
-    if (!isAbsolute(input.capture_path))
-      return failure(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["capture_path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     if (
       input.record_ordinals !== undefined &&
       new Set(input.record_ordinals).size !== input.record_ordinals.length
@@ -91,19 +80,6 @@ export class WebNetworkCaptureService {
           },
         ]),
       );
-    if (
-      input.protobuf?.schema !== undefined &&
-      !isAbsolute(input.protobuf.schema.descriptor_set_path)
-    )
-      return failure(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["protobuf", "schema", "descriptor_set_path"],
-            reason: "invalid_format",
-            message: "Expected an absolute descriptor-set path on this host.",
-          },
-        ]),
-      );
     const loaded = await this.port.inspect(input, options);
     if (!loaded.ok) {
       const partial = webNetworkCaptureSchema.safeParse(
@@ -250,6 +226,9 @@ export class WebNetworkCaptureService {
             },
           }),
       sensitive_value_count: input.sensitive_values.length,
+      ...(input.capture_timeout_ms === undefined
+        ? {}
+        : { capture_timeout_ms: input.capture_timeout_ms }),
     });
     return ok(
       createEvidence(

src/application/WebSourceLocationPorts.ts

@@ -36,6 +36,7 @@ export interface WebSourceMapPort {
       readonly path: string;
       readonly url: string;
       readonly position: WebSourceLocationInput["generated_position"];
+      readonly decodeTimeoutMs?: number;
     },
     options?: ExecutionOptions,
   ): Promise<Result<WebSourceMapReport, AnalysisError>>;

src/application/WebSourceLocationService.test.ts

@@ -11,12 +11,55 @@ import {
   AnalysisOutputError,
 } from "../domain/analysisErrorCore.js";
 import { ok } from "../domain/result.js";
-import { webSourceLocationResultSchema } from "../domain/webSourceLocation.js";
+import {
+  DEFAULT_WEB_SOURCE_MAP_DECODE_TIMEOUT_MS,
+  webSourceLocationResultSchema,
+} from "../domain/webSourceLocation.js";
 import { WebSourceLocationService } from "./WebSourceLocationService.js";
 import type { WebSourceMapPort } from "./WebSourceLocationPorts.js";
 
 const service = (data = webSourceLocationFixture(), port = decoder) =>
   new WebSourceLocationService({ load: () => Promise.resolve(ok(data)) }, port);
+const expectCodecDeadline = (
+  evidence: {
+    readonly limitations: readonly string[];
+    readonly normalized_result: unknown;
+  },
+  timeoutMs: number,
+): void => {
+  const phrase = `${String(timeoutMs)} ms decode_timeout_ms deadline`;
+  const result = webSourceLocationResultSchema.parse(
+    evidence.normalized_result,
+  );
+  expect(
+    evidence.limitations.filter((text) => text.includes(phrase)),
+  ).toHaveLength(1);
+  expect(
+    result.limitations.filter((text) => text.includes(phrase)),
+  ).toHaveLength(1);
+};
+it("passes an explicit decode deadline and omits the default from Evidence", async () => {
+  const seen: Array<number | undefined> = [];
+  const port: WebSourceMapPort = {
+    trace: (input) => {
+      seen.push(input.decodeTimeoutMs);
+      return decoder.trace(input);
+    },
+  };
+  const explicit = await service(undefined, port).trace({
+    ...args,
+    decode_timeout_ms: 250,
+  });
+  if (!explicit.ok) throw explicit.error;
+  expect(explicit.value.parameters.decode_timeout_ms).toBe(250);
+  expectCodecDeadline(explicit.value, 250);
+  const omitted = await service(undefined, port).trace(args);
+  if (!omitted.ok) throw omitted.error;
+  expect(omitted.value.parameters).not.toHaveProperty("decode_timeout_ms");
+  expectCodecDeadline(omitted.value, DEFAULT_WEB_SOURCE_MAP_DECODE_TIMEOUT_MS);
+  expect(seen).toEqual([250, undefined]);
+});
+
 it.each([
   { ...args, manifest_path: "relative.json" },
   { ...args, script_index: -1 },

src/application/WebSourceLocationService.ts

@@ -1,6 +1,5 @@
 import { closeOwnedWebResources } from "./closeOwnedWebResources.js";
 import { createHash } from "node:crypto";
-import { isAbsolute } from "node:path";
 import { z } from "zod";
 import type { AnalysisError } from "../domain/analysisErrorBase.js";
 import {
@@ -17,6 +16,7 @@ import {
   webArtifactFileSchema,
 } from "../domain/webScriptArtifacts.js";
 import {
+  DEFAULT_WEB_SOURCE_MAP_DECODE_TIMEOUT_MS,
   WEB_SOURCE_MAP_LIMITS,
   webSourceLocationInputSchema,
   webSourceLocationResultSchema,
@@ -52,17 +52,19 @@ const LIMITATIONS = [
   "Lookup returns all segments at the greatest generated position not greater than the selected point, including earlier lines and generated-only segments. A mapped point does not establish an executed range or UI causality.",
   "Regular maps and inline indexed sections are supported. External section URLs are unsupported; unknown extensions are retained in raw map text and are not interpreted.",
 ];
-const CODEC_BUDGET =
-  "Complete evidence has a 4 MiB map, 32 MiB reply, 262144 decoded rows/segments and 64-level section budget. The owned codec has a 20-second deadline";
+const codecBudget = (timeoutMs: number): string =>
+  `Complete evidence has a 4 MiB map, 32 MiB reply, 262144 decoded rows/segments and 64-level section budget. The owned codec has a ${String(timeoutMs)} ms decode_timeout_ms deadline`;
 /** Bun accepts but ignores the codec's V8 heap flags; Windows enforces a commit limit instead. */
 const codecBudgetLimitation = (
   runtime: WebSourceMapReport["runtime"],
+  timeoutMs: number,
 ): string => {
+  const budget = codecBudget(timeoutMs);
   if (runtime.id === "node-v8")
-    return `${CODEC_BUDGET}, ${String(WEB_SOURCE_MAP_LIMITS.codecHeapMiB)} MiB old-generation heap and one V8 worker; cleanup may extend the deadline. V8 heap limits do not establish aggregate RSS limits.`;
+    return `${budget}, ${String(WEB_SOURCE_MAP_LIMITS.codecHeapMiB)} MiB old-generation heap and one V8 worker; cleanup may extend the deadline. V8 heap limits do not establish aggregate RSS limits.`;
   return runtime.process_memory_limit_bytes === null
-    ? `${CODEC_BUDGET}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags, so no codec heap limit is established.`
-    : `${CODEC_BUDGET}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags; a Windows Job Object limited its committed memory to ${String(runtime.process_memory_limit_bytes)} bytes, which is not a heap or RSS limit.`;
+    ? `${budget}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags, so no codec heap limit is established.`
+    : `${budget}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags; a Windows Job Object limited its committed memory to ${String(runtime.process_memory_limit_bytes)} bytes, which is not a heap or RSS limit.`;
 };
 
 /** Join verified captured bytes with an explicitly selected source-map point. */
@@ -125,15 +127,20 @@ export class WebSourceLocationService {
         path: map.file.path,
         url: map.url,
         position: input.generated_position,
+        ...(input.decode_timeout_ms === undefined
+          ? {}
+          : { decodeTimeoutMs: input.decode_timeout_ms }),
       },
       options,
     );
     if (!traced.ok) return traced;
     const report = verifyReport(input, map.file.sha256, traced.value);
     if (!report.ok) return report;
+    const decodeTimeoutMs =
+      input.decode_timeout_ms ?? DEFAULT_WEB_SOURCE_MAP_DECODE_TIMEOUT_MS;
     const limitations = [
       ...LIMITATIONS,
-      codecBudgetLimitation(report.value.runtime),
+      codecBudgetLimitation(report.value.runtime, decodeTimeoutMs),
     ];
     const normalized = webSourceLocationResultSchema.safeParse({
       ...report.value,
@@ -201,15 +208,6 @@ const invalid = (
 const admitContext = (
   input: WebSourceLocationInput,
 ): Result<null, AnalysisError> => {
-  for (const [path, value] of [
-    ["manifest_path", input.manifest_path],
-    ["source_map.path", input.source_map.path],
-  ] as const)
-    if (!isAbsolute(value))
-      return invalid(
-        path.split("."),
-        "Expected an absolute filesystem path on this host.",
-      );
   if (!URL.canParse(input.source_map.url))
     return invalid(
       ["source_map", "url"],

src/application/analysisView/AnalysisViewService.ts

@@ -1,5 +1,6 @@
 import { setImmediate } from "node:timers/promises";
 import { INSPECT_ANALYSIS_VIEW_OPERATION } from "../../domain/analysisView/analysisViewErrors.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { z } from "zod";
 
 import { ANALYSIS_VIEW_PROVIDER } from "../InvestigationProviders.js";
@@ -25,7 +26,6 @@ import {
   type AnalysisViewRequest,
   type InspectAnalysisViewInput,
 } from "../../domain/analysisView/analysisView.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
 import {
   immutableJsonSnapshotMember,
   isImmutableJsonSnapshot,
@@ -332,39 +332,44 @@ const createAnalysisViewEvidence = (
             ? {}
             : { architecture: parent.subject.architecture }),
         };
-  return createEvidence(target, ANALYSIS_VIEW_PROVIDER, {
-    predicateType: "rea.analysis-view",
-    operation: INSPECT_ANALYSIS_VIEW_OPERATION,
-    parameters: {
-      parent_evidence_id: parent.evidence_id,
-      view: jsonValueSchema.parse(input.view),
+  return createEvidence(
+    target,
+    ANALYSIS_VIEW_PROVIDER,
+    {
+      predicateType: "rea.analysis-view",
+      operation: INSPECT_ANALYSIS_VIEW_OPERATION,
+      parameters: {
+        parent_evidence_id: parent.evidence_id,
+        view: jsonValueSchema.parse(input.view),
+      },
+      result: jsonValueSchema.parse(result),
+      rawResult: null,
+      confidence:
+        // Grouping is whole-capture, so any templated group or parameter makes the result inferred;
+        // entity types and identity in an extracted state always are.
+        result.kind === "environment-state" ||
+        ((result.kind === "api-surface" ||
+          result.kind === "environment-manifest") &&
+          result.templated_groups > 0)
+          ? "inferred"
+          : "derived",
+      authority: parent.authority,
+      limitations: result.limitations,
+      ...(result.kind === "native" && parent.relationship_coverage !== null
+        ? { relationshipCoverage: parent.relationship_coverage }
+        : {}),
+      locations: [
+        ...(result.artifact != null && result.artifact.path.length > 0
+          ? [{ kind: "artifact-path" as const, path: result.artifact.path }]
+          : []),
+        ...(result.kind === "native" &&
+        result.procedure_address !== null &&
+        result.procedure_address.length > 0
+          ? [{ kind: "address" as const, address: result.procedure_address }]
+          : []),
+      ],
+      evidenceLinks: [parent.evidence_id],
     },
-    result: jsonValueSchema.parse(result),
-    rawResult: null,
-    confidence:
-      // Grouping is whole-capture, so any templated group or parameter makes the result inferred;
-      // entity types and identity in an extracted state always are.
-      result.kind === "environment-state" ||
-      ((result.kind === "api-surface" ||
-        result.kind === "environment-manifest") &&
-        result.templated_groups > 0)
-        ? "inferred"
-        : "derived",
-    authority: parent.authority,
-    limitations: result.limitations,
-    ...(result.kind === "native" && parent.relationship_coverage !== null
-      ? { relationshipCoverage: parent.relationship_coverage }
-      : {}),
-    locations: [
-      ...(result.artifact != null && result.artifact.path.length > 0
-        ? [{ kind: "artifact-path" as const, path: result.artifact.path }]
-        : []),
-      ...(result.kind === "native" &&
-      result.procedure_address !== null &&
-      result.procedure_address.length > 0
-        ? [{ kind: "address" as const, address: result.procedure_address }]
-        : []),
-    ],
-    evidenceLinks: [parent.evidence_id],
-  });
+    { immutable: true },
+  );
 };

src/application/analysisView/evidenceFileSource.ts

@@ -32,16 +32,13 @@ export const readEvidenceFileSource = async (
         cause: signal.reason,
       }),
     );
-  const loaded = await readJsonFile(path, signal, resources);
-  if (!loaded.ok) {
-    if (loaded.error instanceof AnalysisCancelledError)
-      return err(
-        new AnalysisCancelledError(INSPECT_ANALYSIS_VIEW_OPERATION, {
-          cause: loaded.error.cause,
-        }),
-      );
-    return loaded;
-  }
+  const loaded = await readJsonFile(
+    path,
+    signal,
+    resources,
+    INSPECT_ANALYSIS_VIEW_OPERATION,
+  );
+  if (!loaded.ok) return loaded;
   if (signal?.aborted)
     return err(
       new AnalysisCancelledError(INSPECT_ANALYSIS_VIEW_OPERATION, {

src/application/android/AndroidApplicationService.ts

@@ -1,19 +1,21 @@
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
-import type { Evidence } from "../../domain/evidence.js";
 import {
   androidApplicationProjectionInputSchema,
   projectAndroidApplication,
 } from "../../domain/android/androidApplication.js";
 import type { Result } from "../../domain/result.js";
 import { ANDROID_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
-import { projectInventoryEvidence } from "../InventoryProjectionEvidence.js";
+import {
+  projectInventoryEvidence,
+  type InventoryProjectionEvidenceResult,
+} from "../InventoryProjectionEvidence.js";
 
 const OPERATION = "project_android_application_graph" as const;
 
 /** Project authenticated APK inventory Evidence into Android application Evidence. */
 export const projectAndroidApplicationEvidence = (
   rawInput: unknown,
-): Result<Evidence, AnalysisError> => {
+): Result<InventoryProjectionEvidenceResult, AnalysisError> => {
   return projectInventoryEvidence({
     rawInput,
     schema: androidApplicationProjectionInputSchema,

src/application/apple/AppleApplicationService.ts

@@ -1,19 +1,21 @@
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
-import type { Evidence } from "../../domain/evidence.js";
 import {
   appleApplicationProjectionInputSchema,
   projectAppleApplication,
 } from "../../domain/apple/appleApplication.js";
 import type { Result } from "../../domain/result.js";
 import { APPLE_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
-import { projectInventoryEvidence } from "../InventoryProjectionEvidence.js";
+import {
+  projectInventoryEvidence,
+  type InventoryProjectionEvidenceResult,
+} from "../InventoryProjectionEvidence.js";
 
 const OPERATION = "project_apple_application_graph" as const;
 
 /** Project authenticated IPA or macOS app inventory Evidence into Apple application evidence. */
 export const projectAppleApplicationEvidence = (
   rawInput: unknown,
-): Result<Evidence, AnalysisError> => {
+): Result<InventoryProjectionEvidenceResult, AnalysisError> => {
   return projectInventoryEvidence({
     rawInput,
     schema: appleApplicationProjectionInputSchema,

src/application/artifacts/DesktopApplicationService.ts

@@ -1,4 +1,3 @@
-import { isAbsolute } from "node:path";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { DesktopApplicationPort } from "./DesktopApplicationPort.js";
 import { ARTIFACT_GRAPH_PROVIDER } from "../InvestigationProviders.js";
@@ -41,16 +40,6 @@ export class DesktopApplicationService {
           cause: parsed.error,
         }),
       );
-    if (!isAbsolute(parsed.data.path))
-      return err(
-        new AnalysisInputError(operation, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute directory path on this host.",
-          },
-        ]),
-      );
     const result = await this.reader.inspect(parsed.data, options);
     if (!result.ok) return result;
     const report = desktopApplicationSchema.safeParse(result.value);

src/application/binaryDiagnostics/BinaryLayoutService.test.ts

@@ -25,10 +25,18 @@ it.each([
         throw new Error("must not run");
       },
     });
-    expect(await service.inspect(input)).toMatchObject({
+    const result = await service.inspect(input);
+    expect(result).toMatchObject({
       ok: false,
       error: { _tag: "AnalysisInputError" },
     });
+    if (input.path === "relative.elf")
+      expect(result).toMatchObject({
+        ok: false,
+        error: {
+          issues: [{ path: ["path"], reason: "invalid_format" }],
+        },
+      });
   },
 );
 

src/application/binaryDiagnostics/BinaryLayoutService.ts

@@ -1,10 +1,8 @@
-import { isAbsolute } from "node:path";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { BinaryLayoutPort } from "./BinaryLayoutPort.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
 import { createEvidence, type Evidence } from "../../domain/evidence.js";
@@ -66,16 +64,6 @@ export class BinaryLayoutService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     const inspected = await inspect(input.data);
     if (!inspected.ok) return inspected;
     const diagnostics = binaryLayoutSchema.shape.diagnostics.safeParse(

src/application/binaryDiagnostics/PeResourcesService.ts

@@ -1,10 +1,8 @@
-import { isAbsolute } from "node:path";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { PeResourcesPort } from "./PeResourcesPort.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
 import { createEvidence, type Evidence } from "../../domain/evidence.js";
@@ -47,16 +45,6 @@ export class PeResourcesService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(operation, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     const result = await this.provider.inspect(input.data, options);
     if (!result.ok) return result;
     const report = peResourcesSchema.safeParse(result.value);

src/application/binaryDiagnostics/RecordedCrashService.test.ts

@@ -70,10 +70,18 @@ it.each([
         throw new Error("must not run");
       },
     });
-    expect(await service.inspect(input)).toMatchObject({
+    const result = await service.inspect(input);
+    expect(result).toMatchObject({
       ok: false,
       error: { _tag: "AnalysisInputError" },
     });
+    if (input.path === "relative.elf")
+      expect(result).toMatchObject({
+        ok: false,
+        error: {
+          issues: [{ path: ["path"], reason: "invalid_format" }],
+        },
+      });
   },
 );
 

src/application/binaryDiagnostics/RecordedCrashService.ts

@@ -1,10 +1,8 @@
-import { isAbsolute } from "node:path";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { RecordedCrashPort } from "./RecordedCrashPort.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
 import { createEvidence, type Evidence } from "../../domain/evidence.js";
@@ -67,16 +65,6 @@ export class RecordedCrashService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     const inspected = await inspect(input.data);
     if (!inspected.ok) return inspected;
     const diagnostics = recordedCrashSchema.shape.diagnostics.safeParse(

src/application/captures/PacketCaptureService.test.ts

@@ -0,0 +1,102 @@
+import { expect, it } from "vitest";
+
+import {
+  createAnalysisExecution,
+  type ExecutionOptions,
+} from "../AnalysisProvider.js";
+import { PacketCaptureService } from "./PacketCaptureService.js";
+import { createAnalysisProfile } from "../../domain/analysisProfile.js";
+import { inspectPacketCaptureInputSchema } from "../../domain/captures/packetCapture.js";
+import { ok } from "../../domain/result.js";
+
+it("retains provider metadata in a late-cancellation observation", async () => {
+  const input = inspectPacketCaptureInputSchema.parse({
+    path: process.platform === "win32" ? "C:\\capture.pcap" : "/capture.pcap",
+    fields: ["ip.addr"],
+  });
+  const provider = {
+    id: "fixture-capture",
+    name: "Fixture capture provider",
+    version: "1",
+  } as const;
+  const subject = {
+    path: input.path,
+    sha256: "a".repeat(64),
+    format: "file",
+  } as const;
+  const report = {
+    artifact: { path: input.path, sha256: subject.sha256, bytes: 12 },
+    selection: input,
+    packets: [],
+    output_window: {
+      matching_packets: 0,
+      returned_packets: 0,
+      has_more: false,
+    },
+    read_scope: "to-eof",
+    diagnostics: "",
+    tool: {
+      configured_path: "/fixture/tshark",
+      path: "/fixture/tshark",
+      sha256: "b".repeat(64),
+      version_banner: "TShark fixture",
+      version_diagnostics: "",
+      arguments: [],
+    },
+    configuration: "private-empty-personal-profile",
+    resource_limiter: {
+      configured_path: "/fixture/prlimit",
+      path: "/fixture/prlimit",
+      sha256: "c".repeat(64),
+      arguments: [],
+    },
+    limits: {
+      input_bytes: 1,
+      output_bytes: 1,
+      command_timeout_ms: 1,
+      address_space_bytes: 0,
+      file_bytes: 0,
+      cpu_seconds: 0,
+    },
+    hardware_acquisition: "not-performed",
+  } as const;
+  const rawResult = { producer: "fixture", bytes: 12 };
+  const profile = createAnalysisProfile(provider, { filter: null });
+  const relationshipCoverage = {
+    status: "unknown",
+    reason: "Packet relationships are not reported.",
+  } as const;
+  const execution = createAnalysisExecution(report, provider, {
+    subject,
+    rawResult,
+    analysisProfile: profile,
+    relationshipCoverage,
+    locations: [{ kind: "artifact-path", path: input.path }],
+  });
+  const controller = new AbortController();
+  const reason = Object.freeze({ requested: "cancel after capture result" });
+  const service = new PacketCaptureService({
+    inspect: async (_input, options?: ExecutionOptions) => {
+      controller.abort(reason);
+      expect(options?.signal).toBe(controller.signal);
+      return ok(execution);
+    },
+    inspectFields: async () => {
+      throw new Error("Unexpected field discovery call");
+    },
+    close: async () => {},
+  });
+
+  const result = await service.inspect(input, { signal: controller.signal });
+
+  expect(result.ok).toBe(false);
+  if (result.ok) throw new Error("Expected late cancellation");
+  expect(result.error).toMatchObject({ _tag: "AnalysisCancelledError" });
+  expect(result.error.cause).toBe(reason);
+  expect(result.error.partialObservation).toMatchObject({
+    operation: "inspect_packet_capture",
+    raw_result: rawResult,
+    analysis_profile: profile,
+    relationship_coverage: relationshipCoverage,
+  });
+});

src/application/captures/PacketCaptureService.ts

@@ -3,26 +3,25 @@ import {
   packetFieldsCatalogSchema,
   type InspectPacketFieldsInput,
 } from "../../domain/captures/packetFields.js";
-import type { JsonValue } from "../../domain/jsonValue.js";
-import { isAbsolute } from "node:path";
-import type {
-  AnalysisExecution,
-  ExecutionOptions,
+import {
+  createAnalysisExecutionEvidence,
+  type AnalysisExecution,
+  type ExecutionOptions,
 } from "../AnalysisProvider.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
-import { createEvidence, type Evidence } from "../../domain/evidence.js";
+import type { Evidence } from "../../domain/evidence.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import {
   inspectPacketCaptureInputSchema,
   packetCaptureSchema,
   type InspectPacketCaptureInput,
 } from "../../domain/captures/packetCapture.js";
-import { err, ok, type Result } from "../../domain/result.js";
+import { err, type Result } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 
 export interface PacketCapturePort {
   /** Release per-call resources before returning, or retain failed cleanup for close/retry. */
@@ -59,16 +58,6 @@ export class PacketCaptureService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(operation, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute local path.",
-          },
-        ]),
-      );
     const decoded = await this.provider.inspect(input.data, options);
     if (!decoded.ok) return decoded;
     const execution = decoded.value;
@@ -86,7 +75,15 @@ export class PacketCaptureService {
           "Capture analyzer returned malformed data or changed the selected artifact identity/options.",
         ),
       );
-    return this.#evidence(operation, input.data, execution, options);
+    return completeProviderEvidence(
+      createAnalysisExecutionEvidence(
+        operation,
+        input.data,
+        execution,
+        "observed",
+      ),
+      options?.signal,
+    );
   }
   async inspectFields(
     raw: unknown,
@@ -120,33 +117,14 @@ export class PacketCaptureService {
           "Field discovery returned malformed data or changed the selected installation/options.",
         ),
       );
-    return this.#evidence(operation, input.data, execution, options);
-  }
-  #evidence(
-    operation: string,
-    parameters: Readonly<Record<string, JsonValue>>,
-    execution: AnalysisExecution,
-    options?: ExecutionOptions,
-  ): Result<Evidence, AnalysisError> {
-    const evidence = createEvidence(
-      execution.subject ?? undefined,
-      execution.provider,
-      {
+    return completeProviderEvidence(
+      createAnalysisExecutionEvidence(
         operation,
-        parameters,
-        result: execution.result,
-        confidence: "observed",
-        locations: execution.locations,
-        limitations: execution.limitations,
-      },
+        input.data,
+        execution,
+        "observed",
+      ),
+      options?.signal,
     );
-    return options?.signal?.aborted
-      ? err(
-          new AnalysisCancelledError(operation, {
-            cause: options.signal.reason,
-            partialObservation: evidence,
-          }),
-        )
-      : ok(evidence);
   }
 }

src/application/electron/ElectronFuseService.ts

@@ -1,11 +1,8 @@
-import { isAbsolute } from "node:path";
-
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { ElectronFusePort } from "./ElectronFusePort.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
 import {
@@ -45,16 +42,6 @@ export class ElectronFuseService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     const inspected = await this.provider.inspect(input.data, options);
     if (!inspected.ok) return inspected;
     const report = electronFuseReportSchema.safeParse(inspected.value);

src/application/environment/environmentBundle.test.ts

@@ -22,7 +22,7 @@ import {
 } from "./environmentBundle.js";
 import type { EnvironmentSource } from "./environmentSource.js";
 import { prepareServedState } from "./environmentState.js";
-import { environmentToolAnswer } from "./environmentToolAnswer.js";
+import { environmentToolAnswer } from "./environmentStateAnswer.js";
 import { EnvironmentStateStore } from "./environmentStateStore.js";
 
 const fixture = environmentServeFixture();
@@ -218,9 +218,7 @@ describe("planEnvironmentBundle", () => {
     expect(readme).not.toContain("agent-env run grafana-example");
     expect(readme).toContain("## What the environment serves");
     expect(readme).not.toContain("What replay means");
-    expect(readme).toContain(
-      "write tools are served only where the capture's later reads confirmed\ntheir effect",
-    );
+    expect(readme).toContain("write tools are not served yet");
     expect(readme).toContain(
       "`rea environment-serve --replay-only` serves pure replay",
     );
@@ -389,10 +387,11 @@ describe("planEnvironmentBundle without a state", () => {
 
   it("serves and predicts replay when the state's catalog exceeds the discovery budget that replay's fits", () => {
     // Read tools only, so leaving out write tools saves nothing while each state description is longer.
+    // 300 sits between the two catalogs on this fixture: replay still fits and the state catalog does not.
     const reads = servedSource.manifest.tools.filter(
       ({ method }) => method === "GET",
     );
-    const tools = Array.from({ length: 310 }, (_, index) => {
+    const tools = Array.from({ length: 300 }, (_, index) => {
       const tool = reads[index % reads.length]!;
       return index < reads.length
         ? tool
@@ -418,7 +417,7 @@ describe("planEnvironmentBundle without a state", () => {
       served: false,
       code: "resource_constraint",
     });
-    expect(planned.value.toolCount).toBe(310);
+    expect(planned.value.toolCount).toBe(300);
     expect(planned.value.check).toEqual({
       tool: "get_annotations",
       recordOrdinal: 25,

src/application/environment/environmentBundle.ts

@@ -7,7 +7,7 @@ import { servedCatalog, type PreparedState } from "./environmentState.js";
 import {
   environmentToolAnswer,
   type EnvironmentToolAnswer,
-} from "./environmentToolAnswer.js";
+} from "./environmentStateAnswer.js";
 import { EnvironmentStateStore } from "./environmentStateStore.js";
 import type { EnvironmentToolDefinition } from "./environmentTools.js";
 
@@ -52,7 +52,7 @@ export interface EnvironmentServedCheck {
 export interface EnvironmentBundlePlan {
   readonly name: string;
   readonly packageSource: EnvironmentPackageSource;
-  /** Tools the bundle serves: every manifest tool for replay; from a state, the read tools and the served write tools. */
+  /** Tools the bundle serves: every manifest tool for replay, the read tools from a state. */
   readonly toolCount: number;
   readonly check: EnvironmentServedCheck | null;
   /** Whether the bundle serves from the state, as `environment-serve` reports it. */
@@ -282,8 +282,7 @@ server derives the state the capture observed, the \`environment-state\` view
 of the capture with the manifest's template rules, and serves from it: read
 tools answer from the state where it backs them and from their recordings
 otherwise, \`/agentenv\` serves \`data/reset\`, \`data/add\` and \`data/get\` on
-it, and write tools are served only where the capture's later reads confirmed
-their effect. When the state cannot be derived, or
+it, and write tools are not served yet. When the state cannot be derived, or
 its catalog exceeds the discovery budget, the server logs why and replays
 instead: each MCP tool call selects the retained record whose path and query
 values best match the arguments and returns that record's recorded status,
@@ -333,7 +332,7 @@ export const planEnvironmentBundle = (
   // The catalog and answers the bundle's server will have, so the verifier and README predict them.
   const catalog = servedCatalog(
     source,
-    state,
+    state !== undefined,
     name,
     ENVIRONMENT_EXPORT_OPERATION,
   );

src/application/environment/environmentReplay.test.ts

@@ -13,13 +13,13 @@ import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { inspectAnalysisView } from "../analysisView/AnalysisViewService.js";
 import {
   REPLAY_BODY_LIMIT_BYTES,
+  type EnvironmentSource,
+  type RecordedExchange,
+} from "./environmentSource.js";
+import {
   replayEnvironmentTool,
   selectReplayExchange,
 } from "./environmentReplay.js";
-import type {
-  EnvironmentSource,
-  RecordedExchange,
-} from "./environmentSource.js";
 
 const source = environmentServeSource();
 

src/application/environment/environmentReplay.ts

@@ -16,8 +16,6 @@ import {
   type RecordedExchange,
 } from "./environmentSource.js";
 
-export { REPLAY_BODY_LIMIT_BYTES } from "./environmentSource.js";
-
 /** Caller arguments as the MCP tool receives them. */
 export type ReplayArguments = Readonly<Record<string, unknown>>;
 

src/application/environment/environmentState.test.ts

@@ -24,7 +24,6 @@ import {
 } from "../analysisView/AnalysisViewService.js";
 import { loadEnvironmentSource } from "./environmentSource.js";
 import {
-  admitServedState,
   deriveEnvironmentState,
   loadEnvironmentState,
   prepareServedState,
@@ -273,28 +272,6 @@ describe("prepareServedState", () => {
   });
 });
 
-describe("admitServedState", () => {
-  it("refuses a derived state data/get would write past what data/add loads back", () => {
-    expect(admitServedState(state, "environment_serve").ok).toBe(true);
-    // A euro sign is one UTF-16 unit but three bytes as data/get writes it.
-    const notes = "\u20ac".repeat(12_000_000);
-    const [first] = state.entities;
-    const large = {
-      ...state,
-      entities: [
-        ...state.entities,
-        { ...first!, id: "large", fields: { ...first!.fields, notes } },
-      ],
-    };
-    const admitted = admitServedState(large, "environment_serve");
-    if (admitted.ok) throw new Error("Expected the state to be refused");
-    expect(projectAnalysisError(admitted.error)).toMatchObject({
-      code: "resource_constraint",
-      message: expect.stringContaining("larger than data/add loads"),
-    });
-  });
-});
-
 describe("EnvironmentStateStore", () => {
   it("reports its state as rea-state/v1, accepts that report back and resets to the initial state", () => {
     const store = new EnvironmentStateStore(state);
@@ -441,6 +418,30 @@ describe("EnvironmentStateStore", () => {
   });
 });
 
+describe("caller-owned state replacement", () => {
+  it("does not retain mutable data from a caller-owned replacement", () => {
+    const store = new EnvironmentStateStore(state);
+    const document = documentWith((value) => {
+      const entity = value.rea_state.entities.find((item) => item.id === "2");
+      if (!entity) throw new Error("Expected the user entity");
+      entity.fields = { ...(entity.fields as object), login: "renamed" };
+    });
+    expect(store.replace(document).ok).toBe(true);
+    const callerEntity = document.rea_state.entities.find(
+      (entity) => entity.id === "2",
+    );
+    if (!callerEntity) throw new Error("Expected the caller's user entity");
+    (callerEntity.fields as Record<string, unknown>).login = "later edit";
+
+    expect(store.snapshot().rea_state.entities).toContainEqual(
+      expect.objectContaining({
+        id: "2",
+        fields: expect.objectContaining({ login: "renamed" }),
+      }),
+    );
+  });
+});
+
 describe("rea-state/v1 validation", () => {
   it.each([
     [
@@ -484,8 +485,8 @@ describe("rea-state/v1 validation", () => {
       "a document for a tool that is not a document view",
       (document: Editable) => {
         document.rea_state.documents.push({
-          tool: "get_users_by_id",
-          path: "/api/users/2",
+          tool: "get_folders",
+          path: "/api/folders",
           value: {},
         });
       },
@@ -593,3 +594,36 @@ describe("rea-state/v1 validation", () => {
     ).toMatchObject({ path: "rea_state/version" });
   });
 });
+
+describe("wide state value validation", () => {
+  it("preserves a wide caller value through the state replacement boundary", () => {
+    const wide = Array.from({ length: 200_000 }, (_, index) => index % 10);
+    const wideObject = Object.fromEntries(
+      Array.from({ length: 20_000 }, (_, index) => [
+        `field_${String(index)}`,
+        index,
+      ]),
+    );
+    const document = documentWith((value) => {
+      const fields = value.rea_state.entities[0]!.fields as Record<
+        string,
+        unknown
+      >;
+      value.rea_state.entities[0]!.fields = {
+        ...fields,
+        caller_wide: wide,
+        caller_wide_object: wideObject,
+      };
+    });
+    const store = new EnvironmentStateStore(state);
+
+    expect(store.replace(document).ok).toBe(true);
+    const retained = store.snapshot().rea_state.entities[0]?.fields.caller_wide;
+    if (!Array.isArray(retained)) throw new Error("Expected the wide value");
+    expect(retained).toHaveLength(wide.length);
+    expect(retained.at(-1)).toBe(wide.at(-1));
+    const retainedObject =
+      store.snapshot().rea_state.entities[0]?.fields.caller_wide_object;
+    expect(retainedObject).toEqual(wideObject);
+  });
+});

src/application/environment/environmentState.ts

@@ -6,11 +6,10 @@ import {
   type StateType,
   type StateView,
 } from "../../domain/analysisView/environmentStateRules.js";
-import type { StateWritePlan } from "../../domain/analysisView/environmentStateWriteRules.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
-import {
+import type {
+  AnalysisInputIssue,
   AnalysisResourceConstraintError,
-  type AnalysisInputIssue,
 } from "../../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { err, ok, type Result } from "../../domain/result.js";
@@ -23,9 +22,6 @@ import {
   type EnvironmentManifestTool,
   type EnvironmentSource,
 } from "./environmentSource.js";
-import { STATE_INTAKE_LIMIT_BYTES } from "./environmentStateDocument.js";
-import { initialStateBytes } from "./environmentStateStore.js";
-import { describeWrite } from "./environmentStateWriteDescription.js";
 import {
   environmentToolDefinitions,
   type EnvironmentDataPlane,
@@ -45,22 +41,11 @@ export interface EnvironmentState {
   readonly views: ReadonlyMap<string, StateView>;
   readonly entities: readonly StateEntity[];
   readonly documents: readonly StateDocument[];
-  /** Write plans keyed by tool name. */
-  readonly writes: ReadonlyMap<string, StateWritePlan>;
-  /** The instant the served clock starts from, or null when the capture has no times. */
-  readonly writeClock: string | null;
 }
 
-/** The write plans a catalog serves from: none before a state is derived. */
-type ServedWrites = Pick<EnvironmentState, "writes">;
-
-/** Serving from the state serves read tools and the write tools whose effect the capture confirmed. */
-const servedFromState = (
-  tool: EnvironmentManifestTool,
-  state: ServedWrites,
-): boolean =>
-  !changesState(tool.method, tool.path_template) ||
-  state.writes.get(tool.name)?.served === true;
+/** Serving from the state is read-only: tools whose requests may change state are not served. */
+const servedFromState = (tool: EnvironmentManifestTool): boolean =>
+  !changesState(tool.method, tool.path_template);
 
 /** The tools an environment serves and the data plane its card declares. */
 export interface ServedCatalog {
@@ -68,36 +53,27 @@ export interface ServedCatalog {
   readonly dataPlane: EnvironmentDataPlane;
 }
 
-/** The catalog an environment serves: every manifest tool for replay; from a state, the read tools, the confirmed write tools and the data plane. */
+/** The catalog an environment serves: every manifest tool for replay, the read tools and the data plane from a state. */
 export const servedCatalog = (
   source: EnvironmentSource,
-  state: ServedWrites | undefined,
+  fromState: boolean,
   name: string,
   operation: string = ENVIRONMENT_SERVE_OPERATION,
 ): Result<ServedCatalog, AnalysisResourceConstraintError> => {
-  const dataPlane: EnvironmentDataPlane =
-    state === undefined ? "none" : "state";
-  const tools = environmentToolDefinitions(
-    state === undefined
-      ? source
-      : {
-          ...source,
-          manifest: {
-            ...source.manifest,
-            tools: source.manifest.tools.filter((tool) =>
-              servedFromState(tool, state),
-            ),
-          },
+  const dataPlane: EnvironmentDataPlane = fromState ? "state" : "none";
+  const catalogSource: EnvironmentSource = fromState
+    ? {
+        ...source,
+        manifest: {
+          ...source.manifest,
+          tools: source.manifest.tools.filter(servedFromState),
         },
-    name,
-    {
-      operation,
-      dataPlane,
-      ...(state === undefined
-        ? {}
-        : { describe: (tool) => describeWrite(state.writes.get(tool.name)) }),
-    },
-  );
+      }
+    : source;
+  const tools = environmentToolDefinitions(catalogSource, name, {
+    operation,
+    dataPlane,
+  });
   return tools.ok ? ok({ tools: tools.value, dataPlane }) : tools;
 };
 
@@ -186,8 +162,6 @@ export const loadEnvironmentState = (
     views: new Map(view.views.map((entry) => [entry.tool, entry])),
     entities: view.entities,
     documents: view.documents,
-    writes: new Map(view.writes.map((plan) => [plan.tool, plan])),
-    writeClock: view.write_clock,
   });
 };
 
@@ -240,29 +214,6 @@ export interface PreparedState extends ServedState {
   >;
 }
 
-/** The derived state, unless data/get would write it past what data/add loads back, so its own report could not be restored. */
-export const admitServedState = (
-  state: EnvironmentState,
-  operation: string,
-): Result<EnvironmentState, AnalysisResourceConstraintError> => {
-  const bytes = initialStateBytes(state);
-  return bytes > STATE_INTAKE_LIMIT_BYTES
-    ? err(
-        new AnalysisResourceConstraintError(
-          operation,
-          "capacity",
-          "The derived state is larger than data/add loads, so it cannot be served",
-          { max_state_bytes: STATE_INTAKE_LIMIT_BYTES, state_bytes: bytes },
-          {
-            retryable: false,
-            remediationAction:
-              "Capture fewer or smaller responses, or serve the environment as replay only.",
-          },
-        ),
-      )
-    : ok(state);
-};
-
 const unavailable = (error: AnalysisError): PreparedState => {
   const { code, message } = projectAnalysisError(error);
   return {
@@ -281,20 +232,19 @@ export const prepareServedState = (
   } = {},
 ): PreparedState => {
   const operation = options.operation ?? ENVIRONMENT_SERVE_OPERATION;
-  const name = options.name ?? source.manifest.name;
-  // The read catalog depends only on the manifest and name, so checking it first spares deriving a state that cannot be served.
-  const reads = servedCatalog(source, { writes: new Map() }, name, operation);
-  if (!reads.ok) return unavailable(reads.error);
+  // The state catalog depends only on the manifest and name, so checking it first spares deriving a state that cannot be served.
+  const catalog = servedCatalog(
+    source,
+    true,
+    options.name ?? source.manifest.name,
+    operation,
+  );
+  if (!catalog.ok) return unavailable(catalog.error);
   const derived = deriveEnvironmentState(source, captureValue, operation);
-  if (!derived.ok) return unavailable(derived.error);
-  const admitted = admitServedState(derived.value, operation);
-  if (!admitted.ok) return unavailable(admitted.error);
-  // Served write tools join the catalog, so the whole catalog is admitted again.
-  const catalog = servedCatalog(source, derived.value, name, operation);
-  return catalog.ok
+  return derived.ok
     ? {
         state: derived.value,
         report: { served: true, evidence_id: derived.value.evidenceId },
       }
-    : unavailable(catalog.error);
+    : unavailable(derived.error);
 };

src/application/environment/environmentStateAnswer.test.ts

@@ -9,8 +9,10 @@ import {
   environmentStateServeInputs,
 } from "../../../tests/fixtures/environmentServe.js";
 import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
-import { REPLAY_BODY_LIMIT_BYTES } from "./environmentReplay.js";
-import type { EnvironmentSource } from "./environmentSource.js";
+import {
+  REPLAY_BODY_LIMIT_BYTES,
+  type EnvironmentSource,
+} from "./environmentSource.js";
 import {
   answerFromState,
   type StateServing,
@@ -265,27 +267,6 @@ describe("list answers", () => {
     });
   });
 
-  it("answers an unfiltered call from a paging-only line of the parent its path arguments name", () => {
-    const books = servingFrom([
-      ["GET", "/api/orgs/1/books?limit=50", [{ id: 1 }, { id: 2 }]],
-      ["GET", "/api/orgs/2/books?limit=50", [{ id: 3 }]],
-      ["GET", "/api/orgs/3/books?limit=50", [{ id: 4 }]],
-    ]);
-    expect(answer(books, "get_orgs_books_by_id", { id: "2" })).toMatchObject({
-      body: [{ id: 3 }],
-      replay: { record_ordinal: 1, exact_match: false },
-      state: {
-        source: "state",
-        collection: "/api/orgs/2/books",
-        membership: "all",
-        listed: 1,
-      },
-    });
-    expect(answer(books, "get_orgs_books_by_id", { id: "9" })).toMatchObject({
-      state: { source: "recording", reason: "unrecorded-request" },
-    });
-  });
-
   it("refuses a list whose member lacks a field every recording carried, never answering a partial body", () => {
     const serving = servingOf();
     load(serving, (entities) =>
@@ -332,6 +313,17 @@ describe("recorded and document answers", () => {
     });
   });
 
+  it("replays a read whose rendered document exceeds the body limit", () => {
+    const values = Array.from({ length: 60_000 }, () => "1e3").join(",");
+    const body = `{"values":[${values}]}`;
+    const serving = servingFrom([["GET", "/api/config", body]]);
+    expect(serving.store.state.documents).toEqual([]);
+    expect(answer(serving, "get_config", {})).toMatchObject({
+      replay: { record_ordinal: 0 },
+      state: { source: "recording", reason: "rendered-oversize" },
+    });
+  });
+
   it("answers a document's recorded line with the state's value for it", () => {
     const capture = timedCaptureEvidence([
       ["GET", "/api/settings", { theme: "dark", density: "compact" }],

src/application/environment/environmentStateAnswer.ts

@@ -2,7 +2,6 @@ import { stateBodyJson } from "../../domain/analysisView/EnvironmentStateAccumul
 import {
   collectionPathOf,
   listItems,
-  missingRequiredFields,
   renderStateEntity,
   renderStateList,
   replaceAt,
@@ -15,11 +14,6 @@ import {
   type StateListView,
   type StateView,
 } from "../../domain/analysisView/environmentStateRules.js";
-import {
-  pageBound,
-  pagesOnly,
-} from "../../domain/analysisView/environmentStatePaging.js";
-import { isAbsence } from "../../domain/analysisView/environmentStateWriteChecks.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisInputError,
@@ -30,7 +24,6 @@ import { err, ok, type Result } from "../../domain/result.js";
 import {
   decodedPathSegment,
   pathValueMatches,
-  REPLAY_BODY_LIMIT_BYTES,
   replayAnswer,
   replayEnvironmentTool,
   selectReplayExchange,
@@ -40,6 +33,7 @@ import {
 } from "./environmentReplay.js";
 import {
   ENVIRONMENT_SERVE_OPERATION,
+  REPLAY_BODY_LIMIT_BYTES,
   type EnvironmentManifestTool,
   type EnvironmentSource,
   type RecordedExchange,
@@ -51,11 +45,7 @@ import { environmentToolArguments } from "./environmentTools.js";
 export type StateProvenance =
   | {
       readonly source: "recording";
-      readonly reason:
-        | RecordedViewReason
-        | "no-view"
-        | "unrecorded-request"
-        | "page-exceeded";
+      readonly reason: RecordedViewReason | "no-view" | "unrecorded-request";
     }
   | {
       readonly source: "state";
@@ -74,16 +64,8 @@ export type StateProvenance =
     }
   | {
       readonly source: "state";
-      readonly view: "document" | "document-write";
+      readonly view: "document";
       readonly path: string;
-    }
-  | {
-      readonly source: "state";
-      /** A write applied to the state, or the recorded answer for an entity it does not hold. */
-      readonly view: "create" | "update" | "delete" | "missing";
-      readonly type: string;
-      readonly collection: string;
-      readonly id: string;
     };
 
 /** A replay answer that also says whether the state or a recording produced it. */
@@ -97,7 +79,7 @@ export interface StateServing {
   readonly store: EnvironmentStateStore;
 }
 
-export const refused = (
+const refused = (
   tool: EnvironmentManifestTool,
   userMessage: string,
 ): AnalysisError =>
@@ -112,9 +94,12 @@ const shownEntity = (
   entity: StateEntity,
   volatile: ReadonlySet<string>,
 ): Result<JsonObject, AnalysisError> => {
-  const missing = missingRequiredFields(entity, view, volatile);
+  const shown = renderStateEntity(entity, view, volatile);
+  const missing = view.required_fields.filter(
+    (name) => !Object.hasOwn(shown, name),
+  );
   return missing.length === 0
-    ? ok(renderStateEntity(entity, view, volatile))
+    ? ok(shown)
     : err(
         refused(
           tool,
@@ -137,12 +122,11 @@ const fromRecording = (
 };
 
 /** A recorded body the state renders into, usable exactly when extraction could use it. */
-export const recordedJson = (
-  exchange: RecordedExchange,
-): JsonValue | undefined => stateBodyJson(exchange.contentType, exchange);
+const recordedJson = (exchange: RecordedExchange): JsonValue | undefined =>
+  stateBodyJson(exchange.contentType, exchange);
 
 /** The rendered body on the base record's status, content type and provenance; never cut. */
-export const stateAnswer = (
+const stateAnswer = (
   serving: StateServing,
   base: { readonly exchange: RecordedExchange; readonly exact: boolean },
   body: JsonValue,
@@ -173,22 +157,22 @@ export const stateAnswer = (
 };
 
 /** One collection segment an item call names: a template literal, or a supplied path value. */
-export interface CallSegment {
+interface CallSegment {
   readonly text: string;
   readonly supplied: boolean;
 }
 
 /** An item call's collection segments and identity value, kept as supplied rather than joined and re-split. */
-export interface ItemCall {
+interface ItemCall {
   readonly segments: readonly CallSegment[];
   readonly id: string;
 }
 
-/** A call's path segments: template literals and supplied values, or undefined when a path argument is missing. */
-export const callSegments = (
+/** What an item call names, or undefined when a path argument is missing. */
+const itemCall = (
   tool: EnvironmentManifestTool,
   args: ReplayArguments,
-): CallSegment[] | undefined => {
+): ItemCall | undefined => {
   const names = environmentToolArguments(tool).path;
   const params = new Map(tool.params.map((param) => [param.index, param]));
   const segments: CallSegment[] = [];
@@ -205,23 +189,12 @@ export const callSegments = (
     if (typeof value !== "string") return undefined;
     segments.push({ text: value, supplied: true });
   }
-  return segments;
-};
-
-/** What an item call names, or undefined when a path argument is missing. */
-export const itemCall = (
-  tool: EnvironmentManifestTool,
-  args: ReplayArguments,
-): ItemCall | undefined => {
-  const segments = callSegments(tool, args);
-  const last = segments?.pop();
-  return segments !== undefined && last?.supplied === true
-    ? { segments, id: last.text }
-    : undefined;
+  const last = segments.pop();
+  return last?.supplied === true ? { segments, id: last.text } : undefined;
 };
 
 /** How many supplied segments a held collection matches verbatim, when it matches the call under replay's path rule. */
-export const collectionMatch = (
+const collectionMatch = (
   collection: string,
   segments: readonly CallSegment[],
 ): number | undefined => {
@@ -238,7 +211,7 @@ export const collectionMatch = (
 };
 
 /** The entity an item call names, preferring verbatim collection spellings as replay does; the id is tried percent-decoded, then as written. */
-export const namedEntity = (
+const namedEntity = (
   store: EnvironmentStateStore,
   type: string,
   call: ItemCall,
@@ -259,60 +232,7 @@ export const namedEntity = (
   return undefined;
 };
 
-/** The answer for an entity the state does not hold: the tool's latest recorded 400, 404 or 410, else a tool error. */
-export const missingAnswer = (
-  serving: StateServing,
-  tool: EnvironmentManifestTool,
-  missing: {
-    readonly type: string;
-    readonly collection: string;
-    readonly id: string;
-  },
-): Result<StateAnswer, AnalysisError> => {
-  // A read also answers with a 2xx JSON null, the absence the write gate accepts; a write never does, as a 2xx would
-  // report success for an entity that is not there.
-  const nullAbsence = tool.method === "GET";
-  const latestAbsence = (ordinals: readonly number[]) =>
-    ordinals
-      .map((ordinal) => serving.source.exchanges.get(ordinal))
-      .filter(
-        (exchange): exchange is RecordedExchange =>
-          exchange !== undefined &&
-          (isAbsence(exchange.status) ||
-            (nullAbsence &&
-              exchange.status !== null &&
-              exchange.status >= 200 &&
-              exchange.status < 300 &&
-              recordedJson(exchange) === null)),
-      )
-      .at(-1);
-  // The tool's own recorded absence first, else that of an item view of the type.
-  const itemTools = new Set(
-    [...serving.store.state.views.values()].flatMap((view) =>
-      view.shape === "item" && view.type === missing.type ? [view.tool] : [],
-    ),
-  );
-  const recorded =
-    latestAbsence(tool.record_ordinals) ??
-    latestAbsence(
-      serving.source.manifest.tools
-        .filter((candidate) => itemTools.has(candidate.name))
-        .flatMap((candidate) => candidate.record_ordinals),
-    );
-  if (recorded === undefined)
-    return err(
-      refused(
-        tool,
-        `The state holds no ${missing.type} entity ${missing.id} in ${missing.collection}.`,
-      ),
-    );
-  return ok({
-    ...replayAnswer(serving.source, recorded, false),
-    state: { source: "state", view: "missing", ...missing },
-  });
-};
-
-/** An item call renders the named entity into the recorded envelope; it never invents an entity; one the state does not hold answers the tool's recorded absence. */
+/** An item call renders the named entity into the recorded envelope; it never invents an entity. */
 const answerItem = (
   serving: StateServing,
   tool: EnvironmentManifestTool,
@@ -325,11 +245,12 @@ const answerItem = (
     return err(refused(tool, `Tool ${tool.name} needs every path argument.`));
   const entity = namedEntity(store, view.type, call);
   if (entity === undefined)
-    return missingAnswer(serving, tool, {
-      type: view.type,
-      collection: `/${call.segments.map(({ text }) => text).join("/")}`,
-      id: call.id,
-    });
+    return err(
+      refused(
+        tool,
+        `The state holds no ${view.type} entity ${call.id} in /${call.segments.map(({ text }) => text).join("/")}.`,
+      ),
+    );
   const shown = shownEntity(
     tool,
     view,
@@ -376,46 +297,18 @@ const checkedLine = (
   return selectReplayExchange(tool, lines, args)?.exchange;
 };
 
-/** For a list of a whole collection, a call that supplies no query argument answers from a checked line of the collection its path arguments name that only pages it, chosen as replay chooses; a requested page answers from its recording. */
-const unfilteredLine = (
-  source: EnvironmentSource,
-  tool: EnvironmentManifestTool,
-  checked: readonly number[],
-  args: ReplayArguments,
-): RecordedExchange | undefined => {
-  const query = environmentToolArguments(tool).query;
-  const segments = callSegments(tool, args);
-  if (
-    segments === undefined ||
-    [...query.values()].some((argument) => args[argument] !== undefined)
-  )
-    return undefined;
-  const lines = new Map<number, RecordedExchange>();
-  for (const ordinal of checked) {
-    const exchange = source.exchanges.get(ordinal);
-    if (
-      exchange !== undefined &&
-      pagesOnly(exchange.query ?? undefined) &&
-      collectionMatch(collectionPathOf(exchange, false), segments) !== undefined
-    )
-      lines.set(ordinal, exchange);
-  }
-  return selectReplayExchange(tool, lines, args)?.exchange;
-};
-
 type StateDocumentView = Extract<StateView, { shape: "document" }>;
 
-/** One tool call: the tool, the arguments it was called with, and whether they name the answering line exactly. */
+/** One tool call: the tool and the arguments it was called with. */
 interface ToolCall {
   readonly tool: EnvironmentManifestTool;
   readonly args: ReplayArguments;
-  readonly exact: boolean;
 }
 
 /** A list call renders the members of the checked line it names from the state. */
 const answerList = (
   serving: StateServing,
-  { tool, args, exact }: ToolCall,
+  { tool, args }: ToolCall,
   view: StateListView,
   base: RecordedExchange,
 ): Result<StateAnswer, AnalysisError> => {
@@ -427,16 +320,6 @@ const answerList = (
     return fromRecording(source, tool, args, "body-unusable");
   const collection = collectionPathOf(base, false);
   const type = store.type(view.type);
-  // A requested page the collection has outgrown is answered as recorded, never with more items than it asked for.
-  const size = exact
-    ? pageBound(base.query ?? undefined, recorded.length)
-    : undefined;
-  if (
-    view.membership === "all" &&
-    size !== undefined &&
-    store.inCollection(view.type, collection).length > size
-  )
-    return fromRecording(source, tool, args, "page-exceeded");
   const members: readonly StateEntity[] =
     view.membership === "all"
       ? store.inCollection(view.type, collection)
@@ -457,7 +340,7 @@ const answerList = (
   }
   return stateAnswer(
     serving,
-    { exchange: base, exact },
+    { exchange: base, exact: true },
     renderStateList(view, envelope, items),
     {
       source: "state",
@@ -493,27 +376,16 @@ const answerCheckedLine = (
   view: StateListView | StateDocumentView,
   args: ReplayArguments,
 ): Result<StateAnswer, AnalysisError> => {
-  const named = checkedLine(
+  const base = checkedLine(
     serving.source,
     tool,
     view.checked_record_ordinals,
     args,
   );
-  const base =
-    named ??
-    (view.shape === "list" && view.membership === "all"
-      ? unfilteredLine(serving.source, tool, view.checked_record_ordinals, args)
-      : undefined);
   if (base === undefined)
     return fromRecording(serving.source, tool, args, "unrecorded-request");
-  // An unfiltered call answers on a line it did not name, so its replay match is not exact.
   return view.shape === "list"
-    ? answerList(
-        serving,
-        { tool, args, exact: named !== undefined },
-        view,
-        base,
-      )
+    ? answerList(serving, { tool, args }, view, base)
     : answerDocument(serving, tool, base);
 };
 
@@ -536,3 +408,18 @@ export const answerFromState = (
       return answerCheckedLine(serving, tool, view, args);
   }
 };
+
+/** How a served environment answers one tool call. */
+export type EnvironmentToolAnswer = (
+  tool: EnvironmentManifestTool,
+  args: ReplayArguments,
+) => Result<ReplayResult, AnalysisError>;
+
+/** The answer a served environment gives: replay without a state store, the live state with one. */
+export const environmentToolAnswer = (
+  source: EnvironmentSource,
+  store: EnvironmentStateStore | undefined,
+): EnvironmentToolAnswer =>
+  store === undefined
+    ? (tool, args) => replayEnvironmentTool(source, tool, args)
+    : (tool, args) => answerFromState({ source, store }, tool, args);

src/application/environment/environmentStateCollections.ts

@@ -1,49 +0,0 @@
-import { collectionPathOf } from "../../domain/analysisView/environmentStateRules.js";
-import {
-  callSegments,
-  collectionMatch,
-  type StateServing,
-} from "./environmentStateAnswer.js";
-import type { ReplayArguments } from "./environmentReplay.js";
-import type { EnvironmentManifestTool } from "./environmentSource.js";
-
-/** The collections a create may go to: those the store knows, held ones first, then those the type's checked list lines read, so an empty one keeps its spelling. */
-const creatableCollectionsOf = (
-  serving: StateServing,
-  type: string,
-): readonly string[] => {
-  const listed: string[] = [];
-  for (const view of serving.store.state.views.values())
-    if (view.shape === "list" && view.type === type)
-      for (const ordinal of view.checked_record_ordinals) {
-        const exchange = serving.source.exchanges.get(ordinal);
-        if (exchange !== undefined)
-          listed.push(collectionPathOf(exchange, false));
-      }
-  return [...new Set([...serving.store.knownCollectionsOf(type), ...listed])];
-};
-
-/** The collection a create writes to: a known collection the call's path matches, else the path as supplied. */
-export const createdCollection = (
-  serving: StateServing,
-  tool: EnvironmentManifestTool,
-  args: ReplayArguments,
-  type: string,
-): string | undefined => {
-  const segments = callSegments(tool, args);
-  if (segments === undefined) return undefined;
-  // The spelling the call supplies verbatim wins, as item calls choose their entity, then the first known: held ones lead.
-  let held: string | undefined;
-  let verbatim = -1;
-  for (const collection of creatableCollectionsOf(serving, type)) {
-    const matched = collectionMatch(collection, segments);
-    if (matched !== undefined && matched > verbatim) {
-      held = collection;
-      verbatim = matched;
-    }
-  }
-  return (
-    held ??
-    `/${segments.map(({ text, supplied }) => (supplied ? encodeURIComponent(text) : text)).join("/")}`
-  );
-};

src/application/environment/environmentStateDocument.ts

@@ -1,3 +1,4 @@
+import { types } from "node:util";
 import { z } from "zod";
 
 import {
@@ -6,7 +7,6 @@ import {
   same,
   scalarText,
   segmentsOf,
-  type JsonObject,
   type StateDocument,
   type StateEntity,
   type StateType,
@@ -16,11 +16,10 @@ import {
   type AnalysisInputIssue,
 } from "../../domain/analysisErrorCore.js";
 import { canonicalJson } from "../../domain/comparisonSemantics.js";
-import { parseExactJson } from "../../domain/exactJsonNumber.js";
 import { projectInputIssues } from "../../domain/inputIssueProjection.js";
 import {
   jsonValueSchema,
-  jsonValueValidationIssue,
+  ownedJsonValueSchema,
   type JsonValue,
 } from "../../domain/jsonValue.js";
 import { err, ok, type Result } from "../../domain/result.js";
@@ -43,37 +42,42 @@ export interface StateContent {
   readonly documents: readonly HeldDocument[];
 }
 
-const fieldsSchema = z.record(z.string(), jsonValueSchema);
-const ordinalSchema = z.number().int().nonnegative();
+const stateDocumentSchemaFor = (jsonValue: z.ZodType<JsonValue, unknown>) => {
+  const fieldsSchema = z.record(z.string(), jsonValue);
+  const ordinalSchema = z.number().int().nonnegative();
 
-const stateDocumentSchema = z.strictObject({
-  rea_state: z.strictObject({
-    version: z.literal(1),
-    // `data/get` reports these; accepting them back lets its output be loaded unchanged.
-    state_evidence_id: z.string().optional(),
-    types: z.array(jsonValueSchema).optional(),
-    entities: z.array(
-      z.strictObject({
-        type: z.string(),
-        collection: z.string(),
-        id: z.string(),
-        fields: fieldsSchema,
-        view_fields: z
-          .array(z.strictObject({ tool: z.string(), fields: fieldsSchema }))
-          .optional(),
-        record_ordinals: z.array(ordinalSchema).optional(),
-      }),
-    ),
-    documents: z.array(
-      z.strictObject({
-        tool: z.string(),
-        path: z.string(),
-        value: jsonValueSchema,
-        record_ordinal: ordinalSchema.optional(),
-      }),
-    ),
-  }),
-});
+  return z.strictObject({
+    rea_state: z.strictObject({
+      version: z.literal(1),
+      // `data/get` reports these; accepting them back lets its output be loaded unchanged.
+      state_evidence_id: z.string().optional(),
+      types: z.array(jsonValue).optional(),
+      entities: z.array(
+        z.strictObject({
+          type: z.string(),
+          collection: z.string(),
+          id: z.string(),
+          fields: fieldsSchema,
+          view_fields: z
+            .array(z.strictObject({ tool: z.string(), fields: fieldsSchema }))
+            .optional(),
+          record_ordinals: z.array(ordinalSchema).optional(),
+        }),
+      ),
+      documents: z.array(
+        z.strictObject({
+          tool: z.string(),
+          path: z.string(),
+          value: jsonValue,
+          record_ordinal: ordinalSchema.optional(),
+        }),
+      ),
+    }),
+  });
+};
+
+const stateDocumentSchema = stateDocumentSchemaFor(jsonValueSchema);
+const ownedStateDocumentSchema = stateDocumentSchemaFor(ownedJsonValueSchema);
 
 type ParsedDocument = z.output<typeof stateDocumentSchema>["rea_state"];
 type ParsedEntity = ParsedDocument["entities"][number];
@@ -111,47 +115,86 @@ const memberProblem = (path: Path): AnalysisInputIssue => {
 
 /** The path of the first `__proto__` member in document order; schema parsing would drop such a member rather than refuse it. */
 const prototypeMemberPath = (root: unknown): Path | undefined => {
-  interface Node {
+  interface Cursor {
     readonly value: unknown;
-    readonly parent: Node | undefined;
+    readonly parent: Cursor | undefined;
     readonly key: string | number;
+    readonly entries?: Generator<string>;
+    index: number;
   }
-  const pathOf = (node: Node): (string | number)[] => {
+  const pathOf = (node: Cursor): (string | number)[] => {
     const path: (string | number)[] = [];
-    for (let at: Node = node; at.parent !== undefined; at = at.parent)
+    for (let at: Cursor = node; at.parent !== undefined; at = at.parent)
       path.push(at.key);
     return path.reverse();
   };
-  const pending: Node[] = [{ value: root, parent: undefined, key: "" }];
-  for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+  function* ownKeys(value: Record<string, unknown>): Generator<string> {
+    // `for...in` is lazy. The ownership check keeps inherited enumerable
+    // properties out, matching Object.entries without allocating all entries.
+    for (const key in value) if (Object.hasOwn(value, key)) yield key;
+  }
+  const cursor = (
+    value: unknown,
+    parent: Cursor | undefined,
+    key: string | number,
+  ): Cursor => ({
+    value,
+    parent,
+    key,
+    index: 0,
+    ...(!Array.isArray(value) && typeof value === "object" && value !== null
+      ? { entries: ownKeys(value as Record<string, unknown>) }
+      : {}),
+  });
+  const pending: Cursor[] = [cursor(root, undefined, "")];
+  while (pending.length > 0) {
+    const node = pending[pending.length - 1]!;
     const { value } = node;
-    if (typeof value !== "object" || value === null) continue;
+    if (typeof value !== "object" || value === null) {
+      pending.pop();
+      continue;
+    }
+    // The canonical JSON validator reports proxies without invoking their traps.
+    if (types.isProxy(value)) {
+      pending.pop();
+      continue;
+    }
     const array = Array.isArray(value);
     if (!array && Object.hasOwn(value, "__proto__"))
       return [...pathOf(node), "__proto__"];
-    const entries = Object.entries(value);
-    for (let index = entries.length - 1; index >= 0; index -= 1)
-      pending.push({
-        value: entries[index]![1],
-        parent: node,
-        key: array ? index : entries[index]![0],
-      });
+    if (array) {
+      if (node.index >= value.length) {
+        pending.pop();
+        continue;
+      }
+      const index = node.index++;
+      const descriptor = Object.getOwnPropertyDescriptor(value, index);
+      if (
+        descriptor?.enumerable !== true ||
+        !Object.hasOwn(descriptor, "value")
+      )
+        continue;
+      const child: unknown = descriptor.value;
+      if (typeof child === "object" && child !== null)
+        pending.push(cursor(child, node, index));
+      continue;
+    }
+    const next = node.entries?.next();
+    if (next === undefined || next.done) {
+      pending.pop();
+      continue;
+    }
+    const key = next.value;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor?.enumerable !== true || !Object.hasOwn(descriptor, "value"))
+      continue;
+    const child: unknown = descriptor.value;
+    if (typeof child === "object" && child !== null)
+      pending.push(cursor(child, node, key));
   }
   return undefined;
 };
 
-/** Whether `data/add` accepts a value as a `fields` member or a document's `value`: bounded nesting, no `__proto__` member, and numbers exact as `data/get` writes them. */
-export const isLoadableValue = (value: JsonValue): boolean =>
-  jsonValueValidationIssue(value) === undefined &&
-  prototypeMemberPath(value) === undefined &&
-  parseExactJson(JSON.stringify(value)) !== undefined;
-
-/** The first member of an object `data/add` would refuse as `fields`, if any: a `__proto__` member, or one whose value does not load. */
-export const unloadableMember = (object: JsonObject): string | undefined =>
-  Object.keys(object).find(
-    (member) => member === "__proto__" || !isLoadableValue(object[member]!),
-  );
-
 /** The first schema problem, located without naming the caller's data. */
 const schemaProblem = (
   issues: readonly z.core.$ZodIssue[],
@@ -383,9 +426,12 @@ const heldContent = (
 export const parseStateDocument = (
   state: EnvironmentState,
   value: unknown,
+  owned = false,
 ): Result<StateContent, AnalysisInputError> => {
   const prototype = prototypeMemberPath(value);
-  const parsed = stateDocumentSchema.safeParse(value);
+  const parsed = (
+    owned ? ownedStateDocumentSchema : stateDocumentSchema
+  ).safeParse(value);
   const initial = new Map(
     state.entities.map((entity) => [entityKey(entity), entity]),
   );

src/application/environment/environmentStateStore.ts

@@ -2,11 +2,7 @@ import type {
   StateEntity,
   StateType,
 } from "../../domain/analysisView/environmentStateRules.js";
-import {
-  AnalysisInputError,
-  AnalysisResourceConstraintError,
-} from "../../domain/analysisErrorCore.js";
-import type { JsonValue } from "../../domain/jsonValue.js";
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
 import { jsonParts } from "../../domain/jsonSerialization.js";
 import { err, ok, type Result } from "../../domain/result.js";
 import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
@@ -19,6 +15,13 @@ import {
   type StateContent,
 } from "./environmentStateDocument.js";
 
+/** The UTF-8 bytes a value's JSON takes, counted part by part so it is never one string. */
+const jsonBytes = (value: unknown): number => {
+  let bytes = 0;
+  for (const part of jsonParts(value)) bytes += Buffer.byteLength(part, "utf8");
+  return bytes;
+};
+
 /** What `data/get` reports: the current state as a `rea-state/v1` document. */
 export interface StateSnapshot {
   readonly rea_state: {
@@ -30,45 +33,10 @@ export interface StateSnapshot {
   };
 }
 
-/** The UTF-8 bytes a value's JSON takes, counted part by part so it is never one string. */
-const jsonBytes = (value: unknown): number => {
-  let bytes = 0;
-  for (const part of jsonParts(value)) bytes += Buffer.byteLength(part, "utf8");
-  return bytes;
-};
-
-/** The bytes JSON writes for these array items and the commas between them. */
-const itemsBytes = (items: readonly unknown[]): number =>
-  items.reduce<number>((sum, item) => sum + jsonBytes(item), 0) +
-  Math.max(0, items.length - 1);
-
-/** What `data/get` reports for some content of a state. */
-const snapshotOf = (
-  state: EnvironmentState,
-  entities: readonly StateEntity[],
-  documents: readonly HeldDocument[],
-): StateSnapshot => ({
-  rea_state: {
-    version: 1,
-    state_evidence_id: state.evidenceId,
-    types: state.types,
-    entities,
-    documents,
-  },
-});
-
-/** What `data/get` writes for a state as the Evidence holds it, in UTF-8 bytes, summed item by item. */
-export const initialStateBytes = (state: EnvironmentState): number =>
-  jsonBytes(snapshotOf(state, [], [])) +
-  itemsBytes(state.entities) +
-  itemsBytes(state.documents);
-
 /**
  * The live state one served environment answers from, shared by every MCP
  * session and the data plane. Mutations are synchronous and swap the whole
- * state, so every answer reads one consistent state. A mutation that would take
- * what `data/get` reports past the size `data/add` loads is refused, so that
- * report always loads back.
+ * state, so every answer reads one consistent state.
  */
 export class EnvironmentStateStore {
   #entities: ReadonlyMap<string, StateEntity> = new Map();
@@ -77,48 +45,37 @@ export class EnvironmentStateStore {
   #documents: ReadonlyMap<string, HeldDocument> = new Map();
   #content: StateContent = { entities: [], documents: [] };
   readonly #types: ReadonlyMap<string, StateType>;
-  readonly #clockStart: number;
-  /** What `data/get` writes for the current state, in UTF-8 bytes; kept by each mutation rather than reserialized. */
-  #bytes = 0;
-  /** The bytes of `data/get` with no entities or documents. */
-  readonly #frameBytes: number;
-  readonly #initialBytes: number;
-  /** Served writes since the state was last reset or loaded: the clock's seconds and the generators' counter. */
-  #writes = 0;
-  /** The largest value each sequence has generated since the last reset or load, so a deleted entity's value is not reused. */
-  readonly #sequences = new Map<string, number>();
-  /** The entities the state held when it was last reset or loaded, whose values no sequence reuses either. */
-  #started: readonly StateEntity[] = [];
-  /** Every collection spelling a type's entities have been held under since the last reset or load, kept when a collection empties. */
-  readonly #knownCollections = new Map<string, string[]>();
-  /** The collections of the Evidence's own state, which stay known after any load. */
-  #evidenceCollections: ReadonlyMap<string, readonly string[]> = new Map();
 
   constructor(readonly state: EnvironmentState) {
     this.#types = new Map(
       state.types.map((type) => [type.collection_template, type]),
     );
-    this.#clockStart =
-      state.writeClock === null ? 0 : Date.parse(state.writeClock);
-    this.#frameBytes = jsonBytes(snapshotOf(state, [], []));
-    this.#initialBytes = initialStateBytes(state);
     this.reset();
   }
 
-  /** Restore the initial state the Evidence holds; the clock and counter start again. */
+  /** Restore the initial state the Evidence holds. */
   reset(): void {
-    this.#install(this.state, this.#initialBytes);
-    this.#evidenceCollections = this.#typeCollections;
-    this.#restart();
+    this.#install(this.state);
   }
 
-  /** Validate a `rea-state/v1` document and, only when it is valid, make it the whole state; the clock and counter start again. */
+  /** Validate a caller-owned document and copy its JSON values before retaining them. */
   replace(document: unknown): Result<void, AnalysisInputError> {
-    const content = parseStateDocument(this.state, document);
+    return this.#replace(document, false);
+  }
+
+  /** Validate and retain a JSON document created exclusively by the serving boundary. */
+  replaceOwnedDocument(document: unknown): Result<void, AnalysisInputError> {
+    return this.#replace(document, true);
+  }
+
+  #replace(
+    document: unknown,
+    owned: boolean,
+  ): Result<void, AnalysisInputError> {
+    const content = parseStateDocument(this.state, document, owned);
     if (!content.ok) return content;
     // data/get writes members a document may omit, so the state it reports must still be one data/add loads.
-    const bytes = this.#contentBytes(content.value);
-    if (bytes > STATE_INTAKE_LIMIT_BYTES)
+    if (jsonBytes(this.#snapshotOf(content.value)) > STATE_INTAKE_LIMIT_BYTES)
       return err(
         new AnalysisInputError(
           ENVIRONMENT_SERVE_OPERATION,
@@ -135,163 +92,10 @@ export class EnvironmentStateStore {
           ],
         ),
       );
-    this.#install(content.value, bytes);
-    this.#restart();
+    this.#install(content.value);
     return ok(undefined);
   }
 
-  /** The write a served call would be: its number since the last reset or load, and its clock instant, one second past the previous applied write. */
-  pendingWrite(): { readonly count: number; readonly clockMs: number } {
-    const count = this.#writes + 1;
-    return { count, clockMs: this.#clockStart + count * 1000 };
-  }
-
-  /** Count an applied write and keep the sequence values it took, so a refused call takes none. */
-  commitWrite(sequences: ReadonlyMap<string, number>): void {
-    this.#writes += 1;
-    for (const [key, value] of sequences)
-      this.#sequences.set(key, Math.max(value, this.#sequences.get(key) ?? 0));
-  }
-
-  /** The next value of a sequence: one past both the largest held value and the largest an applied write took. */
-  sequenceAfter(key: string, held: number): number {
-    return Math.max(held, (this.#sequences.get(key) ?? 0) + 1);
-  }
-
-  #restart(): void {
-    this.#writes = 0;
-    this.#sequences.clear();
-    this.#started = this.#content.entities;
-    // A reset or load knows the Evidence's spellings and its own, never those of a state it replaced.
-    this.#knownCollections.clear();
-    this.#remember(this.#evidenceCollections);
-    this.#remember(this.#typeCollections);
-  }
-
-  #remember(named: ReadonlyMap<string, readonly string[]>): void {
-    for (const [type, collections] of named) {
-      const known = this.#knownCollections.get(type) ?? [];
-      for (const collection of collections)
-        if (!known.includes(collection)) known.push(collection);
-      this.#knownCollections.set(type, known);
-    }
-  }
-
-  /** The entities of a type the state held when it was last reset or loaded. */
-  startedWith(type: string): readonly StateEntity[] {
-    return this.#started.filter((entity) => entity.type === type);
-  }
-
-  /** Every held entity of a type, in state order. */
-  ofType(type: string): readonly StateEntity[] {
-    return this.#content.entities.filter((entity) => entity.type === type);
-  }
-
-  /** Add an entity at `index` of its collection's order, unless the state would outgrow what `data/add` loads. */
-  insert(
-    entity: StateEntity,
-    index: number,
-  ): Result<void, AnalysisResourceConstraintError> {
-    const entities = this.#content.entities;
-    const bytes = this.#grown(
-      jsonBytes(entity) + (entities.length > 0 ? 1 : 0),
-    );
-    if (!bytes.ok) return bytes;
-    const members = this.inCollection(entity.type, entity.collection);
-    const anchor =
-      index < members.length
-        ? entities.indexOf(members[index]!)
-        : members.length > 0
-          ? entities.indexOf(members.at(-1)!) + 1
-          : entities.length;
-    this.#install(
-      {
-        ...this.#content,
-        entities: [
-          ...entities.slice(0, anchor),
-          entity,
-          ...entities.slice(anchor),
-        ],
-      },
-      bytes.value,
-    );
-    return ok(undefined);
-  }
-
-  /** Replace a held entity's values in place, unless the state would outgrow what `data/add` loads. */
-  update(entity: StateEntity): Result<void, AnalysisResourceConstraintError> {
-    const key = compositeKey([entity.type, entity.collection, entity.id]);
-    const held = this.#entities.get(key);
-    if (held === undefined) return ok(undefined);
-    const bytes = this.#grown(jsonBytes(entity) - jsonBytes(held));
-    if (!bytes.ok) return bytes;
-    this.#install(
-      {
-        ...this.#content,
-        entities: this.#content.entities.map((candidate) =>
-          candidate === held ? entity : candidate,
-        ),
-      },
-      bytes.value,
-    );
-    return ok(undefined);
-  }
-
-  remove(entity: StateEntity): void {
-    const held = this.#entities.get(
-      compositeKey([entity.type, entity.collection, entity.id]),
-    );
-    if (held === undefined) return;
-    const entities = this.#content.entities.filter(
-      (candidate) => candidate !== held,
-    );
-    this.#install(
-      { ...this.#content, entities },
-      this.#bytes - jsonBytes(held) - (entities.length > 0 ? 1 : 0),
-    );
-  }
-
-  /** Set a held document's value, unless the state would outgrow what `data/add` loads; a value that is not the Evidence's cites no record. */
-  setDocument(
-    tool: string,
-    value: JsonValue,
-  ): Result<void, AnalysisResourceConstraintError> {
-    const held = this.#documents.get(tool);
-    if (held === undefined) return ok(undefined);
-    const written = { tool: held.tool, path: held.path, value };
-    const bytes = this.#grown(jsonBytes(written) - jsonBytes(held));
-    if (!bytes.ok) return bytes;
-    this.#install(
-      {
-        ...this.#content,
-        documents: this.#content.documents.map((document) =>
-          document === held ? written : document,
-        ),
-      },
-      bytes.value,
-    );
-    return ok(undefined);
-  }
-
-  /** The state's bytes after a change of `delta`, or a refusal when a change that grows it would pass the intake limit. */
-  #grown(delta: number): Result<number, AnalysisResourceConstraintError> {
-    const bytes = this.#bytes + delta;
-    if (delta <= 0 || bytes <= STATE_INTAKE_LIMIT_BYTES) return ok(bytes);
-    return err(
-      new AnalysisResourceConstraintError(
-        ENVIRONMENT_SERVE_OPERATION,
-        "capacity",
-        "The write would take the served state past the size data/add loads",
-        { max_state_bytes: STATE_INTAKE_LIMIT_BYTES, state_bytes: bytes },
-        {
-          retryable: false,
-          remediationAction:
-            "Delete entities, or restore a smaller state with data/reset or data/add.",
-        },
-      ),
-    );
-  }
-
   type(collectionTemplate: string): StateType | undefined {
     return this.#types.get(collectionTemplate);
   }
@@ -314,44 +118,28 @@ export class EnvironmentStateStore {
     return this.#typeCollections.get(type) ?? [];
   }
 
-  /** Every collection spelling a type's entities have been held under since the last reset or load, or the Evidence's state holds: those holding entities first. */
-  knownCollectionsOf(type: string): readonly string[] {
-    return [
-      ...new Set([
-        ...this.collectionsOf(type),
-        ...(this.#knownCollections.get(type) ?? []),
-      ]),
-    ];
-  }
-
   document(tool: string): HeldDocument | undefined {
     return this.#documents.get(tool);
   }
 
   snapshot(): StateSnapshot {
-    return snapshotOf(
-      this.state,
-      this.#content.entities,
-      this.#content.documents,
-    );
+    return this.#snapshotOf(this.#content);
   }
 
-  /** What `data/get` writes for the current state, in UTF-8 bytes. */
-  byteLength(): number {
-    return this.#bytes;
-  }
-
-  /** What `data/get` writes for some content, summed item by item so the whole state is never one string. */
-  #contentBytes(content: StateContent): number {
-    return (
-      this.#frameBytes +
-      itemsBytes(content.entities) +
-      itemsBytes(content.documents)
-    );
+  #snapshotOf(content: StateContent): StateSnapshot {
+    return {
+      rea_state: {
+        version: 1,
+        state_evidence_id: this.state.evidenceId,
+        types: this.state.types,
+        entities: content.entities,
+        documents: content.documents,
+      },
+    };
   }
 
   /** Build every index before assigning any, so a reader never sees half a state. */
-  #install(content: StateContent, bytes: number): void {
+  #install(content: StateContent): void {
     const entities = new Map<string, StateEntity>();
     const collections = new Map<string, StateEntity[]>();
     const typeCollections = new Map<string, string[]>();
@@ -375,11 +163,9 @@ export class EnvironmentStateStore {
     this.#entities = entities;
     this.#collections = collections;
     this.#typeCollections = typeCollections;
-    this.#remember(typeCollections);
     this.#documents = new Map(
       content.documents.map((document) => [document.tool, document]),
     );
     this.#content = content;
-    this.#bytes = bytes;
   }
 }

src/application/environment/environmentStateWriteAnswer.test.ts

@@ -1,826 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  servedFrom,
-  type Served,
-} from "../../../tests/fixtures/environmentStateServing.js";
-import {
-  BOOK_INIT_ROWS,
-  BOOK_NOT_FOUND,
-  BOOK_ROWS,
-  DELETE_NOT_FOUND,
-  FIRST_BOOK,
-  SECOND_BOOK,
-  THIRD_BOOK,
-  book,
-  bookClock,
-  renamedBook,
-  type Book,
-} from "../../../tests/fixtures/environmentStateWrites.js";
-import type { TimedCaptureRow } from "../../../tests/fixtures/analysisView.js";
-import { seededUuid } from "../../domain/analysisView/environmentStateWriteValues.js";
-import type { ReplayArguments } from "./environmentReplay.js";
-import { servedCatalog } from "./environmentState.js";
-import {
-  environmentToolArguments,
-  environmentToolDefinitions,
-} from "./environmentTools.js";
-
-/** The book the first served create of "New Book" makes: the next id, one second past the served clock's start. */
-const NEW_BOOK = book(3, "New Book", bookClock(13));
-const CREATE_NEW_BOOK = { body: { name: "New Book" } };
-
-const entityOf = (books: Served, id: string) =>
-  books.store.snapshot().rea_state.entities.find((entity) => entity.id === id);
-
-/** Load what data/get reports back through data/add: the state must come back byte for byte. */
-const expectReloadsUnchanged = (books: Served): void => {
-  const before = books.snapshot();
-  expect(books.store.replace(JSON.parse(before)).ok).toBe(true);
-  expect(books.snapshot()).toBe(before);
-};
-
-describe("served creates", () => {
-  it("refuses an exhausted generated-value collision search without changing state", () => {
-    const existing = {
-      id: "123e4567-e89b-42d3-a456-426614174000",
-      ref: "223e4567-e89b-42d3-a456-426614174000",
-      name: "Existing",
-    };
-    const created = {
-      id: "323e4567-e89b-42d3-a456-426614174000",
-      ref: "423e4567-e89b-42d3-a456-426614174000",
-      name: "Created",
-    };
-    const books = servedFrom([
-      ["GET", "/api/items", [existing]],
-      ["GET", `/api/items/${existing.id}`, existing],
-      ["POST", "/api/items", created, 201, { name: "Created" }],
-      ["GET", `/api/items/${created.id}`, created],
-      ["GET", "/api/items", [existing, created]],
-    ]);
-    const plan = books.store.state.writes.get("post_items");
-    if (plan?.served !== true)
-      throw new Error("Expected post_items to be served");
-    const rule = plan.rules.find((candidate) => candidate.rule === "unique");
-    expect(rule).toMatchObject({ field: "ref", rule: "unique" });
-    if (rule?.rule !== "unique") throw new Error("Expected a unique ref rule");
-    const candidates = Array.from({ length: 65 }, (_, attempt) =>
-      seededUuid(
-        `${books.state.evidenceId}:${plan.tool}:${rule.field}:1:${String(attempt)}`,
-        created.ref,
-      ),
-    );
-    const snapshot = books.store.snapshot();
-    const collisions = candidates.map((ref, index) => ({
-      type: "/api/items",
-      collection: "/api/items",
-      id: `collision-${String(index)}`,
-      fields: { id: `collision-${String(index)}`, ref, name: "Collision" },
-      view_fields: [],
-      record_ordinals: [],
-    }));
-    const loaded = {
-      ...snapshot,
-      rea_state: {
-        ...snapshot.rea_state,
-        entities: [...snapshot.rea_state.entities, ...collisions],
-      },
-    };
-    const replaced = books.store.replace(loaded);
-    if (!replaced.ok) throw new Error(JSON.stringify(replaced.error));
-    const before = books.snapshot();
-    const pending = books.store.pendingWrite();
-
-    const refusal = books.refusal(plan.tool, { body: { name: "Created" } });
-
-    expect(JSON.stringify(refusal)).toContain(
-      "Could not generate a unique value for ref after 64 attempts",
-    );
-    expect(books.snapshot()).toBe(before);
-    expect(books.store.pendingWrite()).toEqual(pending);
-  });
-  it("creates a book with the next id, the served clock and a derived slug, which later reads show", () => {
-    const books = servedFrom();
-    const created = books.answer("post_books", CREATE_NEW_BOOK);
-    expect(created).toMatchObject({
-      status: 201,
-      content_type: "application/json",
-      state: {
-        source: "state",
-        view: "create",
-        type: "/api/books",
-        collection: "/api/books",
-        id: "3",
-      },
-    });
-    expect(created.body).toEqual(NEW_BOOK);
-    expect(books.answer("get_books_by_id", { id: "3" })).toMatchObject({
-      status: 200,
-      body: NEW_BOOK,
-      state: { source: "state", view: "item", id: "3" },
-    });
-    expect(books.answer("get_books")).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK, NEW_BOOK],
-      state: { source: "state", view: "list", membership: "all", listed: 3 },
-    });
-  });
-
-  it("reports a created book in data/get without record citations and loads it back unchanged", () => {
-    const books = servedFrom();
-    books.answer("post_books", CREATE_NEW_BOOK);
-    expect(entityOf(books, "3")).toEqual({
-      type: "/api/books",
-      collection: "/api/books",
-      id: "3",
-      fields: NEW_BOOK,
-      view_fields: [],
-      record_ordinals: [],
-    });
-    expectReloadsUnchanged(books);
-    expect(books.answer("get_books_by_id", { id: "3" }).body).toEqual(NEW_BOOK);
-  });
-});
-
-describe("served updates and deletes", () => {
-  it("keeps an entity's identity when the application ignored the id an update sent", () => {
-    const renamed = renamedBook(FIRST_BOOK, "Renamed Book", 3);
-    const books = servedFrom([
-      ...BOOK_INIT_ROWS,
-      [
-        "PATCH",
-        "/api/books/1",
-        renamed,
-        200,
-        { id: 999, name: "Renamed Book" },
-      ],
-      ["GET", "/api/books/1", renamed],
-    ]);
-    const answer = books.answer("patch_books_by_id", {
-      id: "2",
-      body: { id: 999, name: "Second Edition" },
-    });
-    expect(answer.body).toMatchObject({ id: 2, name: "Second Edition" });
-    expect(books.answer("get_books_by_id", { id: "2" }).body).toMatchObject({
-      id: 2,
-    });
-  });
-
-  const SECOND_EDITION = renamedBook(SECOND_BOOK, "Second Edition", 13);
-  const RENAME_SECOND = { id: "2", body: { name: "Second Edition" } };
-
-  it("changes only the sent members, the slug that follows them and the clock", () => {
-    const books = servedFrom();
-    expect(books.answer("patch_books_by_id", RENAME_SECOND)).toMatchObject({
-      status: 200,
-      body: SECOND_EDITION,
-      state: { source: "state", view: "update", id: "2" },
-    });
-    expect(books.answer("get_books_by_id", { id: "2" }).body).toEqual(
-      SECOND_EDITION,
-    );
-    expect(books.answer("get_books").body).toEqual([
-      FIRST_BOOK,
-      SECOND_EDITION,
-    ]);
-  });
-
-  it("cites no records for an updated book in data/get, so it loads back unchanged", () => {
-    const books = servedFrom();
-    books.answer("patch_books_by_id", RENAME_SECOND);
-    expect(entityOf(books, "2")).toMatchObject({
-      fields: SECOND_EDITION,
-      record_ordinals: [],
-    });
-    expectReloadsUnchanged(books);
-  });
-
-  it("removes a deleted book; a later read answers the recorded 404 as a missing entity", () => {
-    const books = servedFrom();
-    expect(books.answer("delete_books_by_id", { id: "2" })).toMatchObject({
-      status: 204,
-      body: null,
-      state: { source: "state", view: "delete", id: "2" },
-    });
-    expect(books.answer("get_books_by_id", { id: "2" })).toMatchObject({
-      status: 404,
-      body: BOOK_NOT_FOUND,
-      state: {
-        source: "state",
-        view: "missing",
-        type: "/api/books",
-        collection: "/api/books",
-        id: "2",
-      },
-    });
-    expect(books.answer("get_books").body).toEqual([FIRST_BOOK]);
-  });
-
-  it("answers an update or delete of a missing book with a recorded 404, else refuses it", () => {
-    const books = servedFrom();
-    const before = books.snapshot();
-    // The update recorded no absence, so it answers the item view's; the delete answers its own.
-    expect(
-      books.answer("patch_books_by_id", { id: "99", body: { name: "Ghost" } }),
-    ).toMatchObject({
-      status: 404,
-      body: BOOK_NOT_FOUND,
-      state: { view: "missing", id: "99" },
-    });
-    expect(books.answer("delete_books_by_id", { id: "99" })).toMatchObject({
-      status: 404,
-      body: DELETE_NOT_FOUND,
-      state: { view: "missing", id: "99" },
-    });
-    expect(books.snapshot()).toBe(before);
-    const unrecorded = servedFrom(
-      BOOK_ROWS.filter(([, , , status]) => status !== 404),
-    );
-    for (const [name, args] of [
-      ["patch_books_by_id", { id: "99", body: { name: "Ghost" } }],
-      ["delete_books_by_id", { id: "99" }],
-    ] as const)
-      expect(unrecorded.refusal(name, args)).toMatchObject({
-        code: "invalid_request",
-        message: expect.stringContaining(
-          "holds no /api/books entity 99 in /api/books",
-        ),
-      });
-  });
-});
-
-describe("refusals", () => {
-  it("refuses a body the capture does not support and leaves the state unchanged", () => {
-    const books = servedFrom();
-    const before = books.snapshot();
-    const refused: [string, ReplayArguments, string][] = [
-      [
-        "post_books",
-        { body: { name: "Extra", color: "red" } },
-        "Member color is not one the capture showed stored",
-      ],
-      ["post_books", { body: {} }, "lacks required members name"],
-      [
-        "post_books",
-        { body: { name: 42 } },
-        "Member name must be a JSON string",
-      ],
-      ["post_books", { body: ["New Book"] }, "takes a JSON object body"],
-      [
-        "patch_books_by_id",
-        { id: "1", body: "New Book" },
-        "takes a JSON object body",
-      ],
-      ["patch_books_by_id", { id: "1", body: {} }, "sends none of the members"],
-      [
-        "patch_books_by_id",
-        { id: "1", body: { title: "New" } },
-        "Member title is not one",
-      ],
-    ];
-    for (const [name, args, message] of refused) {
-      expect(books.refusal(name, args)).toMatchObject({
-        code: "invalid_request",
-        message: expect.stringContaining(message),
-      });
-      expect(books.snapshot()).toBe(before);
-    }
-  });
-
-  it("accepts a member the application stored differently only with the value the capture sent", () => {
-    const bound = (entry: Book, format: string): Book => ({ ...entry, format });
-    const books = servedFrom([
-      [
-        "GET",
-        "/api/books",
-        [bound(FIRST_BOOK, "PAPERBACK"), bound(SECOND_BOOK, "PAPERBACK")],
-      ],
-      ["GET", "/api/books/1", bound(FIRST_BOOK, "PAPERBACK")],
-      ["GET", "/api/books/2", bound(SECOND_BOOK, "PAPERBACK")],
-      [
-        "POST",
-        "/api/books",
-        bound(THIRD_BOOK, "HARDCOVER"),
-        201,
-        { name: "Third Book", format: "hardcover" },
-      ],
-      ["GET", "/api/books/3", bound(THIRD_BOOK, "HARDCOVER")],
-    ]);
-    const before = books.snapshot();
-    expect(
-      books.refusal("post_books", {
-        body: { name: "Soft", format: "softcover" },
-      }),
-    ).toMatchObject({
-      message: expect.stringContaining(
-        "Member format is accepted only with the value the capture sent",
-      ),
-    });
-    expect(books.snapshot()).toBe(before);
-    expect(
-      books.answer("post_books", {
-        body: { name: "Hard", format: "hardcover" },
-      }).body,
-    ).toMatchObject({ id: 3, name: "Hard", format: "HARDCOVER" });
-  });
-
-  it("generates the same values after a refused call as without it", () => {
-    const refusedFirst = servedFrom();
-    refusedFirst.refusal("post_books", { body: {} });
-    refusedFirst.refusal("patch_books_by_id", {
-      id: "1",
-      body: { title: "New" },
-    });
-    expect(refusedFirst.answer("post_books", CREATE_NEW_BOOK).body).toEqual(
-      servedFrom().answer("post_books", CREATE_NEW_BOOK).body,
-    );
-  });
-});
-
-describe("generated values", () => {
-  it("answers the same calls identically after a reset, never reusing a deleted id", () => {
-    const books = servedFrom();
-    const session = () => {
-      const answers = [
-        books.answer("post_books", CREATE_NEW_BOOK),
-        books.answer("patch_books_by_id", {
-          id: "3",
-          body: { name: "Newer Book" },
-        }),
-        books.answer("delete_books_by_id", { id: "3" }),
-        books.answer("post_books", { body: { name: "Another Book" } }),
-        books.answer("get_books"),
-      ];
-      return { answers, text: JSON.stringify([answers, books.snapshot()]) };
-    };
-    const first = session();
-    books.store.reset();
-    expect(session().text).toBe(first.text);
-    expect(first.answers[3]?.body).toMatchObject({
-      id: 4,
-      name: "Another Book",
-    });
-  });
-
-  it("restarts the clock and the sequences when data/add loads a state", () => {
-    const books = servedFrom();
-    const initial: unknown = JSON.parse(books.snapshot());
-    const created = books.answer("post_books", CREATE_NEW_BOOK);
-    books.answer("post_books", { body: { name: "Another Book" } });
-    expect(books.store.replace(initial).ok).toBe(true);
-    // Had the sequence and clock run on, this create would take id 5 one second later.
-    expect(books.answer("post_books", CREATE_NEW_BOOK).body).toEqual(
-      created.body,
-    );
-  });
-});
-
-describe("served catalog", () => {
-  it("adds only the served write tools, saying what each does to the state", () => {
-    const { source, state } = servedFrom();
-    const catalog = servedCatalog(source, state, "books");
-    if (!catalog.ok) throw catalog.error;
-    const described = new Map(
-      catalog.value.tools.map((tool) => [tool.name, tool]),
-    );
-    // The export write targets no state type, so it is not served.
-    expect([...described.keys()].sort()).toEqual([
-      "delete_books_by_id",
-      "get_books",
-      "get_books_by_id",
-      "patch_books_by_id",
-      "post_books",
-    ]);
-    expect(described.get("post_books")?.description).toContain(
-      "creates an entity of /api/books in the served environment state (body members name; required: name), modelled on the recorded calls",
-    );
-    expect(described.get("patch_books_by_id")?.description).toContain(
-      "changes the entity the path names in the served environment state (body members name; send at least one)",
-    );
-    expect(described.get("delete_books_by_id")?.description).toContain(
-      "removes the entity the path names from the served environment state",
-    );
-    expect(described.get("post_books")?.annotations.readOnlyHint).toBe(false);
-    expect(described.get("get_books")?.description).toContain(
-      "answers from the served environment state where the state backs this tool",
-    );
-  });
-
-  it("serves every manifest tool unchanged in replay mode", () => {
-    const { source } = servedFrom();
-    const replay = servedCatalog(source, undefined, "books");
-    const definitions = environmentToolDefinitions(source, "books");
-    if (!replay.ok || !definitions.ok) throw new Error("Expected a catalog");
-    expect(replay.value).toEqual({
-      tools: definitions.value,
-      dataPlane: "none",
-    });
-    expect(replay.value.tools.map(({ name }) => name)).toContain(
-      "post_exports",
-    );
-  });
-});
-
-describe("paged list lines", () => {
-  it("answers an argument-less list from the state on a line that only pages, and another page from its recording", () => {
-    const paged = servedFrom([
-      ["GET", "/api/books?limit=50", [FIRST_BOOK, SECOND_BOOK]],
-      ...BOOK_INIT_ROWS.slice(1),
-      ["POST", "/api/books", THIRD_BOOK, 201, { name: "Third Book" }],
-      ["GET", "/api/books/3", THIRD_BOOK],
-      ["GET", "/api/books?limit=50", [FIRST_BOOK, SECOND_BOOK, THIRD_BOOK]],
-    ]);
-    const created = paged.answer("post_books", CREATE_NEW_BOOK).body;
-    expect(paged.answer("get_books")).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK, created],
-      replay: { record_ordinal: 0, exact_match: false },
-      state: { source: "state", view: "list", listed: 3 },
-    });
-    expect(paged.answer("get_books", { limit: "10" })).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK],
-      state: { source: "recording", reason: "unrecorded-request" },
-    });
-  });
-});
-
-describe("path values", () => {
-  const orgBook = (id: number, org: string, name: string): Book => ({
-    id,
-    org,
-    name,
-  });
-  const ALPHA = orgBook(1, "my org1", "Alpha");
-  const BETA = orgBook(2, "acme2", "Beta");
-  const GAMMA = orgBook(3, "my org1", "Gamma");
-  const DELTA = orgBook(4, "acme2", "Delta");
-  /** Books under two organisations, one whose name the paths percent-encode, and a create under each. */
-  const ROWS: readonly TimedCaptureRow[] = [
-    ["GET", "/api/orgs/my%20org1/books", [ALPHA]],
-    ["GET", "/api/orgs/acme2/books", [BETA]],
-    ["GET", "/api/orgs/my%20org1/books/1", ALPHA],
-    ["GET", "/api/orgs/acme2/books/2", BETA],
-    ["POST", "/api/orgs/my%20org1/books", GAMMA, 201, { name: "Gamma" }],
-    ["GET", "/api/orgs/my%20org1/books", [ALPHA, GAMMA]],
-    ["POST", "/api/orgs/acme2/books", DELTA, 201, { name: "Delta" }],
-    ["GET", "/api/orgs/acme2/books", [BETA, DELTA]],
-  ];
-
-  it("stores a parent path value decoded, as the gate learned it, whichever spelling the call uses", () => {
-    for (const spelling of ["my%20org1", "my org1"]) {
-      const books = servedFrom(ROWS);
-      const tool = books.source.manifest.tools.find(
-        (candidate) => candidate.method === "POST",
-      )!;
-      expect(books.state.writes.get(tool.name)).toMatchObject({
-        served: true,
-        rules: expect.arrayContaining([
-          expect.objectContaining({ field: "org", rule: "path" }),
-        ]),
-      });
-      const [org] = environmentToolArguments(tool).path.values();
-      books.answer(tool.name, { [org!]: spelling, body: { name: "Epsilon" } });
-      const created = books.store
-        .snapshot()
-        .rea_state.entities.find(
-          (entity) => entity.fields["name"] === "Epsilon",
-        );
-      expect(created).toMatchObject({
-        collection: "/api/orgs/my%20org1/books",
-        fields: { org: "my org1" },
-      });
-    }
-  });
-});
-
-describe("collections a create chooses", () => {
-  const orgBook = (id: number, name: string): Book => ({ id, name });
-  /** One organisation listed under two spellings and another organisation, each with a create. */
-  const ROWS: readonly TimedCaptureRow[] = [
-    ["GET", "/api/orgs/%61cme1/books", [orgBook(1, "Alpha")]],
-    ["GET", "/api/orgs/acme1/books", [orgBook(2, "Beta")]],
-    ["GET", "/api/orgs/beta2/books", [orgBook(3, "Gamma")]],
-    [
-      "POST",
-      "/api/orgs/acme1/books",
-      orgBook(4, "Delta"),
-      201,
-      { name: "Delta" },
-    ],
-    ["GET", "/api/orgs/acme1/books", [orgBook(2, "Beta"), orgBook(4, "Delta")]],
-    [
-      "POST",
-      "/api/orgs/beta2/books",
-      orgBook(5, "Epsilon"),
-      201,
-      { name: "Epsilon" },
-    ],
-    [
-      "GET",
-      "/api/orgs/beta2/books",
-      [orgBook(3, "Gamma"), orgBook(5, "Epsilon")],
-    ],
-  ];
-
-  it("creates in the collection the call spells verbatim, as item calls choose their entity", () => {
-    const books = servedFrom(ROWS);
-    const tool = books.source.manifest.tools.find(
-      (candidate) => candidate.method === "POST",
-    )!;
-    expect(books.state.writes.get(tool.name)).toMatchObject({ served: true });
-    const [org] = environmentToolArguments(tool).path.values();
-    books.answer(tool.name, { [org!]: "acme1", body: { name: "Zeta" } });
-    expect(
-      books.store
-        .snapshot()
-        .rea_state.entities.find((entity) => entity.fields["name"] === "Zeta")
-        ?.collection,
-    ).toBe("/api/orgs/acme1/books");
-  });
-});
-
-describe("missing entities after a delete", () => {
-  it("answers with a recorded 2xx null, which the gate also took as an absence", () => {
-    const books = servedFrom([
-      ...BOOK_INIT_ROWS,
-      ["DELETE", "/api/books/2", "", 204],
-      ["GET", "/api/books/2", null],
-    ]);
-    expect(books.state.writes.get("delete_books_by_id")).toMatchObject({
-      served: true,
-    });
-    books.answer("delete_books_by_id", { id: "1" });
-    expect(books.answer("get_books_by_id", { id: "1" })).toMatchObject({
-      status: 200,
-      body: null,
-      state: { view: "missing", id: "1" },
-    });
-  });
-
-  it("never answers a write of a missing entity with success, even when the write recorded a 2xx null", () => {
-    const books = servedFrom([
-      ...BOOK_INIT_ROWS,
-      ["DELETE", "/api/books/2", null, 200],
-      ["GET", "/api/books/2", BOOK_NOT_FOUND, 404],
-    ]);
-    expect(books.state.writes.get("delete_books_by_id")).toMatchObject({
-      served: true,
-    });
-    expect(books.answer("delete_books_by_id", { id: "9" })).toMatchObject({
-      status: 404,
-      body: BOOK_NOT_FOUND,
-      state: { view: "missing", id: "9" },
-    });
-  });
-});
-
-describe("values the state started with", () => {
-  it("never reuses a seeded id for a create, even after its entity is deleted first", () => {
-    const books = servedFrom();
-    books.answer("delete_books_by_id", { id: "2" });
-    books.answer("post_books", CREATE_NEW_BOOK);
-    expect(entityOf(books, "2")).toBeUndefined();
-    expect(entityOf(books, "3")?.fields).toMatchObject({ name: "New Book" });
-  });
-
-  const orgBook = (id: number, org: string, name: string): Book => ({
-    id,
-    org,
-    name,
-  });
-  /** Books under two organisations, one spelled `first` in its paths, with creates and a delete the lists confirm. */
-  const twoOrgs = (first: string, org: string) => {
-    const alpha = orgBook(1, org, "Alpha");
-    const beta = orgBook(2, "acme2", "Beta");
-    const gamma = orgBook(3, org, "Gamma");
-    const delta = orgBook(4, "acme2", "Delta");
-    const books = servedFrom([
-      ["GET", `/api/orgs/${first}/books`, [alpha]],
-      ["GET", "/api/orgs/acme2/books", [beta]],
-      ["GET", `/api/orgs/${first}/books/1`, alpha],
-      ["GET", "/api/orgs/acme2/books/2", beta],
-      ["POST", `/api/orgs/${first}/books`, gamma, 201, { name: "Gamma" }],
-      ["GET", `/api/orgs/${first}/books`, [alpha, gamma]],
-      ["POST", "/api/orgs/acme2/books", delta, 201, { name: "Delta" }],
-      ["GET", "/api/orgs/acme2/books", [beta, delta]],
-      ["DELETE", `/api/orgs/${first}/books/3`, "", 204],
-      ["GET", `/api/orgs/${first}/books`, [alpha]],
-    ]);
-    const toolOf = (method: string) =>
-      books.source.manifest.tools.find(
-        (candidate) => candidate.method === method,
-      )!;
-    const create = (value: string, name: string): string | undefined => {
-      const tool = toolOf("POST");
-      const [parent] = environmentToolArguments(tool).path.values();
-      books.answer(tool.name, { [parent!]: value, body: { name } });
-      return books.store
-        .snapshot()
-        .rea_state.entities.find((entity) => entity.fields["name"] === name)
-        ?.collection;
-    };
-    return { books, toolOf, create };
-  };
-
-  it("creates in a collection's recorded spelling after the collection empties", () => {
-    const { books, toolOf, create } = twoOrgs("my%20org1", "my org1");
-    const remove = toolOf("DELETE");
-    const [parent, id] = environmentToolArguments(remove).path.values();
-    for (const held of ["1", "3"])
-      books.answer(remove.name, { [parent!]: "my%20org1", [id!]: held });
-    expect(books.store.collectionsOf("/api/orgs/{org}/books")).not.toContain(
-      "/api/orgs/my%20org1/books",
-    );
-    expect(create("my%20org1", "Epsilon")).toBe("/api/orgs/my%20org1/books");
-  });
-
-  it("creates in the Evidence's spelling of a collection a loaded state does not hold", () => {
-    const { books, create } = twoOrgs("my%20org1", "my org1");
-    const { rea_state: held } = books.store.snapshot();
-    expect(
-      books.store.replace({
-        rea_state: {
-          version: held.version,
-          entities: held.entities.filter(
-            (entity) => !entity.collection.includes("%20"),
-          ),
-          documents: held.documents,
-        },
-      }).ok,
-    ).toBe(true);
-    expect(create("my%20org1", "Epsilon")).toBe("/api/orgs/my%20org1/books");
-  });
-
-  it("creates in the loaded state's collection when the Evidence spells the same one differently", () => {
-    const { books, create } = twoOrgs("%61cme1", "acme1");
-    const { rea_state: held } = books.store.snapshot();
-    expect(
-      books.store.replace({
-        rea_state: {
-          version: held.version,
-          entities: held.entities.map((entity) =>
-            entity.collection.includes("%61cme1")
-              ? {
-                  ...entity,
-                  collection: entity.collection.replace("%61cme1", "a%63me1"),
-                  record_ordinals: [],
-                }
-              : entity,
-          ),
-          documents: held.documents,
-        },
-      }).ok,
-    ).toBe(true);
-    // Both spellings decode to the argument; the one holding books wins over the Evidence's emptied one.
-    expect(create("acme1", "Epsilon")).toBe("/api/orgs/a%63me1/books");
-  });
-
-  it("creates in the spelling of a collection the capture listed empty", () => {
-    const beta = orgBook(2, "acme2", "Beta");
-    const gamma = orgBook(3, "my org1", "Gamma");
-    const delta = orgBook(4, "acme2", "Delta");
-    // The state starts before the first create, when the encoded organisation's list was empty.
-    const books = servedFrom([
-      ["GET", "/api/orgs/my%20org1/books", []],
-      ["GET", "/api/orgs/acme2/books", [beta]],
-      ["GET", "/api/orgs/acme2/books/2", beta],
-      ["POST", "/api/orgs/my%20org1/books", gamma, 201, { name: "Gamma" }],
-      ["GET", "/api/orgs/my%20org1/books", [gamma]],
-      ["POST", "/api/orgs/acme2/books", delta, 201, { name: "Delta" }],
-      ["GET", "/api/orgs/acme2/books", [beta, delta]],
-    ]);
-    const tool = books.source.manifest.tools.find(
-      (candidate) => candidate.method === "POST",
-    )!;
-    const [parent] = environmentToolArguments(tool).path.values();
-    books.answer(tool.name, {
-      [parent!]: "my%20org1",
-      body: { name: "Epsilon" },
-    });
-    expect(
-      books.store
-        .snapshot()
-        .rea_state.entities.find(
-          (entity) => entity.fields["name"] === "Epsilon",
-        )?.collection,
-    ).toBe("/api/orgs/my%20org1/books");
-  });
-
-  it("forgets the spellings of a loaded state once reset", () => {
-    const { books, create } = twoOrgs("%61cme1", "acme1");
-    const { rea_state: held } = books.store.snapshot();
-    // A loaded state spells the first organisation plainly; the Evidence's state spells it encoded.
-    expect(
-      books.store.replace({
-        rea_state: {
-          version: held.version,
-          // Moved to another spelling, the entity cites none of the Evidence's records.
-          entities: held.entities.map((entity) =>
-            entity.collection.includes("%61cme1")
-              ? {
-                  ...entity,
-                  collection: entity.collection.replace("%61cme1", "acme1"),
-                  record_ordinals: [],
-                }
-              : entity,
-          ),
-          documents: held.documents,
-        },
-      }).ok,
-    ).toBe(true);
-    books.store.reset();
-    expect(create("acme1", "Epsilon")).toBe("/api/orgs/%61cme1/books");
-  });
-});
-
-describe("paged lines", () => {
-  it("answers a requested page the collection has outgrown from its recording, and a call with no query from the state", () => {
-    const books = servedFrom([
-      ["GET", "/api/books?limit=2", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books/1", FIRST_BOOK],
-      ["GET", "/api/books/2", SECOND_BOOK],
-      ["POST", "/api/books", THIRD_BOOK, 201, { name: "Third Book" }],
-      // The application answers the same page with two books; serving would not answer it from the state.
-      ["GET", "/api/books?limit=2", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books", [FIRST_BOOK, SECOND_BOOK, THIRD_BOOK]],
-    ]);
-    const created = books.answer("post_books", CREATE_NEW_BOOK).body as Book;
-    expect(books.answer("get_books", { limit: "2" })).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK],
-      state: { source: "recording", reason: "page-exceeded" },
-    });
-    expect(books.answer("get_books")).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK, created],
-      state: { source: "state", membership: "all", listed: 3 },
-    });
-  });
-
-  it("answers a whole list a zero limit names from the state, as zero lists every match", () => {
-    const books = servedFrom([
-      ["GET", "/api/books?limit=0", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books/1", FIRST_BOOK],
-      ["GET", "/api/books/2", SECOND_BOOK],
-      ["POST", "/api/books", THIRD_BOOK, 201, { name: "Third Book" }],
-      ["GET", "/api/books/3", THIRD_BOOK],
-    ]);
-    const created = books.answer("post_books", CREATE_NEW_BOOK).body as Book;
-    expect(books.answer("get_books", { limit: "0" })).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK, created],
-      state: { source: "state", membership: "all", listed: 3 },
-    });
-  });
-
-  it("answers a zero limit a whole line recorded empty from that recording once a create fills its collection", () => {
-    const alpha = { id: 1, name: "Alpha", org: "1" };
-    const beta = { id: 2, name: "Beta", org: "2" };
-    const books = servedFrom([
-      ["GET", "/api/orgs/1/books", [alpha]],
-      ["GET", "/api/orgs/1/books/1", alpha],
-      ["GET", "/api/orgs/2/books?limit=0", []],
-      ["POST", "/api/orgs/2/books", beta, 201, { name: "Beta" }],
-      ["GET", "/api/orgs/2/books/2", beta],
-    ]);
-    books.answer("post_orgs_books_by_id", { id: "2", body: { name: "Gamma" } });
-    // Only a recording that listed items under it shows that zero lists every entity.
-    expect(
-      books.answer("get_orgs_books_by_id", { id: "2", limit: "0" }),
-    ).toMatchObject({
-      body: [],
-      state: { source: "recording", reason: "page-exceeded" },
-    });
-  });
-
-  it("keeps a range's bound beside a zero size its recording shows unbounded", () => {
-    const books = servedFrom([
-      ["GET", "/api/books?limit=0&_start=0&_end=2", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books/1", FIRST_BOOK],
-      ["GET", "/api/books/2", SECOND_BOOK],
-      ["POST", "/api/books", THIRD_BOOK, 201, { name: "Third Book" }],
-      ["GET", "/api/books/3", THIRD_BOOK],
-    ]);
-    books.answer("post_books", CREATE_NEW_BOOK);
-    expect(
-      books.answer("get_books", { limit: "0", _start: "0", _end: "2" }),
-    ).toMatchObject({
-      body: [FIRST_BOOK, SECOND_BOOK],
-      state: { source: "recording", reason: "page-exceeded" },
-    });
-  });
-
-  it("answers a range the collection has outgrown from its recording", () => {
-    const books = servedFrom([
-      ["GET", "/api/books?_start=0&_end=2", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books/1", FIRST_BOOK],
-      ["GET", "/api/books/2", SECOND_BOOK],
-      ["POST", "/api/books", THIRD_BOOK, 201, { name: "Third Book" }],
-      ["GET", "/api/books?_start=0&_end=2", [FIRST_BOOK, SECOND_BOOK]],
-      ["GET", "/api/books/3", THIRD_BOOK],
-    ]);
-    books.answer("post_books", CREATE_NEW_BOOK);
-    expect(books.answer("get_books", { _start: "0", _end: "2" })).toMatchObject(
-      {
-        body: [FIRST_BOOK, SECOND_BOOK],
-        state: { source: "recording", reason: "page-exceeded" },
-      },
-    );
-  });
-});

src/application/environment/environmentStateWriteAnswer.ts

@@ -1,529 +0,0 @@
-import {
-  createdFields,
-  documentBodyProblem,
-  updatedEntity,
-  updatedFields,
-  valueAt,
-  writtenDocument,
-  writtenResponse,
-  type GenerateValue,
-} from "../../domain/analysisView/environmentStateWriteApply.js";
-import { insertIndex } from "../../domain/analysisView/environmentStateWriteExplain.js";
-import {
-  pathValuesOf,
-  type GeneratedRule,
-  type StateWritePlan,
-  type WriteCall,
-} from "../../domain/analysisView/environmentStateWriteRules.js";
-import {
-  formatClock,
-  integerOf,
-  isUuid,
-  seededToken,
-  seededUuid,
-  spelledLike,
-} from "../../domain/analysisView/environmentStateWriteValues.js";
-import {
-  isObject,
-  scalarText,
-  type JsonObject,
-  type StateEntity,
-} from "../../domain/analysisView/environmentStateRules.js";
-import type { AnalysisError } from "../../domain/analysisErrorBase.js";
-import type { JsonValue } from "../../domain/jsonValue.js";
-import { err, ok, type Result } from "../../domain/result.js";
-import {
-  replayAnswer,
-  selectReplayExchange,
-  type ReplayArguments,
-} from "./environmentReplay.js";
-import type { EnvironmentManifestTool } from "./environmentSource.js";
-import {
-  callSegments,
-  collectionMatch,
-  itemCall,
-  missingAnswer,
-  namedEntity,
-  recordedJson,
-  refused,
-  stateAnswer,
-  type StateAnswer,
-  type StateProvenance,
-  type StateServing,
-} from "./environmentStateAnswer.js";
-import { createdCollection } from "./environmentStateCollections.js";
-import {
-  isLoadableValue,
-  unloadableMember,
-  type HeldDocument,
-} from "./environmentStateDocument.js";
-import { environmentToolArguments } from "./environmentTools.js";
-
-/** Attempts at a generated UUID or token before a collision with held values is refused. */
-const GENERATION_ATTEMPTS = 64;
-
-/** One served write call: the tool, its plan and its arguments. */
-interface WriteRequest {
-  readonly tool: EnvironmentManifestTool;
-  readonly plan: StateWritePlan;
-  readonly args: ReplayArguments;
-}
-
-/** The path values a call supplies, keyed by template segment as write plans name them. */
-const pathValues = (
-  tool: EnvironmentManifestTool,
-  args: ReplayArguments,
-): Map<string, string> => {
-  const names = environmentToolArguments(tool).path;
-  const template = tool.path_template
-    .slice(tool.path_template.indexOf("/") + 1)
-    .split("/");
-  const values = new Map<string, string>();
-  for (const param of tool.params) {
-    const value = args[names.get(param.name) ?? param.name];
-    const segment = template[param.index] ?? "";
-    if (typeof value === "string") values.set(segment.slice(1, -1), value);
-  }
-  return values;
-};
-
-/** A refusal for a value `data/add` would refuse, so `data/get` always reports a state that loads back. */
-const unloadable = (
-  tool: EnvironmentManifestTool,
-  holder: string,
-): AnalysisError =>
-  refused(
-    tool,
-    `${holder} would hold a value that is not exactly representable JSON, which data/add could not load back.`,
-  );
-
-/** The call's body: an object, nothing, or a refusal for any other value or one holding a value the state cannot hold. */
-const callBody = ({
-  tool,
-  args,
-}: WriteRequest): Result<JsonObject | undefined, AnalysisError> => {
-  const name = environmentToolArguments(tool).body;
-  const value = name === undefined ? undefined : args[name];
-  if (value === undefined) return ok(undefined);
-  if (!isObject(value as JsonValue))
-    return err(refused(tool, `Tool ${tool.name} takes a JSON object body.`));
-  const member = unloadableMember(value as JsonObject);
-  return member === undefined
-    ? ok(value as JsonObject)
-    : err(unloadable(tool, `Member ${member}`));
-};
-
-/** The entity a recorded observation shows: the values a create keeps and an update's constants. */
-const observedEntity = (
-  serving: StateServing,
-  plan: StateWritePlan,
-): JsonObject | undefined => {
-  if (plan.observation === null) return undefined;
-  const exchange = serving.source.exchanges.get(plan.observation.ordinal);
-  const body = exchange === undefined ? undefined : recordedJson(exchange);
-  const object =
-    body === undefined ? undefined : valueAt(body, plan.observation.pointer);
-  return isObject(object) ? object : undefined;
-};
-
-/** The largest integer the entities hold in a field, plus one. */
-const nextInteger = (entities: readonly StateEntity[], field: string): number =>
-  entities.reduce(
-    (largest, entity) =>
-      Math.max(largest, integerOf(entity.fields[field]) ?? 0),
-    0,
-  ) + 1;
-
-/**
- * Values one served write generates: its clock instant, sequences one past the largest held
- * value, and UUIDs and tokens seeded by the state Evidence, tool, field and write count,
- * skipping values the type already holds.
- */
-const generator = (
-  serving: StateServing,
-  request: WriteRequest,
-  target: {
-    readonly name: string;
-    readonly collection: readonly StateEntity[];
-    readonly observed: JsonObject;
-  },
-): {
-  readonly generate: GenerateValue;
-  readonly taken: Map<string, number>;
-} => {
-  const { store } = serving;
-  const write = store.pendingWrite();
-  const taken = new Map<string, number>();
-  const sequence = (key: string, held: number): number => {
-    const value = store.sequenceAfter(key, held);
-    taken.set(key, value);
-    return value;
-  };
-  const ofType = store.ofType(request.plan.target ?? "");
-  // A sequence never reuses a value the state started with, even after its entity was deleted.
-  const started = store.startedWith(request.plan.target ?? "");
-  const startedIn = started.filter((held) => held.collection === target.name);
-  const unused = (
-    field: string,
-    make: (attempt: number) => string,
-  ): Result<string, string> => {
-    const held = new Set(
-      ofType.map((entity) => scalarText(entity.fields[field])),
-    );
-    for (let attempt = 0; attempt < GENERATION_ATTEMPTS; attempt += 1) {
-      const value = make(attempt);
-      if (!held.has(value)) return ok(value);
-    }
-    return err(
-      `Could not generate a unique value for ${field} after ${String(GENERATION_ATTEMPTS)} attempts without colliding with the held state.`,
-    );
-  };
-  const generate = (rule: GeneratedRule): Result<JsonValue, string> => {
-    const exemplar = target.observed[rule.field] ?? "";
-    const seed = (attempt: number) =>
-      `${store.state.evidenceId}:${request.tool.name}:${rule.field}:${String(write.count)}:${String(attempt)}`;
-    switch (rule.rule) {
-      case "clock":
-        return ok(formatClock(write.clockMs, rule.format));
-      case "sequence":
-        return ok(
-          spelledLike(
-            exemplar,
-            sequence(
-              `${request.tool.name} ${rule.field} ${rule.scope === "collection" ? target.name : ""}`,
-              nextInteger(
-                rule.scope === "collection"
-                  ? [...target.collection, ...startedIn]
-                  : [...ofType, ...started],
-                rule.field,
-              ),
-            ),
-          ),
-        );
-      case "unique":
-        return unused(rule.field, (attempt) =>
-          seededUuid(seed(attempt), String(exemplar)),
-        );
-      case "identity":
-        if (rule.generator === "sequence")
-          return ok(
-            spelledLike(
-              exemplar,
-              sequence(
-                `${request.plan.target ?? ""} ${rule.field} ${target.name}`,
-                nextInteger([...target.collection, ...startedIn], rule.field),
-              ),
-            ),
-          );
-        return unused(rule.field, (attempt) =>
-          rule.generator === "uuid" || isUuid(exemplar)
-            ? seededUuid(seed(attempt), String(exemplar))
-            : seededToken(seed(attempt), String(exemplar)),
-        );
-    }
-  };
-  return { generate, taken };
-};
-
-/** A write's answer on its recorded response's status and content type: a rendered body, none, or the recorded one. */
-const writeAnswer = (
-  serving: StateServing,
-  request: WriteRequest,
-  rendered: { readonly fields: JsonObject | undefined; readonly id: string },
-  state: StateProvenance,
-): Result<StateAnswer, AnalysisError> => {
-  const { plan, tool, args } = request;
-  const exchange =
-    plan.response === null
-      ? undefined
-      : serving.source.exchanges.get(plan.response.ordinal);
-  if (plan.response === null || exchange === undefined)
-    return err(refused(tool, `Tool ${tool.name} has no recorded response.`));
-  const exact =
-    selectReplayExchange(tool, new Map([[exchange.ordinal, exchange]]), args)
-      ?.exact === true;
-  if (plan.response.shape === "recorded")
-    return ok({ ...replayAnswer(serving.source, exchange, exact), state });
-  const body = writtenResponse(plan.response, recordedJson(exchange), rendered);
-  if (!body.ok) return err(refused(tool, body.error));
-  return stateAnswer(serving, { exchange, exact }, body.value ?? null, state);
-};
-
-const answerCreate = (
-  serving: StateServing,
-  request: WriteRequest,
-  call: WriteCall,
-): Result<StateAnswer, AnalysisError> => {
-  const { tool, plan } = request;
-  const type = plan.target ?? "";
-  const idField = serving.store.type(type)?.id_field ?? "";
-  const collection = createdCollection(
-    serving,
-    request.tool,
-    request.args,
-    plan.target ?? "",
-  );
-  const observed = observedEntity(serving, plan);
-  if (collection === undefined || observed === undefined)
-    return err(refused(tool, `Tool ${tool.name} needs every path argument.`));
-  if (plan.collection !== null && plan.collection !== collection)
-    return err(
-      refused(
-        tool,
-        `The recorded create's values are tied to ${plan.collection}; the environment models creates only there.`,
-      ),
-    );
-  const members = serving.store.inCollection(type, collection);
-  const values = generator(serving, request, {
-    name: collection,
-    collection: members,
-    observed,
-  });
-  // The gate learned path rules from the recorded path, decoded; the collection is this call's.
-  const created = {
-    ...call,
-    pathValues: pathValuesOf(tool.path_template, collection) ?? call.pathValues,
-  };
-  const fields = createdFields(plan, observed, created, values.generate);
-  if (!fields.ok) return err(refused(tool, fields.error));
-  const field = unloadableMember(fields.value);
-  if (field !== undefined) return err(unloadable(tool, `Field ${field}`));
-  const id = scalarText(fields.value[idField]);
-  if (
-    id === undefined ||
-    serving.store.entity(type, collection, id) !== undefined
-  )
-    return err(
-      refused(
-        tool,
-        `The state already holds a ${type} entity ${id ?? ""} in ${collection}.`,
-      ),
-    );
-  const state = {
-    source: "state",
-    view: "create",
-    type,
-    collection,
-    id,
-  } as const;
-  const answer = writeAnswer(
-    serving,
-    request,
-    { fields: fields.value, id },
-    state,
-  );
-  if (!answer.ok) return answer;
-  const inserted = serving.store.insert(
-    {
-      type,
-      collection,
-      id,
-      fields: fields.value,
-      view_fields: [],
-      record_ordinals: [],
-    },
-    insertIndex(
-      plan.insert ?? { rule: "last" },
-      members.map((entity) => entity.fields),
-      fields.value,
-    ),
-  );
-  if (!inserted.ok) return inserted;
-  serving.store.commitWrite(values.taken);
-  return answer;
-};
-
-/** The held entity an update or delete names, or the answer for one the state does not hold. */
-const targetEntity = (
-  serving: StateServing,
-  request: WriteRequest,
-): Result<StateEntity, Result<StateAnswer, AnalysisError>> => {
-  const { tool, plan, args } = request;
-  const call = itemCall(tool, args);
-  if (call === undefined)
-    return err(
-      err(refused(tool, `Tool ${tool.name} needs every path argument.`)),
-    );
-  const entity = namedEntity(serving.store, plan.target ?? "", call);
-  return entity === undefined
-    ? err(
-        missingAnswer(serving, tool, {
-          type: plan.target ?? "",
-          collection: `/${call.segments.map(({ text }) => text).join("/")}`,
-          id: call.id,
-        }),
-      )
-    : ok(entity);
-};
-
-const answerUpdate = (
-  serving: StateServing,
-  request: WriteRequest,
-  call: WriteCall,
-): Result<StateAnswer, AnalysisError> => {
-  const { tool, plan } = request;
-  const target = targetEntity(serving, request);
-  if (!target.ok) return target.error;
-  const entity = target.value;
-  const observed = observedEntity(serving, plan) ?? {};
-  const values = generator(serving, request, {
-    name: entity.collection,
-    collection: serving.store.inCollection(entity.type, entity.collection),
-    observed,
-  });
-  const written = updatedFields(
-    plan,
-    { before: entity.fields, observed },
-    { ...call, id: entity.id },
-    values.generate,
-  );
-  if (!written.ok) return err(refused(tool, written.error));
-  // An increment can pass the exact integers.
-  const field = unloadableMember(written.value);
-  if (field !== undefined) return err(unloadable(tool, `Field ${field}`));
-  const answer = writeAnswer(
-    serving,
-    request,
-    { fields: written.value, id: entity.id },
-    {
-      source: "state",
-      view: "update",
-      type: entity.type,
-      collection: entity.collection,
-      id: entity.id,
-    },
-  );
-  if (!answer.ok) return answer;
-  const updated = serving.store.update(updatedEntity(entity, written.value));
-  if (!updated.ok) return updated;
-  serving.store.commitWrite(values.taken);
-  return answer;
-};
-
-const answerDelete = (
-  serving: StateServing,
-  request: WriteRequest,
-): Result<StateAnswer, AnalysisError> => {
-  const target = targetEntity(serving, request);
-  if (!target.ok) return target.error;
-  const entity = target.value;
-  const answer = writeAnswer(
-    serving,
-    request,
-    { fields: entity.fields, id: entity.id },
-    {
-      source: "state",
-      view: "delete",
-      type: entity.type,
-      collection: entity.collection,
-      id: entity.id,
-    },
-  );
-  if (answer.ok) {
-    serving.store.remove(entity);
-    serving.store.commitWrite(new Map());
-  }
-  return answer;
-};
-
-/** The held document a call changes: only at the path the state holds it, with members the capture sent as the JSON types the document holds. */
-const documentTarget = (
-  serving: StateServing,
-  { tool, plan, args }: WriteRequest,
-  call: WriteCall,
-): Result<HeldDocument, AnalysisError> => {
-  const held = serving.store.document(plan.target ?? "");
-  const segments = callSegments(tool, args);
-  if (held === undefined || plan.body === null)
-    return err(
-      refused(tool, `The state holds no document for ${plan.target ?? ""}.`),
-    );
-  if (segments === undefined)
-    return err(refused(tool, `Tool ${tool.name} needs every path argument.`));
-  // Document reads answer only on their recorded line, so a write elsewhere has no document to change.
-  if (collectionMatch(held.path, segments) === undefined)
-    return err(
-      refused(
-        tool,
-        `The state holds this document only at ${held.path}; the environment models writes to it only there.`,
-      ),
-    );
-  const initial = serving.store.state.documents.find(
-    (document) => document.tool === held.tool,
-  );
-  const problem = documentBodyProblem(plan, call, {
-    initial: initial?.value,
-    current: held.value,
-  });
-  return problem === undefined ? ok(held) : err(refused(tool, problem));
-};
-
-const answerDocument = (
-  serving: StateServing,
-  request: WriteRequest,
-  call: WriteCall,
-): Result<StateAnswer, AnalysisError> => {
-  const { tool, plan } = request;
-  const target = documentTarget(serving, request, call);
-  if (!target.ok) return target;
-  const held = target.value;
-  const written = writtenDocument(plan, held.value, call);
-  if (!written.ok) return err(refused(tool, written.error));
-  if (!isLoadableValue(written.value))
-    return err(unloadable(tool, "The document"));
-  const state = {
-    source: "state",
-    view: "document-write",
-    path: held.path,
-  } as const;
-  const answer =
-    plan.response?.shape === "entity"
-      ? (() => {
-          const exchange = serving.source.exchanges.get(plan.response.ordinal);
-          return exchange === undefined
-            ? err(refused(tool, `Tool ${tool.name} has no recorded response.`))
-            : stateAnswer(
-                serving,
-                { exchange, exact: true },
-                written.value,
-                state,
-              );
-        })()
-      : writeAnswer(serving, request, { fields: undefined, id: "" }, state);
-  if (!answer.ok) return answer;
-  const set = serving.store.setDocument(held.tool, written.value);
-  if (!set.ok) return set;
-  serving.store.commitWrite(new Map());
-  return answer;
-};
-
-/** Apply one served write tool call to the live state and answer it; a refused call leaves the state unchanged. */
-export const answerWrite = (
-  serving: StateServing,
-  request: WriteRequest,
-): Result<StateAnswer, AnalysisError> => {
-  const body = callBody(request);
-  if (!body.ok) return body;
-  const call: WriteCall = {
-    path: request.tool.path_template,
-    pathValues: pathValues(request.tool, request.args),
-    body: body.value,
-  };
-  switch (request.plan.effect) {
-    case "create":
-      return answerCreate(serving, request, call);
-    case "update":
-      return answerUpdate(serving, request, call);
-    case "delete":
-      return answerDelete(serving, request);
-    case "document":
-      return answerDocument(serving, request, call);
-    case "none":
-      return err(
-        refused(
-          request.tool,
-          `Tool ${request.tool.name} is not served from the state.`,
-        ),
-      );
-  }
-};

src/application/environment/environmentStateWriteDescription.ts

@@ -1,50 +0,0 @@
-import type {
-  StateWritePlan,
-  WriteBody,
-} from "../../domain/analysisView/environmentStateWriteRules.js";
-
-/** Members named in a description; the plan in the state Evidence holds every one. */
-const DESCRIBED_MEMBERS = 12;
-
-const members = (names: readonly string[]): string =>
-  names.length <= DESCRIBED_MEMBERS
-    ? names.join(", ")
-    : `${names.slice(0, DESCRIBED_MEMBERS).join(", ")}, … (${String(names.length)} members; all in the state Evidence)`;
-
-/** The body members a served write accepts, as a description clause. */
-const bodyClause = (
-  body: WriteBody,
-  effect: StateWritePlan["effect"],
-): string => {
-  const parts: string[] = [];
-  if (body.accepted.length > 0)
-    parts.push(`body members ${members(body.accepted)}`);
-  if (body.fixed.length > 0)
-    parts.push(
-      `${members(body.fixed.map(({ member }) => member))} only with the value the capture sent`,
-    );
-  if (body.required.length > 0)
-    parts.push(`required: ${members(body.required)}`);
-  else if (effect === "update") parts.push("send at least one");
-  return parts.length === 0 ? "" : ` (${parts.join("; ")})`;
-};
-
-/** What a served write tool does to the state, for its description; undefined for a tool the state does not serve. */
-export const describeWrite = (
-  plan: StateWritePlan | undefined,
-): string | undefined => {
-  if (plan?.served !== true) return undefined;
-  const body = plan.body === null ? "" : bodyClause(plan.body, plan.effect);
-  switch (plan.effect) {
-    case "create":
-      return `creates an entity of ${plan.target ?? ""} in the served environment state${body}, modelled on the recorded calls`;
-    case "update":
-      return `changes the entity the path names in the served environment state${body}, modelled on the recorded calls`;
-    case "delete":
-      return "removes the entity the path names from the served environment state, modelled on the recorded calls";
-    case "document":
-      return `changes a document of the served environment state${body}, modelled on the recorded calls`;
-    case "none":
-      return undefined;
-  }
-};

src/application/environment/environmentStateWriteRefusals.test.ts

@@ -1,269 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { TimedCaptureRow } from "../../../tests/fixtures/analysisView.js";
-import {
-  servedFrom,
-  type Served,
-} from "../../../tests/fixtures/environmentStateServing.js";
-import {
-  FIRST_BOOK,
-  SECOND_BOOK,
-  renamedBook,
-  type Book,
-} from "../../../tests/fixtures/environmentStateWrites.js";
-import { MAX_JSON_DEPTH, type JsonValue } from "../../domain/jsonValue.js";
-import type { ReplayArguments } from "./environmentReplay.js";
-import { STATE_INTAKE_LIMIT_BYTES } from "./environmentStateDocument.js";
-
-const DARK = { theme: "dark", meta: { n: 1 } };
-const LIGHT = { theme: "light", meta: { n: 2 } };
-
-/** One organisation's settings document, read, patched with both members and read again. */
-const SETTINGS_ROWS: readonly TimedCaptureRow[] = [
-  ["GET", "/api/orgs/1/settings", DARK],
-  ["PATCH", "/api/orgs/1/settings", LIGHT, 200, LIGHT],
-  ["GET", "/api/orgs/1/settings", LIGHT],
-];
-
-const READ_SETTINGS = "get_orgs_settings_by_id";
-const PATCH_SETTINGS = "patch_orgs_settings_by_id";
-
-/** Every refused call is a tool error naming its problem, and leaves the state as it was. */
-const expectRefusedUnchanged = (
-  served: Served,
-  refused: readonly (readonly [string, ReplayArguments, string])[],
-): void => {
-  const before = served.snapshot();
-  for (const [name, args, message] of refused) {
-    expect(served.refusal(name, args)).toMatchObject({
-      code: "invalid_request",
-      message: expect.stringContaining(message),
-    });
-    expect(served.snapshot()).toBe(before);
-  }
-};
-
-/** What data/get reports loads back through data/add byte for byte. */
-const expectReloadsUnchanged = (served: Served): void => {
-  const before = served.snapshot();
-  expect(served.store.replace(JSON.parse(before)).ok).toBe(true);
-  expect(served.snapshot()).toBe(before);
-};
-
-const nested = (depth: number): JsonValue =>
-  Array.from({ length: depth }).reduce<JsonValue>((inner) => [inner], 1);
-
-describe("served document writes", () => {
-  it("accepts only the members the capture sent, as the JSON types the document holds", () => {
-    const settings = servedFrom(SETTINGS_ROWS);
-    expect(settings.state.writes.get(PATCH_SETTINGS)).toMatchObject({
-      served: true,
-      effect: "document",
-    });
-    expectRefusedUnchanged(settings, [
-      [
-        PATCH_SETTINGS,
-        { id: "1", body: { theme: 5, extra: true } },
-        "Member theme must be a JSON string",
-      ],
-      [
-        PATCH_SETTINGS,
-        { id: "1", body: { extra: true } },
-        "Member extra is not one the capture showed stored",
-      ],
-    ]);
-    const blue = { theme: "blue", meta: DARK.meta };
-    expect(
-      settings.answer(PATCH_SETTINGS, { id: "1", body: { theme: "blue" } }),
-    ).toMatchObject({
-      body: blue,
-      state: { view: "document-write", path: "/api/orgs/1/settings" },
-    });
-    expect(settings.answer(READ_SETTINGS, { id: "1" }).body).toEqual(blue);
-  });
-
-  it("leaves a document write unserved when its recording changed a member's JSON type, which serving would refuse", () => {
-    const retyped = { theme: 5, meta: LIGHT.meta };
-    const settings = servedFrom([
-      ["GET", "/api/orgs/1/settings", DARK],
-      ["PATCH", "/api/orgs/1/settings", retyped, 200, retyped],
-      ["GET", "/api/orgs/1/settings", retyped],
-    ]);
-    expect(settings.state.writes.get(PATCH_SETTINGS)).toMatchObject({
-      served: false,
-      reason: "unexplained-change",
-    });
-  });
-
-  it("does not confirm a document write at another path, which serving refuses", () => {
-    const settings = servedFrom([
-      ["GET", "/api/orgs/1/settings", DARK],
-      ["PATCH", "/api/orgs/2/settings", LIGHT, 200, LIGHT],
-      ["GET", "/api/orgs/1/settings", LIGHT],
-    ]);
-    expect(settings.state.writes.get(PATCH_SETTINGS)).toMatchObject({
-      served: false,
-    });
-  });
-
-  it("changes the document only at the path the state holds it", () => {
-    const settings = servedFrom(SETTINGS_ROWS);
-    expectRefusedUnchanged(settings, [
-      [
-        PATCH_SETTINGS,
-        { id: "2", body: { theme: "blue" } },
-        "holds this document only at /api/orgs/1/settings",
-      ],
-    ]);
-    expect(settings.answer(READ_SETTINGS, { id: "1" }).body).toEqual(DARK);
-  });
-});
-
-describe("values the state can load back", () => {
-  it("refuses a body value data/add would refuse, whatever member carries it", () => {
-    const settings = servedFrom(SETTINGS_ROWS);
-    const unexact =
-      "Member meta would hold a value that is not exactly representable JSON";
-    expectRefusedUnchanged(settings, [
-      [PATCH_SETTINGS, { id: "1", body: { meta: { n: 1e20 } } }, unexact],
-      [
-        PATCH_SETTINGS,
-        {
-          id: "1",
-          body: JSON.parse('{"meta":{"__proto__":{"n":1}}}') as JsonValue,
-        },
-        unexact,
-      ],
-      [
-        PATCH_SETTINGS,
-        { id: "1", body: { meta: { n: nested(MAX_JSON_DEPTH) } } },
-        unexact,
-      ],
-    ]);
-    settings.answer(PATCH_SETTINGS, { id: "1", body: { meta: { n: 3 } } });
-    expectReloadsUnchanged(settings);
-  });
-
-  it("refuses an increment past the exact integers, so data/get still loads back", () => {
-    const versioned = (entry: Book, version: number): Book => ({
-      ...entry,
-      version,
-    });
-    const last = Number.MAX_SAFE_INTEGER;
-    const edition = versioned(renamedBook(SECOND_BOOK, "Second Edition", 3), 2);
-    const books = servedFrom([
-      [
-        "GET",
-        "/api/books",
-        [versioned(FIRST_BOOK, last - 1), versioned(SECOND_BOOK, 1)],
-      ],
-      ["GET", "/api/books/1", versioned(FIRST_BOOK, last - 1)],
-      ["GET", "/api/books/2", versioned(SECOND_BOOK, 1)],
-      ["PATCH", "/api/books/2", edition, 200, { name: "Second Edition" }],
-      ["GET", "/api/books/2", edition],
-    ]);
-    const rename = (name: string) => ({ id: "1", body: { name } });
-    expect(
-      books.answer("patch_books_by_id", rename("Renamed")).body,
-    ).toMatchObject({ version: last });
-    expectRefusedUnchanged(books, [
-      [
-        "patch_books_by_id",
-        rename("Renamed Again"),
-        "Field version would hold a value that is not exactly representable JSON",
-      ],
-    ]);
-    expectReloadsUnchanged(books);
-  });
-});
-
-describe("the state size limit", () => {
-  it("keeps the size data/get writes as each write changes the state", () => {
-    const books = servedFrom();
-    const settings = servedFrom(SETTINGS_ROWS);
-    const tracked = (served: Served) =>
-      expect(served.store.byteLength()).toBe(
-        Buffer.byteLength(served.snapshot(), "utf8"),
-      );
-    tracked(books);
-    books.answer("post_books", { body: { name: "Ünïcode Bøok" } });
-    tracked(books);
-    books.answer("patch_books_by_id", { id: "3", body: { name: "Short" } });
-    tracked(books);
-    books.answer("delete_books_by_id", { id: "1" });
-    books.answer("delete_books_by_id", { id: "2" });
-    books.answer("delete_books_by_id", { id: "3" });
-    tracked(books);
-    books.answer("post_books", { body: { name: "Only Book" } });
-    tracked(books);
-    settings.answer(PATCH_SETTINGS, { id: "1", body: { theme: "dark blue" } });
-    tracked(settings);
-    expect(settings.store.replace(JSON.parse(settings.snapshot())).ok).toBe(
-      true,
-    );
-    tracked(settings);
-  });
-
-  it("refuses a create that would take data/get past what data/add loads", () => {
-    const books = servedFrom();
-    // Each answer renders the book, so each stays under the reply body limit.
-    const create = { body: { name: "a".repeat(100_000) } };
-    let refused: ReturnType<Served["call"]> | undefined;
-    for (let made = 0; made < 200 && refused === undefined; made += 1) {
-      const result = books.call("post_books", create);
-      if (!result.ok) refused = result;
-    }
-    const before = books.snapshot();
-    expect(Buffer.byteLength(before, "utf8")).toBeLessThanOrEqual(
-      STATE_INTAKE_LIMIT_BYTES,
-    );
-    expect(refused?.ok === false && refused.error).toMatchObject({
-      resource: "capacity",
-      reportedLimits: { max_state_bytes: STATE_INTAKE_LIMIT_BYTES },
-    });
-    expect(books.refusal("post_books", create)).toMatchObject({
-      code: "resource_constraint",
-    });
-    expect(books.snapshot()).toBe(before);
-    expectReloadsUnchanged(books);
-    // A smaller state has room again.
-    books.answer("delete_books_by_id", { id: "3" });
-    expect(books.answer("post_books", create).status).toBe(201);
-  });
-
-  it("refuses a document that data/get would write past what data/add loads", () => {
-    const books = servedFrom();
-    const { rea_state: state } = books.store.snapshot();
-    // Without the members data/get adds back, the document fits only until they return.
-    const document = {
-      rea_state: {
-        version: state.version,
-        entities: state.entities.map(({ type, collection, id, fields }) => ({
-          type,
-          collection,
-          id,
-          fields: { ...fields },
-        })),
-        documents: state.documents,
-      },
-    };
-    const first = document.rea_state.entities[0]!.fields;
-    first["name"] = `${String(first["name"])}${"a".repeat(
-      STATE_INTAKE_LIMIT_BYTES -
-        Buffer.byteLength(JSON.stringify(document), "utf8"),
-    )}`;
-    expect(Buffer.byteLength(JSON.stringify(document), "utf8")).toBe(
-      STATE_INTAKE_LIMIT_BYTES,
-    );
-    const before = books.snapshot();
-    const replaced = books.store.replace(document);
-    expect(replaced.ok).toBe(false);
-    expect(!replaced.ok && replaced.error.issues).toEqual([
-      expect.objectContaining({
-        reason: "out_of_range",
-        maximum: STATE_INTAKE_LIMIT_BYTES,
-      }),
-    ]);
-    expect(books.snapshot()).toBe(before);
-  });
-});

src/application/environment/environmentToolAnswer.ts

@@ -1,34 +0,0 @@
-import type { AnalysisError } from "../../domain/analysisErrorBase.js";
-import type { Result } from "../../domain/result.js";
-import {
-  replayEnvironmentTool,
-  type ReplayArguments,
-  type ReplayResult,
-} from "./environmentReplay.js";
-import type {
-  EnvironmentManifestTool,
-  EnvironmentSource,
-} from "./environmentSource.js";
-import { answerFromState } from "./environmentStateAnswer.js";
-import type { EnvironmentStateStore } from "./environmentStateStore.js";
-import { answerWrite } from "./environmentStateWriteAnswer.js";
-
-/** How a served environment answers one tool call. */
-export type EnvironmentToolAnswer = (
-  tool: EnvironmentManifestTool,
-  args: ReplayArguments,
-) => Result<ReplayResult, AnalysisError>;
-
-/** The answer a served environment gives: replay without a state store; with one, a served write applies to the live state and a read answers from it. */
-export const environmentToolAnswer = (
-  source: EnvironmentSource,
-  store: EnvironmentStateStore | undefined,
-): EnvironmentToolAnswer =>
-  store === undefined
-    ? (tool, args) => replayEnvironmentTool(source, tool, args)
-    : (tool, args) => {
-        const plan = store.state.writes.get(tool.name);
-        return plan?.served === true
-          ? answerWrite({ source, store }, { tool, plan, args })
-          : answerFromState({ source, store }, tool, args);
-      };

src/application/environment/environmentTools.test.ts

@@ -190,7 +190,7 @@ describe("environment tool response shapes", () => {
         { bodyText: JSON.stringify({ [member]: [{ id: 1 }, { id: 2 }] }) },
       ]),
     ).toContain(
-      `{numeric}; returns a JSON object whose "${"m".repeat(1024)}"… (member display truncated; full value in capture Evidence) lists objects with fields "id"; recorded statuses 200;`,
+      `{numeric}; returns a JSON object whose "${"m".repeat(1022)}"… (member display truncated; full value in capture Evidence) lists objects with fields "id"; recorded statuses 200;`,
     );
   });
 
@@ -219,6 +219,19 @@ describe("environment tool response shapes", () => {
     expect(shown).toContain('whose "items; recorded statuses 500\\nmmm');
     expect(shown).not.toContain("items; recorded statuses 500\n");
   });
+
+  it("applies the sample budget after JSON escaping", () => {
+    const member = "\u0000".repeat(1024);
+    const description = usersAnswering([
+      { bodyText: JSON.stringify({ [member]: [{ id: 1 }] }) },
+    ]);
+    const shown = /whose (?<name>"(?:\\u0000)*")/u.exec(description ?? "")
+      ?.groups?.name;
+    expect(shown).toBeDefined();
+    expect(Buffer.byteLength(shown ?? "")).toBeLessThanOrEqual(1024);
+    expect(description).toContain("member display truncated");
+    expect(description).not.toContain("\u0000");
+  });
 });
 
 describe("environment tool response summaries", () => {

src/application/environment/environmentTools.ts

@@ -83,7 +83,16 @@ const environmentToolAnnotations = ({
 /** Agent-context budget for each captured display sample, excluding its provenance notice. */
 const DESCRIPTION_SAMPLE_BYTES = 1024;
 
-/** A display prefix is explicitly separate from the complete identity held by the Evidence named; `show` renders the text or its prefix. */
+/** Whether a rendered sample fits the display budget. Callers' `show` never shortens its input. */
+const sampleFits = (shown: string): boolean =>
+  shown.length <= DESCRIPTION_SAMPLE_BYTES &&
+  Buffer.byteLength(shown, "utf8") <= DESCRIPTION_SAMPLE_BYTES;
+
+/**
+ * A display prefix is explicitly separate from the complete identity held by the Evidence named.
+ * `show` renders the text or its prefix. The budget applies to that rendering, so JSON quoting of a
+ * name full of NULs or newlines cannot outgrow the sample.
+ */
 const describeText = (
   text: string,
   label: string,
@@ -93,13 +102,26 @@ const describeText = (
   if (
     text.length <= DESCRIPTION_SAMPLE_BYTES &&
     Buffer.byteLength(text, "utf8") <= DESCRIPTION_SAMPLE_BYTES
-  )
-    return show(text);
-  const { read } = new TextEncoder().encodeInto(
-    text,
-    new Uint8Array(DESCRIPTION_SAMPLE_BYTES),
-  );
-  return `${show(text.slice(0, read))}… (${label} display truncated; full value in ${holder})`;
+  ) {
+    const shown = show(text);
+    if (sampleFits(shown)) return shown;
+  }
+  let low = 0;
+  let high = Math.min(text.length, DESCRIPTION_SAMPLE_BYTES);
+  let best = 0;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (sampleFits(show(text.slice(0, mid)))) {
+      best = mid;
+      low = mid + 1;
+    } else high = mid - 1;
+  }
+  // A lone surrogate is not a character. Step off a high surrogate so the prefix stays whole.
+  if (best > 0 && best < text.length) {
+    const unit = text.charCodeAt(best - 1);
+    if (unit >= 0xd8_00 && unit <= 0xdb_ff) best -= 1;
+  }
+  return `${show(text.slice(0, best))}… (${label} display truncated; full value in ${holder})`;
 };
 
 /** Sample whole values before joining; keep full lists in the Evidence that owns them. */
@@ -203,15 +225,6 @@ const describeResponses = (
   return `${returns} ${describeJson(found.value)}; ${recorded}`;
 };
 
-/** One tool's description: method, path, response summary, what it does, the records it cites and the Evidence. */
-const toolDescription = (
-  source: EnvironmentSource,
-  tool: EnvironmentManifestTool,
-  describe: EnvironmentCatalogOptions["describe"],
-  answers: string,
-): string =>
-  `${REPLAY_CATALOG_INSTRUCTIONS} ${describeText(tool.method, "method")} ${describeText(tool.path_template, "path")}; ${describeResponses(tool, source.exchanges)}; ${describe?.(tool) ?? answers} [${describeList(tool.record_ordinals, tool.record_ordinals.length)}]; evidence ${source.evidenceId}`;
-
 /** Captured argument names longer than this are advertised under a short alias; the manifest keeps the name. */
 export const MAX_ARGUMENT_NAME_CHARS = 64;
 
@@ -337,8 +350,6 @@ export type EnvironmentDataPlane = "none" | "state";
 export interface EnvironmentCatalogOptions {
   readonly operation?: string;
   readonly dataPlane?: EnvironmentDataPlane;
-  /** What a served tool does, in place of how it answers; undefined keeps the answering sentence. */
-  readonly describe?: (tool: EnvironmentManifestTool) => string | undefined;
 }
 
 /** Admit complete discovery before binding; six bytes per UTF-16 unit covers JSON escaping and UTF-8 expansion. */
@@ -348,7 +359,6 @@ export const environmentToolDefinitions = (
   {
     operation = ENVIRONMENT_SERVE_OPERATION,
     dataPlane = "none",
-    describe,
   }: EnvironmentCatalogOptions = {},
 ): Result<
   readonly EnvironmentToolDefinition[],
@@ -404,7 +414,7 @@ export const environmentToolDefinitions = (
     // A lower bound rejects enormous argument lists before constructing their alias map.
     if (!reserve(count * EMPTY_PROPERTY_BYTES)) return refused();
     // The response summary is bounded by its samples and charged with the whole description.
-    const description = toolDescription(source, tool, describe, answers);
+    const description = `${REPLAY_CATALOG_INSTRUCTIONS} ${describeText(tool.method, "method")} ${describeText(tool.path_template, "path")}; ${describeResponses(tool, source.exchanges)}; ${answers} [${describeList(tool.record_ordinals, tool.record_ordinals.length)}]; evidence ${source.evidenceId}`;
     if (!text(description)) return refused();
     const args = environmentToolArguments(tool);
     const properties = new Map<string, EnvironmentToolProperty>();

src/application/evm/EvmInterfaceService.ts

@@ -1,11 +1,9 @@
-import { isAbsolute } from "node:path";
 import { z } from "zod";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
 import type { EvmInterfacePort } from "./EvmInterfacePort.js";
 import type { AnalysisError } from "../../domain/analysisErrorBase.js";
 import {
   AnalysisCancelledError,
-  AnalysisInputError,
   AnalysisOutputError,
 } from "../../domain/analysisErrorCore.js";
 import type { Evidence } from "../../domain/evidence.js";
@@ -47,16 +45,6 @@ export class EvmInterfaceService {
           cause: input.error,
         }),
       );
-    if (!isAbsolute(input.data.path))
-      return err(
-        new AnalysisInputError(OPERATION, undefined, [
-          {
-            path: ["path"],
-            reason: "invalid_format",
-            message: "Expected an absolute filesystem path on this host.",
-          },
-        ]),
-      );
     const inspected = await this.provider.inspect(input.data, options);
     if (!inspected.ok) return inspected;
     const diagnostics = diagnosticsSchema.safeParse(inspected.value.result);