experiment(re): validate guard slices and record token tradeoffs

Verify three repaired zlib mappings, a SQLite call guard and all ordinary 16-bit header values against retained native evidence. Record producer omissions, failed-run costs and the small-function context counterexample. Preserve existing capture outputs with exclusive writes.

Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

.github/workflows/ci.yml

@@ -60,7 +60,6 @@ jobs:
       web_runtime: ${{ steps.plan.outputs.web_runtime }}
       web_source_map: ${{ steps.plan.outputs.web_source_map }}
       nativeaot: ${{ steps.plan.outputs.nativeaot }}
-      ghidra_bridge: ${{ steps.plan.outputs.ghidra_bridge }}
       website: ${{ steps.plan.outputs.website }}
       matrix: ${{ steps.plan.outputs.matrix }}
       test_selection: ${{ steps.plan.outputs.test_selection }}
@@ -140,11 +139,6 @@ jobs:
       - name: Validate workflow syntax and expressions
         if: needs.changes.outputs.workflows == 'true'
         run: go run github.com/rhysd/actionlint/cmd/actionlint@v1.7.7 -shellcheck= -pyflakes=
-      # Code tiers run this source-only policy test in their existing shards.
-      # Workflow-only changes need the guard, without preparing runtime artifacts.
-      - name: Check action pins for workflow-only changes
-        if: needs.changes.outputs.workflows == 'true' && needs.changes.outputs.code != 'true'
-        run: node scripts/run-exact-tests.mjs run tests/boundary/filesystem/workflowActionPinning.test.ts
       - name: Record static task source and execution identity
         continue-on-error: true
         if: needs.changes.outputs.code == 'true'
@@ -905,11 +899,6 @@ jobs:
     if: needs.changes.outputs.nativeaot == 'true'
     uses: ./.github/workflows/nativeaot-fixtures.yml
 
-  ghidra_bridge:
-    needs: [changes, static]
-    if: needs.changes.outputs.ghidra_bridge == 'true'
-    uses: ./.github/workflows/ghidra-bridge-sources.yml
-
   website:
     needs: [changes, static]
     if: needs.changes.outputs.website == 'true'
@@ -945,7 +934,6 @@ jobs:
         web_runtime,
         web_source_map,
         nativeaot,
-        ghidra_bridge,
         website,
       ]
     runs-on: ubuntu-24.04

.github/workflows/ghidra-bridge-sources.yml

@@ -1,48 +0,0 @@
-name: Ghidra bridge source compilation
-
-on:
-  workflow_dispatch:
-  workflow_call:
-
-permissions:
-  contents: read
-
-env:
-  HUSKY: "0"
-
-jobs:
-  ghidra-bridge-sources:
-    name: Compile packaged Ghidra bridge sources
-    runs-on: ubuntu-24.04
-    timeout-minutes: 15
-    env:
-      GHIDRA_RELEASE_URL: https://github.com/NationalSecurityAgency/ghidra/releases/download/Ghidra_12.1.4_build/ghidra_12.1.4_PUBLIC_20260921.zip
-      GHIDRA_RELEASE_SHA256: ddac49f903da9d5bac833e5cc79395098b9c33cfd3279be5f31bd00387d2d4db
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-        with:
-          node-version-file: .nvmrc
-      - name: Validate the SDK pin against the provider's verified release
-        run: node scripts/verify-ghidra-bridge-sources.mjs --check-sdk-pin >> "$GITHUB_ENV"
-      # Only the jars and application.properties are extracted: the check
-      # compiles against them and never launches Ghidra or imports a target.
-      - name: Acquire checksum-verified Ghidra jars in isolated runner storage
-        shell: bash
-        run: |
-          ghidra_root="${RUNNER_TEMP}/rea-ghidra"
-          mkdir -p "${ghidra_root}"
-          curl -fsSL --retry 3 --write-out 'ghidra_download_bytes=%{size_download} ghidra_download_seconds=%{time_total}\n' -o "${ghidra_root}/ghidra.zip" "${GHIDRA_RELEASE_URL}"
-          echo "${GHIDRA_RELEASE_SHA256}  ${ghidra_root}/ghidra.zip" | sha256sum -c -
-          unzip -q "${ghidra_root}/ghidra.zip" '*/Ghidra/*.jar' '*/Ghidra/application.properties' -d "${ghidra_root}"
-          rm "${ghidra_root}/ghidra.zip"
-          properties="$(find "${ghidra_root}" -path '*/Ghidra/application.properties' -print -quit)"
-          test -n "${properties}"
-          echo "GHIDRA_INSTALL_DIR=$(dirname "$(dirname "${properties}")")" >> "${GITHUB_ENV}"
-      # JAVA_HOME_<major>_X64 comes from the runner image, not the env context.
-      - name: Compile bridge sources with the verified runner JDK
-        shell: bash
-        run: |
-          java_home_variable="JAVA_HOME_${GHIDRA_JAVA_MAJOR}_X64"
-          test -n "${!java_home_variable}"
-          JAVA_HOME="${!java_home_variable}" npm run verify:ghidra:bridge-sources -- --verified-sdk

.github/workflows/real-cutter.yml

@@ -22,7 +22,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install --no-install-recommends -y g++-mingw-w64-x86-64
       - run: npm run build:windows-native
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@v4
         with:
           name: cutter-windows-native
           path: native/windows/build/
@@ -53,7 +53,7 @@ jobs:
         uses: ./.github/actions/npm-cache
       - run: npm ci
       - if: matrix.platform == 'Windows'
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        uses: actions/download-artifact@v4
         with:
           name: cutter-windows-native
           path: native/windows/build/
@@ -67,7 +67,7 @@ jobs:
         env:
           EXPECTED_PLATFORM: ${{ matrix.platform }}
         run: npm run verify:cutter
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: cutter-upstream-${{ matrix.platform }}

AGENTS.md

@@ -20,8 +20,6 @@ Give each interpretation and resource a clear owner. Consumers must use that own
 
 Keep proof of ownership separate from validity, editability, and readiness. Malformed owned data may still be safely removable. Unresolved identity or applicability must remain unknown rather than be treated as absent, foreign, or aligned.
 
-For lifecycle changes, follow [ownership and completion invariants](docs/tool-design.md#own-the-lifecycle) and select the applicable [lifecycle regressions](docs/testing.md#lifecycle-regressions). Include late handshakes, cancellation during final cleanup, mixed child outcomes, and cleanup retry where those stages exist; active-execution cancellation alone does not cover finalization.
-
 Assess brittleness in touched code during implementation, debugging, review, and maintenance. Fix the producing representation or ownership rule before adding downstream repairs. Normalize once at the owning boundary using format-aware parsers. Remove superseded representations, aliases, wrappers, and redundant tests after verifying affected consumers. Introduce abstractions only when they remove observed complexity.
 
 When fixing a bug, inspect the producing boundary and affected consumers for duplicated interpretation or unclear ownership. Complete any directly related refactor in the same change and remove superseded code. Passing regression tests alone does not establish that the brittleness is resolved. If related cleanup remains, explain what remains and why.

bridge/hopper_bridge.py

@@ -1057,10 +1057,6 @@ def _serve_connection(connection):
                 ):
                     raise PermissionError("Invalid bridge capability")
                 authenticated = True
-                # The connection grace period only bounds unauthenticated idle
-                # clients. Native analysis and a connected owner's idle time
-                # remain unbounded after capability validation.
-                connection.settimeout(None)
                 _write_message(file, {"id": request_id, "event": {
                     "type": "progress",
                     "phase": "hopper_bridge",
@@ -1152,17 +1148,13 @@ def _run():
     server.bind(REA_SOCKET)
     os.chmod(REA_SOCKET, 0o600)
     server.listen(1)
-    # A bridge can start after its caller's startup/cleanup deadline. Bound
-    # the first accept as well as reconnects so an orphan cannot pin Hopper's
-    # dedicated Python thread and prevent later documents from starting REA.
-    server.settimeout(REA_RECONNECT_TIMEOUT_SECONDS)
     try:
         while True:
             try:
                 connection, _ = server.accept()
             except socket.timeout:
                 break
-            connection.settimeout(REA_RECONNECT_TIMEOUT_SECONDS)
+            connection.settimeout(None)
             if _serve_connection(connection):
                 break
             # Match REA's cleanup handshake budget without pinning Hopper's

bridge/native/rea_lldb_tracer.py

@@ -555,38 +555,6 @@ def _failed_launch_description(process):
     return None
 
 
-def _retire_failed_launch(process, config, listener, stdout, stderr):
-    """Reconcile an SBProcess returned alongside a failed Launch error."""
-    if not process.IsValid():
-        stdout.close()
-        stderr.close()
-        return False
-
-    pid = process.GetProcessID()
-    if pid > 0:
-        # Even an already-exited process needs its PID published so the host
-        # can distinguish a completed launch failure from an unknown target.
-        with open(config["pid_path"], "w") as handle:
-            handle.write(str(pid))
-
-    if process.GetState() != lldb.eStateExited:
-        stdout.mark_launched()
-        stderr.mark_launched()
-        if pid > 0:
-            # Hold a surviving target until the host has captured its start
-            # identity. If that proof is unavailable, Kill still addresses
-            # this exact SBProcess created by the current launch request.
-            _wait_for_identity_ack(config)
-        process.Kill()
-        _wait_for_exit(listener, process, 5)
-
-    exit_observed = process.GetState() == lldb.eStateExited
-    expected_exit = exit_observed
-    stdout.close(expected_exit=expected_exit)
-    stderr.close(expected_exit=expected_exit)
-    return exit_observed
-
-
 def trace(debugger, config):
     global _TRACE_CONTEXT
     debugger.SetAsync(True)
@@ -662,9 +630,8 @@ def trace(debugger, config):
             )
         process = target.Launch(_launch_info(target, config, listener), error)
         if not error.Success() or not process.IsValid():
-            exit_observed = _retire_failed_launch(
-                process, config, listener, stdout, stderr
-            )
+            stdout.close()
+            stderr.close()
             return {
                 "status": "launch-error",
                 "error": error.GetCString(),
@@ -673,26 +640,15 @@ def trace(debugger, config):
                     if process.IsValid()
                     else {}
                 ),
-                **(
-                    {"target_process_exit_observed": True}
-                    if exit_observed
-                    else {}
-                ),
             }
         launch_failure = _failed_launch_description(process)
         if launch_failure is not None:
-            exit_observed = _retire_failed_launch(
-                process, config, listener, stdout, stderr
-            )
+            stdout.close(expected_exit=True)
+            stderr.close(expected_exit=True)
             return {
                 "status": "launch-error",
                 "error": launch_failure,
                 "target_process_created": True,
-                **(
-                    {"target_process_exit_observed": True}
-                    if exit_observed
-                    else {}
-                ),
             }
         stdout.mark_launched()
         stderr.mark_launched()

bridge/native/test_rea_lldb_tracer.py

@@ -15,8 +15,6 @@ fake_lldb = sys.modules.setdefault("lldb", types.ModuleType("lldb"))
 fake_lldb.LLDB_INVALID_ADDRESS = -1
 fake_lldb.eLaunchFlagDebug = 2
 fake_lldb.eLaunchFlagStopAtEntry = 4
-fake_lldb.eStateExited = 10
-fake_lldb.SBEvent = lambda: object()
 spec = importlib.util.spec_from_file_location(
     "rea_lldb_tracer", os.path.join(os.path.dirname(__file__), "rea_lldb_tracer.py")
 )
@@ -25,136 +23,6 @@ spec.loader.exec_module(tracer)
 
 
 class NativeTraceBudgetTests(unittest.TestCase):
-    def test_failed_launch_does_not_infer_exit_from_a_failed_kill(self):
-        class Process:
-            def IsValid(self):
-                return True
-
-            def GetProcessID(self):
-                return 12345
-
-            def GetState(self):
-                return 6
-
-            def Kill(self):
-                return None
-
-        class Sink:
-            close_exit = None
-
-            def mark_launched(self):
-                pass
-
-            def close(self, expected_exit=False):
-                self.close_exit = expected_exit
-
-        with tempfile.TemporaryDirectory() as directory:
-            stdout, stderr = Sink(), Sink()
-            with patch.object(tracer, "_wait_for_identity_ack", return_value="unavailable"), patch.object(
-                tracer, "_wait_for_exit", return_value=None
-            ):
-                exited = tracer._retire_failed_launch(
-                    Process(), {"pid_path": os.path.join(directory, "pid")}, object(), stdout, stderr
-                )
-        self.assertFalse(exited)
-        self.assertFalse(stdout.close_exit)
-        self.assertFalse(stderr.close_exit)
-
-    def test_failed_launch_publishes_pid_and_retires_live_process(self):
-        class Process:
-            state = 6
-            killed = False
-
-            def IsValid(self):
-                return True
-
-            def GetProcessID(self):
-                return 12345
-
-            def GetState(self):
-                return self.state
-
-            def Kill(self):
-                self.killed = True
-                self.state = tracer.lldb.eStateExited
-
-        class Sink:
-            launched = False
-            close_exit = None
-
-            def mark_launched(self):
-                self.launched = True
-
-            def close(self, expected_exit=False):
-                self.close_exit = expected_exit
-
-        with tempfile.TemporaryDirectory() as directory:
-            pid_path = os.path.join(directory, "pid")
-            process = Process()
-            stdout, stderr = Sink(), Sink()
-
-            def acknowledge(config):
-                with open(config["pid_path"], "r") as pid_file:
-                    self.assertEqual(pid_file.read(), "12345")
-                return "readable"
-
-            with patch.object(tracer, "_wait_for_identity_ack", acknowledge):
-                exited = tracer._retire_failed_launch(
-                    process,
-                    {"pid_path": pid_path},
-                    object(),
-                    stdout,
-                    stderr,
-                )
-
-        self.assertTrue(exited)
-        self.assertTrue(process.killed)
-        self.assertTrue(stdout.launched)
-        self.assertTrue(stderr.launched)
-        self.assertTrue(stdout.close_exit)
-        self.assertTrue(stderr.close_exit)
-
-    def test_failed_launch_records_when_valid_process_is_already_exited(self):
-        class Process:
-            def IsValid(self):
-                return True
-
-            def GetProcessID(self):
-                return 12345
-
-            def GetState(self):
-                return tracer.lldb.eStateExited
-
-            def Kill(self):
-                raise AssertionError("an exited process must not be killed")
-
-        class Sink:
-            close_exit = None
-
-            def mark_launched(self):
-                raise AssertionError("an exited process has no output to drain")
-
-            def close(self, expected_exit=False):
-                self.close_exit = expected_exit
-
-        with tempfile.TemporaryDirectory() as directory:
-            pid_path = os.path.join(directory, "pid")
-            stdout, stderr = Sink(), Sink()
-            with patch.object(
-                tracer,
-                "_wait_for_identity_ack",
-                side_effect=AssertionError("exit is already observed"),
-            ):
-                exited = tracer._retire_failed_launch(
-                    Process(), {"pid_path": pid_path}, object(), stdout, stderr
-                )
-            with open(pid_path, "r") as pid_file:
-                self.assertEqual(pid_file.read(), "12345")
-
-        self.assertTrue(exited)
-        self.assertTrue(stdout.close_exit)
-        self.assertTrue(stderr.close_exit)
-
     def test_pre_target_integrity_failure_reports_no_process_created(self):
         original_debugger = getattr(tracer.lldb, "SBDebugger", None)
 

docs/installation.md

@@ -635,11 +635,6 @@ bridge readiness. For large targets, set `REA_HOPPER_STARTUP_TIMEOUT_MS` to a
 decimal integer from 1 to 2,147,483,647 milliseconds in the environment that
 starts REA. CLI and MCP use the same setting; invalid values fail configuration
 validation. An MCP client's own request timeout must also allow enough time.
-`open_binary` validates and selects a target without waiting for native provider
-readiness. During Hopper startup, `binary_session.provider_operation_health`
-reports `busy` at stage `launch`; `analysis_activity` describes bridge requests
-and can remain idle until the socket is ready. Cleanup work reports `busy` at
-stage `connection`.
 
 If macOS denies Apple Events, allow the application that starts REA under
 **System Settings → Privacy & Security → Automation**, then retry. REA releases
@@ -649,12 +644,9 @@ Arguments containing quotes, backslashes, or line breaks remain unchanged but
 cannot establish that a failed handoff opened no document. Other failed handoffs
 retain ownership until document closure is confirmed. If a timed-out bridge
 becomes ready later, `close_binary` connects to that run, authenticates its
-identity, and requests document shutdown. Once its listener is ready, the bridge
-allows 30 seconds for the first connection and capability validation. After a
-connection drops, it allows the same grace period for an authenticated cleanup
-reconnect, then releases Hopper's Python execution thread. Initial analysis is
-outside this listener grace period, and authenticated native work is not bounded
-by it. Expiry does not establish document closure, so REA
+identity, and requests document shutdown. After a connection drops, the bridge
+allows 30 seconds for an authenticated cleanup reconnect, then releases Hopper's
+Python execution thread. Expiry does not establish document closure, so REA
 retains unconfirmed ownership. Retry close while the bridge remains available.
 
 If a Linux launcher exists but cannot start, inspect its shared libraries:
@@ -744,17 +736,9 @@ Once document and process closure are confirmed, the lease can be released even
 if temporary-file cleanup fails. Another client can then launch, but the owning
 client must finish its retained cleanup before starting again.
 An unconfirmed external document can be retried while its authenticated bridge
-remains available. The same authentication and process-identity capture apply
-when the first successful handshake occurs during cleanup after a startup
-timeout. REA can confirm closure if that exact authenticated process exits,
-including while a shutdown request is in flight. A helper exit alone is
-insufficient, and an application that never authenticated has no verified
-process identity. If no matching bridge becomes available, inspect and close
-the reported document in Hopper before ending the owning REA connection.
-Export the Evidence bundle before `close_binary` clears session records.
-`binary_session.cleanup_pending` remains true while provider cleanup is retained,
-and provider health remains visible even with `open: false`; that flag alone
-does not establish successful cleanup.
+remains connected. If that bridge has disconnected, another close cannot confirm
+the document: inspect and close the reported document in Hopper before ending
+the owning REA connection.
 
 ### Hopper in CI
 

docs/javascript-application-workflows.md

@@ -95,14 +95,6 @@ matches exactly. Otherwise the result recommends provider-neutral follow-up
 tools and reports `requires-provider-analysis`; it never starts or switches a
 provider implicitly.
 
-A handoff requires the add-on's exact content identity. Unavailable unpacked
-companions remain visible in the trace graph with their canonical path,
-availability and container-backed Evidence. They yield no actionable handoff
-until their bytes are available and the application is reanalyzed; the archive
-digest does not identify the missing add-on. An empty handoff list does not prove
-that the trace contains no native components. Source partial coverage remains
-visible independently of handoff eligibility.
-
 ## Semantic relation tracing
 
 `trace_javascript_semantics` queries the authenticated companion graph without

docs/kuna-provider.md

@@ -48,7 +48,6 @@ The first text or assembly request in a session looks for this target's export i
   - REA starts `kuna decompile-project` in the background on a private copy of the target.
   - Meanwhile, pseudocode comes from one `kuna decompile --addr` run. Name and address lookups, and listings, use the inventory the export takes with `kuna functions --json` before it decompiles. The session runs `kuna functions` itself, under `REA_KUNA_TIMEOUT_MS`, only when no export is building (an inventory-only request does not start one) or the export ends without an inventory.
   - Requests for the same function share one run; it stops when its last waiting request is cancelled. Each run analyzes the whole image again in its own process, so one REA process runs at most as many at once as the host has cores beyond `REA_KUNA_JOBS` (at least one). Further requests wait in order, and a waiting request is answered from the export if it finishes first. A run whose stop REA cannot prove keeps its slot until `close_binary` proves it stopped.
-  - The session keeps each completed single-function text, up to 16 MiB in all with the least recently used dropped first, and answers repeats from it until the export can. After a failed export that lasts for the session.
   - Assembly and data names wait for the export; progress notifications report the wait every ten seconds. A session does not rebuild a failed export: requests that need it fail with `retryable: false`, the export's failure, its captured Kuna output and what to change before reopening the target. A setting such as `REA_KUNA_PROJECT_TIMEOUT_MS` or `REA_KUNA_JOBS` is read when REA starts, so changing it also needs a restart. Pseudocode keeps using single-function runs.
   - A single-function answer says so in its limitations. It lacks the export's whole-program prototypes, so a later request can return different text for the same function.
 

docs/mcp-contracts.md

@@ -402,13 +402,6 @@ is `unavailable` with a reason when ownership could not be revalidated, or
 at that bounded check. These are historical snapshots, not live process
 inventories, and do not claim that no short-lived descendant existed.
 
-`binary_session.cleanup_pending` reports whether the session retains a provider
-client whose cleanup has not succeeded. It can be true with `open: false`;
-target retirement does not establish resource release. Health, activity, and
-lineage remain available from that retained client where the provider supplies
-them. Follow the cleanup error's reported resources and recovery action before
-reopening; a missing health observation does not establish an idle provider.
-
 ## Progress and cancellation
 
 REA accepts ordinary `tools/call` progress tokens. The numeric `progress` counts
@@ -435,10 +428,6 @@ Native call tracing and process capture retain available observations in
 `details.partial_observation` on failure, including when cleanup succeeds.
 The observation reports its partial coverage; cleanup details describe host
 state separately from the execution failure.
-For these tools, cancellation observed during result finalization or owned
-cleanup also returns typed cancellation with the available observations.
-A normal target exit does not establish request completion. Incomplete cleanup
-still takes precedence and retains its resource diagnostics.
 A process capture that fails during a finalization interval keeps every signal
 attempt and its delivery result in `details.partial_observation`, with
 `elapsed_ms` and `exit_code` null when no exit was observed.
@@ -705,20 +694,6 @@ after SDK conversion and check advertised validation and actual calls.
 Individual model APIs can impose additional nesting limits; complete producer
 captures can exceed ten structural levels.
 
-Boolean literal constraints in input schemas are relaxed only in this
-advertisement. For example, a boolean `const` is presented as `type: boolean`;
-an affected `not` is omitted, conditional predicates and their branches are
-omitted together, pure boolean-literal `oneOf` branches collapse to a boolean,
-and other affected `oneOf` branches are presented as `anyOf` to retain branch
-guidance without making overlapping widened branches reject inputs.
-This can make the advertised schema accept inputs the canonical contract
-rejects. The MCP handler still validates every call with the canonical
-contract. The Gemini CLI verifier checks the outgoing
-`parametersJsonSchema` and canonical contract examples against that declaration
-using a loopback model fixture; it does not establish live Google API or
-OpenCode client behavior. Set `REA_VERIFY_GEMINI_SCHEMA_PROFILE=compact` to
-verify the compact advertisement through the same client boundary.
-
 ### Compact input schema profile
 
 Some function-calling providers reject a request while any single tool's

docs/native-investigation.md

@@ -451,11 +451,6 @@ The run ends when the process exits, `max_events` entries are recorded,
 Bounded termination reports partial coverage. REA checks process termination
 using a launch-time OS start identity; if ownership or cleanup cannot be
 verified, the result or error preserves that uncertainty. The result reports:
-Launch errors keep the fact that LLDB created a process separate from whether
-it remains alive. An exited `SBProcess` is reported as exited only after LLDB
-confirms that state; unresolved ownership remains retained for cleanup retry.
-Cancellation observed while output and Evidence are finalized returns partial
-cancellation Evidence, even if the target has already exited.
 
 - the outcome, exit status and captured stdout/stderr (1 MiB kept per stream
   while excess bytes are drained and counted without growing capture files).

docs/process-capture.md

@@ -425,9 +425,7 @@ results for unaffected dimensions and mark affected dimensions unknown; an
 incomplete capture cannot locate the first divergence across all dimensions.
 Trace assertions use coverage for the sources they select, so an assertion
 about complete raw terminal output need not fail because rendered snapshots
-were omitted. A trace difference applies to the dimensions identified by its
-diagnostic; unrelated dimensions retain their own comparison, including unknown
-coverage. Captures missing `truncation_details` are rejected on import;
+were omitted. Captures missing `truncation_details` are rejected on import;
 preserve them as historical files and recapture for current comparisons.
 `limits.file_bytes` is already the cumulative whole-file hashing budget,
 independent of `limits.output_bytes`, which bounds retained terminal content.

docs/sqlite-databases.md

@@ -105,14 +105,6 @@ overall native heap and total resident memory are not capped. Row limits do not
 override these byte and resource limits. Resource-limit failures do not return
 an incomplete schema as successful complete evidence.
 
-If the combined database and WAL exceed the snapshot budget, the refusal is a
-`resource_constraint` and reports both the configured byte limit and the exact
-observed combined size as a decimal string. The remediation directs callers to
-create a smaller consistent offline snapshot containing only relevant data
-through the application's supported export workflow. A generic backup or copy
-does not guarantee a smaller result; REA does not truncate or modify the
-selected source.
-
 MCP also applies its configured response budget to the complete Evidence
 envelope. If delivery exceeds that budget, it reports a transport constraint
 with guidance for exporting retained Evidence, requesting a matching larger

docs/testing.md

@@ -199,44 +199,6 @@ Measure slow cases before pruning capacity coverage. Retain inputs beyond the
 formerly failing size/depth and distinguish cold runs, warm builds, coverage,
 and toolchain conditions when comparing timings.
 
-## Lifecycle regressions
-
-For changes to resource acquisition, readiness, cancellation, or cleanup, select
-the affected owners and applicable scenarios below. Include temporary snapshots
-and one-shot commands. Use public CLI/MCP workflows where practical and a
-controlled production seam for interleavings that cannot be reproduced reliably.
-
-| Scenario                                                                                | Assertion and control                                                                                                                                                                                                          |
-| --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Target admitted; startup still pending                                                  | Status preserves the readiness distinction and observed startup activity; readiness requires the provider's documented proof.                                                                                                  |
-| First handshake is late, absent, invalid, or recovered during close                     | Initial and recovery paths retain the same authenticated identity facts. Foreign run/token controls cannot authorize cleanup; authenticated idle/native work survives the unauthenticated listener deadline.                   |
-| Launch returns an error with a valid process handle                                     | Cover already-exited and still-live owned processes. Verify observed exit separately from creation; failed termination or unavailable identity remains unresolved.                                                             |
-| Cancellation arrives after workload exit, during result reads or temporary-root removal | Return typed cancellation with available partial observations and actual cleanup status. The non-aborted control succeeds; existing primary/cleanup failures keep their precedence.                                            |
-| Children have mixed health or cleanup outcomes                                          | Missing peer health does not erase an observed failure or activity. Idle plus unknown stays unknown. Retry a failed child without closing a successful peer again, including after a close-option change.                      |
-| Cleanup fails after success or primary failure                                          | Public output retains the completed observation or primary diagnostic, remaining resources, and owner recovery action. Restore the denied resource and verify the owning cleanup retry.                                        |
-| Target exits without an acknowledgement, or transport disappears while it stays alive   | Positive owned exit proof resolves target lifetime; other resources still need cleanup. Lost transport alone does not prove exit. Verify unrelated/attached targets survive and same-connection recovery works when supported. |
-
-Synchronize cancellation with the finalization boundary being tested; a fixed
-delay after dispatch does not establish that phase. Use markers, barriers, or
-owned cleanup seams while preserving real cleanup where feasible. Check server
-settlement and retained resources even if the MCP SDK rejects the client promise
-before the handler finishes. A cancellation during active execution does not
-cover cancellation during final cleanup.
-
-For atomic writes, exercise cancellation on both sides of the documented commit
-point and preserve any publication receipt. A late interruption does not prove
-that no output was published.
-
-Representative regressions include
-[process cleanup-time SIGINT](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/process/processCaptureCancellationAdapters.test.ts),
-[late authenticated cleanup](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/providers/hopper/hopperClient.handshakeRecovery.test.ts),
-[LLDB launch and finalization](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/providers/native/lldbCallTracerFailures.test.ts),
-[composed child ownership](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/src/application/binary/CompositeProvider.test.ts),
-and [public CLI cleanup denial](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/cli/wasmCleanupCli.test.ts).
-These controlled probes do not replace the matching real-provider lane. Record
-the base failure, passing control, exact host/provider, verified cleanup, and
-unavailable coverage; a missing engine is not a pass.
-
 ## Behavioral depths
 
 | Depth        | Location                | What it proves                                                                                        |
@@ -1027,19 +989,7 @@ the Apple or Windows curated lanes invoke explicitly, which also select that
 lane. Edits to verifier entrypoints run only by manual, licensed or self-hosted
 workflows run static checks and the Linux suite. Website changes run website
 checks. Provider workflow changes validate the workflow and run that provider's
-verifier. Changes under `bridge/ghidra/` also select the `ghidra_bridge` lane,
-which compiles the packaged bridge sources against the pinned Ghidra 12.1.4
-jars with `npm run verify:ghidra:bridge-sources`. It never launches Ghidra or
-imports a target, so a missing import fails the PR instead of every Ghidra
-session. The launcher, compiler and package checks share named required source
-roles. The manifest must match the complete Java cohort, so deleting a helper
-or adding an unregistered dependency cannot silently change the shipped set.
-The preflight reuses the provider's Java Properties parser with the pinned Node
-toolchain's native type stripping, without an npm install or runtime build.
-The shared release policy owns the verified version and JDK major. CI checks
-the archive pin before downloading and verifies the extracted SDK version;
-changes to these source owners also select the compile lane.
-Manual-provider/Android workflow changes run workflow validation only.
+verifier. Manual-provider/Android workflow changes run workflow validation only.
 The four-version SQLite compatibility matrix has its own `sqlite` scope for
 SQLite implementation, contracts, CLI/MCP registration, fixtures, and shared
 runtime boundaries. SQLite and server-lifecycle test edits and the SQLite npm

docs/tool-design.md

@@ -68,45 +68,6 @@ satisfy. A plan without execution does not establish runtime behavior.
   constraints. Report pagination, truncation, cancellation, and partial failure.
   An assumed agent budget is insufficient justification for a limit.
 
-## Own the lifecycle
-
-For tools that acquire resources, identify the owner and the observations that
-establish each transition. Include temporary files and one-shot commands, as
-well as persistent engine sessions. Use the existing provider contracts;
-providers need not expose identical state machines.
-
-- Keep target admission, provider readiness, active work, observed process exit,
-  and resource release separate. A valid process handle, successful launcher,
-  or selected target establishes only its own fact. Publish available identity
-  and exit observations even when launch fails; retain unknown ownership.
-- Authenticate and capture identity through the same boundary on initial and
-  recovery handshakes. Bound abandoned unauthenticated listeners where the
-  protocol permits it; that deadline must not expire authenticated idle sessions
-  or long-running native work. Listener expiry does not prove target closure.
-- For cancellable observations, carry cancellation through result consumption
-  and awaited cleanup. Before returning success, check the signal after the
-  last awaited finalization step.
-  Retain collected observations under typed cancellation. Preserve an existing
-  primary failure and let incomplete cleanup retain its own classification.
-  Client cancellation alone does not prove native work stopped.
-  For atomic publication, document the cancellation cutoff and preserve any
-  committed output's publication receipt.
-- Release only owned resources. Attaching owns a connection or session unless
-  the provider contract explicitly establishes target ownership. A helper exit,
-  missing reply, or missing PID does not establish target exit.
-- Retain successful child cleanup and retry only unresolved children, including
-  when close options change. Preserve observed child failure or activity when
-  another child's health is unavailable; idle plus missing coverage stays
-  unknown.
-- Await one-shot cleanup without discarding the completed result or primary
-  diagnostic. Preserve partial observations, remaining resources, and the cleanup
-  owner's recovery instructions. CLI adapters should reuse
-  [`finishAnalysisCommand`](https://github.com/morluto/rea/blob/main/src/cli/finishAnalysisCommand.ts) where its contract
-  applies rather than duplicate close/finally handling.
-
-Exercise the applicable [lifecycle regression scenarios](testing.md#lifecycle-regressions)
-through the producing owner and affected CLI/MCP consumers.
-
 ## Implement and evaluate
 
 Put provider protocols/parsing in adapters and shared CLI/MCP workflows in the

docs/verification/javascript-native-handoff-identity-2026-10-15.md

@@ -1,179 +0,0 @@
-# Native handoff byte-identity verification
-
-Tracks #3926 under #4027. Baseline: `9f8659e0536e4e50a438f5b9d5661f3c9624f6ac`.
-Final integration base: `62bf09809ef7bb224028916424f8f07652a20f4f`.
-
-The analyst already knows an ASAR-relative native path and supplies prior native
-Evidence. The question is which Evidence can be linked to that component's exact
-bytes. Discovery and native-provider execution are outside this task.
-
-## Observed behavior and correction
-
-The native-node producer distinguishes a content digest from a canonical path
-whose bytes are unavailable. Its unavailable observation legitimately cites the
-containing archive. The handoff consumer previously treated that supporting
-artifact digest as the native component's digest.
-
-Public CLI/stdio MCP regression: the missing-companion case failed and the
-available-byte control passed. Real Joplin reproduced the same result: missing
-keytar bytes produced an `evidence-linked` handoff with the ASAR digest and the
-simulated container observation. CLI/MCP agreed on that incorrect answer.
-
-The consumer now uses only the node owner's content-digest identity. The fallback
-observation scan is removed. Unavailable native nodes retain their canonical
-path, availability, container-backed provenance and partial coverage in the
-inline graph; they yield no false actionable handoff or native Evidence link.
-An empty handoff list describes eligibility, not absence of native components.
-The per-query node index is allocated only after an eligible target exists; no
-persistent cache, schema, tool or target authority is added.
-
-Final real checks passed both cases with exact CLI/MCP trace parity. The available
-control preserved the complete parent/trace Evidence IDs, native facts, links,
-coverage and all token projections. The missing control preserved its parent,
-native node, source provenance and coverage, while removing the wrong handoff
-and container Evidence link.
-
-## Real input and scope
-
-[Official Joplin v3.7.21 Linux AppImage](https://github.com/laurent22/joplin/releases/download/v3.7.21/Joplin-3.7.21.AppImage),
-published 2026-09-25, 201,462,481 bytes, SHA-256
-`5d202dcaca31e14206826aa3f04125e7c218dbc3dc3d98479d811efbd6b856c1`.
-
-Read-only 7z 26.02 inspection found 6,324 ASAR files, 46 unpacked entries and
-three `.node` components. Extract only the ASAR and those three binaries:
-
-```sh
-input_root="$(mktemp -d -t rea-native-handoff-XXXXXX)"
-curl --fail --location --output "$input_root/Joplin-3.7.21.AppImage" \
-  https://github.com/laurent22/joplin/releases/download/v3.7.21/Joplin-3.7.21.AppImage
-sha256sum "$input_root/Joplin-3.7.21.AppImage"
-7z x -mmt=1 "-o$input_root/extracted" "$input_root/Joplin-3.7.21.AppImage" \
-  resources/app.asar \
-  resources/app.asar.unpacked/node_modules/keytar/build/Release/keytar.node \
-  resources/app.asar.unpacked/node_modules/sqlite3/lib/binding/napi-v6-linux-glibc-x64/node_sqlite3.node \
-  resources/app.asar.unpacked/node_modules/onnxruntime-node/bin/napi-v6/linux/x64/onnxruntime_binding.node
-python3 - "$input_root" <<'PY'
-import os, sys
-from pathlib import Path
-root = Path(sys.argv[1])
-source = root / 'extracted/resources'
-for mode in ('available', 'missing'):
-    case = root / 'cases' / mode
-    case.mkdir(parents=True)
-    os.link(source / 'app.asar', case / 'app.asar')
-    if mode == 'available':
-        for native in (source / 'app.asar.unpacked').rglob('*.node'):
-            target = case / native.relative_to(source)
-            target.parent.mkdir(parents=True, exist_ok=True)
-            os.link(native, target)
-PY
-```
-
-Verify the asset digest above before extraction. The ASAR is 233,575,014 bytes,
-SHA-256 `767df409b18effe60421fbefcca873de237c7e813eac744ecdeebbc5e825a33a`.
-Keytar is 76,960 bytes, SHA-256
-`0700016bcd761cbe02d275f2046c7cc42f39f730a50d66e3d3307aa9d413373a`.
-All extracted component hashes are in the JSON record. 7z reported one
-trailing-data warning for the AppImage's embedded SquashFS and exited 0.
-
-Both cases select only `package.json` for static source analysis while retaining
-the inventory. The available case stages all three native companions; the other
-43 unpacked entries are not staged. The missing case stages none. Whole-application
-coverage is therefore partial in both cases, independently of the selected
-native component's known or unknown byte identity. Neither the application nor
-a native analysis provider is executed. Native Evidence is explicitly simulated
-to test exact subject linkage. Live Electron, real Ghidra/Hopper/IDA behavior and
-Windows/macOS verification are **NOT_ENOUGH_INFO**.
-
-## Reproduce the public workflow
-
-Use pinned Node 24.18.0/npm 11.16.0, `npm ci`, then `npm run build:cached`.
-The verifier returns compact records and deletes its private exported parent and
-CLI input after owned cleanup. No downloadable application or large Evidence is
-archived.
-
-```sh
-for mode in available missing; do
-  node scripts/verify/javascript/native-handoffs.mjs \
-    --artifact "$input_root/cases/$mode/app.asar" \
-    --addon-path node_modules/keytar/build/Release/keytar.node \
-    --native-sha256 0700016bcd761cbe02d275f2046c7cc42f39f730a50d66e3d3307aa9d413373a \
-    --source-path package.json --rounds 3 --cli-parity --require-safe
-done
-```
-
-Add `--tokenizer-python /absolute/path/to/python-with-tiktoken-0.12.0` for the
-reported BPE projections. The npm alias `verify:javascript:native-handoffs`
-builds first; recorded costs use the direct Node invocation above after building.
-For a pre-fix observation, run the saved verifier on the baseline build without
-`--require-safe`; `safe_identity: false` is an incorrect answer, not a passing
-analyst task. Paths affect serialized requests and some Evidence identities.
-
-The exact resource runs additionally used the preserved
-[8 GiB observer](https://github.com/morluto/rea/blob/b3bdabab694af1f9801eff7caf75001b92314a58/experiments/analysis-efficiency/resource-run.py)
-and adjacent `resource_payload.py`; both hashes are pinned in the JSON.
-
-## Completed workflow costs and limits
-
-| Case                   | Revision |  Wall s |      CPU s | Peak cgroup bytes | Identity oracle            |
-| ---------------------- | -------- | ------: | ---------: | ----------------: | -------------------------- |
-| Native bytes available | Before   |  60.369 |  59.806670 |     2,662,629,376 | pass                       |
-| Native bytes available | After    | 258.885 | 106.221003 |     2,678,456,320 | pass, exact baseline facts |
-| Native bytes missing   | Before   |  57.930 |  57.479109 |     2,719,457,280 | wrong identity/linkage     |
-| Native bytes missing   | After    |  59.738 |  59.254776 |     2,571,235,328 | pass, unknown retained     |
-
-Whole-verifier resources include input hashing, analysis, three retained trace
-queries, export, CLI parity and tokenization. One CPU, 8 GiB hard cap, 6 GiB early
-stop, no swap; cleanup verified and no OOM. Memory includes charged file cache,
-not summed RSS. Counters are at payload exit while the observer remains alive.
-The available control's final wall and CPU times are substantially higher than
-baseline. Earlier post-fix controls on the original base took 61.657/74.956 s wall
-and 61.135962/60.352428 s CPU for available/missing cases; their complete receipts
-remain separately recorded. The final missing case took 59.738 s wall. This
-variability is unresolved and cannot be attributed to the native consumer change.
-These runs establish neither speedup nor performance equivalence. Input hashing warms the ASAR
-cache, build/OS caches and shared-host scheduling are uncontrolled. Fresh MCP
-sessions do not establish OS-cold conditions. First post-analysis and repeated
-warm-query samples are preserved separately; query CPU/memory are unmeasured.
-
-One defined task is one analysis summary plus one retained trace, with the path
-and prior Evidence already supplied. Static `cl100k_base`/tiktoken 0.12.0 counts
-include both requests, replies and name/description/inputSchema contracts:
-
-| Available-byte task, unchanged before/after     | BPE tokens |
-| ----------------------------------------------- | ---------: |
-| Selected catalog + structured replies           |     12,340 |
-| Selected catalog + complete tool replies        |     18,906 |
-| Full catalog projection + structured replies    |    202,292 |
-| Full catalog projection + complete tool replies |    208,858 |
-
-These are alternative reply/catalog projections. The selected catalog alone is
-5,570 BPE; the full projection is 195,522. Output schemas, annotations, host
-rendering/replay, reasoning, final answers and model billing are unmeasured.
-Repeated queries/export/CLI/tokenization are validation overhead outside this
-one-task token count, but inside resource receipts. Missing-case structured-task
-counts change 11,372 → 11,103 by removing unsupported claims; the incorrect
-baseline earns no efficiency credit.
-
-## Regression and verification record
-
-The initial four-file focused selection passed 24 tests. The two public cases
-were rerun after adding named summary-result parsing and correcting an optional
-architecture factory input. Omitting that field instead of passing null produced
-byte-identical normalized simulated Evidence in all four real-case inputs.
-The initial CLI-selector harness error and first typecheck failure are retained
-as harness/validation attempts, not product reproductions.
-
-After syncing the reviewed upstream changes, the updated application workflow
-CLI acceptance file passed 34 tests, bringing the focused selection to 58 distinct
-cases across five files. Both Joplin controls were then repeated on the final
-integration base. Canonical byte identity is also used by the related version
-matching/content comparison consumers; no equivalent observation-digest fallback
-was found there.
-
-Final `npm run check && npm run docs:check` passed on the integration base,
-including five documentation consistency tests: 128.732 s wall, 115.518920 s CPU,
-4,301,684,736 B peak cgroup memory, clean owned exit and no OOM.
-
-Final public and static/docs outcomes are recorded in the
-[compact measurements and source pins](javascript-native-handoff-identity-2026-10-15.json).

experiments/atomic-re-tools/README.md

@@ -0,0 +1,154 @@
+# Atomic RE tools: an experiment
+
+Experimental branch only: no PR, merge, production registration, or Code Mode.
+Started from REA main `5b16f2431062eea6ffd245a9e05512790007cb13`.
+
+Read [measured results](results.md) and [mechanism / prior-art notes](research.md).
+The first round includes an object-reference counterexample and a failed
+code-mapping composition; it does not claim every hypothesis succeeded.
+The [control-flow / SSA follow-up](relations.md) repairs three zlib mapping
+paths, tests a SQLite call guard, and records where structured slices cost more.
+
+The question is whether composable facts improve **completed reverse-engineering
+tasks**, especially on complex software. Three outcomes matter together:
+
+1. Time, native work, CPU and process-family memory, including startup and retries.
+2. Whole-task estimated tokens: catalog, arguments, results and necessary follow-up.
+3. Correct answers with traceable evidence, meaningful coverage and explicit unknowns.
+
+Smaller replies, fewer tool names and fewer calls are intermediate measurements,
+not proof of a better investigation. Negative results are useful experiment results.
+
+## Working definition
+
+An atom is a coherent fact or relationship about an identified object, with its
+producing evidence and uncertainty. It need not be a single field, MCP call,
+instruction, native command or engine pass. A string's encoding and the status of
+that encoding belong together; separating them can change the meaning.
+
+Candidate reusable building blocks:
+
+| Object / fact                        | Relationships and questions                                                             |
+| ------------------------------------ | --------------------------------------------------------------------------------------- |
+| Artifact and analysis context        | Which bytes, architecture, address space and analysis profile produced this?            |
+| Location and byte span               | What is mapped here? Where are the source bytes? Is the span initialized?               |
+| Instruction                          | What bytes decoded here, and with which mode and provenance?                            |
+| Function                             | Which entry is identified? Which locations does the engine actually assign to its body? |
+| String, symbol, type                 | What was observed or recovered, and what remains unknown?                               |
+| Reference / call / control-flow edge | What are both endpoints, the reference site, kind and coverage?                         |
+| Decompiled view                      | Which engine reconstruction and machine locations support this selected text?           |
+
+An inventory extent is an upper bound, not proof that an interior address belongs
+to the preceding function. A reference to a string's start address is not proof
+of a runtime string use, and misses references into its interior. Different
+providers' recovered functions and types are not automatically the same entities.
+
+Identity needs artifact digest + analysis profile + address space + object kind
+and location/discriminator. A separate session lease controls whether a handle
+is still usable. Identity, existence, lookup success and readiness are distinct.
+
+## Hypotheses to try to falsify
+
+- Fine-grained getters can lose to coherent fact batches through repeated
+  envelopes, schemas and round trips.
+- A small workflow can be built from the same facts without maintaining a second
+  analysis implementation. Explicit selection must survive composition.
+- Batching at MCP may reduce agent turns without saving any native analysis.
+  The engine's unit of work must be measured separately from the fact/read unit.
+- Richer structured relations can improve investigation completeness more than
+  another wrapper around whole-function C text.
+- On complex targets, a narrow result can omit the decisive evidence. Compare
+  coverage and final answers, counting all extra reads and failed paths.
+
+## First prototype
+
+`facts.mjs` consumes REA's existing normalized observations. It does not parse
+assembly/C or guess ownership. The same methods support individual reads,
+homogeneous batches, and one string-reference-function workflow. Native analysis,
+target admission, caches, cancellation and full Evidence ownership stay in REA.
+
+`server.mjs` adds experimental tools to the **complete** production MCP catalog.
+It does not hide unrelated schemas to manufacture catalog savings. The additional
+schemas are included in costs. Its operations are static reads; it never executes
+the target or mutates an attached analysis database.
+
+`benchmark.mjs` compares production calls, individual fact calls, batches and
+composition using actual MCP clients and actual Kuna/Ghidra. Verification runs
+are separate from timed equivalent-work runs. Each performance run repeats the
+task in one session to distinguish first queries and warm native caches. Cold
+Ghidra import/open cost must also be reported, not hidden in the query timer.
+
+The prototype projects the current address-only `xrefs` contract. Reference kinds
+stay unknown. Unsupported containing-function resolution stays unknown without
+futile retries. This is intentionally a way to expose integration gaps rather
+than claim that the adapter can recover information already discarded upstream.
+Full Evidence is explicitly readable while its existing session owner retains
+it; closing the binary expires those records. Paging covers the provider-returned
+set and never establishes complete artifact discovery.
+
+This is not a production contract proposal. Overlays, non-default address spaces,
+typed edges, native batching and live agent decision quality need further work.
+No measured claim about improved complex-program reasoning is established yet.
+
+## Native experiments
+
+After the build described below, with `REA_KUNA_COMMAND` configured:
+
+```sh
+mkdir -p .cache/atomic-re-tools
+gcc -O2 -fno-pie -no-pie -o .cache/atomic-re-tools/interior-reference \
+  experiments/atomic-re-tools/interior-reference.c
+
+# Run once for each variant: per-address, then inventory.
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+  node experiments/atomic-re-tools/native-relations.mjs \
+  .cache/atomic-re-tools/interior-reference HEAD:REA per-address \
+  .cache/atomic-re-tools/native-interior-per-address
+
+python3 experiments/atomic-re-tools/verify-interior.py \
+  .cache/atomic-re-tools/interior-reference \
+  .cache/atomic-re-tools/native-interior-per-address.report.json \
+  .cache/atomic-re-tools/native-interior-inventory.report.json
+```
+
+Use the installed zlib/SQLite paths and `incorrect`/`malformed` to repeat the
+native plan comparison. Append `--code-slice` to the per-address experiment for
+an exact instruction-to-line probe. `mapped-code.mjs` rejects unsupported address
+precision and never substitutes a nearby line for a missing mapping.
+
+The experiment adds an opt-in typed reference projection at the existing Kuna
+protocol owner. The existing public address-only result and its retained cache
+shape remain the same; ordinary queries do not materialize the richer facts.
+Experimental MCP tools have live-validated input schemas, but no canonical
+output-schema/product-catalog integration. They are not a production SDK/API.
+
+The v2 facade labels reference scope explicitly and connects **locations** in its
+point-reference edges. A result's `target` preserves the caller's selector; it
+is not a separate observation proving that an object exists at that address.
+All experimental MCP results carry REA's canonical untrusted-target-content
+marker. The v1 measurement table is retained with its revision label; it is not
+relabelled as a measurement of this later response shape.
+
+## Reproduce
+
+Use the repository's pinned Node/npm and run `npm ci`, then
+`npm run build:cached`. Supply existing installations through `REA_KUNA_COMMAND`,
+`GHIDRA_INSTALL_DIR` and `JAVA_HOME`; this experiment installs no provider.
+
+```sh
+node --test experiments/atomic-re-tools/facts.test.mjs
+
+# Existing bounded runner: one CPU, 4 GiB hard memory cap, early stop at 3 GiB.
+# Its payload-exit counters include all processes in the owned scope.
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+  node experiments/atomic-re-tools/benchmark.mjs \
+  kuna batch /usr/lib/x86_64-linux-gnu/libz.so.1 incorrect \
+  .cache/atomic-re-tools/kuna-batch
+```
+
+Use `baseline`, `fine`, `batch`, or `workflow`, and `ghidra` or `kuna`.
+Append `--verify` for additional lifecycle, paging, negative and Evidence checks;
+those runs must not be used as equivalent-work performance samples. Binaries,
+provider projects, captured catalogs/traffic and local measurements stay ignored
+under `.cache/atomic-re-tools/`, never in commits. Summarize reproducible results
+and limitations here as experiments finish.

experiments/atomic-re-tools/benchmark.mjs

@@ -0,0 +1,375 @@
+import assert from "node:assert/strict";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import Ajv2020 from "ajv/dist/2020.js";
+import { requireMcpOperationResult } from "../../scripts/lib/mcp-verifier-results.mjs";
+import {
+  createVerifierRun,
+  completeVerifierRun,
+  assertVerifierCleanupComplete,
+} from "../../scripts/lib/verifier-run.mjs";
+
+const [provider, variant, binary, pattern, prefix, verification] =
+  process.argv.slice(2);
+assert.ok(["ghidra", "kuna"].includes(provider));
+assert.ok(["baseline", "fine", "batch", "workflow"].includes(variant));
+assert.ok(binary && pattern && prefix);
+await mkdir(dirname(prefix), { recursive: true });
+const verifier = createVerifierRun();
+const client = new Client({ name: "rea-atomic-experiment", version: "0.1.0" });
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [
+    resolve(
+      variant === "baseline"
+        ? "dist/main.js"
+        : "experiments/atomic-re-tools/server.mjs",
+    ),
+  ],
+  env: {
+    ...process.env,
+    REA_LOG_LEVEL: "error",
+    REA_MCP_OUTPUT_SCHEMA_PROFILE:
+      process.env.REA_MCP_OUTPUT_SCHEMA_PROFILE ?? "full",
+    REA_KUNA_CACHE_DIR: resolve(`${prefix}.kuna-cache`),
+    REA_KUNA_JOBS: "1",
+    GHIDRA_HEADLESS_MAXMEM: "1G",
+    REA_GHIDRA_STARTUP_TIMEOUT_MS: "120000",
+  },
+  stderr: "pipe",
+});
+let stderr = "";
+transport.stderr?.on("data", (part) => {
+  stderr = (stderr + part).slice(-32_768);
+});
+const wire = [],
+  calls = [],
+  checks = [],
+  failures = [];
+let phase = "lifecycle";
+const call = async (name, arguments_ = {}, expectError = false) => {
+  const started = performance.now();
+  const response = await client.callTool(
+    { name, arguments: arguments_ },
+    { timeout: 180000 },
+  );
+  wire.push({ request: { name, arguments: arguments_ }, response, phase });
+  if (name.startsWith("experiment_"))
+    assert.equal(
+      response._meta?.provenance?.untrusted_content,
+      true,
+      "Experimental results lost the canonical target-content marker",
+    );
+  calls.push({ name, phase, elapsed_ms: performance.now() - started });
+  if (expectError) {
+    assert.equal(response.isError, true);
+    return JSON.parse(
+      response.content.find((part) => part.type === "text").text,
+    );
+  }
+  assert.notEqual(
+    response.isError,
+    true,
+    JSON.stringify(response).slice(0, 2000),
+  );
+  return name.startsWith("experiment_")
+    ? JSON.parse(response.content.find((part) => part.type === "text").text)
+    : requireMcpOperationResult(response, name);
+};
+const contextInput = (context) => ({ ref: context.ref, lease: context.lease });
+const stringLimit = 3,
+  referenceLimit = 4;
+const query = { pattern, mode: "literal", case_sensitive: true };
+const identity = (row) => ({
+  kind: "string",
+  address: row.address,
+  encoding: row.string?.encoding ?? null,
+});
+
+const readBatch = async (name, common, { key, items, individually }) => {
+  if (!individually) return call(name, { ...common, [key]: items });
+  const results = [];
+  for (const item of items)
+    results.push(...(await call(name, { ...common, [key]: [item] })).results);
+  return { results };
+};
+const readExperimentalTask = async (supportsOwners) => {
+  const input = { query, limit: stringLimit, fields: ["value"] };
+  if (variant === "workflow") {
+    const traced = await call("experiment_trace_string_uses", {
+      ...input,
+      reference_limit: referenceLimit,
+    });
+    return {
+      found: traced.strings,
+      refs: traced.references,
+      owners: traced.functions,
+    };
+  }
+  const found = await call("experiment_find_strings", input);
+  const context = contextInput(found.context);
+  const refs = await readBatch(
+    "experiment_incoming_refs",
+    { context, limit: referenceLimit },
+    {
+      key: "targets",
+      items: found.items.map((row) => row.id),
+      individually: variant === "fine",
+    },
+  );
+  const locations = [
+    ...new Map(
+      refs.results
+        .flatMap((row) => row.items ?? [])
+        .map((row) => [row.from.address, row.from]),
+    ).values(),
+  ];
+  const owners = await readBatch(
+    "experiment_resolve_functions",
+    { context },
+    {
+      key: "locations",
+      items: locations,
+      individually: variant === "fine" && supportsOwners,
+    },
+  );
+  return { found, refs, owners };
+};
+
+let catalog,
+  firstSourceId,
+  firstContext,
+  outcomes = [];
+try {
+  await client.connect(transport);
+  catalog = await client.listTools();
+  const expectedOutputSchemas =
+    process.env.REA_MCP_OUTPUT_SCHEMA_PROFILE === "off"
+      ? 0
+      : catalog.tools.filter((tool) => !tool.name.startsWith("experiment_"))
+          .length;
+  assert.equal(
+    catalog.tools.filter((tool) => Object.hasOwn(tool, "outputSchema")).length,
+    expectedOutputSchemas,
+    "Advertised output-schema profile differs from the requested profile",
+  );
+  const ajv = new Ajv2020({ strict: false, validateFormats: false });
+  for (const tool of catalog.tools.filter((tool) =>
+    tool.name.startsWith("experiment_"),
+  )) {
+    assert.equal(
+      ajv.validateSchema(tool.inputSchema),
+      true,
+      JSON.stringify(ajv.errors),
+    );
+    ajv.compile(tool.inputSchema);
+  }
+  await call("open_binary", { path: resolve(binary), provider_id: provider });
+  const status = await call("binary_session");
+  const supportsOwners = status.capabilities.some(
+    (row) => row.operation === "resolve_containing_procedure" && row.available,
+  );
+  for (phase of ["cold", "warm"]) {
+    const started = performance.now();
+    let strings, references, functions;
+    if (variant === "baseline") {
+      const all = await call("search_strings", query);
+      strings = all
+        .slice(0, stringLimit)
+        .map((row) => ({ id: identity(row), value: row.value }));
+      references = [];
+      for (const string of strings)
+        references.push({
+          target: string.id,
+          items: (await call("xrefs", { address: string.id.address })).slice(
+            0,
+            referenceLimit,
+          ),
+        });
+      const locations = [...new Set(references.flatMap((row) => row.items))];
+      functions = [];
+      for (const address of locations)
+        functions.push(
+          supportsOwners
+            ? {
+                address,
+                resolution: await call("resolve_containing_procedure", {
+                  address,
+                }),
+              }
+            : { address, status: "unknown" },
+        );
+    } else {
+      const { found, refs, owners } =
+        await readExperimentalTask(supportsOwners);
+      assert.equal(found.status, "ok");
+      assert.ok(refs.results.every((row) => row.status === "ok"));
+      firstSourceId ??= found.evidence_id;
+      firstContext ??= found.context;
+      strings = found.items.map((row) => ({ id: row.id, value: row.value }));
+      references = refs.results.map((row) => ({
+        target: row.target,
+        items: row.items.map((edge) => edge.from.address),
+      }));
+      functions = owners.results.map((row) =>
+        row.status === "ok"
+          ? { address: row.location.address, resolution: row.resolution }
+          : { address: row.location.address, status: "unknown" },
+      );
+    }
+    outcomes.push({
+      phase,
+      elapsed_ms: performance.now() - started,
+      strings,
+      references,
+      functions,
+    });
+  }
+  assert.deepEqual(outcomes[0].strings, outcomes[1].strings);
+  assert.deepEqual(outcomes[0].references, outcomes[1].references);
+  assert.deepEqual(outcomes[0].functions, outcomes[1].functions);
+  assert.ok(outcomes[0].strings.length > 0);
+  phase = "verification";
+  if (variant !== "baseline" && verification === "--verify") {
+    const raw = await call("experiment_read_evidence", {
+      evidence_id: firstSourceId,
+    });
+    assert.equal(raw.evidence.operation, "search_strings");
+    assert.equal(
+      raw.evidence.analysis_profile.digest,
+      firstContext.analysis_profile_digest,
+    );
+    assert.equal(
+      raw.evidence.subject.digest.sha256,
+      createHash("sha256")
+        .update(await readFile(binary))
+        .digest("hex"),
+    );
+    assert.deepEqual(
+      raw.evidence.normalized_result
+        .slice(0, stringLimit)
+        .map((row) => ({ id: identity(row), value: row.value })),
+      outcomes[0].strings,
+    );
+    const duplicate = await call("experiment_incoming_refs", {
+      context: contextInput(firstContext),
+      targets: [outcomes[0].strings[0].id, outcomes[0].strings[0].id],
+      limit: 1,
+    });
+    assert.deepEqual(duplicate.results[0], duplicate.results[1]);
+    const nextPage = await call("experiment_find_strings", {
+      query,
+      offset: stringLimit,
+      limit: stringLimit,
+    });
+    assert.deepEqual(
+      nextPage.items.map((row) => row.id),
+      raw.evidence.normalized_result
+        .slice(stringLimit, stringLimit * 2)
+        .map(identity),
+    );
+    const negative = await call("experiment_find_strings", {
+      query: { pattern: "\u0000REA-atomic-negative\u0000" },
+    });
+    assert.equal(negative.items.length, 0);
+    assert.equal(negative.coverage.status, "unknown");
+    const stale = await call(
+      "experiment_incoming_refs",
+      {
+        context: {
+          ref: "different-artifact-or-profile",
+          lease: firstContext.lease,
+        },
+        targets: [outcomes[0].strings[0].id],
+      },
+      true,
+    );
+    assert.equal(stale.status, "error");
+    await call("close_binary");
+    assert.equal(
+      (
+        await call(
+          "experiment_read_evidence",
+          { evidence_id: firstSourceId },
+          true,
+        )
+      ).error.code,
+      "not_found",
+    );
+    await call("open_binary", { path: resolve(binary), provider_id: provider });
+    const expired = await call(
+      "experiment_incoming_refs",
+      {
+        context: contextInput(firstContext),
+        targets: [outcomes[0].strings[0].id],
+      },
+      true,
+    );
+    assert.equal(expired.status, "error");
+    checks.push(
+      "retained-evidence",
+      "paging",
+      "duplicate-targets",
+      "negative-unknown",
+      "foreign-context",
+      "expired-lease",
+    );
+  }
+} catch (error) {
+  failures.push(String(error.stack ?? error));
+}
+phase = "lifecycle";
+try {
+  await call("close_binary");
+} catch (error) {
+  failures.push(String(error));
+}
+await client.close().catch((error) => failures.push(String(error)));
+await transport.close().catch((error) => failures.push(String(error)));
+const lifecycle = await completeVerifierRun(verifier);
+try {
+  assertVerifierCleanupComplete(lifecycle.process_lineage);
+} catch (error) {
+  failures.push(String(error));
+}
+const report = {
+  provider,
+  variant,
+  binary: resolve(binary),
+  pattern,
+  node_version: process.versions.node,
+  target_sha256: createHash("sha256")
+    .update(await readFile(binary))
+    .digest("hex"),
+  string_limit: stringLimit,
+  reference_limit: referenceLimit,
+  outcomes,
+  calls,
+  checks,
+  failures,
+  verification_only: verification === "--verify",
+  lifecycle,
+};
+await writeFile(`${prefix}.wire.json`, JSON.stringify(wire));
+await writeFile(`${prefix}.catalog.json`, JSON.stringify(catalog));
+await writeFile(`${prefix}.report.json`, JSON.stringify(report, null, 2));
+await writeFile(`${prefix}.stderr.txt`, stderr);
+console.log(
+  JSON.stringify({
+    provider,
+    variant,
+    calls: calls.length,
+    outcomes: outcomes.map(({ strings, references, functions, ...rest }) => ({
+      ...rest,
+      strings: strings.length,
+      references: references.flatMap((row) => row.items).length,
+      functions: functions.length,
+    })),
+    failures,
+  }),
+);
+assert.deepEqual(failures, []);

experiments/atomic-re-tools/capture-function.mjs

@@ -0,0 +1,140 @@
+// Capture the existing public MCP function dossier, without changing its contract.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import {
+  requireMcpOperationResult,
+  requireMcpToolError,
+} from "../../scripts/lib/mcp-verifier-results.mjs";
+import {
+  createVerifierRun,
+  completeVerifierRun,
+  assertVerifierCleanupComplete,
+} from "../../scripts/lib/verifier-run.mjs";
+
+const [provider, binary, procedure, prefix] = process.argv.slice(2);
+assert.ok(
+  ["ghidra", "kuna"].includes(provider) && binary && procedure && prefix,
+);
+await mkdir(dirname(prefix), { recursive: true });
+const verifier = createVerifierRun();
+const client = new Client({
+  name: "rea-relation-experiment",
+  version: "0.1.0",
+});
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [resolve("dist/main.js")],
+  env: {
+    ...process.env,
+    REA_LOG_LEVEL: "error",
+    REA_MCP_OUTPUT_SCHEMA_PROFILE: "off",
+    GHIDRA_HEADLESS_MAXMEM: "1G",
+    REA_GHIDRA_STARTUP_TIMEOUT_MS: "120000",
+    REA_KUNA_CACHE_DIR: resolve(`${prefix}.kuna-cache`),
+    REA_KUNA_JOBS: "1",
+  },
+  stderr: "pipe",
+});
+let stderr = "";
+transport.stderr?.on("data", (part) => {
+  stderr = (stderr + part).slice(-32_768);
+});
+const wire = [],
+  calls = [],
+  failures = [];
+let catalog;
+const call = async (name, arguments_ = {}, acceptRetained = false) => {
+  const start = performance.now();
+  const response = await client.callTool(
+    { name, arguments: arguments_ },
+    { timeout: 180000 },
+  );
+  wire.push({ request: { name, arguments: arguments_ }, response });
+  calls.push({ name, elapsed_ms: performance.now() - start });
+  if (response.isError === true && acceptRetained) {
+    const error = requireMcpToolError(response);
+    const source = error.details?.reported_limits?.evidence_reference;
+    assert.equal(error.code, "resource_constraint");
+    assert.equal(source?.kind, "retained-evidence");
+    await call("inspect_analysis_view", {
+      source,
+      view: { kind: "native", facet: "value_flow_summary" },
+    });
+    return { retained: source, initial_error: error };
+  }
+  assert.notEqual(
+    response.isError,
+    true,
+    JSON.stringify(response).slice(0, 1600),
+  );
+  return requireMcpOperationResult(response, name);
+};
+try {
+  await client.connect(transport);
+  catalog = await client.listTools();
+  assert.ok(
+    catalog.tools.every((tool) => !Object.hasOwn(tool, "outputSchema")),
+  );
+  await call("open_binary", { path: resolve(binary), provider_id: provider });
+  await call("binary_session");
+  for (const phase of ["first", "warm"]) {
+    const dossier = await call("analyze_function", { procedure }, true);
+    await writeFile(`${prefix}.${phase}.json`, JSON.stringify(dossier), {
+      flag: "wx",
+    });
+  }
+  await call("export_evidence_bundle", {
+    path: resolve(`${prefix}.bundle.json`),
+  });
+} catch (error) {
+  failures.push(String(error.stack ?? error));
+} finally {
+  try {
+    await call("close_binary");
+  } catch (error) {
+    failures.push(String(error));
+  }
+  await client.close().catch((error) => failures.push(String(error)));
+  await transport.close().catch((error) => failures.push(String(error)));
+}
+const lifecycle = await completeVerifierRun(verifier);
+let cleanupVerified = false;
+try {
+  assertVerifierCleanupComplete(lifecycle.process_lineage);
+  cleanupVerified = true;
+} catch (error) {
+  failures.push(String(error));
+}
+await writeFile(`${prefix}.wire.json`, JSON.stringify(wire), { flag: "wx" });
+await writeFile(`${prefix}.catalog.json`, JSON.stringify(catalog), {
+  flag: "wx",
+});
+await writeFile(`${prefix}.stderr.txt`, stderr, { flag: "wx" });
+const report = {
+  provider,
+  binary: resolve(binary),
+  procedure,
+  target_sha256: createHash("sha256")
+    .update(await readFile(binary))
+    .digest("hex"),
+  node_version: process.versions.node,
+  calls,
+  failures,
+  lifecycle,
+};
+await writeFile(`${prefix}.report.json`, JSON.stringify(report, null, 2), {
+  flag: "wx",
+});
+console.log(
+  JSON.stringify({
+    provider,
+    calls,
+    failures,
+    cleanup_verified: cleanupVerified,
+  }),
+);
+if (failures.length) process.exitCode = 1;

experiments/atomic-re-tools/capture-kuna-structure.mjs

@@ -0,0 +1,109 @@
+// Native diagnostic probes; these text dumps are not a typed provider contract.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { parseBinaryTarget } from "../../dist/application/BinaryTargetResolver.js";
+import { inspectKunaInstallation } from "../../dist/kuna/KunaInstallation.js";
+import { KunaTargetCommands } from "../../dist/kuna/KunaTargetCommands.js";
+import { AnalysisError } from "../../dist/domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../../dist/domain/analysisErrorProjection.js";
+import {
+  createVerifierRun,
+  completeVerifierRun,
+  assertVerifierCleanupComplete,
+} from "../../scripts/lib/verifier-run.mjs";
+
+const [binary, procedure, view, prefix] = process.argv.slice(2);
+assert.ok(binary && /^0x[0-9a-f]+$/u.test(procedure) && prefix);
+assert.ok(["raw", "regions", "assembly"].includes(view));
+await mkdir(dirname(prefix), { recursive: true });
+const verifier = createVerifierRun();
+const lifetime = new AbortController();
+const target = await parseBinaryTarget(binary);
+assert.ok(target.ok);
+const installed = await inspectKunaInstallation({
+  ...process.env,
+  REA_KUNA_CACHE_DIR: resolve(`${prefix}.cache`),
+});
+assert.ok(installed.ok);
+const commands = new KunaTargetCommands(target.value, {
+  signal: lifetime.signal,
+});
+const failures = [],
+  calls = [];
+try {
+  const arguments_ = (input) =>
+    view === "assembly"
+      ? ["disassemble", input, procedure, "--addr", "--json"]
+      : [
+          "decompile",
+          input,
+          procedure,
+          "--addr",
+          `--${view}`,
+          "--max-fn-memory",
+          "1024",
+        ];
+  const start = performance.now();
+  const outcome = await commands.run({
+    installation: installed.value,
+    operation: "experiment:structure",
+    arguments: arguments_,
+    outputBytes: 16 * 1024 * 1024,
+    timeoutMs: 120000,
+    signal: lifetime.signal,
+  });
+  if (!outcome.ok) throw outcome.error;
+  const snapshot = outcome.value;
+  const file = `${prefix}.native.txt`;
+  await writeFile(file, snapshot.stdout.text, { flag: "wx" });
+  calls.push({
+    arguments: arguments_(snapshot.input),
+    elapsed_ms: performance.now() - start,
+    file,
+    bytes: Buffer.byteLength(snapshot.stdout.text),
+    sha256: createHash("sha256").update(snapshot.stdout.text).digest("hex"),
+  });
+} catch (error) {
+  failures.push(
+    error instanceof AnalysisError
+      ? projectAnalysisError(error)
+      : String(error.stack ?? error),
+  );
+} finally {
+  lifetime.abort();
+  await commands.close();
+}
+const lifecycle = await completeVerifierRun(verifier);
+let cleanupVerified = false;
+try {
+  assertVerifierCleanupComplete(lifecycle.process_lineage);
+  cleanupVerified = true;
+} catch (error) {
+  failures.push(String(error));
+}
+const report = {
+  binary: resolve(binary),
+  procedure,
+  view,
+  calls,
+  failures,
+  lifecycle,
+  engine: { version: installed.value.version, sha256: installed.value.sha256 },
+  target_sha256: createHash("sha256")
+    .update(await readFile(binary))
+    .digest("hex"),
+};
+await writeFile(`${prefix}.report.json`, JSON.stringify(report, null, 2), {
+  flag: "wx",
+});
+console.log(
+  JSON.stringify({
+    view,
+    calls,
+    failures,
+    cleanup_verified: cleanupVerified,
+  }),
+);
+if (failures.length) process.exitCode = 1;

experiments/atomic-re-tools/facts.mjs

@@ -0,0 +1,210 @@
+// Experimental application layer. Provider parsing and native caches remain in REA.
+import { createHash } from "node:crypto";
+
+export const contextFor = (artifactSha, profile, lease) => {
+  const identity = {
+    artifact_sha256: artifactSha,
+    analysis_profile_digest: profile.digest,
+    address_space: "provider-default",
+  };
+  return {
+    ref: createHash("sha256").update(JSON.stringify(identity)).digest("hex"),
+    ...identity,
+    provider: profile.provider,
+    lease,
+  };
+};
+
+const failure = (code, message) => ({
+  status: "error",
+  error: { code, message },
+});
+const source = (evidence) => ({
+  evidence_id: evidence.evidence_id,
+  confidence: evidence.confidence,
+  limitations: evidence.limitations,
+});
+const pageOf = (items, offset, limit) => ({
+  items: items.slice(offset, offset + limit),
+  selection: {
+    matched: items.length,
+    offset,
+    returned: Math.max(0, Math.min(limit, items.length - offset)),
+    next_offset: offset + limit < items.length ? offset + limit : null,
+  },
+});
+
+/** One fact can be read alone or in a batch; a batch is not a new fact kind. */
+export class FactQueries {
+  constructor(port) {
+    this.port = port;
+  }
+
+  async findStrings({ query, offset = 0, limit = 20, fields = ["value"] }) {
+    const observed = await this.port.observe("search_strings", query);
+    if (!observed.ok) return { status: "error", error: observed.error };
+    const evidence = observed.value;
+    const all = evidence.normalized_result;
+    const page = pageOf(all, offset, limit);
+    return {
+      status: "ok",
+      context: this.port.context(),
+      ...source(evidence),
+      selection: page.selection,
+      // Paging is complete over this provider's answer, not all artifact strings.
+      coverage: {
+        status: "unknown",
+        reason:
+          "Provider inventory is not proof of every string in the artifact.",
+      },
+      items: page.items.map((row) => ({
+        id: {
+          kind: "string",
+          address: row.address,
+          encoding: row.string?.encoding ?? null,
+        },
+        ...Object.fromEntries(
+          fields
+            .filter((key) => Object.hasOwn(row, key))
+            .map((key) => [key, row[key]]),
+        ),
+      })),
+    };
+  }
+
+  validContext(context) {
+    const current = this.port.context();
+    return context.ref === current.ref && context.lease === current.lease;
+  }
+
+  async incomingReferences({ context, targets, offset = 0, limit = 20 }) {
+    if (!this.validContext(context))
+      return failure(
+        "invalid_request",
+        "Fact context or session lease is stale; find facts again on the selected target.",
+      );
+    // Share duplicate targets within this batch. Native/session cache ownership
+    // remains with the provider; this layer adds no long-lived result cache.
+    const observations = new Map();
+    const results = [];
+    for (const target of targets) {
+      let observed = observations.get(target.address);
+      if (observed === undefined) {
+        observed = await this.port.observe("xrefs", {
+          address: target.address,
+        });
+        observations.set(target.address, observed);
+      }
+      if (!observed.ok) {
+        results.push({ target, status: "error", error: observed.error });
+        continue;
+      }
+      const evidence = observed.value;
+      const page = pageOf(evidence.normalized_result, offset, limit);
+      results.push({
+        target,
+        status: "ok",
+        scope: { kind: "exact-address", address: target.address },
+        ...source(evidence),
+        selection: page.selection,
+        coverage: {
+          status: "unknown",
+          reason:
+            "The existing xrefs contract does not carry reference completeness.",
+        },
+        items: page.items.map((address) => ({
+          from: { kind: "location", address },
+          to: { kind: "location", address: target.address },
+          kind: "unknown",
+          kind_reason: "The existing xrefs contract projects addresses only.",
+        })),
+      });
+    }
+    return {
+      status: results.every((row) => row.status === "ok") ? "ok" : "partial",
+      context: this.port.context(),
+      results,
+    };
+  }
+
+  async resolveFunctions({ context, locations }) {
+    if (!this.validContext(context))
+      return failure(
+        "invalid_request",
+        "Fact context or session lease is stale; find facts again on the selected target.",
+      );
+    if (!this.port.supports("resolve_containing_procedure"))
+      return {
+        status: locations.length === 0 ? "ok" : "partial",
+        context: this.port.context(),
+        results: locations.map((location) => ({
+          location,
+          status: "unknown",
+          error: {
+            code: "unsupported",
+            message:
+              "The selected provider does not advertise containing-procedure resolution.",
+          },
+        })),
+      };
+    const observations = new Map();
+    const results = [];
+    for (const location of locations) {
+      let observed = observations.get(location.address);
+      if (observed === undefined) {
+        observed = await this.port.observe("resolve_containing_procedure", {
+          address: location.address,
+        });
+        observations.set(location.address, observed);
+      }
+      results.push(
+        observed.ok
+          ? {
+              location,
+              status: "ok",
+              ...source(observed.value),
+              // Preserve the owner's complete tagged found/negative outcome.
+              resolution: observed.value.normalized_result,
+            }
+          : { location, status: "unknown", error: observed.error },
+      );
+    }
+    return {
+      status: results.every((row) => row.status === "ok") ? "ok" : "partial",
+      context: this.port.context(),
+      results,
+    };
+  }
+
+  async traceStringUses(input) {
+    const strings = await this.findStrings(input);
+    if (strings.status !== "ok") return strings;
+    const references = await this.incomingReferences({
+      context: strings.context,
+      targets: strings.items.map((row) => row.id),
+      offset: 0,
+      limit: input.reference_limit ?? 20,
+    });
+    if (references.status === "error") return references;
+    const locations = [
+      ...new Map(
+        references.results
+          .flatMap((row) => row.items ?? [])
+          .map((row) => [row.from.address, row.from]),
+      ).values(),
+    ];
+    const functions =
+      input.include_functions === false
+        ? null
+        : await this.resolveFunctions({ context: strings.context, locations });
+    return {
+      status:
+        references.status === "partial" || functions?.status === "partial"
+          ? "partial"
+          : "ok",
+      strings,
+      references,
+      functions,
+    };
+  }
+}

experiments/atomic-re-tools/facts.test.mjs

@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { FactQueries, contextFor } from "./facts.mjs";
+
+const profile = {
+  digest: "p1",
+  provider: { id: "test", name: "Test", version: "1" },
+};
+const context = contextFor("artifact-a", profile, "lease-1");
+const evidence = (normalized_result) => ({
+  evidence_id: "ev:test",
+  confidence: "derived",
+  limitations: ["fixture coverage only"],
+  normalized_result,
+});
+const port = (observe, extra = {}) => ({
+  context: () => context,
+  supports: () => true,
+  observe,
+  ...extra,
+});
+const string = {
+  kind: "string",
+  address: "0x20000000000001",
+  encoding: "utf8",
+};
+
+test("artifact, profile and lease boundaries reject joins before invoking analysis", async () => {
+  let calls = 0;
+  const facts = new FactQueries(
+    port(async () => {
+      calls++;
+      throw new Error("must not run");
+    }),
+  );
+  for (const foreign of [
+    contextFor("artifact-b", profile, "lease-1"),
+    contextFor("artifact-a", { ...profile, digest: "p2" }, "lease-1"),
+    contextFor("artifact-a", profile, "lease-2"),
+  ]) {
+    assert.equal(
+      (await facts.incomingReferences({ context: foreign, targets: [string] }))
+        .status,
+      "error",
+    );
+    assert.equal(
+      (await facts.resolveFunctions({ context: foreign, locations: [] }))
+        .status,
+      "error",
+    );
+  }
+  assert.equal(calls, 0);
+  assert.equal(contextFor("artifact-a", profile, "lease-2").ref, context.ref);
+});
+
+test("partial batches retain good observations and exact failure reasons", async () => {
+  const cancelled = {
+    code: "cancelled",
+    message: "caller cancelled",
+    details: { stage: "native" },
+  };
+  const facts = new FactQueries(
+    port(async (_, parameters) =>
+      parameters.address === "0xbad"
+        ? { ok: false, error: cancelled }
+        : { ok: true, value: evidence(["0x20000000000002"]) },
+    ),
+  );
+  const result = await facts.incomingReferences({
+    context,
+    targets: [string, { ...string, address: "0xbad" }],
+  });
+  assert.equal(result.status, "partial");
+  assert.equal(result.results[0].items[0].from.address, "0x20000000000002");
+  assert.equal(result.results[0].items[0].kind, "unknown");
+  assert.deepEqual(result.results[1].error, cancelled);
+  assert.equal(result.results[0].coverage.status, "unknown");
+});
+
+test("duplicate point lookups share work without turning selectors into observed objects", async () => {
+  let calls = 0;
+  const facts = new FactQueries(
+    port(async () => {
+      calls++;
+      return { ok: true, value: evidence(["0x20"]) };
+    }),
+  );
+  const otherEncoding = { ...string, encoding: "utf16le" };
+  const result = await facts.incomingReferences({
+    context,
+    targets: [string, otherEncoding, string],
+  });
+  assert.equal(calls, 1);
+  assert.deepEqual(
+    result.results.map((row) => row.target),
+    [string, otherEncoding, string],
+  );
+  assert.deepEqual(
+    result.results.map((row) => row.items[0].to),
+    Array(3).fill({ kind: "location", address: string.address }),
+  );
+  assert.equal(result.results[0].scope.kind, "exact-address");
+});
+
+test("paging and field selection retain identities, source and unknown coverage", async () => {
+  const rows = [
+    {
+      address: string.address,
+      value: "😀 marker",
+      string: {
+        encoding: "utf8",
+        encoding_status: "observed",
+        byte_length: 12,
+      },
+    },
+    { address: "0x20000000000002", value: "other" },
+  ];
+  const facts = new FactQueries(
+    port(async () => ({ ok: true, value: evidence(rows) })),
+  );
+  const page = await facts.findStrings({
+    query: { pattern: "" },
+    limit: 1,
+    fields: ["string"],
+  });
+  assert.deepEqual(page.items, [{ id: string, string: rows[0].string }]);
+  assert.equal(page.selection.next_offset, 1);
+  assert.equal(page.evidence_id, "ev:test");
+  assert.equal(page.coverage.status, "unknown");
+  const beyond = await facts.findStrings({
+    query: { pattern: "" },
+    offset: 99,
+    limit: 1,
+  });
+  assert.equal(beyond.selection.matched, 2);
+  assert.equal(beyond.selection.returned, 0);
+  assert.equal(beyond.coverage.status, "unknown");
+});
+
+test("unsupported function resolution remains unknown without futile native calls", async () => {
+  const facts = new FactQueries(
+    port(
+      async () => {
+        throw new Error("unsupported capability must not run");
+      },
+      { supports: () => false },
+    ),
+  );
+  const result = await facts.resolveFunctions({
+    context,
+    locations: [{ kind: "location", address: "0x12" }],
+  });
+  assert.equal(result.status, "partial");
+  assert.equal(result.results[0].status, "unknown");
+  assert.equal(result.results[0].error.code, "unsupported");
+  assert.equal(
+    (await facts.resolveFunctions({ context, locations: [] })).status,
+    "ok",
+  );
+});

experiments/atomic-re-tools/interior-reference.c

@@ -0,0 +1,12 @@
+/* Static fixture: compile and inspect, never execute. The only reference into
+ * this string lands after its first byte. Point xrefs and object uses differ. */
+static const char marker[] = "HEAD:REA atomic interior-only marker";
+
+__attribute__((noinline)) const char *give_suffix(void) {
+  return marker + 5;
+}
+
+int main(int argc, char **argv) {
+  (void)argv;
+  return (unsigned char)*give_suffix() == (unsigned char)argc;
+}

experiments/atomic-re-tools/kuna-ssa.mjs

@@ -0,0 +1,300 @@
+// Decoder for the pinned 1.833 print_raw format, not a production Kuna API.
+// Relations come from native SSA annotations, never from reconstructed C text.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+
+const pc = "0x[0-9a-f]{1,16}";
+const seq = `${pc}:[0-9a-f]{1,16}`;
+const operationLine = new RegExp(`^(${seq}):\\s+(.+)$`, "u");
+const blockLine = new RegExp(`^Basic Block (\\d+) (${pc})-(${pc})$`, "u");
+const definitionToken = new RegExp(`\\((${seq})\\)`, "gu");
+const constantToken = /#(0x[0-9a-f]{1,16})(?::(\d+))?(?![0-9a-f])/gu;
+const destination = `Block_(\\d+):(${pc})`;
+const conditional = new RegExp(
+  `^goto ${destination} if (.+) else ${destination}$`,
+  "u",
+);
+const direct = new RegExp(`^goto ${destination}$`, "u");
+const implied = new RegExp(`^(${pc}):\\s+\\[ goto ${destination} \\]$`, "u");
+const address = (value) => `0x${BigInt(value).toString(16)}`;
+const operationId = (value) => {
+  const [location, time] = value.split(":");
+  return `${address(location)}:${BigInt(`0x${time}`).toString(16)}`;
+};
+const indexInto = (index, key, row) => {
+  if (!index.has(key)) index.set(key, []);
+  index.get(key).push(row);
+};
+const ordinal = (value) => {
+  const n = Number(value);
+  assert.ok(Number.isSafeInteger(n) && n >= 0);
+  return n;
+};
+const freeze = (value) => {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+};
+const validateDefinitions = (operations, issues) => {
+  for (const row of operations.values()) {
+    for (const relation of row.definitions) {
+      if (!operations.has(relation.definition))
+        issues.push({
+          source_line: row.source_line,
+          reason: `Missing definition ${relation.definition}`,
+        });
+    }
+  }
+};
+
+const parseOperation = (match, blockId, sourceLine) => {
+  const id = operationId(match[1]);
+  const statement = match[2];
+  const split = statement.indexOf(" = ");
+  const lhs = split < 0 ? "" : statement.slice(0, split);
+  const rhs = split < 0 ? statement : statement.slice(split + 3);
+  const kind = lhs.startsWith("*(")
+    ? "store"
+    : rhs.startsWith("*(")
+      ? "load"
+      : rhs.startsWith("call ")
+        ? "call"
+        : statement.startsWith("goto ")
+          ? "branch"
+          : statement.startsWith("switch ")
+            ? "switch"
+            : statement.startsWith("return(")
+              ? "return"
+              : rhs.includes(" ? ")
+                ? "phi"
+                : "value";
+  // STORE's address is an input. An ordinary assignment's LHS is its output.
+  const inputText = kind === "store" ? statement : rhs;
+  const definitions = [...inputText.matchAll(definitionToken)].map(
+    (token, occurrence) => ({
+      definition: operationId(token[1]),
+      use: id,
+      occurrence,
+      // This is printed-varnode order, NOT a p-code input_index or phi predecessor.
+    }),
+  );
+  const literals = [...inputText.matchAll(constantToken)].map((token) => ({
+    value: address(token[1]),
+    printed_size_bytes: token[2] === undefined ? null : ordinal(token[2]),
+  }));
+  const row = {
+    id,
+    address: id.split(":")[0],
+    block: blockId,
+    kind,
+    statement,
+    definitions,
+    constants: literals,
+    source_line: sourceLine,
+  };
+  return row;
+};
+
+const controlEdges = (row) => {
+  const { statement } = row;
+  const edges = [];
+  const branch = conditional.exec(statement);
+  const jump = direct.exec(statement);
+  if (branch) {
+    for (const [target, targetAddress, polarity] of [
+      [branch[1], branch[2], "true"],
+      [branch[4], branch[5], "false"],
+    ]) {
+      edges.push({
+        from: row.block,
+        to: ordinal(target),
+        target_address: address(targetAddress),
+        kind: "conditional",
+        polarity,
+        predicate: branch[3],
+        operation: row.id,
+        source_line: row.source_line,
+      });
+    }
+  } else if (jump) {
+    edges.push({
+      from: row.block,
+      to: ordinal(jump[1]),
+      target_address: address(jump[2]),
+      kind: "direct",
+      operation: row.id,
+      source_line: row.source_line,
+    });
+  }
+  return edges;
+};
+
+const graphStart = (lines) => {
+  const first = lines.findIndex(
+    (line, i) => line.startsWith("Basic Block 0 ") && lines[i - 1] === "0",
+  );
+  assert.ok(first >= 0, "Missing native SSA block graph header");
+  return first;
+};
+export const parseKunaSsaDump = (text) => {
+  assert.ok(
+    Buffer.byteLength(text) <= 16 * 1024 * 1024,
+    "SSA dump exceeds capture budget",
+  );
+  const lines = text.split("\n");
+  // The CLI places C before the root block graph header. Ignore that C entirely.
+  const first = graphStart(lines);
+  const operations = new Map(),
+    blocks = new Map(),
+    constants = new Map();
+  const users = new Map(),
+    incoming = new Map(),
+    edges = [],
+    issues = [];
+  let block;
+  for (let i = first; i < lines.length; i++) {
+    const line = lines[i];
+    const header = blockLine.exec(line);
+    if (header) {
+      const id = ordinal(header[1]);
+      assert.ok(!blocks.has(id), "Duplicate block identity");
+      // Stop is the last instruction's address, NOT an exclusive byte bound.
+      block = {
+        id,
+        start: address(header[2]),
+        stop_instruction: address(header[3]),
+        operations: [],
+        source_line: i + 1,
+      };
+      blocks.set(id, block);
+      continue;
+    }
+    if (!line.trim()) continue;
+    const fallthrough = implied.exec(line);
+    if (fallthrough) {
+      edges.push({
+        from: block.id,
+        to: ordinal(fallthrough[2]),
+        target_address: address(fallthrough[3]),
+        kind: "printed-implied-goto",
+        operation: null,
+        source_line: i + 1,
+      });
+      continue;
+    }
+    const match = operationLine.exec(line);
+    if (!match) {
+      issues.push({
+        source_line: i + 1,
+        reason: "Unrecognized native dump line",
+      });
+      continue;
+    }
+    const row = parseOperation(match, block.id, i + 1);
+    assert.ok(!operations.has(row.id), "Duplicate operation identity");
+    operations.set(row.id, row);
+    block.operations.push(row.id);
+    for (const literal of new Set(row.constants.map((c) => c.value)))
+      indexInto(constants, literal, row.id);
+    for (const edge of row.definitions) indexInto(users, edge.definition, edge);
+    edges.push(...controlEdges(row));
+  }
+  validateDefinitions(operations, issues);
+  for (const edge of edges) {
+    assert.equal(
+      blocks.get(edge.to)?.start,
+      edge.target_address,
+      "Branch target identity mismatch",
+    );
+    indexInto(incoming, edge.to, edge);
+  }
+  const outgoing = new Set(edges.map((edge) => edge.from));
+  const unrepresented = [...blocks.values()]
+    .filter((b) => {
+      const tail = operations.get(b.operations.at(-1));
+      return tail?.kind !== "return" && !outgoing.has(b.id);
+    })
+    .map((b) => b.id);
+  const digest = createHash("sha256").update(text).digest("hex");
+  for (const table of [operations, blocks, constants, users, incoming])
+    for (const value of table.values()) freeze(value);
+  return freeze({
+    identity: { kind: "native-ssa-snapshot", sha256: digest },
+    coverage: {
+      scope: "printed-SSA",
+      operations: operations.size,
+      blocks: blocks.size,
+      explicit_control_edges: edges.length,
+      unrepresented_outgoing_blocks: unrepresented,
+      issues,
+      control_flow: "partial",
+      machine_semantic_equivalence: "unknown",
+    },
+    // The owner parses/indexes once; all compositions reuse the same facts.
+    operation: (id) => operations.get(id) ?? null,
+    block: (id) => blocks.get(id) ?? null,
+    findConstant: (value) => [...(constants.get(address(value)) ?? [])],
+    uses: (id) => users.get(id) ?? [],
+    incoming: (id) => incoming.get(id) ?? [],
+  });
+};
+
+// Dependency-closed only within the caller's selected budget and boundaries.
+export const backwardSlice = (
+  snapshot,
+  seeds,
+  { maxOperations = 48, stopAt = [], stopKinds = ["phi", "load"] } = {},
+) => {
+  assert.ok(Number.isSafeInteger(maxOperations) && maxOperations > 0);
+  const stopped = new Set(stopAt),
+    kinds = new Set(stopKinds);
+  const queue = [...new Set(seeds)],
+    queued = new Set(queue),
+    seen = new Set(),
+    selected = [],
+    boundaries = [],
+    missing = [];
+  for (let cursor = 0; cursor < queue.length; cursor++) {
+    const id = queue[cursor];
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const row = snapshot.operation(id);
+    if (!row) {
+      missing.push(id);
+      continue;
+    }
+    if (selected.length >= maxOperations) {
+      boundaries.push({ id, reason: "operation-budget" });
+      continue;
+    }
+    selected.push(row);
+    if (stopped.has(id) || kinds.has(row.kind)) {
+      boundaries.push({
+        id,
+        reason: stopped.has(id) ? "caller-selected" : row.kind,
+      });
+    } else
+      for (const edge of row.definitions) {
+        if (!queued.has(edge.definition)) {
+          queue.push(edge.definition);
+          queued.add(edge.definition);
+        }
+      }
+  }
+  return {
+    operations: selected,
+    coverage: {
+      status:
+        boundaries.length || missing.length || snapshot.coverage.issues.length
+          ? "partial"
+          : "complete-for-printed-definitions",
+      boundaries,
+      missing,
+      source_issues: snapshot.coverage.issues.length,
+      runtime_reachability: "unknown",
+      memory_alias_dependencies: "unknown",
+    },
+  };
+};

experiments/atomic-re-tools/kuna-ssa.test.mjs

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { backwardSlice, parseKunaSsaDump } from "./kuna-ssa.mjs";
+import { queryLiteralUses } from "./query-ssa.mjs";
+
+// Minimal native print_raw syntax, including a STORE pointer on its LHS.
+const dump = `ignored C text
+0
+Basic Block 0 0x100-0x106
+0x100:1: r0(0x100:1) = #0xffffffffffffffff
+0x102:2: u0(0x102:2) = r0(0x100:1) != #0x0
+0x106:3: goto Block_1:0x110 if (u0(0x102:2) != 0) else Block_2:0x120
+Basic Block 1 0x110-0x114
+0x110:4: u1(0x110:4) = ->(RDI(i),#0x30)
+0x112:5: *(ram,u1(0x110:4)) = r0(0x100:1)
+0x114:6: return(#0x0)
+Basic Block 2 0x120-0x120
+0x120:7: switch r0(0x100:1)
+`;
+
+test("SSA definitions preserve STORE address dependencies, exact u64 and conditional polarity", () => {
+  const snapshot = parseKunaSsaDump(dump);
+  assert.deepEqual(snapshot.findConstant("0xffffffffffffffff"), ["0x100:1"]);
+  assert.deepEqual(
+    snapshot.operation("0x112:5").definitions.map((e) => e.definition),
+    ["0x110:4", "0x100:1"],
+  );
+  assert.equal(snapshot.operation("0x100:1").definitions.length, 0);
+  assert.deepEqual(
+    snapshot.incoming(1).map((e) => [e.from, e.polarity]),
+    [[0, "true"]],
+  );
+  assert.deepEqual(
+    snapshot.incoming(2).map((e) => [e.from, e.polarity]),
+    [[0, "false"]],
+  );
+  assert.deepEqual(snapshot.coverage.unrepresented_outgoing_blocks, [2]);
+  assert.equal(snapshot.coverage.control_flow, "partial");
+});
+
+test("a bounded slice names budget frontiers; graph cycles terminate", () => {
+  const snapshot = parseKunaSsaDump(dump);
+  const result = backwardSlice(snapshot, ["0x112:5"], { maxOperations: 1 });
+  assert.equal(result.operations.length, 1);
+  assert.equal(result.coverage.boundaries.length, 2);
+  assert.equal(result.coverage.status, "partial");
+  const cyclic = parseKunaSsaDump(
+    dump.replace("#0xffffffffffffffff", "r0(0x100:1)"),
+  );
+  assert.equal(backwardSlice(cyclic, ["0x100:1"]).operations.length, 1);
+});
+
+test("snapshot identity changes with source; malformed and missing facts cannot look complete", () => {
+  assert.notEqual(
+    parseKunaSsaDump(dump).identity.sha256,
+    parseKunaSsaDump(dump + "unknown native line\n").identity.sha256,
+  );
+  assert.equal(
+    parseKunaSsaDump(dump + "unknown native line\n").coverage.issues.length,
+    1,
+  );
+  assert.throws(
+    () => parseKunaSsaDump(dump.replace("Block_1:0x110", "Block_1:0x111")),
+    /identity mismatch/u,
+  );
+  assert.throws(
+    () => parseKunaSsaDump(dump.replace("0x112:5:", "0x100:1:")),
+    /Duplicate operation/u,
+  );
+  const missing = parseKunaSsaDump(
+    dump.replace("r0(0x100:1) !=", "r0(0xff:9) !="),
+  );
+  assert.equal(missing.coverage.issues.length, 1);
+  assert.deepEqual(backwardSlice(missing, ["0x102:2"]).coverage.missing, [
+    "0xff:9",
+  ]);
+});
+
+test("phi/load cutoffs preserve boundary rows and do not invent memory or predecessor bindings", () => {
+  const snapshot = parseKunaSsaDump(
+    dump.replace("r0(0x100:1) != #0x0", "r0(0x100:1) ? r0(0x100:1)"),
+  );
+  const result = backwardSlice(snapshot, ["0x102:2"]);
+  assert.deepEqual(result.coverage.boundaries, [
+    { id: "0x102:2", reason: "phi" },
+  ]);
+  assert.equal(result.operations.length, 1);
+  assert.equal(result.operations[0].definitions.length, 2);
+  assert.equal(result.coverage.memory_alias_dependencies, "unknown");
+});
+
+test("cloned blocks share starts; operation identity includes sequence, and facts stay immutable", () => {
+  const snapshot = parseKunaSsaDump(dump.replaceAll("0x120", "0x110"));
+  assert.equal(snapshot.block(1).start, snapshot.block(2).start);
+  assert.notEqual(snapshot.block(1).id, snapshot.block(2).id);
+  assert.throws(() => {
+    snapshot.operation("0x100:1").kind = "store";
+  }, TypeError);
+  assert.throws(() => snapshot.uses("0x100:1").pop(), TypeError);
+  const query = queryLiteralUses(snapshot, "0xffffffffffffffff");
+  assert.deepEqual(query.constant_operations, ["0x100:1"]);
+  assert.ok(query.direct_uses.includes("0x112:5"));
+  assert.equal(query.coverage.control_flow, "partial");
+});
+
+test("a literal directly in STORE is itself an effect seed; shared block edges are returned once", () => {
+  const snapshot = parseKunaSsaDump(
+    dump.replace(
+      "*(ram,u1(0x110:4)) = r0(0x100:1)",
+      "*(ram,u1(0x110:4)) = #0x20",
+    ),
+  );
+  const query = queryLiteralUses(snapshot, "0x20");
+  assert.deepEqual(query.effect_seed_operations, ["0x112:5"]);
+  assert.deepEqual(
+    query.control_edges.map((e) => e.operation),
+    ["0x106:3"],
+  );
+  assert.ok(query.operations.some((row) => row.id === "0x102:2"));
+});

experiments/atomic-re-tools/mapped-code.mjs

@@ -0,0 +1,121 @@
+// A view over native printer-to-instruction mappings, never a C-text parser.
+import assert from "node:assert/strict";
+import { z } from "zod";
+
+const mapping = z.object({
+  line_number: z.number().int().positive(),
+  addresses: z.array(z.number().nonnegative()),
+});
+const documentSchema = z.object({
+  binary: z.string(),
+  count: z.number().int().nonnegative(),
+  functions: z.array(
+    z.object({
+      address_hex: z.string(),
+      address: z.number().nonnegative(),
+      code: z.string().nullable(),
+      error: z.string().nullable(),
+      line_mappings: z.array(mapping).optional(),
+    }),
+  ),
+});
+
+export const mappedCode = async (native, reference, contextLines = 16) => {
+  if (reference.functions.length !== 1 || !Array.isArray(reference.sites))
+    return {
+      status: "unknown",
+      reason:
+        "A unique native owning function and exact reference sites are required.",
+    };
+  const entry = reference.functions[0].address;
+  const snapshot = await native((input) => [
+    "decompile",
+    input,
+    entry,
+    "--addr",
+    "--json",
+    "--max-fn-memory",
+    "1024",
+  ]);
+  const document = documentSchema.parse(JSON.parse(snapshot.stdout.text));
+  assert.equal(document.binary, snapshot.input);
+  assert.equal(document.count, document.functions.length);
+  const candidates = document.functions.filter(
+    (row) => row.address_hex === entry,
+  );
+  const fn = candidates.length === 1 ? candidates[0] : undefined;
+  if (fn === undefined || fn.code === null || fn.line_mappings === undefined)
+    return {
+      status: "unknown",
+      reason:
+        "Native decompilation did not supply a body with instruction-to-line mappings.",
+      native_error: fn?.error ?? null,
+    };
+  // This low-VMA experiment rejects unsafe numeric arrays, rather than rounding
+  // u64 addresses. General u64 array support would need the owning JSON parser.
+  if (
+    !Number.isSafeInteger(fn.address) ||
+    `0x${fn.address.toString(16)}` !== entry ||
+    fn.line_mappings.some((row) =>
+      row.addresses.some((value) => !Number.isSafeInteger(value)),
+    )
+  )
+    return {
+      status: "unknown",
+      reason:
+        "Instruction mapping contains an address outside this prototype's exact safe-integer coverage.",
+    };
+  const sites = new Set(reference.sites.map((row) => row.from));
+  const hits = fn.line_mappings.filter((row) =>
+    row.addresses.some((value) => sites.has(`0x${value.toString(16)}`)),
+  );
+  const mappedSites = new Set(
+    hits.flatMap((row) =>
+      row.addresses.map((value) => `0x${value.toString(16)}`),
+    ),
+  );
+  const unmappedSites = [...sites].filter((site) => !mappedSites.has(site));
+  const lines = fn.code.split("\n");
+  for (const hit of hits) assert.ok(hit.line_number <= lines.length);
+  if (!hits.length)
+    return {
+      status: "unknown",
+      reason:
+        "No exact reference site maps to an emitted line; nearest-line guessing is disabled.",
+    };
+  const ranges = hits.map((hit) => ({
+    start_line: Math.max(1, hit.line_number - contextLines),
+    end_line: Math.min(lines.length, hit.line_number + contextLines),
+  }));
+  const slices = [];
+  for (const range of ranges.sort((a, b) => a.start_line - b.start_line)) {
+    const previous = slices.at(-1);
+    if (previous !== undefined && range.start_line <= previous.end_line + 1)
+      previous.end_line = Math.max(previous.end_line, range.end_line);
+    else slices.push({ ...range });
+  }
+  return {
+    status: unmappedSites.length || fn.error !== null ? "partial" : "ok",
+    native_error: fn.error,
+    entry,
+    reference_sites: [...sites],
+    unmapped_reference_sites: unmappedSites,
+    exact_mapped_lines: hits.map((row) => row.line_number),
+    total_lines: lines.length,
+    total_characters: fn.code.length,
+    slices: slices.map((range) => ({
+      ...range,
+      text: lines.slice(range.start_line - 1, range.end_line).join("\n"),
+    })),
+    coverage: {
+      status: "partial",
+      reason:
+        "Selected text around exact mapped sites; not a proof that every relevant guard or data dependency is included.",
+    },
+    limitations: [
+      "Single-function engine reconstruction, not original source.",
+      "Printer line mappings are derived and do not prove runtime reachability.",
+      "Complete native body and mappings remain in the retained source document.",
+    ],
+  };
+};

experiments/atomic-re-tools/mapped-code.test.mjs

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mappedCode } from "./mapped-code.mjs";
+
+const reference = {
+  functions: [{ address: "0x1000" }],
+  sites: [{ from: "0x2000" }, { from: "0x2001" }],
+};
+const document = () => ({
+  binary: "/private/input",
+  count: 1,
+  functions: [
+    {
+      address: 4096,
+      address_hex: "0x1000",
+      code: "one\ntwo\nthree\nfour\nfive",
+      error: null,
+      line_mappings: [{ line_number: 3, addresses: [8192] }],
+    },
+  ],
+});
+const native = (value) => async () => ({
+  input: "/private/input",
+  stdout: { text: JSON.stringify(value) },
+});
+
+test("a mapped subset names unmapped sites instead of implying complete mapping", async () => {
+  const result = await mappedCode(native(document()), reference, 1);
+  assert.equal(result.status, "partial");
+  assert.deepEqual(result.unmapped_reference_sites, ["0x2001"]);
+  assert.deepEqual(result.slices, [
+    { start_line: 2, end_line: 4, text: "two\nthree\nfour" },
+  ]);
+  assert.equal(result.coverage.status, "partial");
+});
+
+test("unmapped locations never select a nearby printed line", async () => {
+  const result = await mappedCode(native(document()), {
+    ...reference,
+    sites: [{ from: "0x1fff" }],
+  });
+  assert.equal(result.status, "unknown");
+});
+
+test("unsafe numeric address arrays stay unknown without lossy conversion", async () => {
+  const value = document();
+  value.functions[0].line_mappings[0].addresses = [Number.MAX_SAFE_INTEGER + 1];
+  const result = await mappedCode(native(value), reference);
+  assert.equal(result.status, "unknown");
+});
+
+test("malformed line locations reject the view before publishing fragments", async () => {
+  const value = document();
+  value.functions[0].line_mappings[0].line_number = 99;
+  await assert.rejects(mappedCode(native(value), reference));
+});

experiments/atomic-re-tools/native-relations.mjs

@@ -0,0 +1,274 @@
+// Native-boundary experiment, not MCP and not a production provider extension.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+import { AnalysisError } from "../../dist/domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../../dist/domain/analysisErrorProjection.js";
+import { mappedCode } from "./mapped-code.mjs";
+import { parseBinaryTarget } from "../../dist/application/BinaryTargetResolver.js";
+import { inspectKunaInstallation } from "../../dist/kuna/KunaInstallation.js";
+import { KunaTargetCommands } from "../../dist/kuna/KunaTargetCommands.js";
+import { parseKunaJson } from "../../dist/kuna/KunaJson.js";
+import { parseKunaStringInventory } from "../../dist/kuna/KunaStringInventory.js";
+import { parseKunaIncomingReferenceFacts } from "../../dist/kuna/KunaReferenceFiles.js";
+import {
+  createVerifierRun,
+  completeVerifierRun,
+  assertVerifierCleanupComplete,
+} from "../../scripts/lib/verifier-run.mjs";
+
+const [binary, pattern, variant, prefix, codeOption] = process.argv.slice(2);
+assert.ok(binary && pattern && prefix);
+assert.ok(["per-address", "inventory"].includes(variant));
+await mkdir(dirname(prefix), { recursive: true });
+const verifier = createVerifierRun();
+const lifetime = new AbortController();
+const parsed = await parseBinaryTarget(binary);
+assert.ok(parsed.ok);
+const installed = await inspectKunaInstallation({
+  ...process.env,
+  REA_KUNA_CACHE_DIR: resolve(`${prefix}.cache`),
+});
+assert.ok(installed.ok);
+const commands = new KunaTargetCommands(parsed.value, {
+  signal: lifetime.signal,
+});
+const address = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]{0,15})$/u);
+const functionSchema = z.object({
+  name: z.string(),
+  address,
+  address_hex: address,
+});
+const relatedRow = z.object({
+  address,
+  address_hex: address,
+  text: z.string(),
+  length: z.number().int().nonnegative(),
+  encoding: z.string(),
+  byte_length: z.number().int().nonnegative(),
+  nul_terminated: z.boolean(),
+  xrefs_count: z.number().int().nonnegative(),
+  functions: z.array(functionSchema),
+});
+const sourceKeys = new Set(["address", "from_address", "to_address"]);
+const limit = 16 * 1024 * 1024;
+const calls = [],
+  failures = [];
+let facts;
+const native = async (arguments_) => {
+  const start = performance.now();
+  const outcome = await commands.run({
+    installation: installed.value,
+    operation: "experiment:native-relations",
+    arguments: arguments_,
+    outputBytes: limit,
+    timeoutMs: 120000,
+    signal: lifetime.signal,
+  });
+  if (!outcome.ok) throw outcome.error;
+  const snapshot = outcome.value;
+  const file = `${prefix}.native-${calls.length}.json`;
+  await writeFile(file, snapshot.stdout.text);
+  calls.push({
+    elapsed_ms: performance.now() - start,
+    file,
+    arguments: arguments_(snapshot.input),
+    sha256: createHash("sha256").update(snapshot.stdout.text).digest("hex"),
+    bytes: Buffer.byteLength(snapshot.stdout.text),
+  });
+  return snapshot;
+};
+try {
+  // Common producer: validate all string facts once through the existing owner.
+  const scan = await native((input) => [
+    "strings",
+    input,
+    "--json",
+    "--encoding",
+    "all",
+    "--min-length",
+    "5",
+    "--termination",
+    "any",
+    "--no-xrefs",
+  ]);
+  const inventory = parseKunaStringInventory(scan.stdout.text, scan.input);
+  assert.ok(inventory.ok, inventory.error);
+  const selected = inventory.value.items
+    .filter((row) => row.value.includes(pattern))
+    .slice(0, 3);
+  assert.ok(selected.length > 0);
+  const results = [];
+  if (variant === "per-address") {
+    for (const item of selected) {
+      const result = await native((input) => [
+        "xrefs",
+        input,
+        "--to",
+        item.address,
+        "--json",
+      ]);
+      // Consume the owning parser's facts, without reinterpreting raw JSON.
+      const validated = parseKunaIncomingReferenceFacts(
+        result.stdout.text,
+        result.input,
+        item.address,
+      );
+      assert.ok(validated.ok, validated.error);
+      const rows = validated.value.facts;
+      const functions = [
+        ...new Map(
+          rows
+            .flatMap((row) =>
+              row.fromFunction === null ? [] : [row.fromFunction],
+            )
+            .map((fn) => [fn.address, fn]),
+        ).values(),
+      ];
+      results.push({
+        string: item,
+        scope: "exact-start-address",
+        xrefs_count: rows.length,
+        functions,
+        sites: rows.map((row) => ({
+          from: row.from,
+          to: row.to,
+          kind: row.kind,
+          instruction: row.instruction,
+        })),
+        source: calls.at(-1),
+      });
+    }
+  } else {
+    const result = await native((input) => [
+      "strings",
+      input,
+      "--json",
+      "--encoding",
+      "all",
+      "--min-length",
+      "5",
+      "--termination",
+      "any",
+    ]);
+    const document = parseKunaJson(result.stdout.text, limit, sourceKeys);
+    assert.equal(document.binary, result.input);
+    assert.equal(document.xrefs, true);
+    assert.equal(document.encoding, "all");
+    assert.equal(document.min_length, 5);
+    assert.equal(document.termination, "any");
+    assert.equal(document.filter, null);
+    assert.equal(document.section, null);
+    assert.equal(document.scanned, inventory.value.scanned);
+    assert.equal(document.count, document.strings.length);
+    assert.equal(document.count, inventory.value.items.length);
+    const known = new Map(
+      inventory.value.items.map((row) => [
+        `${row.address}|${row.string.encoding}`,
+        row,
+      ]),
+    );
+    const examined = new Map();
+    for (const value of document.strings) {
+      const row = relatedRow.parse(value);
+      assert.equal(row.address, row.address_hex);
+      const key = `${row.address}|${row.encoding}`;
+      assert.ok(!examined.has(key));
+      const expected = known.get(key);
+      assert.ok(expected);
+      assert.equal(row.text, expected.value);
+      assert.equal(row.length, [...expected.value].length);
+      assert.equal(row.byte_length, expected.string.byte_length);
+      assert.equal(
+        row.nul_terminated,
+        expected.string.termination === "present_or_not_required",
+      );
+      const entries = new Set();
+      for (const fn of row.functions) {
+        assert.equal(fn.address, fn.address_hex);
+        assert.ok(!entries.has(fn.address));
+        entries.add(fn.address);
+      }
+      assert.ok(row.functions.length <= row.xrefs_count);
+      examined.set(key, row);
+    }
+    for (const item of selected) {
+      const row = examined.get(`${item.address}|${item.string.encoding}`);
+      results.push({
+        string: item,
+        scope: "any-byte-in-string-extent",
+        xrefs_count: row.xrefs_count,
+        functions: row.functions,
+        sites: {
+          status: "unknown",
+          reason:
+            "Native string attribution does not return reference sites or kinds.",
+        },
+        source: calls.at(-1),
+      });
+    }
+  }
+  const code =
+    codeOption === "--code-slice" ? await mappedCode(native, results[0]) : null;
+  facts = {
+    artifact_sha256: parsed.value.sha256,
+    engine: {
+      version: installed.value.version,
+      sha256: installed.value.sha256,
+    },
+    inventory_count: inventory.value.items.length,
+    selected_count: selected.length,
+    results,
+    mapped_code: code === null ? null : { ...code, source: calls.at(-1) },
+    limitations: [
+      "These are native derived static references, not runtime uses.",
+      "The per-address and inventory scopes differ; their timings do not establish equivalent-query speedup.",
+      "An empty function set can mean unowned references, not that a string is unused.",
+      "Complete native source documents are retained locally by file and SHA-256; this is not an MCP token measurement.",
+    ],
+  };
+} catch (error) {
+  failures.push(
+    error instanceof AnalysisError
+      ? projectAnalysisError(error)
+      : { message: String(error), stack: error.stack ?? null },
+  );
+}
+lifetime.abort();
+const closed = await commands.close();
+if (!closed.ok) failures.push(String(closed.error));
+const lifecycle = await completeVerifierRun(verifier);
+try {
+  assertVerifierCleanupComplete(lifecycle.process_lineage);
+} catch (error) {
+  failures.push(String(error));
+}
+await writeFile(
+  `${prefix}.report.json`,
+  JSON.stringify(
+    {
+      variant,
+      binary: resolve(binary),
+      pattern,
+      calls,
+      facts,
+      failures,
+      lifecycle,
+    },
+    null,
+    2,
+  ),
+);
+console.log(
+  JSON.stringify({
+    variant,
+    native_commands: calls.length,
+    native_ms: calls.reduce((sum, row) => sum + row.elapsed_ms, 0),
+    selected: facts?.selected_count,
+    owners: facts?.results.map((row) => row.functions.length),
+    failures,
+  }),
+);
+assert.deepEqual(failures, []);

experiments/atomic-re-tools/query-ssa.mjs

@@ -0,0 +1,168 @@
+// A composition over one validated, immutable snapshot; no new engine work.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { backwardSlice, parseKunaSsaDump } from "./kuna-ssa.mjs";
+import { assertVerifierCleanupComplete } from "../../scripts/lib/verifier-run.mjs";
+
+export const queryLiteralUses = (snapshot, literal, maxOperations = 48) => {
+  const allSeeds = snapshot.findConstant(literal);
+  const seeds = allSeeds.slice(0, 16);
+  const effectSeeds = seeds.filter((id) =>
+    ["store", "call"].includes(snapshot.operation(id).kind),
+  );
+  const allUses = [
+    ...new Set([
+      ...effectSeeds,
+      ...seeds.flatMap((id) => snapshot.uses(id).map((e) => e.use)),
+    ]),
+  ];
+  const selectedUses = allUses.slice(0, 16);
+  const consumers = selectedUses.map((id) => snapshot.operation(id));
+  const controlEdges = [
+    ...new Map(
+      consumers
+        .flatMap((row) => snapshot.incoming(row.block))
+        .map((edge) => [
+          JSON.stringify([edge.from, edge.to, edge.operation, edge.polarity]),
+          edge,
+        ]),
+    ).values(),
+  ];
+  const branchIds = [
+    ...new Set(
+      controlEdges.flatMap((edge) =>
+        edge.operation === null ? [] : [edge.operation],
+      ),
+    ),
+  ];
+  const guards = backwardSlice(snapshot, branchIds, { maxOperations });
+  const facts = [
+    ...new Map(
+      [
+        ...seeds.map((id) => snapshot.operation(id)),
+        ...consumers,
+        ...guards.operations,
+      ].map((row) => [row.id, row]),
+    ).values(),
+  ];
+  const selected = new Set(facts.map((row) => row.id));
+  return {
+    literal,
+    snapshot: snapshot.identity,
+    constant_operations: seeds,
+    effect_seed_operations: effectSeeds,
+    direct_uses: selectedUses,
+    control_edges: controlEdges,
+    operations: facts,
+    coverage: {
+      status: "partial",
+      seed_matches: allSeeds.length,
+      omitted_seed_matches: allSeeds.length - seeds.length,
+      omitted_direct_uses: allUses.length - selectedUses.length,
+      dependencies: guards.coverage,
+      unexpanded_definition_ids: [
+        ...new Set(
+          facts.flatMap((row) =>
+            row.definitions
+              .filter((edge) => !selected.has(edge.definition))
+              .map((edge) => edge.definition),
+          ),
+        ),
+      ],
+      control_flow: snapshot.coverage.control_flow,
+      unrepresented_outgoing_blocks:
+        snapshot.coverage.unrepresented_outgoing_blocks.length,
+      source_issues: snapshot.coverage.issues.length,
+      scope:
+        "literal equality, effect seeds and direct printed uses, their explicit incoming edges and bounded branch definitions",
+      address_object_identity: "unknown",
+      call_argument_bindings: "unknown",
+    },
+  };
+};
+
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const main = async () => {
+  const [prefix, values, output] = process.argv.slice(2);
+  assert.ok(prefix && values && output);
+  const literals = values.split(",");
+  assert.ok(
+    literals.length <= 16 &&
+      literals.every((s) => /^0x[0-9a-f]{1,16}$/u.test(s)),
+  );
+  const report = JSON.parse(await readFile(`${prefix}.report.json`, "utf8"));
+  assert.equal(report.view, "raw");
+  assert.deepEqual(report.failures, []);
+  assert.equal(report.calls.length, 1);
+  assert.equal(
+    report.engine.version,
+    "1.833",
+    "Decoder is pinned to the inspected printer format",
+  );
+  assertVerifierCleanupComplete(report.lifecycle.process_lineage);
+  const source = report.calls[0];
+  const raw = await readFile(source.file, "utf8");
+  assert.equal(sha256(raw), source.sha256);
+  assert.equal(Buffer.byteLength(raw), source.bytes);
+  assert.equal(
+    sha256(await readFile(report.binary)),
+    report.target_sha256,
+    "Artifact changed since capture",
+  );
+  const start = performance.now();
+  const snapshot = parseKunaSsaDump(raw);
+  const parseIndexMs = performance.now() - start;
+  const runs = [];
+  for (const phase of ["first-projection", "reused-index"]) {
+    const before = performance.now();
+    const answers = literals.map((literal) =>
+      queryLiteralUses(snapshot, literal),
+    );
+    const serialized = JSON.stringify(answers);
+    runs.push({
+      phase,
+      query_and_serialization_ms: performance.now() - before,
+      answers,
+      serialized_bytes: Buffer.byteLength(serialized),
+    });
+  }
+  assert.deepEqual(runs[0].answers, runs[1].answers);
+  await writeFile(
+    output,
+    JSON.stringify(
+      {
+        source: {
+          artifact_sha256: report.target_sha256,
+          engine: report.engine,
+          procedure: report.procedure,
+          capture_report: `${prefix}.report.json`,
+          raw: source,
+          profile:
+            "one-function native decompile defaults + --raw; no annotations",
+        },
+        parse_index_ms: parseIndexMs,
+        coverage: snapshot.coverage,
+        runs,
+        lifetime:
+          "One local process; validated immutable snapshot reused without native analysis. No cross-session cache.",
+      },
+      null,
+      2,
+    ),
+    { flag: "wx" },
+  );
+  console.log(
+    JSON.stringify({
+      output,
+      parse_index_ms: parseIndexMs,
+      runs: runs.map(({ answers, ...timing }) => ({
+        ...timing,
+        selected_operations: answers.map((a) => a.operations.length),
+      })),
+    }),
+  );
+};
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
+  await main();

experiments/atomic-re-tools/relations.md

@@ -0,0 +1,239 @@
+# Control-flow and definition/use experiment
+
+This continues the first-round experiment on the same REA source baseline and
+Kuna 1.833. It is an exploratory native-boundary decoder, not a production
+provider capability or a new MCP catalog. No PR or merge is intended.
+
+The analyst questions are which local conditions lead to zlib's
+`incorrect header check` assignment and SQLite's
+`malformed MATCH expression: [%s]` error-formatting call. Runtime reachability,
+memory aliasing, phi predecessor bindings and complete entry-state conditions
+remain unknown. These are not controlled agent trials.
+
+`capture-function.mjs` records the existing public MCP function dossier. It
+preserves transport-budget failures and follows retained Evidence for a value-flow
+summary, then exports the complete local Evidence bundle before closing.
+`capture-kuna-structure.mjs` uses REA's existing target/process owners to capture
+the native `--raw`, `--regions` or disassembly output. All target inspection is
+static. The engine and artifact digests, command arguments, raw digest and cleanup
+proof are retained locally.
+
+`kuna-ssa.mjs` owns the decoder for the inspected 1.833 SSA diagnostic format.
+It indexes explicit definition annotations, literal values, block membership and
+printed branch destinations once. Immutable rows carry native source lines;
+operation and block IDs are local to the content-digested snapshot. A block's
+printed stop is an instruction address, not an exclusive extent. Blocks can share
+start addresses. Unknown lines, omitted outgoing relationships, missing definitions
+and traversal boundaries remain explicit. Printed operand occurrences do not
+claim p-code input indexes or phi-to-predecessor bindings.
+
+`query-ssa.mjs` composes literal equality, direct uses, incoming explicit edges
+and bounded backward definitions. It validates the retained capture against its
+digest and the current artifact before indexing. It retains complete native
+evidence; its local cache lives for one process. Default phi/load boundaries avoid
+expanding the whole program state. Selection limits report omissions.
+
+Use the pinned Node from `.nvmrc`, an existing build and caller-supplied Kuna:
+
+```sh
+node --test experiments/atomic-re-tools/kuna-ssa.test.mjs
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+  node experiments/atomic-re-tools/capture-kuna-structure.mjs \
+  /usr/lib/x86_64-linux-gnu/libz.so.1 0xc1e0 raw .cache/atomic-re-tools/relations-zlib
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+  node experiments/atomic-re-tools/query-ssa.mjs .cache/atomic-re-tools/relations-zlib \
+  0x18fc4 .cache/atomic-re-tools/relations-zlib-query.json
+```
+
+The addresses above apply only to the exact zlib artifact in [results](results.md).
+Do not reuse them across provider load spaces or binary versions. Complete
+measurement and validation notes follow below.
+
+## Observed results
+
+The same artifact and engine digests as [round one](results.md) apply. This is
+the existing experiment, not a newly rebased feature branch: newer REA main
+`42fc6c53ae188978deb3bedfe88287b6b316ba22` was fetched for inspection, but these
+runs retain baseline `5b16f2431062eea6ffd245a9e05512790007cb13` and Kuna 1.833.
+The source decoder was checked against Kuna's pinned
+[SSA renderer](https://github.com/Noelo-Lab/kuna/blob/fe01d6294eb0d1053ce343c8943646df88e143fc/decompiler/crates/kuna-decomp/src/substrate/funcdata_printraw.rs).
+No newer Kuna version was tested.
+
+1. **SSA value origins repair all three failed zlib mappings.** The original
+   string xrefs are LEAs whose addresses do not appear in printer mappings.
+   Literal equality in optimized SSA finds a pointer-valued operation; its
+   explicit def-use points to a STORE at a different instruction origin. Those
+   origins do appear in the retained JSON line mappings:
+
+   | String address | Original LEA | STORE origin | Exact emitted line |
+   | -------------- | ------------ | ------------ | -----------------: |
+   | `0x18fc4`      | `0xded7`     | `0xdee6`     |                164 |
+   | `0x19003`      | `0xdc6a`     | `0xdc74`     |                551 |
+   | `0x19018`      | `0xcd05`     | `0xcd0f`     |                653 |
+
+   The independently captured raw-mode C and JSON-mode C are byte-equal after
+   removing outer whitespace. The verifier checks both retained source digests,
+   artifact and engine equality before joining instruction origins. This is
+   corroboration between two captures, not proof of a shared internal IR revision.
+   A production interface should export these relationships together.
+
+2. **Control and def-use answer a bounded local question.** For the header error,
+   the result contains 21 operations: the literal origin, STORE and 19 branch
+   dependencies. Two explicit incoming edges enter block 446. They correspond
+   to a missing low wrap bit and a failed divisibility check on the constructed
+   header value. The branch definitions stop at a memory load and a phi node.
+   Original machine instructions independently show `test $1` / `je` and the
+   reciprocal-division sequence / `jne` into the error block. The verifier
+   exhaustively checks all 65,536 ordinary 16-bit header values against both
+   the captured arithmetic sequence and modulo 31. No target code is executed.
+   This agrees with [zlib 1.2.13 source](https://github.com/madler/zlib/blob/v1.2.13/inflate.c#L633)
+   and [RFC 1950](https://www.rfc-editor.org/rfc/rfc1950.html#section-2.2).
+   It does not establish all entry-state preconditions or primed bit-buffer states.
+
+3. **The same composition finds a SQLite call guard.** For the first malformed
+   MATCH string at `0x11dcd8`, five selected operations connect the literal to
+   `sqlite3Fts3ErrMsg` and the observed condition `EBX == 1`. The original bytes
+   have `cmp $1,%ebx` and `je` to the formatting path; the corresponding
+   [3.40.1 source](https://github.com/sqlite/sqlite/blob/version-3.40.1/ext/fts3/fts3_expr.c#L1057)
+   uses `rc == SQLITE_ERROR`, whose [code is 1](https://www.sqlite.org/rescode.html#error).
+   The slice stops at the return-code phi: it does not explain why a particular
+   input caused the parser error. Source-version agreement is corroboration,
+   not proof of an exact Debian source/build match.
+
+4. **Addresses do not identify IR blocks.** SQLite blocks 20 and 22 both start at
+   `0x6523e`, yet have distinct identities and paths. Several operations also
+   share instruction origins. Do not use a block's printed address span as its
+   membership set, or pair phi inputs with CFG predecessors by printed order.
+
+5. **Retained paging cannot recover producer omissions.** Ghidra `inflate` by
+   name is ambiguous between PLT and body. Its exact body is `0x10c1e0`, in a
+   different load space from Kuna's `0xc1e0`. The complete MCP dossier exceeded
+   the 10 MiB transport budget. The server correctly retained Evidence and
+   supplied continuation arguments; summary reads and local bundle export worked.
+   However, high p-code was already truncated to 3,000 operations, with 239 known
+   omitted edges and at least one omitted operation. The late error literal is
+   outside that prefix. Its absence remains **unknown**. Raising the response
+   limit or paging the retained prefix would not repair this missing coverage.
+
+Kuna's raw dump contains 3,860 operations / 472 blocks for `inflate`, and
+253 operations / 23 blocks for the SQLite function. All printed definition IDs
+resolved in these captures. Nevertheless, 63 / 1 blocks respectively have
+unrepresented outgoing relationships. In particular, the diagnostic format does
+not enumerate switch successors or every layout fallthrough. Incoming edges are
+local observations, not a complete control-dependence or feasible-path proof.
+`--regions` exposes structuring output; it did not provide the missing typed CFG.
+
+## Cost and limits of the comparison
+
+The estimates below use tiktoken 0.14.0 / `o200k_base`, not bytes-to-token ratios.
+Full C is native text; the selected answer is JSON including source identity,
+raw-Evidence access, facts and unknown coverage. No hypothetical MCP wrapper is
+counted. These are **representation costs**, not equivalent completed agent tasks.
+
+| Target / question  | Full C tokens | Full raw C + SSA tokens | Selected answer tokens |
+| ------------------ | ------------: | ----------------------: | ---------------------: |
+| zlib header error  |        17,726 |                 254,265 |                  3,270 |
+| SQLite MATCH error |           931 |                  14,928 |                  1,283 |
+
+The three zlib answers together cost 5,485 tokens with one shared source envelope.
+The SQLite counterexample matters: a small function is cheaper as complete C than
+as this structured slice. A successful atomic API does not force tiny getters or
+graph output for every question. A C window around zlib line 164, on the other
+hand, still misses the earlier guard at lines 122–124; locating a line alone did
+not complete the local explanation.
+
+| Stage                                                      | Elapsed s | Family CPU s | Peak family MiB |
+| ---------------------------------------------------------- | --------: | -----------: | --------------: |
+| zlib native raw, first capture                             |     6.965 |        6.608 |           208.1 |
+| zlib native raw, fresh repeat                              |    18.749 |       13.462 |           195.9 |
+| SQLite native raw                                          |     2.738 |        2.557 |           172.5 |
+| zlib validation, index and two projections                 |     0.423 |        0.227 |            43.7 |
+| SQLite validation, index and two projections               |     0.322 |        0.095 |            24.9 |
+| Ghidra exact selection, retained summary / bundle workflow |    49.170 |       48.536 |         1,466.6 |
+
+The fresh zlib captures have identical raw digests, but different elapsed/CPU
+costs; the cause is unisolated. These samples establish neither native-analysis
+acceleration nor a cross-provider speed ranking. OS caches were not flushed.
+The Ghidra row includes first/warm requests and lifecycle, and is not equivalent
+to the one-command native rows. Its analyst question remained unfinished.
+
+Within the final projection runs, parse/index took 130.20 ms / 7.96 ms for
+zlib / SQLite. First query plus serialization took 1.10 ms / 0.64 ms; repeat
+queries on the same immutable index took 0.29 ms / 0.09 ms. Native analysis did
+not run during either projection. This is a useful reuse mechanism, not a claim
+that the original native decompilation becomes that fast.
+
+All resource observations use the existing one-CPU, 4 GiB hard limit, 3 GiB early
+stop and 192-task owner. Peak memory is the kernel cgroup `memory.peak` for the
+whole process family, **including charged file cache**, not RSS. Every captured
+run had verified payload-exit cleanup and zero OOM kills. The complete 12-run
+ledger includes the ambiguous-name failure, the transport failure, the region
+probe, superseded projections and automated verification: 178.051 s wall and
+168.094 s family CPU in total. Manual investigation, old discovery/xrefs, objdump,
+tokenization and development checks are outside that ledger.
+
+The actual Ghidra retained workflow used the existing complete input-only catalog:
+206,954 estimated catalog tokens plus 39,620 captured request/response tokens,
+including failures, lifecycle and export. Exported bundle contents stayed local.
+These costs do not count as a successful solution or as comparable Kuna savings.
+No model reasoning tokens, answer-quality score, controlled agent A/B trial or
+end-to-end agent latency was measured.
+
+## What to explore next
+
+The useful candidate is a shared analysis snapshot with typed facts and relations,
+then bounded question-specific projections. Stable identity must include artifact,
+load space, profile and snapshot; value definitions and block membership need
+native identities in addition to instruction origins. Complete control dependence
+requires a CFG with coverage; alias effects and phi predecessor bindings need
+explicit producer support.
+
+The nearest existing surfaces are `trace_native_values` for analysis and native
+facets of `inspect_analysis_view` for retained reads. Retained views should remain
+read-only: new analysis belongs to the analysis owner. Seeded selection must happen
+before Ghidra's producer limit. Kuna should ideally export a structured IR/CFG
+subset from the native owner instead of making this diagnostic-text decoder a
+production protocol. Do not add a separate MCP tool for each getter or a custom
+query language on the basis of these two functions.
+
+Complex-software superiority is still unproven. The next discriminating question
+is why an input reaches a selected error: that needs phi predecessor bindings and
+control dependencies beyond these local slices, with a completed-task comparison
+against the ordinary C workflow. Keep the small-SQLite counterexample in that
+evaluation rather than optimizing only the large-function case.
+
+## Verification and retained evidence
+
+Six distinct SSA module tests plus the existing nine fact/mapping tests passed.
+Real static captures, exact mapping replay for three errors, bounded SQLite
+composition, 65,536 arithmetic cases, original instruction checks and Ghidra
+retained-Evidence recovery passed. The Ghidra late-literal query did not have
+sufficient producer coverage. Formatter, targeted lint, syntax and whitespace
+checks ran; no production runtime source was changed in this round.
+
+Locally retained evidence is under `.cache/atomic-re-tools/`, including
+`relations-*.{report.json,log}`, `relations-*-raw*.native.txt`, the exported Ghidra
+bundle, `relations-*-query-v2.json`, `relations-verification-v2.json` and
+`relations-summary-v2.json`. Raw captures are not committed. Their SHA-256 values:
+
+- zlib raw: `b1d6bc61755041d2934e4ab173aca4e5fdf40f5bda01ca404458a163b129681b`.
+- SQLite raw: `8a945a1549b855802958bd4d33f37b9aaf00781aa57059fe25cb740244a1cdde`.
+- zlib JSON body/mappings: `21631d31b4b93aa75c200be71a71ffe9f4b209982a9c329a2120d9f7c7509ea3`.
+
+After producing captures with the prefixes used in the scripts, replay and count:
+
+```sh
+node experiments/atomic-re-tools/verify-relations.mjs \
+  .cache/atomic-re-tools .cache/atomic-re-tools/relations-verification-v2.json
+python experiments/atomic-re-tools/summarize-relations.py \
+  .cache/atomic-re-tools .cache/atomic-re-tools/relations-summary-v2.json
+```
+
+The second command requires tiktoken. The checked-in verifier intentionally binds
+to these exact artifacts and oracle addresses; it is not a generic correctness
+test for arbitrary zlib/SQLite versions. Capture Ghidra with
+`capture-function.mjs ghidra <zlib-path> 0x10c1e0 <prefix>`, and SQLite with
+`capture-kuna-structure.mjs <sqlite-path> 0x65180 raw <prefix>`. Caller-supplied
+engine paths and the existing resource wrapper are required as in round one.
+Capture prefixes and output paths must be fresh; exclusive writes preserve any
+existing evidence or caller-owned file.

experiments/atomic-re-tools/research.md

@@ -0,0 +1,112 @@
+# What might count as an RE atom?
+
+This is an experiment record, not a claim that a new universal instruction set
+has been discovered. APIs already expose many relevant primitives. The open
+question here is how to make their evidence, cost and composition useful to an
+agent investigating a real program.
+
+## Existing mechanisms and what they establish
+
+- Ghidra has a program database, `ReferenceManager.getReferencesTo`, function-body
+  ownership through `FunctionManager.getFunctionContaining`, listing objects and
+  decompiler IR. Fine-grained **engine APIs already exist**. A poor MCP projection
+  can still discard their metadata or require excessive round trips.
+  Sources: [ReferenceManager](https://ghidra.re/ghidra_docs/api/ghidra/program/model/symbol/ReferenceManager.html),
+  [FunctionManager](https://ghidra.re/ghidra_docs/api/ghidra/program/model/listing/FunctionManager.html).
+- Binary Ninja distinguishes code/data, type and variable references, including
+  IL-level references. This shows why one undifferentiated `xref` is insufficient
+  for some questions. It does not establish that an MCP interface using these
+  APIs will be token-efficient or that another provider can reproduce the facts.
+  Sources: [type/variable references](https://binary.ninja/2021/04/12/type-and-variable-xrefs.html),
+  [BinaryView API](https://dev-api.binary.ninja/binaryninja.binaryview-module.html).
+- Kuna's Rust engine and SLEIGH compiler derive from Ghidra, while its standalone
+  loader/analyzer tier and CLI are separate components. Port lineage does not
+  imply identical observations or a shared live program database.
+  Source: [NOTICE](https://github.com/Noelo-Lab/kuna/blob/fe01d6294eb0d1053ce343c8943646df88e143fc/NOTICE).
+- In **tested Kuna 1.833**, an `xrefs` command loads a program and builds an
+  `XrefIndex` for its query. A different CLI invocation does that again.
+  `strings` with attribution instead loads/indexes once and joins references over
+  each string's byte extent. That is already internal composition, even though
+  the CLI does not expose an arbitrary persistent query interface.
+  Sources: [xref producer](https://github.com/Noelo-Lab/kuna/blob/fe01d6294eb0d1053ce343c8943646df88e143fc/decompiler/crates/kuna-cli/src/xrefs.rs),
+  [string attribution](https://github.com/Noelo-Lab/kuna/blob/fe01d6294eb0d1053ce343c8943646df88e143fc/decompiler/crates/kuna-cli/src/strings.rs).
+
+These are source-derived observations. They are not measurements of current
+upstream main, a guarantee of decompilation correctness, or a novelty claim.
+
+## Granularity has at least three independent dimensions
+
+| Dimension      | Example                                                | Consequence                                                           |
+| -------------- | ------------------------------------------------------ | --------------------------------------------------------------------- |
+| Fact unit      | One typed reference with both endpoints and provenance | Can be retained and joined without reading unrelated C text           |
+| Transport unit | A batch of references for several selectors            | Amortizes headers and agent turns; need not change native work        |
+| Compute unit   | One image load and reference walk                      | Can serve many fact queries; may cost much more than one returned row |
+
+Calling all three "atomic tools" hides the main optimization opportunity. A tiny
+getter can repeat a whole-program analysis. Conversely, one expensive shared
+analysis can provide precise, small, independently addressable facts.
+
+## Candidate semantic core
+
+1. **Identified objects and located observations**: artifact, image/address-space,
+   byte span, decoded instruction, symbol, string candidate, recovered function,
+   variable and type. Keep width, encoding, storage and confidence where needed
+   to interpret a value. A recovered object is an analysis claim, not necessarily
+   a source-language object that existed before compilation.
+2. **Relations and constraints**: maps-to, owns/contains, references, calls,
+   flows-to, defines/uses, argument binding, type/storage association and branch
+   guard. Keep source and destination, reference site, kind, supporting evidence
+   and unknown/partial coverage. Do not collapse a call site into just a callee.
+3. **Evidence views**: retain the original observations and expose the requested
+   fields, range or neighborhood. A readable decompilation is an important view;
+   it does not replace a machine-grounded relation or prove original source.
+
+Useful query operations resemble selection, projection, traversal, join and
+aggregation. This is a design vocabulary, **not a proposal to add a SQL/graph
+language or Code Mode**. Start with named, typed analyst questions; add more
+general execution only if repeated real workflows demonstrate the need.
+
+## Composition rules that prevent false conclusions
+
+- Entity identity and an observation's identity differ. Artifact/profile/location
+  can identify a function candidate; `evidence_id` identifies one exact claim
+  about it. Keep disagreeing claims instead of deduplicating them by address.
+- A session lease prevents using a handle after close/reopen. It is not a frozen
+  analysis revision. In particular, Kuna's whole-project and early single-function
+  reconstructions can differ under the same selected profile. Target admission
+  prevents a target switch; it does not establish a consistent analysis snapshot.
+- A string spans bytes. A point-address xref and a reference anywhere inside that
+  object answer different questions. A data-pointer reference is not automatically
+  a runtime call, string consumption, or a reachable execution path.
+- Omission, an unsupported operation, cancellation, an unowned reference and an
+  examined empty set are different outcomes. No empty set proves global absence
+  unless the producing analysis actually establishes that coverage.
+- Field selection must not detach a value from the metadata that makes it
+  meaningful. For example, the first prototype keeps REA's complete `string`
+  metadata record as one selectable field, including its encoding status.
+- Expensive producer work should be shared with explicit identity, lifetime,
+  invalidation and cancellation ownership. A client-side batch is insufficient
+  evidence that native work was shared.
+
+## What complex-program effectiveness would require
+
+Navigation is only the first tier. Finding a string and its users is weaker than
+explaining why a branch rejects input or how data reaches a privileged operation.
+The next tier needs definition/use, call-argument and memory-flow relationships,
+with explicit analysis assumptions. The existing prototypes do **not** supply
+those relationships, and slicing C text cannot manufacture them.
+
+For every harder trial, specify the analyst question, independent answer/evidence
+oracle, input artifact/profile, initial knowledge and allowed budget. Compare:
+
+- whether the actual question was answered correctly;
+- decisive evidence recovered and relevant evidence omitted;
+- remaining unknowns and unsafe conclusions;
+- all calls, follow-up reads, failures, latency, CPU, family memory and estimated
+  token traffic, including tool discovery and retained Evidence reads.
+
+Source inspection can establish architectural opportunities. Scripted equivalent
+workflows can establish transport and engine costs. Neither alone establishes
+that a live agent reasons better on complex software; a controlled agent trial
+is a separate validation step. Likewise, byte/token reductions alone do not
+establish improved correctness or analyst productivity.

experiments/atomic-re-tools/results.md

@@ -0,0 +1,216 @@
+# First-round results
+
+Continued in the [control-flow / SSA experiment](relations.md). The results below
+remain the fixed first-round baseline, including its failed mapping composition.
+
+This is a completed, bounded first round of exploration, including failures.
+It does **not** establish that an agent solves complex RE tasks better than with
+the existing tools. No PR, merge, target execution or executable mutation occurred;
+Ghidra used its normal ephemeral analysis databases.
+
+## Inputs and measurement
+
+- REA base: `5b16f2431062eea6ffd245a9e05512790007cb13`; experiment commits retain
+  the runnable code and tests. Node 24.18.0 / npm 11.16.0.
+- Kuna 1.833, executable SHA-256
+  `d858918b0766435cd96b999a77f2d5a31a0cc4f07256421c883b5b9dc4dd58e4`.
+  These results do not verify newer Kuna releases.
+- Ghidra 12.1.4, Temurin JDK 21.0.12.1+1, Java heap 1 GiB.
+- Installed zlib: `/usr/lib/x86_64-linux-gnu/libz.so.1.2.13`, SHA-256
+  `7e2a72b4c4b38c61e6962de6e3f4a5e9ae692e732c68deead10a7ce2135a7f68`.
+- Installed SQLite: `/usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6`, SHA-256
+  `2e6eef9a727f081f0d453b4e5e6cbd8b9ef8b6f86cbf7681cbad444d3b0b55c8`.
+- Real-provider jobs used the existing scope runner: one CPU, affinity to one
+  allowed core, 4 GiB hard memory limit, early stop at 3 GiB. They ran serially.
+  Build/type/test gates used separate bounded scopes, up to two CPUs / 4 GiB.
+- CPU is complete owned-cgroup CPU at payload exit. Memory is kernel
+  `memory.peak` for the process family, **including charged file cache**, not RSS.
+  The observer verified cleanup and resource counters while its scope was alive.
+- Tokens below are **offline `o200k_base` estimates**, tiktoken 0.14.0, over actual
+  captured MCP payloads, including text and structured copies. They are not
+  model-billed tokens. Model reasoning, tool selection, host rendering, cache
+  billing and JSON-RPC framing were not measured.
+- Each table row is **one sample**, not a median or controlled causal estimate.
+  OS caches were not flushed. Startup and native work varied substantially on
+  this shared host. No universal latency improvement is established.
+
+## Experiment 1: transport granularity
+
+Task: case-sensitive literal search (`incorrect` in zlib, `malformed` in SQLite),
+select the first three provider-ordered string candidates, read at most four
+exact-start reference sites per candidate, then resolve their containing
+functions when advertised. Repeat in the same session to measure warm reads.
+Unsupported Kuna function resolution remains unknown, rather than guessed.
+
+The four variants use the same application/provider observations. Native query
+planning was unchanged. `fine` reads individual facts; `batch` groups homogeneous
+reads; `workflow` composes those same fact methods in one call.
+
+These captures measure the **v1 fact response shape**, introduced at `fa8d6a7a2`.
+Later selector/scope and transport-provenance clarifications are not retroactive
+performance measurements; rerun the harness to measure their current payload.
+
+| Provider / target | Variant  | Calls per task | Query payload tokens, first / warm | First query task ms | Warm task ms | Session CPU s | Peak family MiB |
+| ----------------- | -------- | -------------: | ---------------------------------: | ------------------: | -----------: | ------------: | --------------: |
+| Ghidra / zlib     | existing |             10 |                    41,565 / 41,565 |              34,926 |          429 |         50.00 |           1,444 |
+| Ghidra / zlib     | fine     |             10 |                    23,483 / 23,483 |              34,260 |          120 |         47.37 |           1,376 |
+| Ghidra / zlib     | batch    |              3 |                    20,114 / 20,114 |              75,202 |          218 |         52.63 |           1,360 |
+| Ghidra / zlib     | workflow |              1 |                    19,824 / 19,824 |              75,491 |          198 |         51.76 |           1,276 |
+| Kuna / zlib       | existing |              4 |                      5,638 / 5,638 |               4,079 |           44 |         16.12 |             905 |
+| Kuna / zlib       | fine     |              5 |                      4,702 / 4,702 |               2,857 |           51 |         15.61 |             927 |
+| Kuna / zlib       | batch    |              3 |                      3,774 / 3,774 |               2,843 |           59 |         15.14 |             911 |
+| Kuna / zlib       | workflow |              1 |                      3,509 / 3,509 |               1,376 |           11 |         14.34 |             922 |
+| Kuna / SQLite     | existing |              4 |                      6,039 / 6,039 |               5,874 |           24 |         19.15 |             994 |
+| Kuna / SQLite     | fine     |              5 |                      4,753 / 4,753 |              13,058 |           47 |         20.40 |             989 |
+| Kuna / SQLite     | batch    |              3 |                      3,829 / 3,829 |              25,868 |          217 |         25.85 |           1,022 |
+| Kuna / SQLite     | workflow |              1 |                      3,560 / 3,560 |              36,231 |           39 |         58.19 |           1,004 |
+
+Session CPU/memory include MCP startup, catalog/status discovery, both tasks and
+close/cleanup. Query timers exclude the earlier `open_binary`; Ghidra lazily
+performs import/preparation during its first query. Whole-session elapsed times
+for existing/workflow were 50.67/104.15 s (Ghidra zlib), 32.46/16.63 s (Kuna zlib),
+and 19.46/159.81 s (Kuna SQLite). The SQLite workflow's `open_binary` itself took
+64.98 s versus 7.31 s in the existing-tools sample, before any experimental fact
+query. Cause is unresolved; neither host contention nor adapter overhead has
+been established as the explanation. Do not interpret these samples as a
+controlled speedup or slowdown attributable to atomization.
+
+**Failure retained:** the first Ghidra batch attempt hit its 120 s provider
+request deadline during cold preparation. Its log ended in `ReaGhidraNoReturnFix`
+after reporting successful auto-analysis. The attempt cost 141.45 s elapsed,
+106.19 CPU s and 1,211 MiB peak; cleanup was verified and OOM kills were zero.
+The successful batch row excludes that failed attempt; any retry-cost comparison
+must add it. All twelve successful rows agreed on the selected strings,
+reference sites and function-resolution outcomes within each provider/target.
+That is adapter equivalence, not an independent proof of native discovery.
+
+### Fixed context costs
+
+The existing catalog had 207 tools; the prototype added five, retaining every
+existing tool. Actual default catalogs included output schemas: about 842k /
+843k estimated tokens. Removing only output schemas gives about 207k / 208k.
+This input-only projection is **not** an assertion about any particular model
+host: hosts can omit output schemas, deduplicate content or cache declarations.
+
+For a session containing both completed tasks plus lifecycle/status traffic,
+the input-only-catalog estimate changed as follows:
+
+| Provider / target | Existing tools | Workflow |
+| ----------------- | -------------: | -------: |
+| Ghidra / zlib     |        319,907 |  277,458 |
+| Kuna / zlib       |        245,476 |  242,249 |
+| Kuna / SQLite     |        245,803 |  241,870 |
+
+Thus a large reduction in query payload need not produce a large whole-task
+context reduction. Catalog/discovery and repeated envelopes deserve separate
+attention. This experiment has not yet tested a client that loads declarations
+on demand or an explicitly smaller, separately declared service surface.
+
+## Experiment 2: compute sharing in native Kuna
+
+Both plans first obtain a complete reference-free scan, validated by REA's
+existing string-fact owner. Then select three matching strings. The point plan
+runs `xrefs --to` separately; the inventory plan runs `strings` with attribution
+once, letting Kuna share its reference index. Full source JSON is retained
+locally, while only selected facts need be exposed to a caller.
+
+| Target | Plan               | Native commands | Elapsed s | CPU s | Peak family MiB |
+| ------ | ------------------ | --------------: | --------: | ----: | --------------: |
+| zlib   | per address        |               4 |     3.846 | 1.796 |           110.4 |
+| zlib   | shared attribution |               2 |     2.838 | 1.341 |           114.4 |
+| SQLite | per address        |               4 |    13.221 | 6.497 |           196.1 |
+| SQLite | shared attribution |               2 |     6.261 | 3.028 |           196.6 |
+
+For these selected samples, both plans found one owner per string. Their scopes
+are nevertheless **different**: point references cover the first address;
+attribution covers any byte in the string extent. Attribution also does not
+return individual sites/kinds. These figures establish costs of the two real
+plans, not a universally equivalent-query speedup. They support investigating
+producer-level work sharing, with query selectivity and coverage kept explicit.
+This is a native-boundary experiment, not an MCP/model token measurement.
+
+## Experiment 3: the point/object distinction changes correctness
+
+`interior-reference.c` is compiled with `gcc -O2 -fno-pie -no-pie` and never run.
+Its `give_suffix` returns a pointer five bytes into `marker`. In this build,
+`nm` reports `marker=0x402020`, `give_suffix=0x401120`; `objdump` independently
+shows `mov $0x402025,%eax` followed by `ret` in `give_suffix`.
+
+- Exact-start xref query: zero references, no owner.
+- Extent attribution: one reference, owner `give_suffix` at `0x401120`.
+
+`verify-interior.py` checks the compiled symbols, input and retained-source
+digests, and both native results. This is a genuine counterexample to treating
+"no xref to the start address" as "the string has no users". Neither tool was
+wrong about its own scope. The compositional representation must carry the
+object span and reference offset/scope instead of silently equating the questions.
+
+## Experiment 4: existing relations do not always bridge into code
+
+On real zlib, the three selected string references belong to `inflate` at
+`0xc1e0`; their reference instructions are at `0xded7`, `0xdc6a` and `0xcd05`.
+The native single-function JSON contains 52,431 characters / 1,620 code lines,
+1,167 mapping records and 1,568 mapped instruction addresses. **None of those
+three reference instructions occurs in the printer's line mappings.**
+
+The exact-address composition therefore returns **unknown**, not a guessed
+nearby line. The mapped-code run cost 8.387 s / 8.091 CPU s / 202.0 MiB, including
+discovery/references and decompilation. It did not finish the analyst question
+"which condition triggers the error?" and must not count as a successful
+context-saving answer. Single-function work uses REA's owned command deadline
+and the native `--max-fn-memory` option shown by the tested CLI's actual help.
+
+The retained C text does contain the error literal at line 164, but a small
+fixed window there omits the earlier check around lines 122–124. Literal search
+and a larger manual read can help, but they are **reconstructed-text evidence**,
+not the missing machine-to-source relation. This is not proof that Kuna's line
+mapping is buggy: the contract does not promise every contributing instruction
+survives transformation into an emitted line.
+
+The next useful relations to test are instruction/block ownership, control-flow
+guards and definition/use or contributing-origin edges across transformations.
+For a stronger zlib question, an independent expected mechanism is the FCHECK
+constraint in [RFC 1950 §2.2](https://www.rfc-editor.org/rfc/rfc1950.html#section-2.2):
+the network-order CMF/FLG value must be divisible by 31. Testing an agent's
+explanation against that mechanism would be a separate trial; this experiment
+does not claim to have completed that trial.
+
+## Validation
+
+- All **191 Kuna regression cases in 20 files passed with one worker**; the
+  owning reference parser's 18 cases include typed endpoints, distinct kinds,
+  unknown ownership, alias exclusion and late malformed rows. A prior two-worker
+  CPU-limited run had three timing-sensitive failures in existing project/export
+  tests. Those tests were not edited; the isolated cause is not established.
+- Nine experiment boundary cases passed, including stale artifact/profile/lease,
+  partial batches, duplicate point lookups, paging, unsupported ownership,
+  unmapped/unsafe addresses and invalid line locations.
+- Typecheck passed with one checker. Changed experiment files passed formatter
+  and lint; the existing graph parser's complexity warning remains unrelated.
+- A real Kuna MCP run with the actual output-schema **off** profile passed
+  paging, duplicate-selector, negative/unknown, retained-Evidence, foreign-context
+  and expired-lease checks. Its live catalog had 212 tools and zero output
+  schemas. Verification runs are excluded from the performance table.
+- The v2 facade was also exercised through a real Kuna MCP client: edges carry
+  explicit point scope and location endpoints, caller selectors stay separate,
+  and successful/error results retain the canonical untrusted-target marker.
+  The same six additional verification groups passed. This v2 verification is
+  not relabelled as a new performance comparison.
+- All real-provider measurements reported verified cleanup and zero OOM kills.
+  No default parallel-suite stability, live-model reasoning improvement, general
+  high-address code mapping, overlay support or newer Kuna compatibility is claimed.
+
+## What this round supports
+
+- A coherent fact includes the metadata needed to interpret it. One-field
+  getters are not necessarily useful atoms.
+- Fact, transport and compute units are different. Batches/workflows can share
+  one fact implementation while the producer independently shares analysis.
+- Identity and evidence are necessary, but scope and uncertainty determine
+  whether joins answer the analyst's actual question.
+- Complex-program effectiveness remains **unproven**. The experiments found a
+  real coverage distinction and a real composition gap, not a universal RE API.
+
+Raw captures, projects, binaries and counters remain ignored under
+`.cache/atomic-re-tools/`. `summarize.py` checks selected-answer equivalence,
+payload-exit cleanup and OOM counters, and includes failed runs separately.

experiments/atomic-re-tools/run-matrix.py

@@ -0,0 +1,40 @@
+"""Run comparable real-provider tasks serially using REA's existing scope owner."""
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--provider", choices=["kuna", "ghidra"], required=True)
+    parser.add_argument("--binary", required=True)
+    parser.add_argument("--pattern", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--variants", nargs="+", choices=["baseline", "fine", "batch", "workflow"],
+                        default=["baseline", "fine", "batch", "workflow"])
+    options = parser.parse_args()
+    root = Path(options.output).resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    completed = []
+    for variant in options.variants:
+        prefix = root / (options.provider + "-" + variant)
+        command = [sys.executable, "experiments/analysis-efficiency/resource-run.py", "--observe-payload-exit", "--",
+                   "node", "experiments/atomic-re-tools/benchmark.mjs", options.provider, variant,
+                   options.binary, options.pattern, str(prefix)]
+        with Path(str(prefix) + ".log").open("w") as output:
+            result = subprocess.run(command, stdout=output, stderr=subprocess.STDOUT, check=False)
+        if result.returncode:
+            raise SystemExit(f"{variant} failed ({result.returncode}); retained {prefix}.log")
+        report = json.loads(Path(str(prefix) + ".report.json").read_text())
+        if report["failures"] or report["verification_only"]:
+            raise SystemExit("Not a successful comparable performance sample: " + str(prefix))
+        completed.append(str(prefix))
+        (root / (options.provider + "-completed.json")).write_text(json.dumps(completed, indent=2) + "\n")
+        print(json.dumps({"completed": variant, "provider": options.provider,
+                          "query_ms": [round(row["elapsed_ms"], 2) for row in report["outcomes"]]}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

experiments/atomic-re-tools/server.mjs

@@ -0,0 +1,202 @@
+// Experimental tools are added to the complete production catalog, never shipped.
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { z } from "zod";
+import { run } from "../../dist/main.js";
+import { createServer } from "../../dist/server/createServer.js";
+import { createEvidence } from "../../dist/domain/evidence.js";
+import { projectAnalysisError } from "../../dist/domain/analysisErrorProjection.js";
+import { toolContract } from "../../dist/contracts/toolContracts.js";
+import { TARGET_CONTENT_RESULT_META } from "../../dist/server/toolResultEncoding.js";
+import { expandProviderCapabilities } from "../../dist/contracts/toolOutputSchemaPrimitives.js";
+import { FactQueries, contextFor } from "./facts.mjs";
+
+const contextSchema = z.strictObject({ ref: z.string(), lease: z.string() });
+const location = z.strictObject({
+  kind: z.literal("location"),
+  address: z.string().min(1),
+});
+const stringId = z.strictObject({
+  kind: z.literal("string"),
+  address: z.string().min(1),
+  encoding: z.string().nullable(),
+});
+const paging = {
+  offset: z.number().int().nonnegative().default(0),
+  limit: z.number().int().positive().default(20),
+};
+const stringsInput = z.strictObject({
+  query: toolContract("search_strings").inputSchema,
+  ...paging,
+  fields: z.array(z.enum(["value", "string"])).default(["value"]),
+});
+const contracts = [
+  [
+    "experiment_find_strings",
+    "Find string facts with scoped identities, selected fields, paging and retained source Evidence. Experimental; provider discovery coverage remains unknown.",
+    stringsInput,
+    "findStrings",
+  ],
+  [
+    "experiment_incoming_refs",
+    "Read incoming reference facts for a batch of string identities from this session. Preserve per-target failures and unknown reference kinds. Reuse the context ref and lease returned by find_strings.",
+    z.strictObject({
+      context: contextSchema,
+      targets: z.array(stringId),
+      ...paging,
+    }),
+    "incomingReferences",
+  ],
+  [
+    "experiment_resolve_functions",
+    "Resolve a batch of instruction locations to provider-analyzed containing functions. Unsupported or failed resolution stays unknown; never guess the nearest symbol.",
+    z.strictObject({ context: contextSchema, locations: z.array(location) }),
+    "resolveFunctions",
+  ],
+  [
+    "experiment_trace_string_uses",
+    "Compose the same string, incoming reference and containing-function facts in one call. Page limits and partial outcomes remain explicit.",
+    stringsInput.extend({
+      reference_limit: z.number().int().positive().default(20),
+      include_functions: z.boolean().default(true),
+    }),
+    "traceStringUses",
+  ],
+];
+
+const encode = (value) => ({
+  _meta: TARGET_CONTENT_RESULT_META,
+  content: [{ type: "text", text: JSON.stringify(value) }],
+  structuredContent: value,
+  ...(value.status === "error" ? { isError: true } : {}),
+});
+
+const createFacts = (session, analysis, signal) => {
+  const status = session.status();
+  const context = contextFor(
+    session.activeTarget().sha256,
+    session.analysisProfile("search_strings"),
+    status.analysis_run.run_id,
+  );
+  const capabilities = expandProviderCapabilities(status.capabilities);
+  const facts = new FactQueries({
+    supports: (operation) =>
+      capabilities.some(
+        (capability) =>
+          capability.operation === operation && capability.available,
+      ),
+    context: () => context,
+    observe: async (operation, parameters) => {
+      const outcome = await analysis.execute(
+        operation,
+        toolContract(operation).inputSchema.parse(parameters),
+        { signal: signal },
+      );
+      if (!outcome.ok)
+        return {
+          ok: false,
+          error: projectAnalysisError(outcome.error),
+        };
+      const execution = outcome.value;
+      const evidence = createEvidence(
+        execution.subject ?? session.activeTarget(),
+        execution.provider,
+        {
+          operation,
+          parameters,
+          result: execution.result,
+          analysisProfile: execution.analysisProfile,
+          rawResult: execution.rawResult,
+          limitations: execution.limitations,
+          relationshipCoverage: execution.relationshipCoverage,
+          locations: execution.locations,
+        },
+      );
+      const recorded = session.recordEvidence(evidence);
+      return recorded.ok
+        ? { ok: true, value: evidence }
+        : {
+            ok: false,
+            error: projectAnalysisError(recorded.error),
+          };
+    },
+  });
+
+  return facts;
+};
+
+await run({
+  env: process.env,
+  serve: serveStdio,
+  writeStderr: (value) => process.stderr.write(value),
+  setExitCode: (value) => {
+    process.exitCode = value;
+  },
+  registerShutdown: (handler) => {
+    const registrations = [
+      [process, "SIGINT"],
+      [process, "SIGTERM"],
+      [process.stdin, "end"],
+      [process.stdin, "close"],
+    ];
+    for (const [emitter, event] of registrations) emitter.once(event, handler);
+    return () => {
+      for (const [emitter, event] of registrations) emitter.off(event, handler);
+    };
+  },
+  createServer(source, options) {
+    const server = createServer(source, options);
+    const session = source.session;
+    for (const [name, description, inputSchema, method] of contracts) {
+      server.registerTool(
+        name,
+        { description, inputSchema, annotations: { readOnlyHint: true } },
+        async (input, request) => {
+          const admitted = await session.withAdmittedAnalysis(
+            name,
+            request.mcpReq.signal,
+            async (analysis) => {
+              const facts = createFacts(
+                session,
+                analysis,
+                request.mcpReq.signal,
+              );
+              return facts[method](inputSchema.parse(input));
+            },
+          );
+          return encode(
+            admitted.ok
+              ? admitted.value
+              : {
+                  status: "error",
+                  error: projectAnalysisError(admitted.error),
+                },
+          );
+        },
+      );
+    }
+    server.registerTool(
+      "experiment_read_evidence",
+      {
+        description:
+          "Read complete retained source Evidence explicitly by evidence_id while the existing session record owner retains it. Closing the binary expires these records.",
+        inputSchema: z.strictObject({ evidence_id: z.string().min(1) }),
+        annotations: { readOnlyHint: true },
+      },
+      (input) => {
+        const evidence = session.evidenceById(input.evidence_id);
+        return encode(
+          evidence === undefined
+            ? {
+                status: "error",
+                error: {
+                  code: "not_found",
+                  message: "Evidence is not retained in this server.",
+                },
+              }
+            : { status: "ok", evidence },
+        );
+      },
+    );
+    return server;
+  },
+});

experiments/atomic-re-tools/summarize-relations.py

@@ -0,0 +1,94 @@
+"""Representation estimates and a complete ledger of this round's captured runs.
+
+Run with the tokenizer environment from the first round. This does not measure
+model billing, model reasoning, or equivalent completed agent tasks.
+"""
+import importlib.metadata
+import json
+from pathlib import Path
+import sys
+
+import tiktoken
+
+
+def load(path):
+    return json.loads(path.read_text())
+
+
+def resource(path):
+    records = [json.loads(line) for line in path.read_text().splitlines()
+               if line.startswith('{"resource_scope":')]
+    assert len(records) == 1, path
+    record = records[0]
+    observation = record['payload_resource_observation']
+    assert record['payload_resource_observation_verified'] is True
+    assert observation['payload_cleanup_verified'] is True
+    return {
+        'log': str(path), 'elapsed_s': record['elapsed_seconds'],
+        'cpu_s': observation['cpu_stat']['usage_usec'] / 1_000_000,
+        'family_peak_mib_including_file_cache': observation['memory_peak_bytes'] / 2**20,
+        'exit_code': observation['payload_exit_code'],
+        'oom_kills': observation['resource_events']['memory.events']['oom_kill'],
+    }
+
+
+def main():
+    root, output = map(Path, sys.argv[1:])
+    encoder = tiktoken.get_encoding('o200k_base')
+
+    def tokens(value):
+        return len(encoder.encode(value, disallowed_special=()))
+
+    def encoded(value):
+        return json.dumps(value, ensure_ascii=False, separators=(',', ':'))
+
+    rows = []
+    for name, prefix, query_file in [
+        ('zlib', 'relations-kuna-zlib-raw-v2', 'relations-zlib-query-v2.json'),
+        ('sqlite', 'relations-kuna-sqlite-raw', 'relations-sqlite-query-v2.json'),
+    ]:
+        capture = load(root / (prefix + '.report.json'))
+        query = load(root / query_file)
+        raw = Path(capture['calls'][0]['file']).read_text()
+        code = raw.split('\n0\nBasic Block', 1)[0].strip()
+        answers = query['runs'][0]['answers']
+        rows.append({
+            'target': name, 'artifact_sha256': capture['target_sha256'],
+            'full_code_tokens': tokens(code), 'full_code_bytes': len(code.encode()),
+            'full_native_dump_tokens': tokens(raw),
+            'selected_answer_tokens_with_source': [tokens(encoded({'source': query['source'], 'answer': a})) for a in answers],
+            'batch_answer_tokens_with_source': tokens(encoded({'source': query['source'], 'answers': answers})),
+            'parse_index_ms': query['parse_index_ms'],
+            'projection_runs': [{k: v for k, v in r.items() if k != 'answers'} for r in query['runs']],
+            'snapshot_coverage': query['coverage'],
+        })
+    ghidra = root / 'relations-ghidra-zlib-retained'
+    wire = load(ghidra.with_suffix('.wire.json'))
+    report = load(ghidra.with_suffix('.report.json'))
+    resources = [resource(p) for p in sorted(root.glob('relations-*.log'))]
+    summary = {
+        'encoding': 'o200k_base', 'tiktoken': importlib.metadata.version('tiktoken'),
+        'representation_estimates': rows,
+        'ghidra_retained_workflow': {
+            'wire_tokens_including_errors_and_exports': tokens(encoded(wire)),
+            'input_only_catalog_tokens': tokens(encoded(load(ghidra.with_suffix('.catalog.json')))),
+            'calls': report['calls'], 'analyst_task_completed': False,
+            'reason': 'Late literal not covered by the producer-truncated high-p-code prefix.',
+        },
+        'run_ledger': resources,
+        'scope': [
+            'Raw captures are fresh native analyses; OS caches were not flushed.',
+            'Reused-index runs reuse parsed facts, not a warm native analysis.',
+            'Token counts cover the stated representations. The native probe has no new MCP catalog.',
+            'No controlled agent A/B task, model reasoning tokens or model latency measured.',
+            'Discovery, old xrefs, manual oracle construction, objdump and tokenizer CPU are outside the native/projection runs.',
+            'The ledger retains failed and superseded probes rather than excluding their costs.',
+        ],
+    }
+    with output.open('x') as destination:
+        destination.write(json.dumps(summary, indent=2) + '\n')
+    print(json.dumps({'output': str(output), 'targets': len(rows), 'runs': len(resources)}))
+
+
+if __name__ == '__main__':
+    main()

experiments/atomic-re-tools/summarize.py

@@ -0,0 +1,84 @@
+"""Compare completed equivalent tasks; token counts are offline estimates only."""
+import argparse
+import importlib.metadata
+import json
+from pathlib import Path
+import tiktoken
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("roots", nargs="+")
+    options = parser.parse_args()
+    encoding = tiktoken.get_encoding("o200k_base")
+
+    def tokens(value):
+        return len(encoding.encode(json.dumps(value, ensure_ascii=False, separators=(",", ":")), disallowed_special=()))
+
+    results = []
+    failed_runs = []
+    equivalence = {}
+    for root in map(Path, options.roots):
+        for report_path in sorted(root.glob("*.report.json")):
+            report = json.loads(report_path.read_text())
+            if report["verification_only"]:
+                continue
+            prefix = str(report_path).removesuffix(".report.json")
+            catalog = json.loads(Path(prefix + ".catalog.json").read_text())
+            wire = json.loads(Path(prefix + ".wire.json").read_text())
+            resources = [json.loads(line) for line in Path(prefix + ".log").read_text().splitlines()
+                         if line.startswith('{"resource_scope":')][-1]
+            assert resources["payload_resource_observation_verified"], prefix
+            counters = resources["payload_resource_observation"]
+            assert counters["payload_cleanup_verified"], prefix
+            assert counters["resource_events"]["memory.events"]["oom_kill"] == 0, prefix
+            if report["failures"]:
+                failed_runs.append({"provider": report["provider"], "variant": report["variant"], "target": report["binary"],
+                                    "elapsed_seconds": resources["elapsed_seconds"], "cpu_seconds": round(counters["cpu_stat"]["usage_usec"] / 1e6, 3),
+                                    "peak_process_family_cgroup_mib": round(counters["memory_peak_bytes"] / 1024 ** 2, 1),
+                                    "failure_count": len(report["failures"]), "retained_prefix": prefix,
+                                    "cleanup_verified": True, "oom_kills": 0})
+                continue
+            assert counters["payload_exit_code"] == 0, prefix
+            key = (report["provider"], report["target_sha256"], report["pattern"])
+            outcome = [{name: row[name] for name in ["strings", "references", "functions"]} for row in report["outcomes"]]
+            if key in equivalence:
+                assert outcome == equivalence[key], "Equivalent-task answers differ: " + prefix
+            else:
+                equivalence[key] = outcome
+            phase_traffic = {phase: [{"request": row["request"], "response": row["response"]} for row in wire if row["phase"] == phase]
+                             for phase in ["cold", "warm", "lifecycle"]}
+            used = {row["request"]["name"] for row in wire}
+            input_only_catalog = {**catalog, "tools": [{key: value for key, value in tool.items() if key != "outputSchema"} for tool in catalog["tools"]]}
+            task_traffic = [row for row in wire if row["phase"] in ["cold", "warm", "lifecycle"]]
+            rows = {phase: {"calls": len(traffic), "estimated_tokens": tokens(traffic)} for phase, traffic in phase_traffic.items()}
+            results.append({
+                "provider": report["provider"], "variant": report["variant"], "target_sha256": report["target_sha256"],
+                "pattern": report["pattern"], "catalog_tools": len(catalog["tools"]), "catalog_estimated_tokens": tokens(catalog),
+                "observed_output_schema_count": sum("outputSchema" in tool for tool in catalog["tools"]),
+                "input_only_catalog_estimated_tokens": tokens(input_only_catalog),
+                "phases": rows,
+                "query_elapsed_ms": {row["phase"]: round(row["elapsed_ms"], 2) for row in report["outcomes"]},
+                "session_elapsed_seconds_including_two_tasks": resources["elapsed_seconds"],
+                "session_cpu_seconds_including_two_tasks": round(counters["cpu_stat"]["usage_usec"] / 1e6, 3),
+                "peak_process_family_cgroup_mib": round(counters["memory_peak_bytes"] / 1024 ** 2, 1),
+                "whole_session_estimated_tokens": tokens(catalog) + tokens([{"request": row["request"], "response": row["response"]} for row in task_traffic]),
+                "whole_session_with_input_only_catalog_estimated_tokens": tokens(input_only_catalog) + tokens([{"request": row["request"], "response": row["response"]} for row in task_traffic]),
+                "hypothetical_selected_declarations_estimated_tokens": tokens([tool for tool in catalog["tools"] if tool["name"] in used]),
+                "answer": {"strings": len(outcome[0]["strings"]), "reference_sites": sum(len(row["items"]) for row in outcome[0]["references"]), "locations": len(outcome[0]["functions"])},
+                "cleanup_verified": True, "oom_kills": 0,
+            })
+    summary = {
+        "token_method": {"encoding": "o200k_base", "tiktoken_version": importlib.metadata.version("tiktoken"),
+                         "estimated_not_billed": True, "scope": "Captured MCP tool catalog and request/response payloads, including text and structured copies; excludes JSON-RPC framing, model reasoning, host prompts and model tool selection."},
+        "memory_method": "Kernel memory.peak for the complete owned process-family cgroup, including charged file cache; not summed RSS. Payload-exit counters verified while the observer remains alive.",
+        "workload": "One cold and one warm selected navigation task per fresh session, plus startup, discovery/status, close and cleanup. Additional --verify runs excluded.",
+        "equivalence": "All included variants agree on selected strings, reference sites and per-location function resolutions within each provider/target/query. This is not cross-provider truth or a live-agent reasoning evaluation.",
+        "results": results,
+        "failed_runs": failed_runs,
+    }
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()

experiments/atomic-re-tools/verify-interior.py

@@ -0,0 +1,26 @@
+"""Independent compiled-symbol oracle for the interior-only reference experiment."""
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import sys
+
+binary, point_report, extent_report = map(Path, sys.argv[1:])
+point, extent = [json.loads(path.read_text()) for path in [point_report, extent_report]]
+symbols = {}
+for line in subprocess.check_output(["nm", "--defined-only", "--format=posix", str(binary)], text=True).splitlines():
+    fields = line.split()
+    if fields[0] in ["marker", "give_suffix"]:
+        symbols[fields[0]] = "0x" + format(int(fields[2], 16), "x")
+assert set(symbols) == {"marker", "give_suffix"}
+for report in [point, extent]:
+    assert not report["failures"]
+    assert report["facts"]["artifact_sha256"] == hashlib.sha256(binary.read_bytes()).hexdigest()
+    for call in report["calls"]:
+        assert hashlib.sha256(Path(call["file"]).read_bytes()).hexdigest() == call["sha256"]
+    assert report["facts"]["results"][0]["string"]["address"] == symbols["marker"]
+assert point["facts"]["results"][0]["xrefs_count"] == 0
+assert point["facts"]["results"][0]["functions"] == []
+assert extent["facts"]["results"][0]["xrefs_count"] == 1
+assert [fn["address"] for fn in extent["facts"]["results"][0]["functions"]] == [symbols["give_suffix"]]
+print(json.dumps({"verified": True, "point_references": 0, "extent_references": 1, "symbols": symbols}))

experiments/atomic-re-tools/verify-relations.mjs

@@ -0,0 +1,163 @@
+// Replay real captures against independent machine-byte and arithmetic checks.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { mappedCode } from "./mapped-code.mjs";
+import { parseKunaSsaDump } from "./kuna-ssa.mjs";
+import { queryLiteralUses } from "./query-ssa.mjs";
+
+const [root, output] = process.argv.slice(2);
+assert.ok(root && output);
+const json = async (name) =>
+  JSON.parse(await readFile(join(root, name), "utf8"));
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const zlib = await json("relations-zlib-query-v2.json");
+const sqlite = await json("relations-sqlite-query-v2.json");
+assert.deepEqual(zlib.runs[0].answers, zlib.runs[1].answers);
+assert.deepEqual(sqlite.runs[0].answers, sqlite.runs[1].answers);
+for (const query of [zlib, sqlite]) {
+  const source = await readFile(query.source.raw.file, "utf8");
+  assert.equal(sha256(source), query.source.raw.sha256);
+  const snapshot = parseKunaSsaDump(source);
+  for (const answer of query.runs[0].answers)
+    assert.deepEqual(queryLiteralUses(snapshot, answer.literal), answer);
+}
+const old = await json("native-zlib-code-fixed.report.json");
+assert.equal(zlib.source.artifact_sha256, old.facts.artifact_sha256);
+assert.deepEqual(zlib.source.engine, old.facts.engine);
+const bodySource = old.calls.find((call) => call.arguments[0] === "decompile");
+const body = await readFile(bodySource.file, "utf8");
+assert.equal(sha256(body), bodySource.sha256);
+const bodyDocument = JSON.parse(body);
+const raw = await readFile(zlib.source.raw.file, "utf8");
+assert.equal(sha256(raw), zlib.source.raw.sha256);
+assert.equal(
+  raw.split("\n0\nBasic Block", 1)[0].trim(),
+  bodyDocument.functions[0].code.trim(),
+  "Cross-surface emitted C differs",
+);
+const native = async () => ({
+  input: bodyDocument.binary,
+  stdout: { text: body },
+});
+const mappings = [];
+for (const [i, expectedLine] of [164, 551, 653].entries()) {
+  const answer = zlib.runs[0].answers[i];
+  const original = old.facts.results[i];
+  assert.equal(answer.literal, original.string.address);
+  const failed = await mappedCode(native, original);
+  assert.equal(failed.status, "unknown");
+  const sites = answer.direct_uses.map((id) => ({
+    from: answer.operations.find((op) => op.id === id).address,
+  }));
+  const mapped = await mappedCode(native, {
+    functions: original.functions,
+    sites,
+  });
+  assert.equal(mapped.status, "ok");
+  assert.deepEqual(mapped.exact_mapped_lines, [expectedLine]);
+  mappings.push({
+    literal: answer.literal,
+    original_sites: original.sites.map((s) => s.from),
+    semantic_sites: sites.map((s) => s.from),
+    line: expectedLine,
+  });
+}
+const header = zlib.runs[0].answers[0];
+assert.deepEqual(
+  header.control_edges.map((e) => [e.from, e.to, e.polarity]),
+  [
+    [182, 446, "false"],
+    [183, 446, "false"],
+  ],
+);
+assert.equal(header.operations.length, 21);
+assert.equal(header.coverage.dependencies.boundaries.length, 2);
+assert.ok(header.operations.some((op) => op.statement.includes("& #0x1:4")));
+assert.ok(header.operations.some((op) => op.statement.includes("/ #0x1f")));
+const match = sqlite.runs[0].answers[0];
+assert.equal(
+  match.operations.find((op) => op.id === match.direct_uses[0]).kind,
+  "call",
+);
+assert.ok(match.operations.some((op) => op.statement.includes("!= #0x1:4")));
+assert.deepEqual(
+  match.control_edges.map((e) => e.polarity),
+  ["false"],
+);
+const assemblyProofs = [];
+for (const [file, patterns] of [
+  [
+    "relations-zlib-guard.objdump.txt",
+    [/d9ec:.*je\s+ded7/u, /da32:.*jne\s+ded7/u, /0x842108421084211/u],
+  ],
+  [
+    "relations-sqlite-error.objdump.txt",
+    [
+      /65239:.*cmp\s+\$0x1,%ebx/u,
+      /6523c:.*je\s+65281/u,
+      /65284:.*lea.*11dcd8/u,
+    ],
+  ],
+]) {
+  const text = await readFile(join(root, file), "utf8");
+  for (const pattern of patterns) assert.match(text, pattern);
+  assemblyProofs.push({ file, sha256: sha256(text) });
+}
+// Exhaustive ordinary 16-bit header domain. This executes arithmetic, not targets.
+for (let n = 0n; n < 65536n; n++) {
+  const high = (n * 0x842108421084211n) >> 64n;
+  const machineQ = (((n - high) >> 1n) + high) >> 4n;
+  const ssaQ = (((n - n / 31n) >> 1n) + n / 31n) >> 4n;
+  assert.equal(machineQ, n / 31n);
+  assert.equal(ssaQ, machineQ);
+  assert.equal(n !== machineQ * 31n, n % 31n !== 0n);
+}
+const ghidra = await json("relations-ghidra-zlib-retained.bundle.json");
+const flow = ghidra.records.find((r) => r.normalized_result?.native_value_flow)
+  ?.normalized_result.native_value_flow;
+assert.equal(flow.truncated, true);
+assert.equal(flow.operations.length, 3000);
+assert.equal(flow.known_omitted_edges, 239);
+assert.ok(
+  !flow.operations.some((op) =>
+    op.inputs.some((v) => v.constant_hex === "118fc4"),
+  ),
+);
+await writeFile(
+  output,
+  JSON.stringify(
+    {
+      mappings,
+      zlib_header_selected_operations: header.operations.length,
+      sqlite_selected_operations: match.operations.length,
+      assemblyProofs,
+      arithmetic_oracle: {
+        tested_values: 65536,
+        domain: "ordinary 16-bit header value",
+        target_executed: false,
+      },
+      ghidra: {
+        retained_operations: 3000,
+        known_omitted_edges: 239,
+        late_literal_coverage: "unknown due to truncation",
+      },
+      limitations: [
+        "Printed-SSA observations are derived, not runtime behavior.",
+        "Entry state, complete control dependencies, phi predecessor and memory alias bindings remain unknown.",
+        "Source-version agreement does not prove an exact Debian source/build match.",
+      ],
+    },
+    null,
+    2,
+  ),
+  { flag: "wx" },
+);
+console.log(
+  JSON.stringify({
+    output,
+    mapped_errors: mappings.length,
+    arithmetic_values: 65536,
+  }),
+);

knip.json

@@ -10,6 +10,7 @@
     "scripts/verify/fridaBindingsCompatibility.ts",
     "scripts/verify/termux/browser.mjs",
     "scripts/verify-real-ghidra-noreturn.mjs",
+    "scripts/run-exact-tests.mjs",
     "tests/processOwnershipRunner.ts"
   ],
   "project": ["src/**/*.ts", "tests/**/*.ts", "scripts/**/*.mjs"],

native/windows/README.md

@@ -111,14 +111,9 @@ automatically. Alternatively, build it using the Linux/MinGW lane above.
 - Cleanup walks locked directory objects, removes files by handle, and unlinks
   reparse entries without traversing their targets. Failed removal retains the
   root and ancestor leases for retry; a partially removed runtime accepts only
-  cleanup, and its registry entry remains until removal succeeds. The runtime
-  owner retries only native close failures with Win32 sharing/lock codes 32/33,
-  for at most ten attempts with a 100 ms delay between attempts. Other native
-  errors are returned immediately; exhausting the retry budget preserves the
-  runtime owner for a later explicit close. These cleanup retries do not use an
-  analysis cancellation signal and schedule up to 900 ms of backoff, in
-  addition to native cleanup time. The owned root handle includes attribute-write access so cleanup can clear a
-  read-only marker, matching the child cleanup handles. Normal close, cancellation,
+  cleanup, and its registry entry remains until removal succeeds. The owned root
+  handle includes attribute-write access so cleanup can clear a read-only marker,
+  matching the child cleanup handles. Normal close, cancellation,
   startup failure, and timeout release provider resources. Abrupt owner death
   kills the owned job. The Android provider additionally uses a detached helper
   that owns its private runtime directory and cleans it when the owner pipe
@@ -138,9 +133,7 @@ text do not establish a safe retry. Analysis errors propagate the producer's
 retry disposition through JavaScript, source-map and WABT workflows; transient
 failures report `category: unavailable` and retain the original reason.
 Incomplete cleanup blocks an operation retry until its owned resources settle.
-The close-stage retry is separate from allocation and analysis retries: it
-repeats only the existing owned cleanup operation, and does not retry provider
-work or create another runtime.
+REA adds no automatic retry loop or new analysis cache for this behavior.
 
 Ordinary drive-absolute paths accept backslashes, forward slashes, or mixed
 separators. File identity retains the original requested spelling. Separator

package.json

@@ -214,7 +214,6 @@
     "verify:javascript:digests": "npm run build:cached && node scripts/verify/javascript/digests.mjs",
     "verify:javascript:output": "npm run build:cached && node scripts/verify/javascript/output.mjs",
     "verify:javascript:module-references": "npm run build:cached && node scripts/verify/javascript/module-references.mjs",
-    "verify:javascript:native-handoffs": "npm run build:cached && node scripts/verify/javascript/native-handoffs.mjs",
     "verify:application-workflows": "npm run build:cached && node scripts/verify/javascript/application-workflows.mjs",
     "verify:managed": "npm run build:cached && node scripts/verify/managed/conformance.mjs",
     "verify:firmware": "npm run build:cached && node scripts/verify/firmware/analysis.mjs",
@@ -273,7 +272,6 @@
     "verify:windows-native": "node scripts/verify-windows-native.mjs",
     "verify:ghidra:windows:package": "node scripts/verify-packaged-ghidra-windows.mjs",
     "build:ghidra:nativeaot": "node scripts/build-ghidra-nativeaot.mjs",
-    "verify:ghidra:bridge-sources": "node scripts/verify-ghidra-bridge-sources.mjs",
     "build:fixtures:nativeaot": "node scripts/generate-nativeaot-fixtures.mjs",
     "verify:ghidra:nativeaot": "npm run build:cached && node scripts/verify-real-ghidra-nativeaot.mjs",
     "verify:browser:scripts": "npm run build:cached && node scripts/verify-browser-scripts.mjs",

scripts/build-ghidra-nativeaot.mjs

@@ -157,7 +157,7 @@ function propertyValue(content, name) {
   return null;
 }
 
-/** Release line supported by the separately pinned NativeAOT integration. */
+/** Same 12.1 line as GhidraInstallationPolicy, including a distro suffix. */
 function ghidraReleaseLineAccepted(raw) {
   const match = /^(\d+)\.(\d+)(?:\.(\d+))?([-+].*)?$/u.exec(raw ?? "");
   return match !== null && Number(match[1]) === 12 && Number(match[2]) === 1;

scripts/ci/scopes.mjs

@@ -104,7 +104,6 @@ export const SCOPES = {
     "tests/boundary/filesystem/npmRelease.test.ts",
     "tests/boundary/process/releaseArtifactCanary.test.ts",
     "src/windows/**",
-    "src/ghidra/GhidraBridgeSources.ts",
     "native/windows/**",
     "src/process/capture/FilesystemSnapshot.ts",
     "src/process/capture/FilesystemSnapshot.test.ts",
@@ -437,14 +436,6 @@ export const SCOPES = {
     "tests/fixtures/nativeaot/**",
     ".github/workflows/nativeaot-fixtures.yml",
   ],
-  ghidra_bridge: [
-    "bridge/ghidra/**",
-    "src/ghidra/GhidraBridgeSources.ts",
-    "src/ghidra/GhidraJavaProperties.ts",
-    "src/ghidra/GhidraReleasePolicy.ts",
-    "scripts/verify-ghidra-bridge-sources.mjs",
-    ".github/workflows/ghidra-bridge-sources.yml",
-  ],
   website: [
     "website/**",
     "scripts/*website*.py",

scripts/lib/test-projects.mjs

@@ -17,7 +17,7 @@ export const SOURCE_TEST_PROJECTS = [
     group: "source",
     include: [
       "src/*.test.ts",
-      "src/{apktool,jeb,adb,artifacts,browser,dotnet,electron,evm,firmware,flutter,pcap,ghidra,go,hopper,ida,inspector,javascript,native,process,reference,rust,server,sqlite,wasm,windows}/**/*.test.ts",
+      "src/{apktool,jeb,adb,artifacts,browser,dotnet,electron,evm,firmware,flutter,pcap,ghidra,go,hopper,ida,inspector,javascript,native,process,reference,rust,server,wasm,windows}/**/*.test.ts",
     ],
   },
   {

scripts/verify-gemini-client.mjs

@@ -5,11 +5,6 @@ import { tmpdir } from "node:os";
 import { join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import Ajv2020 from "ajv/dist/2020.js";
-import {
-  schemaArrays,
-  schemaChildren,
-  schemaMaps,
-} from "../dist/contracts/inputSchemaPresentation.js";
 import {
   TOOL_CONTRACTS,
   toolContract,
@@ -22,8 +17,6 @@ const repo = fileURLToPath(new URL("..", import.meta.url));
 const runtimeRoot = process.env.REA_VERIFY_RUNTIME_ROOT ?? repo;
 const command = process.env.REA_VERIFY_GEMINI_COMMAND ?? "gemini";
 const mode = process.argv[2] ?? "call";
-const schemaProfile = process.env.REA_VERIFY_GEMINI_SCHEMA_PROFILE ?? "full";
-assert(["full", "compact"].includes(schemaProfile));
 // npm installs of Gemini CLI provide a JavaScript entry point; on Windows only a gemini.cmd shim reaches
 // PATH, which Node does not spawn without a shell, so a selected .js entry runs under this Node. It is
 // resolved once, because the preflight runs from the caller's directory and the client from the workspace.
@@ -67,7 +60,6 @@ const environment = {
   GEMINI_CLI_NO_RELAUNCH: "1",
   GEMINI_CLI_TRUST_WORKSPACE: "true",
   REA_PROCESS_RUN_ID: verifier.run_id,
-  REA_MCP_INPUT_SCHEMA_PROFILE: schemaProfile,
 };
 let clientVersion;
 try {
@@ -169,43 +161,8 @@ let skillRequested = false;
 let finalSeen = false;
 let catalogSize = 0;
 let schemasChecked = 0;
-let examplesChecked = 0;
 let artifactDigest;
 const schemaValidator = new Ajv2020({ strict: false, validateFormats: false });
-const booleanLiteralPath = (schema, path = "$", seen = new Set()) => {
-  if (!schema || typeof schema !== "object" || seen.has(schema))
-    return undefined;
-  seen.add(schema);
-  for (const [key, child] of Object.entries(schema)) {
-    const childPath = `${path}.${key}`;
-    if (key === "const" && typeof child === "boolean") return childPath;
-    if (
-      key === "enum" &&
-      Array.isArray(child) &&
-      child.some((item) => typeof item === "boolean")
-    )
-      return childPath;
-    const schemaChildrenAtKey =
-      schemaMaps.has(key) &&
-      child &&
-      typeof child === "object" &&
-      !Array.isArray(child)
-        ? Object.entries(child).map(([name, item]) => [
-            `${childPath}.${name}`,
-            item,
-          ])
-        : schemaArrays.has(key) && Array.isArray(child)
-          ? child.map((item, index) => [`${childPath}[${index}]`, item])
-          : schemaChildren.has(key)
-            ? [[childPath, child]]
-            : [];
-    for (const [nestedPath, nested] of schemaChildrenAtKey) {
-      const found = booleanLiteralPath(nested, nestedPath, seen);
-      if (found !== undefined) return found;
-    }
-  }
-  return undefined;
-};
 const extractEvidence = (value) => {
   if (typeof value === "string") {
     if (
@@ -269,22 +226,6 @@ const fixture = await createGeminiModelFixture({
           schemaValidator.validateSchema(tool.parametersJsonSchema),
           `${tool.name}: invalid advertised JSON Schema: ${JSON.stringify(schemaValidator.errors)}`,
         );
-        const booleanLiteral = booleanLiteralPath(tool.parametersJsonSchema);
-        assert.equal(
-          booleanLiteral,
-          undefined,
-          `${tool.name}: Gemini SDK declaration retains a boolean const/enum at ${booleanLiteral}`,
-        );
-        const name = tool.name.slice(prefix.length);
-        const contract = toolContract(name);
-        const validate = schemaValidator.compile(tool.parametersJsonSchema);
-        for (const example of contract.examples) {
-          assert(
-            validate(example.input),
-            `${tool.name}: Gemini SDK declaration rejects canonical example ${example.title}: ${JSON.stringify(schemaValidator.errors)}`,
-          );
-          examplesChecked++;
-        }
         schemasChecked++;
       }
     }
@@ -415,9 +356,6 @@ try {
     client: "Gemini CLI",
     clientVersion,
     mode,
-    schemaProfile,
-    schemasChecked,
-    examplesChecked,
     passed: failure === undefined,
     artifacts: lab,
     runtimeRoot,

scripts/verify-ghidra-bridge-sources.mjs

@@ -1,182 +0,0 @@
-#!/usr/bin/env node
-// Compile the packaged Ghidra bridge sources against an existing Ghidra
-// installation's jars. Ghidra's script provider compiles the whole bridge
-// directory when a session starts, so one unresolved symbol disables every
-// operation and surfaces only after import and auto-analysis. This check
-// reports the same javac diagnostics without launching Ghidra or selecting,
-// importing or executing a target.
-import { spawnSync } from "node:child_process";
-import { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-// The pinned Node toolchain strips types from these dependency-free owners;
-// this preflight therefore uses runtime facts without needing npm ci or a build.
-import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
-import { parseGhidraJavaProperties } from "../src/ghidra/GhidraJavaProperties.ts";
-import {
-  SUPPORTED_GHIDRA_VERSION,
-  SUPPORTED_GHIDRA_JAVA_MAJOR,
-  ghidraReleaseAccepted,
-  ghidraReleaseLine,
-} from "../src/ghidra/GhidraReleasePolicy.ts";
-
-const args = process.argv.slice(2);
-if (
-  args.length > 1 ||
-  (args.length === 1 &&
-    !["--check-sdk-pin", "--verified-sdk"].includes(args[0]))
-)
-  fail(
-    "Usage: verify-ghidra-bridge-sources.mjs [--check-sdk-pin|--verified-sdk]",
-  );
-if (args[0] === "--check-sdk-pin") {
-  let url;
-  try {
-    url = new URL(process.env.GHIDRA_RELEASE_URL);
-  } catch {
-    fail("GHIDRA_RELEASE_URL must name the checksum-pinned official release");
-  }
-  const prefix = `/NationalSecurityAgency/ghidra/releases/download/Ghidra_${SUPPORTED_GHIDRA_VERSION}_build/ghidra_${SUPPORTED_GHIDRA_VERSION}_PUBLIC_`;
-  if (
-    url.origin !== "https://github.com" ||
-    url.username ||
-    url.password ||
-    url.search ||
-    url.hash ||
-    !url.pathname.startsWith(prefix) ||
-    !url.pathname.endsWith(".zip") ||
-    !/^[a-f0-9]{64}$/iu.test(process.env.GHIDRA_RELEASE_SHA256 ?? "")
-  )
-    fail(
-      `SDK URL and SHA256 must match verified Ghidra ${SUPPORTED_GHIDRA_VERSION}`,
-    );
-  console.log(`GHIDRA_JAVA_MAJOR=${SUPPORTED_GHIDRA_JAVA_MAJOR}`);
-  process.exit(0);
-}
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const bridge = join(root, "bridge/ghidra");
-const install = process.env.GHIDRA_INSTALL_DIR;
-if (!install)
-  fail(
-    `Set GHIDRA_INSTALL_DIR to an existing Ghidra ${ghidraReleaseLine()} installation (verified with ${SUPPORTED_GHIDRA_VERSION}). REA does not install Ghidra.`,
-  );
-const properties = await readFile(
-  join(install, "Ghidra/application.properties"),
-  "latin1",
-).catch((cause) =>
-  fail(
-    `GHIDRA_INSTALL_DIR has no readable Ghidra/application.properties: ${cause.message}`,
-  ),
-);
-const parsedProperties = parseGhidraJavaProperties(properties);
-if (!parsedProperties.ok) fail(parsedProperties.error);
-const version = parsedProperties.value.get("application.version");
-if (!ghidraReleaseAccepted(version))
-  fail(
-    `Bridge sources require Ghidra ${ghidraReleaseLine()} (verified with ${SUPPORTED_GHIDRA_VERSION}). Observed application.version=${version === undefined ? "missing" : JSON.stringify(version)}.`,
-  );
-if (args[0] === "--verified-sdk" && version !== SUPPORTED_GHIDRA_VERSION)
-  fail(
-    `CI SDK must be verified Ghidra ${SUPPORTED_GHIDRA_VERSION}; observed ${JSON.stringify(version)}`,
-  );
-const sourceNames = (await readdir(bridge, { withFileTypes: true }))
-  .filter((entry) => entry.isFile() && entry.name.endsWith(".java"))
-  .map((entry) => entry.name);
-for (const name of Object.values(GHIDRA_BRIDGE_SOURCES))
-  if (!sourceNames.includes(name))
-    fail(`Required Ghidra bridge source is missing: bridge/ghidra/${name}`);
-const requiredNames = new Set(Object.values(GHIDRA_BRIDGE_SOURCES));
-const unregistered = sourceNames.filter((name) => !requiredNames.has(name));
-if (unregistered.length)
-  fail(
-    `Ghidra bridge sources absent from the manifest: ${unregistered.join(", ")}`,
-  );
-const sources = sourceNames
-  .map((name) => relative(root, join(bridge, name)))
-  .sort();
-
-const javac = process.env.JAVA_HOME
-  ? join(process.env.JAVA_HOME, "bin", "javac")
-  : "javac";
-const banner = run(javac, ["-version"]);
-if (banner.error || banner.status !== 0)
-  fail(`javac is unavailable: ${banner.error?.message ?? output(banner)}`);
-const major = Number(/^javac (\d+)/mu.exec(output(banner))?.[1]);
-if (!Number.isInteger(major) || major < SUPPORTED_GHIDRA_JAVA_MAJOR)
-  fail(
-    `Ghidra ${ghidraReleaseLine()} compiles bridge scripts with Java ${SUPPORTED_GHIDRA_JAVA_MAJOR} or newer. Observed: ${output(banner) || "no version"}. REA does not install or upgrade Java.`,
-  );
-
-const jars = (
-  await readdir(join(install, "Ghidra"), {
-    recursive: true,
-    withFileTypes: true,
-  })
-)
-  .filter((entry) => entry.isFile() && entry.name.endsWith(".jar"))
-  .map((entry) => join(entry.parentPath, entry.name))
-  .sort();
-if (jars.length === 0) fail(`No jars found under ${join(install, "Ghidra")}.`);
-
-const scratch = await mkdtemp(join(tmpdir(), "rea-ghidra-bridge-"));
-try {
-  // An argument file keeps the jar class path below Windows' command length.
-  const argumentFile = join(scratch, "javac.args");
-  await writeFile(
-    argumentFile,
-    [
-      "-proc:none",
-      "-encoding",
-      "UTF-8",
-      "--release",
-      String(SUPPORTED_GHIDRA_JAVA_MAJOR),
-      "-cp",
-      jars.join(process.platform === "win32" ? ";" : ":"),
-      "-d",
-      join(scratch, "classes"),
-      ...sources,
-    ]
-      .map((s) => `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`)
-      .join("\n"),
-  );
-  // Sources are repository-relative, so diagnostics name bridge/ghidra/<file>:<line>.
-  const result = run(javac, ["-J-Xmx1g", `@${argumentFile}`]);
-  if (result.error || result.status !== 0) {
-    // Set the status instead of exiting so the scratch directory is removed.
-    process.stderr.write(
-      `${output(result) || result.error?.message || "javac failed"}\nGhidra ${version} could not compile the packaged bridge sources; the provider would fail at session start.\n`,
-    );
-    process.exitCode = 1;
-  } else {
-    console.log(
-      JSON.stringify({
-        ghidra_version: version,
-        javac: output(banner),
-        class_path_jars: jars.length,
-        sources,
-      }),
-    );
-  }
-} finally {
-  await rm(scratch, { recursive: true, force: true });
-}
-
-function run(command, args) {
-  return spawnSync(command, args, {
-    cwd: root,
-    encoding: "utf8",
-    timeout: 300_000,
-    maxBuffer: 16 * 1024 * 1024,
-  });
-}
-
-function output(result) {
-  return `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-}
-
-function fail(message) {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}

scripts/verify-package-pack.mjs

@@ -17,10 +17,7 @@ export async function verifyPackagePack({ root, workspace }) {
       })
     ).stdout.trim(),
   );
-  const listing = (await exec("tar", ["-tf", tarball])).stdout;
-  // A bare LF identifies LF output; preceding CRs then belong to filenames.
-  const lineEnding = /(^|[^\r])\n/u.test(listing) ? "\n" : "\r\n";
-  const packedFiles = listing.split(lineEnding);
+  const packedFiles = (await exec("tar", ["-tf", tarball])).stdout.split("\n");
   const packedManifest = JSON.parse(
     (await exec("tar", ["-xOf", tarball, "package/package.json"])).stdout,
   );

scripts/verify-packaged-wasm-artifact.mjs

@@ -2,7 +2,6 @@
 import { join } from "node:path";
 import { mkdir } from "node:fs/promises";
 import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
-import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
 import { exec, execNpm } from "./lib/verify-package-core.mjs";
 import { WABT_WORKFLOW_TIMEOUT_MS } from "./lib/wabt-verifier-timeouts.mjs";
 import { verifyPackagePack } from "./verify-package-pack.mjs";
@@ -10,7 +9,6 @@ import { verifyPackagePack } from "./verify-package-pack.mjs";
 const root = await PrivateRuntimeRoot.create({
   prefix: "rea-wabt-package-verifier-",
 });
-let primaryError;
 try {
   const { tarball } = await verifyPackagePack({
     root: process.cwd(),
@@ -58,9 +56,6 @@ try {
     },
   );
   process.stdout.write(verified.stdout);
-} catch (cause) {
-  primaryError = cause;
-  throw cause;
 } finally {
-  await closeVerifierResources([() => root.close()], primaryError);
+  await root.close();
 }

scripts/verify-packed-bridge.mjs

@@ -1,20 +1,21 @@
 import { execFile } from "node:child_process";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
 
 const exec = promisify(execFile);
 const packedHopperBridge = "package/bridge/hopper_bridge.py";
 const packedCutterBridge = "package/bridge/cutter/rea_bridge.py";
+const packedGhidraBridge = "package/bridge/ghidra/ReaGhidraBridge.java";
+const packedGhidraActivator =
+  "package/bridge/ghidra/ReaGhidraBundleActivator.java";
 
 /** Check shipped bridge files; real-provider lanes verify runtime behavior. */
 export async function verifyPackedBridge({ workspace, tarball, packedFiles }) {
   for (const path of [
     packedHopperBridge,
     packedCutterBridge,
-    ...Object.values(GHIDRA_BRIDGE_SOURCES).map(
-      (name) => `package/bridge/ghidra/${name}`,
-    ),
+    packedGhidraBridge,
+    packedGhidraActivator,
   ]) {
     if (!packedFiles.includes(path)) throw new Error(`package omitted ${path}`);
   }

scripts/verify-packet-capture.mjs

@@ -12,7 +12,6 @@ import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Ajv2020 } from "ajv/dist/2020.js";
 import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
 import { parseEvidence } from "../dist/domain/evidence.js";
-import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
 import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
 
 if (process.platform !== "linux")
@@ -107,7 +106,6 @@ const expectedAddressSpace = Math.min(
     .map((value) => (value === "unlimited" ? Infinity : Number(value))),
 );
 
-let primaryError;
 try {
   await writeFile(path, source);
   await writeFile(bluetooth, bluetoothSource);
@@ -465,14 +463,10 @@ try {
     "network with spaces.pcap",
     "paged.pcap",
   ]);
-} catch (cause) {
-  primaryError = cause;
-  throw cause;
 } finally {
-  await closeVerifierResources(
-    [() => client.close(), () => transport.close(), () => root.close()],
-    primaryError,
-  );
+  await client.close();
+  await transport.close();
+  await root.close();
 }
 console.log(
   JSON.stringify(

scripts/verify-real-ghidra-assertions.mjs

@@ -3,7 +3,7 @@ import { hasTypedSwitchEvidence } from "./verify-real-ghidra-switch-assertions.m
 import { access } from "node:fs/promises";
 
 import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
-import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
+import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
 import { GHIDRA_SESSION_CAPABILITIES } from "../dist/ghidra/GhidraSessionValues.js";
 
 export function assertLocalProcedureInfo(info, expectedAddress) {

scripts/verify-real-ghidra-noreturn.mjs

@@ -11,7 +11,7 @@ import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
 import { parseConfig } from "../dist/config/parseConfig.js";
 import { GhidraClient } from "../dist/ghidra/GhidraClient.js";
 import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
-import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
+import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
 import { GhidraProvider } from "../dist/ghidra/GhidraProvider.js";
 import { silentLogger } from "../dist/logger.js";
 import { cleanupOwnedProcessGroup } from "../dist/process/ProcessOwnership.js";

scripts/verify-real-ghidra-windows.mjs

@@ -19,7 +19,7 @@ import {
   parseGhidraInventoryResult,
 } from "../dist/ghidra/GhidraInventoryValues.js";
 import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
-import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
+import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
 import { GhidraHeadlessLauncher } from "../dist/ghidra/GhidraLauncher.js";
 import { GHIDRA_PROVIDER_IDENTITY } from "../dist/ghidra/GhidraProviderCapabilities.js";
 import {

scripts/verify-real-ghidra.mjs

@@ -11,7 +11,7 @@ import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
 import { resolveGhidraAnalysisProfile } from "../dist/ghidra/GhidraAnalysisProfile.js";
 import { GhidraClient } from "../dist/ghidra/GhidraClient.js";
 import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
-import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
+import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
 import { GhidraHeadlessLauncher } from "../dist/ghidra/GhidraLauncher.js";
 import { GHIDRA_PROVIDER_IDENTITY } from "../dist/ghidra/GhidraProviderCapabilities.js";
 

scripts/verify-signal-recording.mjs

@@ -12,7 +12,6 @@ import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Ajv2020 } from "ajv/dist/2020.js";
 import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
 import { parseEvidence } from "../dist/domain/evidence.js";
-import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
 import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
 
 if (process.platform !== "linux")
@@ -84,7 +83,6 @@ const expectedAddressSpace = Math.min(
     .map((value) => (value === "unlimited" ? Infinity : Number(value))),
 );
 
-let primaryError;
 try {
   await writeFile(path, source);
   await client.connect(transport);
@@ -385,14 +383,10 @@ try {
     "paged.vcd",
     "recording with spaces.vcd",
   ]);
-} catch (cause) {
-  primaryError = cause;
-  throw cause;
 } finally {
-  await closeVerifierResources(
-    [() => client.close(), () => transport.close(), () => root.close()],
-    primaryError,
-  );
+  await client.close();
+  await transport.close();
+  await root.close();
 }
 console.log(
   JSON.stringify(

scripts/verify-windows-native.mjs

@@ -23,7 +23,6 @@ import { pathToFileURL } from "node:url";
 import { verifyWindowsProtocolInput } from "./lib/windows-protocol-input.mjs";
 import { verifyWindowsJobMemoryLimit } from "./lib/windows-job-memory-limit.mjs";
 import { verifyVolumeRootAppendLease } from "./lib/windows-volume-root-append-lease.mjs";
-import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
 
 if (process.platform !== "win32")
   throw new Error(
@@ -67,49 +66,6 @@ const exists = (path) =>
     () => true,
     () => false,
   );
-const startDeleteSharingDeniedReader = async (path) => {
-  const child = spawn(
-    "powershell.exe",
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-Command",
-      "$ErrorActionPreference = 'Stop'; " +
-        "$stream = [IO.File]::Open($env:REA_CLEANUP_HELD_PATH, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::ReadWrite); " +
-        "try { [Console]::WriteLine('ready'); [Console]::In.ReadLine() | Out-Null } " +
-        "finally { $stream.Dispose() }",
-    ],
-    {
-      env: { ...process.env, REA_CLEANUP_HELD_PATH: path },
-      stdio: ["pipe", "pipe", "pipe"],
-    },
-  );
-  const closed = once(child, "close");
-  void closed.catch(() => undefined);
-  try {
-    const [ready] = await once(child.stdout, "data", {
-      signal: AbortSignal.timeout(15_000),
-    });
-    assert.equal(String(ready).trim(), "ready");
-  } catch (cause) {
-    try {
-      child.kill();
-      await closed;
-    } catch (cleanupCause) {
-      throw new AggregateError(
-        [cause, cleanupCause],
-        "Reader startup and child cleanup failed",
-        { cause },
-      );
-    }
-    throw cause;
-  }
-  return { child, closed };
-};
-const stopDeleteSharingDeniedReader = async ({ child, closed }) => {
-  child.kill();
-  await closed;
-};
 const live = (pid) => {
   try {
     process.kill(pid, 0);
@@ -560,14 +516,32 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
       "cleanup-retry-",
     );
     const heldPath = join(retryRuntime.observation.path, "snapshot.bin");
-    let holder;
-    let primaryError;
+    await retryRuntime.snapshot(source, "snapshot.bin");
+    const holder = spawn(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "$ErrorActionPreference = 'Stop'; " +
+          "$stream = [IO.File]::Open($env:REA_CLEANUP_HELD_PATH, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::ReadWrite); " +
+          "try { [Console]::WriteLine('ready'); [Console]::In.ReadLine() | Out-Null } " +
+          "finally { $stream.Dispose() }",
+      ],
+      {
+        env: { ...process.env, REA_CLEANUP_HELD_PATH: heldPath },
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    const holderClosed = once(holder, "close");
+    void holderClosed.catch(() => undefined);
     try {
-      await retryRuntime.snapshot(source, "snapshot.bin");
-      holder = await startDeleteSharingDeniedReader(heldPath);
+      const [ready] = await once(holder.stdout, "data", {
+        signal: AbortSignal.timeout(15_000),
+      });
+      assert.equal(String(ready).trim(), "ready");
       // The reader denies delete sharing. Cleanup must retain ownership when
-      // its handle-relative open receives ERROR_SHARING_VIOLATION (32) through
-      // the bounded automatic retries; a later explicit close must succeed.
+      // its handle-relative open receives ERROR_SHARING_VIOLATION (32).
       await assert.rejects(retryRuntime.close(), { win32Code: 32 });
       assert.equal(
         windowsPrivateRuntime(retryRuntime.observation.path),
@@ -578,8 +552,8 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
         () => retryRuntime.writeFile("after-close.txt", "forbidden"),
         /cleanup is pending/u,
       );
-      holder.child.stdin.end("\n");
-      const [exitCode] = await holder.closed;
+      holder.stdin.end("\n");
+      const [exitCode] = await holderClosed;
       assert.equal(exitCode, 0);
       await retryRuntime.close();
       await retryRuntime.close();
@@ -589,73 +563,10 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
         /No native private runtime/u,
       );
       report.controls.cleanupFailureRetainsOwnershipForRetry = true;
-    } catch (cause) {
-      primaryError = cause;
-      throw cause;
     } finally {
-      await closeVerifierResources(
-        [
-          ...(holder === undefined
-            ? []
-            : [() => stopDeleteSharingDeniedReader(holder)]),
-          () => retryRuntime.close(),
-        ],
-        primaryError,
-      );
-    }
-    const transientRuntime = WindowsPrivateRuntime.create(
-      workspace,
-      "cleanup-transient-",
-    );
-    const transientHeldPath = join(
-      transientRuntime.observation.path,
-      "snapshot.bin",
-    );
-    let transientHolder;
-    let transientPrimaryError;
-    try {
-      await transientRuntime.snapshot(source, "snapshot.bin");
-      transientHolder = await startDeleteSharingDeniedReader(transientHeldPath);
-      // Keep the reader held through the first close attempt. Without retries,
-      // close rejects before the next event-loop turn; with retries, it remains
-      // pending until the caller releases this sharing conflict.
-      let closeSettled = false;
-      const closing = transientRuntime.close();
-      void closing.then(
-        () => {
-          closeSettled = true;
-        },
-        () => {
-          closeSettled = true;
-        },
-      );
-      await new Promise((resolve) => setImmediate(resolve));
-      assert.equal(closeSettled, false);
-      transientHolder.child.stdin.end("\n");
-      const [, [exitCode]] = await Promise.all([
-        closing,
-        transientHolder.closed,
-      ]);
-      assert.equal(exitCode, 0);
-      assert.equal(await exists(transientRuntime.observation.path), false);
-      assert.throws(
-        () => windowsPrivateRuntime(transientRuntime.observation.path),
-        /No native private runtime/u,
-      );
-      report.controls.cleanupTransientConflictRetries = true;
-    } catch (cause) {
-      transientPrimaryError = cause;
-      throw cause;
-    } finally {
-      await closeVerifierResources(
-        [
-          ...(transientHolder === undefined
-            ? []
-            : [() => stopDeleteSharingDeniedReader(transientHolder)]),
-          () => transientRuntime.close(),
-        ],
-        transientPrimaryError,
-      );
+      holder.kill();
+      await holderClosed.catch(() => undefined);
+      await retryRuntime.close();
     }
     report.controls = {
       ...report.controls,

scripts/verify-windows-package.mjs

@@ -14,7 +14,6 @@ import { join } from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
 import { supportedClients } from "../dist/application/SupportedClients.js";
 import { promisify } from "node:util";
-import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
 
 import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
@@ -53,9 +52,7 @@ try {
     );
   const packagedPaths = new Set(packageResult.files.map(({ path }) => path));
   for (const required of [
-    ...Object.values(GHIDRA_BRIDGE_SOURCES).map(
-      (name) => `bridge/ghidra/${name}`,
-    ),
+    "bridge/ghidra/ReaGhidraBridge.java",
     "native/windows/build/manifest.json",
     "native/windows/build/rea-windows-x64.node",
     "dist/android/JadxWorkspaceRoot.js",

scripts/verify/javascript/native-handoffs.mjs

@@ -1,348 +0,0 @@
-#!/usr/bin/env node
-
-import assert from "node:assert/strict";
-import { createHash, randomUUID } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { isAbsolute, join } from "node:path";
-import { performance } from "node:perf_hooks";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-import { Client } from "@modelcontextprotocol/client";
-import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
-import { createEvidence } from "../../../dist/domain/evidence.js";
-import { PrivateRuntimeRoot } from "../../../dist/process/PrivateRuntimeRoot.js";
-import {
-  OwnedCommandFailure,
-  runOwnedCommand,
-} from "../../../dist/process/OwnedCommand.js";
-import { closeVerifierResources } from "../../lib/verifier-cleanup.mjs";
-
-const { values } = parseArgs({
-  options: {
-    artifact: { type: "string" },
-    "addon-path": { type: "string" },
-    "native-sha256": { type: "string" },
-    "source-path": { type: "string", multiple: true },
-    rounds: { type: "string", default: "3" },
-    "cli-parity": { type: "boolean", default: false },
-    "tokenizer-python": { type: "string" },
-    "require-safe": { type: "boolean", default: false },
-  },
-  strict: true,
-});
-assert.ok(
-  values.artifact && isAbsolute(values.artifact),
-  "--artifact must be absolute",
-);
-assert.ok(
-  values["addon-path"] &&
-    !isAbsolute(values["addon-path"]) &&
-    values["addon-path"]
-      .split("/")
-      .every((part) => part !== "" && part !== "." && part !== ".."),
-  "--addon-path must be a normalized archive-relative path",
-);
-assert.match(
-  values["native-sha256"] ?? "",
-  /^[a-f0-9]{64}$/,
-  "--native-sha256 pins prior native bytes; it does not prove availability",
-);
-const rounds = Number(values.rounds);
-assert.ok(Number.isSafeInteger(rounds) && rounds > 0);
-const environment = {
-  PATH: process.env.PATH ?? "/usr/bin:/bin",
-  REA_LOG_LEVEL: "silent",
-  REA_ANALYSIS_PROVIDER: "auto",
-  HOPPER_LAUNCHER_PATH: "/rea-unconfigured-deep-provider/hopper",
-};
-const transport = new StdioClientTransport({
-  command: process.execPath,
-  args: [fileURLToPath(new URL("../../rea.mjs", import.meta.url)), "mcp"],
-  env: environment,
-  stderr: "pipe",
-});
-const client = new Client({
-  name: "javascript-native-handoff-verifier",
-  version: "1",
-});
-const serialize = (value) => JSON.stringify(value);
-const digest = (value) =>
-  createHash("sha256").update(serialize(value)).digest("hex");
-const fileDigest = async (path) => {
-  const hash = createHash("sha256");
-  for await (const chunk of createReadStream(path)) hash.update(chunk);
-  return hash.digest("hex");
-};
-const simulatedNativeEvidence = (path, sha256) =>
-  createEvidence(
-    { path, sha256, format: "raw-binary" },
-    { id: "ghidra", name: "Ghidra", version: "simulated" },
-    {
-      operation: "binary_overview",
-      parameters: {},
-      result: {
-        summary:
-          "Simulated subject-linkage input; no native provider executed.",
-      },
-      limitations: ["No native provider behavior is established."],
-    },
-  );
-let temporary;
-let primaryError;
-let retainTemporary = false;
-let report;
-const ownedCommand = async (command, arguments_, timeoutMs = 60_000) => {
-  try {
-    return await runOwnedCommand(
-      {
-        command,
-        arguments: arguments_,
-        cwd: temporary.path,
-        env: environment,
-        runId: `rea-native-handoff-${randomUUID()}`,
-        expectedCommand: command === process.execPath ? process.execPath : null,
-        sweepTokenOwnedProcesses: true,
-      },
-      { timeoutMs, diagnosticBytes: 16 * 1024 * 1024 },
-    );
-  } catch (cause) {
-    retainTemporary ||=
-      cause instanceof OwnedCommandFailure && cause.cleanupOwner !== undefined;
-    throw cause;
-  }
-};
-try {
-  const archiveSha256 = await fileDigest(values.artifact);
-  const companion = join(`${values.artifact}.unpacked`, values["addon-path"]);
-  let companionSha256 = null;
-  try {
-    companionSha256 = await fileDigest(companion);
-  } catch (cause) {
-    if (cause?.code !== "ENOENT") throw cause;
-  }
-  if (companionSha256 !== null)
-    assert.equal(companionSha256, values["native-sha256"]);
-  const native = simulatedNativeEvidence(companion, values["native-sha256"]);
-  const container = simulatedNativeEvidence(values.artifact, archiveSha256);
-  await client.connect(transport);
-  transport.stderr?.on("data", () => undefined);
-  const tools = (await client.listTools()).tools;
-  const catalog = tools.map(({ name, description, inputSchema }) => ({
-    name,
-    description,
-    inputSchema,
-  }));
-  const selected = catalog.filter(({ name }) =>
-    ["analyze_javascript_application", "trace_application_feature"].includes(
-      name,
-    ),
-  );
-  assert.equal(selected.length, 2);
-  const call = async (name, arguments_) => {
-    const response = await client.callTool(
-      { name, arguments: arguments_ },
-      { timeout: 360_000 },
-    );
-    assert.notEqual(response.isError, true, serialize(response));
-    assert.ok(response.structuredContent?.evidence_id);
-    return {
-      request: { name, arguments: arguments_ },
-      response: response.structuredContent,
-      wire_response: response,
-    };
-  };
-  const prepStart = performance.now();
-  const preparation = await call("analyze_javascript_application", {
-    input_path: values.artifact,
-    detail: "summary",
-    ...(values["source-path"] === undefined
-      ? {}
-      : { source_paths: values["source-path"] }),
-  });
-  const preparationMs = performance.now() - prepStart;
-  assert.equal(preparation.response.subject.digest.sha256, archiveSha256);
-  const sourceId = preparation.response.normalized_result.parent_evidence_id;
-  assert.match(sourceId, /^ev_[a-f0-9]{64}$/);
-  const query = {
-    application: { kind: "retained-evidence", evidence_id: sourceId },
-    native_observations: [container, native],
-    seed: {
-      kind: "string",
-      value: values["addon-path"],
-      match: "exact",
-      case_sensitive: true,
-    },
-    direction: "outgoing",
-  };
-  const samples = [];
-  let first;
-  for (let round = 0; round < rounds; round++) {
-    const start = performance.now();
-    const result = await call("trace_application_feature", query);
-    const elapsedMs = performance.now() - start;
-    if (first === undefined) first = result;
-    else assert.equal(result.response.evidence_id, first.response.evidence_id);
-    samples.push({
-      round,
-      elapsed_ms: elapsedMs,
-      structured_reply_bytes: Buffer.byteLength(serialize(result.response)),
-      full_tool_reply_bytes: Buffer.byteLength(serialize(result.wire_response)),
-    });
-  }
-  const trace = first.response.normalized_result;
-  const addons = trace.graph.nodes.filter(
-    ({ kind }) => kind === "native-addon",
-  );
-  assert.equal(
-    addons.length,
-    1,
-    "The selected native add-on must remain visible",
-  );
-  const addon = addons[0];
-  const unavailable = addon.observations.some(
-    ({ properties }) => properties.availability === "unavailable",
-  );
-  const expectedLinks = [
-    sourceId,
-    ...(companionSha256 === null ? [] : [native.evidence_id]),
-  ].sort();
-  const safeIdentity =
-    serialize(trace.evidence_links) === serialize(expectedLinks) &&
-    (companionSha256 === null
-      ? unavailable &&
-        addon.identity.strategy !== "content-digest" &&
-        trace.coverage.status === "partial" &&
-        trace.native_handoffs.length === 0
-      : addon.identity.strategy === "content-digest" &&
-        addon.identity.sha256 === companionSha256 &&
-        trace.native_handoffs.length === 1 &&
-        trace.native_handoffs[0].artifact_sha256 === companionSha256 &&
-        trace.native_handoffs[0].status === "evidence-linked" &&
-        serialize(trace.native_handoffs[0].evidence_ids) ===
-          serialize([native.evidence_id]));
-  let cliParity = null;
-  if (values["cli-parity"]) {
-    temporary = await PrivateRuntimeRoot.create({
-      prefix: "rea-native-handoff-verifier-",
-    });
-    const bundlePath = join(temporary.path, "bundle.json");
-    const exported = await client.callTool({
-      name: "export_evidence_bundle",
-      arguments: { path: bundlePath },
-    });
-    assert.notEqual(exported.isError, true, serialize(exported));
-    const bundle = JSON.parse(await readFile(bundlePath, "utf8"));
-    const parent = bundle.records.find(
-      ({ evidence_id }) => evidence_id === sourceId,
-    );
-    assert.ok(parent, "Export omitted the retained parent");
-    const request = join(temporary.path, "trace.json");
-    // The CLI's portable file contract takes complete Evidence; MCP resolves a
-    // same-session reference into the same shared application workflow.
-    await writeFile(request, serialize({ ...query, application: parent }));
-    const result = await ownedCommand(
-      process.execPath,
-      [
-        fileURLToPath(new URL("../../rea.mjs", import.meta.url)),
-        "trace-application-feature",
-        request,
-        "--json",
-      ],
-      120_000,
-    );
-    const evidence = JSON.parse(result.stdout.text);
-    assert.deepEqual(evidence.normalized_result, trace);
-    assert.equal(evidence.evidence_id, first.response.evidence_id);
-    cliParity = {
-      exact_cli_mcp_trace_parity: true,
-      evidence_id: evidence.evidence_id,
-    };
-  }
-  let tokenCosts = null;
-  if (values["tokenizer-python"]) {
-    temporary ??= await PrivateRuntimeRoot.create({
-      prefix: "rea-native-handoff-verifier-",
-    });
-    const input = join(temporary.path, "token-input.json");
-    await writeFile(
-      input,
-      serialize({ catalog, selected, preparation, query: first }),
-    );
-    const result = await ownedCommand(values["tokenizer-python"], [
-      "-c",
-      `import json,sys,tiktoken
-with open(sys.argv[1],encoding='utf-8') as f:d=json.load(f)
-enc=tiktoken.get_encoding('cl100k_base')
-def n(v):return len(enc.encode(json.dumps(v,ensure_ascii=False,separators=(',',':')),disallowed_special=()))
-requests=n(d['preparation']['request'])+n(d['query']['request'])
-structured=n(d['preparation']['response'])+n(d['query']['response'])
-full_reply=n(d['preparation']['wire_response'])+n(d['query']['wire_response'])
-s=n(d['selected']);a=n(d['catalog'])
-print(json.dumps(dict(tokenizer='cl100k_base',tiktoken_version=tiktoken.__version__,selected_catalog=s,full_catalog=a,requests=requests,structured_replies=structured,full_tool_replies=full_reply,selected_catalog_structured_task=s+requests+structured,full_catalog_structured_task=a+requests+structured,selected_catalog_full_reply_task=s+requests+full_reply,full_catalog_full_reply_task=a+requests+full_reply)))`,
-      input,
-    ]);
-    tokenCosts = JSON.parse(result.stdout.text);
-  }
-  report = {
-    scope:
-      "Real shipped-ASAR native identity through public CLI/stdio MCP; simulated native Evidence only, no provider/application executed",
-    artifact: { path: values.artifact, sha256: archiveSha256 },
-    addon_path: values["addon-path"],
-    companion_sha256_observed: companionSha256,
-    prior_native_sha256_supplied: values["native-sha256"],
-    source_paths: values["source-path"] ?? null,
-    parent_evidence_id: sourceId,
-    trace_evidence_id: first.response.evidence_id,
-    preparation_ms: preparationMs,
-    samples,
-    safe_identity: safeIdentity,
-    node: {
-      node_id: addon.node_id,
-      identity: addon.identity,
-      unavailable_observed: unavailable,
-      basis: addon.observations.map(({ evidence }) => ({
-        authority: evidence.authority,
-        state: evidence.state,
-        confidence: evidence.confidence,
-        artifact: evidence.artifact,
-        location: evidence.location,
-      })),
-    },
-    native_handoffs: trace.native_handoffs,
-    evidence_links: trace.evidence_links,
-    source_coverage: trace.coverage,
-    graph_coverage: trace.graph.coverage,
-    facts_sha256: digest({
-      node: addon,
-      native_handoffs: trace.native_handoffs,
-      evidence_links: trace.evidence_links,
-      coverage: trace.coverage,
-    }),
-    cli_parity: cliParity,
-    token_costs: tokenCosts,
-    conditions:
-      "Fresh MCP session, one selected analysis followed by repeated identical retained traces. Filesystem/build caches uncontrolled. Task token counts include one analysis summary and one trace with name/description/inputSchema catalog projections; structured and complete-tool-reply projections are alternatives, not billing. Repeated rounds, export, CLI parity and tokenizer are validation overhead outside that one-task token count but inside total resource receipts. A wrong-identity baseline is not a successful equivalent task or efficiency credit.",
-  };
-  if (values["require-safe"])
-    assert.ok(safeIdentity, "Native identity/linkage oracle failed");
-} catch (cause) {
-  primaryError = cause;
-  throw cause;
-} finally {
-  await closeVerifierResources(
-    [
-      () => client.close(),
-      () => transport.close(),
-      async () => {
-        if (retainTemporary)
-          throw new Error(
-            `Command cleanup incomplete; retaining owned inputs at ${temporary?.path}.`,
-          );
-        await temporary?.close();
-      },
-    ],
-    primaryError,
-  );
-}
-console.log(serialize(report));

src/application/AppBundleExecutable.test.ts

@@ -32,46 +32,3 @@ describe("app bundle Info.plist magic", () => {
     }
   });
 });
-
-describe("app bundle program directory containment", () => {
-  it("rejects an escaping programs directory before resolving its child", async () => {
-    const root = await mkdtemp(join(tmpdir(), "rea-app-programs-"));
-    try {
-      const bundle = join(root, "Fixture.app");
-      const programs = join(bundle, "Contents", "MacOS");
-      const executable = join(programs, "Missing");
-      const canonicalBundle = join(root, "Canonical.app");
-      const outsidePrograms = join(root, "outside");
-      const plist =
-        "<plist><dict><key>CFBundleExecutable</key><string>Missing</string></dict></plist>";
-      await mkdir(join(bundle, "Contents"), { recursive: true });
-      await writeFile(join(bundle, "Contents", "Info.plist"), plist);
-      let childResolved = false;
-
-      const result = await resolveAppBundleExecutable(bundle, {
-        readFile: async () => Buffer.from(plist),
-        realpath: async (path) => {
-          if (path === bundle) return canonicalBundle;
-          if (path === programs) return outsidePrograms;
-          if (path === executable) {
-            childResolved = true;
-            throw Object.assign(new Error("missing executable"), {
-              code: "ENOENT",
-            });
-          }
-          return path;
-        },
-      });
-
-      expect(result).toMatchObject({
-        ok: false,
-        error: {
-          reason: "app program directory leaves Contents/MacOS",
-        },
-      });
-      expect(childResolved).toBe(false);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-});

src/application/AppBundleExecutable.ts

@@ -219,24 +219,11 @@ const resolveLayoutExecutable = async (
     );
   const programs = join(bundle, ...layout.programs);
   const executable = join(programs, name);
-  let canonicalBundle: string;
   try {
-    canonicalBundle = await fileSystem.realpath(bundle);
-  } catch (cause: unknown) {
-    return err(
-      new BinaryTargetError(bundle, errorReason(cause, bundle), { cause }),
-    );
-  }
-  try {
-    const canonicalPrograms = await fileSystem.realpath(programs);
-    if (!isPathWithinRoot(canonicalBundle, canonicalPrograms))
-      return err(
-        new BinaryTargetError(
-          bundle,
-          `app program directory leaves ${layout.programsLabel}`,
-        ),
-      );
-    const canonicalExecutable = await fileSystem.realpath(executable);
+    const [canonicalPrograms, canonicalExecutable] = await Promise.all([
+      fileSystem.realpath(programs),
+      fileSystem.realpath(executable),
+    ]);
     if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
       return err(
         new BinaryTargetError(

src/application/DirectAnalysisCleanup.ts

@@ -46,7 +46,6 @@ export const directAnalysisCleanupFailure = (
         ...primary.data,
         code: "cleanup_incomplete",
         retryable: false,
-        remediation: cleanup.remediation,
         details: {
           ...primary.data.details,
           cleanup: "incomplete",
@@ -87,7 +86,6 @@ export const managedAnalysisCleanupFailure = (
       "close_binary",
       {
         cause: error,
-        remediationAction: cleanup.remediation.action,
         cleanup: { reason: cleanup.message, resources: error.cleanupResources },
         diagnostics: {
           cleanup_error: cleanup,

src/application/ReferenceSourceImportEntries.ts

@@ -137,23 +137,7 @@ const readPackageMains = (
   return mains;
 };
 
-/**
- * Extension slots in probe order. Within a slot, files precede directory
- * indexes. The CommonJS loader tries `X.json` after `X.js` and before any
- * directory index; ESM and TypeScript require an explicit `.json`.
- */
-const RESOLUTION_SUFFIXES: readonly (readonly string[])[] = [
-  [""],
-  [".ts"],
-  [".js"],
-  [".mjs"],
-  [".cjs"],
-  [".tsx"],
-  [".jsx"],
-];
-const REQUIRE_RESOLUTION_SUFFIXES = RESOLUTION_SUFFIXES.map((slot) =>
-  slot.includes(".js") ? [...slot, ".json"] : slot,
-);
+const RESOLUTION_SUFFIXES = ["", ".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
 
 /** Inventory facts an internal specifier resolves against. */
 interface SpecifierContext {
@@ -169,7 +153,6 @@ interface SpecifierContext {
 const selectPackageMain = (
   index: string,
   context: SpecifierContext,
-  slots: readonly (readonly string[])[],
 ): { to: string; resolution: "internal" | "unresolved" } => {
   const directory = posix.dirname(index);
   const manifest = context.packageMains.get(directory);
@@ -187,12 +170,11 @@ const selectPackageMain = (
   // Node would load a declared entry outside the imported root.
   if (logicalPathEscapesRoot(target))
     return { to: target, resolution: "unresolved" };
-  const suffixes = slots.flat();
   const selected = context.lookupPath.resolveCandidates([
-    ...suffixes.map((suffix) => `${target}${suffix}`),
-    ...suffixes
-      .filter((suffix) => suffix !== "")
-      .map((suffix) => posix.join(target, `index${suffix}`)),
+    ...RESOLUTION_SUFFIXES.map((suffix) => `${target}${suffix}`),
+    ...RESOLUTION_SUFFIXES.filter((suffix) => suffix !== "").map((suffix) =>
+      posix.join(target, `index${suffix}`),
+    ),
   ]);
   return { to: selected ?? index, resolution: "internal" };
 };
@@ -201,7 +183,6 @@ const resolveInternalSpecifier = (
   fromPath: string,
   specifier: string,
   context: SpecifierContext,
-  slots: readonly (readonly string[])[],
 ): { to: string; resolution: "internal" | "unresolved" } => {
   if (posix.isAbsolute(specifier))
     return { to: specifier, resolution: "unresolved" };
@@ -215,13 +196,9 @@ const resolveInternalSpecifier = (
     specifier.endsWith("/") || [".", ".."].includes(posix.basename(specifier));
   // A directory resolves only to an index with an extension; neither Node nor
   // TypeScript selects an extensionless `index` file.
-  const candidates = slots.flatMap((slot) => [
-    ...(directoryReference
-      ? []
-      : slot.map((suffix) => `${normalized}${suffix}`)),
-    ...slot
-      .filter((suffix) => suffix !== "")
-      .map((suffix) => posix.join(normalized, `index${suffix}`)),
+  const candidates = RESOLUTION_SUFFIXES.flatMap((suffix) => [
+    ...(directoryReference ? [] : [`${normalized}${suffix}`]),
+    ...(suffix === "" ? [] : [posix.join(normalized, `index${suffix}`)]),
   ]);
   // Retain present runtime files first; substitute only a missing counterpart.
   // Counterparts cover explicit filenames, not directory/index resolution.
@@ -237,7 +214,7 @@ const resolveInternalSpecifier = (
     posix.basename(match).startsWith("index.") &&
     posix.dirname(match).normalize("NFC") === normalized.normalize("NFC");
   return resolvedThroughIndex
-    ? selectPackageMain(match, context, slots)
+    ? selectPackageMain(match, context)
     : { to: match, resolution: "internal" };
 };
 
@@ -273,9 +250,6 @@ const appendFile = (
       relationship.from_path,
       relationship.to,
       context,
-      relationship.kind === "requires"
-        ? REQUIRE_RESOLUTION_SUFFIXES
-        : RESOLUTION_SUFFIXES,
     );
     output.relationships.push({
       ...relationship,

src/application/binary/BinarySession.ts

@@ -596,17 +596,18 @@ export class BinarySession
 
   /** Describe the active binary session. */
   status(): JsonValue {
-    const client = this.#active?.client ?? this.#pendingCleanup?.client;
     return binarySessionStatus({
       target: this.#active?.target,
       route: this.#currentRoute(),
       router: this.#providerRouter,
       runtimeUnavailability: this.#runtimeUnavailability,
       runId: this.#active?.runId,
-      runtimeLineageSnapshots: client?.runtimeLineageSnapshots?.() ?? [],
-      requestActivitySnapshots: client?.requestActivitySnapshots?.() ?? [],
-      providerOperationHealth: client?.operationHealthSnapshot?.() ?? null,
-      cleanupPending: this.#pendingCleanup !== undefined,
+      runtimeLineageSnapshots:
+        this.#active?.client.runtimeLineageSnapshots?.() ?? [],
+      requestActivitySnapshots:
+        this.#active?.client.requestActivitySnapshots?.() ?? [],
+      providerOperationHealth:
+        this.#active?.client.operationHealthSnapshot?.() ?? null,
     });
   }
 

src/application/binary/BinarySessionStatus.ts

@@ -30,7 +30,6 @@ interface BinarySessionStatusInput {
   readonly runtimeLineageSnapshots: readonly ProviderRuntimeLineageSnapshot[];
   readonly requestActivitySnapshots: readonly ProviderRequestActivitySnapshot[];
   readonly providerOperationHealth?: ProviderOperationHealth | null;
-  readonly cleanupPending?: boolean;
 }
 
 /** Project internal provider routing state into the caller-visible session status. */
@@ -43,7 +42,6 @@ export const binarySessionStatus = ({
   runtimeLineageSnapshots,
   requestActivitySnapshots,
   providerOperationHealth,
-  cleanupPending = false,
 }: BinarySessionStatusInput): JsonValue => {
   const routeCapabilities = [...route.capabilities.values()]
     .filter(({ operation }) => operation !== "inventory_artifact")
@@ -86,7 +84,6 @@ export const binarySessionStatus = ({
       ),
     }));
   const common = {
-    cleanup_pending: cleanupPending,
     capabilities,
     analysis_provider_binding: analysisProviderBinding,
     analysis_provider_candidates: analysisProviderCandidates,

src/application/binary/CompositeProvider.test.ts

@@ -9,7 +9,6 @@ import {
   type ProviderIdentity,
 } from "../AnalysisProvider.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
-import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { err, ok } from "../../domain/result.js";
 import { CompositeProvider } from "./CompositeProvider.js";
 
@@ -45,15 +44,10 @@ const failingProvider = (
   resource: string,
 ) => {
   const providerIdentity = identity(id);
-  const cleanupError = new ProviderCleanupError(
-    id,
-    [resource],
-    {
-      reason: `${id} cleanup is unresolved`,
-      child_marker: `${id}-detail`,
-    },
-    { remediationAction: `Resolve ${resource} before retrying ${id}.` },
-  );
+  const cleanupError = new ProviderCleanupError(id, [resource], {
+    reason: `${id} cleanup is unresolved`,
+    child_marker: `${id}-detail`,
+  });
   const close = vi.fn(async () => err(cleanupError));
   const provider: AnalysisProvider = {
     identity: () => providerIdentity,
@@ -104,13 +98,6 @@ it("retains every failed child resource across composite cleanup retries", async
       },
     });
     expect(closed.error).toBeInstanceOf(ProviderCleanupError);
-    const projected = projectAnalysisError(closed.error);
-    expect(projected.remediation.action).toContain(
-      "Resolve left-db before retrying provider-left.",
-    );
-    expect(projected.remediation.action).toContain(
-      "Resolve right-db before retrying provider-right.",
-    );
     expect(closed.error.diagnostics).toMatchObject({
       failures: [
         {
@@ -140,97 +127,3 @@ it("preserves one child's typed cleanup error unchanged", async () => {
   if (closed.ok) throw new Error("Expected child cleanup failure");
   expect(closed.error).toBe(child.cleanupError);
 });
-
-it("does not close a child again after its cleanup succeeded", async () => {
-  const firstIdentity = identity("provider-first");
-  const secondIdentity = identity("provider-second");
-  let secondCloseAttempts = 0;
-  const firstClose = vi.fn(async () => ok(null));
-  const secondClose = vi.fn(async () => {
-    secondCloseAttempts += 1;
-    return secondCloseAttempts === 1
-      ? err(new ProviderCleanupError("provider-second", ["second-db"], {}))
-      : ok(null);
-  });
-  const makeProvider = (
-    providerIdentity: ProviderIdentity,
-    operation: Exclude<AnalysisOperation, "health">,
-    close: AnalysisClient["close"],
-  ): AnalysisProvider => ({
-    identity: () => providerIdentity,
-    capabilities: () => [operationCapability(providerIdentity, operation)],
-    createClient: () => ({
-      execute: async () => ok(createAnalysisExecution(null, providerIdentity)),
-      close,
-    }),
-  });
-  const client = new CompositeProvider([
-    makeProvider(firstIdentity, "address_name", firstClose),
-    makeProvider(secondIdentity, "procedure_info", secondClose),
-  ]).createClient(executableTarget);
-  await client.execute("address_name", {});
-  await client.execute("procedure_info", {});
-
-  expect((await client.close({ retainDocument: true })).ok).toBe(false);
-  expect((await client.close()).ok).toBe(true);
-  expect(firstClose).toHaveBeenCalledTimes(1);
-  expect(secondClose).toHaveBeenCalledTimes(2);
-  expect((await client.close({ retainDocument: true })).ok).toBe(true);
-  expect(firstClose).toHaveBeenCalledTimes(1);
-  expect(secondClose).toHaveBeenCalledTimes(2);
-});
-
-it.each(["busy", "unknown", "idle", undefined] as const)(
-  "keeps partial health truthful with child state %s and an unobserved peer",
-  async (state) => {
-    const observedIdentity = identity("provider-observed");
-    const unobservedIdentity = identity("provider-unobserved");
-    const observed: AnalysisProvider = {
-      identity: () => observedIdentity,
-      capabilities: () => [
-        operationCapability(observedIdentity, "address_name"),
-      ],
-      createClient: () => ({
-        execute: async () =>
-          ok(createAnalysisExecution(null, observedIdentity)),
-        operationHealthSnapshot: () =>
-          state === undefined
-            ? undefined
-            : {
-                state,
-                stage: state === "idle" ? null : "analysis",
-                retryAction:
-                  state === "busy"
-                    ? "wait"
-                    : state === "idle"
-                      ? null
-                      : "unknown",
-                exitCode: null,
-                requests: [],
-              },
-        close: async () => ok(null),
-      }),
-    };
-    const unobserved: AnalysisProvider = {
-      identity: () => unobservedIdentity,
-      capabilities: () => [
-        operationCapability(unobservedIdentity, "procedure_info"),
-      ],
-      createClient: () => ({
-        execute: async () =>
-          ok(createAnalysisExecution(null, unobservedIdentity)),
-        close: async () => ok(null),
-      }),
-    };
-    const client = new CompositeProvider([observed, unobserved]).createClient(
-      executableTarget,
-    );
-    await client.execute("address_name", {});
-    await client.execute("procedure_info", {});
-
-    if (state === "idle" || state === undefined)
-      expect(client.operationHealthSnapshot?.()).toBeUndefined();
-    else expect(client.operationHealthSnapshot?.()).toMatchObject({ state });
-    expect((await client.close()).ok).toBe(true);
-  },
-);

src/application/binary/CompositeProvider.ts

@@ -1,7 +1,6 @@
 import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
-import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { err, ok } from "../../domain/result.js";
 import type { BinaryTarget } from "../../domain/binaryTargetTypes.js";
 import type { AnalysisProfileCommitment } from "../../domain/analysisProfile.js";
@@ -28,20 +27,18 @@ const compositeProviderIdentity = (
   version: null,
 });
 
-const closeCompositeClients = (
-  identity: ProviderIdentity,
-  clients: ReadonlyMap<AnalysisProvider, AnalysisClient>,
-): AnalysisClient["close"] => {
-  const completed = new Set<AnalysisClient>();
-  return async (options) => {
+const closeCompositeClients =
+  (
+    identity: ProviderIdentity,
+    clients: ReadonlyMap<AnalysisProvider, AnalysisClient>,
+  ): AnalysisClient["close"] =>
+  async (options) => {
     const outcomes = await Promise.all(
-      [...clients.entries()].map(async ([provider, client]) => {
-        const providerId = provider.identity().id;
-        if (completed.has(client)) return { providerId, result: ok(null) };
-        const result = await closeAnalysisClient(client, providerId, options);
-        if (result.ok) completed.add(client);
-        return { providerId, result };
-      }),
+      [...clients.entries()].map(([provider, client]) =>
+        closeAnalysisClient(client, provider.identity().id, options).then(
+          (result) => ({ providerId: provider.identity().id, result }),
+        ),
+      ),
     );
     const failures = outcomes.flatMap(({ providerId, result }) =>
       result.ok ? [] : [{ providerId, error: result.error }],
@@ -71,13 +68,6 @@ const closeCompositeClients = (
           })),
         },
         {
-          remediationAction: [
-            ...new Set(
-              failures.map(
-                ({ error }) => projectAnalysisError(error).remediation.action,
-              ),
-            ),
-          ].join("\n"),
           cause: new AggregateError(
             failures.map(({ error }) => error),
             "Composed provider cleanup failed.",
@@ -86,7 +76,6 @@ const closeCompositeClients = (
       ),
     );
   };
-};
 
 const executeCompositeHealth = async (
   identity: ProviderIdentity,
@@ -224,21 +213,13 @@ export class CompositeProvider implements AnalysisProvider {
         const snapshots = [...clients.values()].map((client) =>
           client.operationHealthSnapshot?.(),
         );
-        const failed = snapshots.find(
-          (snapshot) =>
-            snapshot !== undefined &&
-            (snapshot.state === "exited" ||
-              snapshot.state === "unreachable" ||
-              snapshot.state === "not_started"),
-        );
-        if (failed !== undefined) return failed;
-        const nonIdle = snapshots.find(
-          (snapshot) => snapshot !== undefined && snapshot.state !== "idle",
-        );
-        if (nonIdle !== undefined) return nonIdle;
         if (snapshots.some((snapshot) => snapshot === undefined))
           return undefined;
-        return snapshots[0];
+        return (
+          snapshots.find(
+            (snapshot) => snapshot !== undefined && snapshot.state !== "idle",
+          ) ?? snapshots[0]
+        );
       },
       close,
     };

src/artifacts/ZipArtifactReader.ts

@@ -127,13 +127,6 @@ class NodeFileReader extends Reader<string> {
     const handle = this.#handle;
     if (handle === undefined) throw new Error("ZIP reader is not initialized");
     const readBytes = Math.min(length, this.size - index);
-    // A central-directory offset can point past EOF. Type that malformed ZIP
-    // read before a negative size reaches Buffer.alloc and becomes an I/O error.
-    if (readBytes < 0)
-      throw new ArtifactReaderFailure(
-        "format",
-        `ZIP archive is malformed: read at ${index} extends beyond the ${this.size}-byte archive`,
-      );
     if (
       this.maximumReadBytes !== undefined &&
       readBytes > this.maximumReadBytes
@@ -198,7 +191,6 @@ export class ZipArtifactReader implements ArtifactReader {
       // ZIP member identity is its directory occurrence, not its filename.
       // Logical path uniqueness belongs to the artifact inventory boundary.
       const metadata = projectZipEntry(entry, index++);
-      if (metadata === undefined) continue;
       // zip.js enforces each member's declared output size, so this sum bounds streamed work.
       if (
         metadata.kind === "file" &&
@@ -266,38 +258,19 @@ export class ZipArtifactReader implements ArtifactReader {
   }
 }
 
-const projectZipEntry = (
-  entry: Entry,
-  index: number,
-): ArtifactEntry | undefined => {
-  const kind = isSymlink(entry)
-    ? "symlink"
-    : entry.directory
-      ? "directory"
-      : "file";
-  const sourcePath = zipEntryPath(entry);
-  const path = sourcePath.replace(/^(?:\.\/)+/u, "");
-  // Root directory markers carry no inventory occurrence. A file with this
-  // spelling is still passed to the shared path validator and rejected there.
-  if (kind === "directory" && (path === "" || path === ".")) return undefined;
+const projectZipEntry = (entry: Entry, index: number): ArtifactEntry => {
+  const symlink = isSymlink(entry);
   return {
-    path,
-    kind,
-    declaredSize: kind === "directory" ? null : entry.uncompressedSize,
-    compressedSize: kind === "directory" ? null : entry.compressedSize,
+    path: zipEntryPath(entry),
+    kind: entry.directory ? "directory" : symlink ? "symlink" : "file",
+    declaredSize: entry.directory ? null : entry.uncompressedSize,
+    compressedSize: entry.directory ? null : entry.compressedSize,
     executable: entry.executable,
     encrypted: entry.encrypted,
     byteOffset: null,
     declaredSha256: null,
     unpacked: false,
-    limitations: [
-      ...(kind === "symlink" ? ["Archive symlink target was not read."] : []),
-      ...(path === sourcePath
-        ? []
-        : [
-            `ZIP member name ${JSON.stringify(sourcePath)} has a leading current-directory prefix omitted from its logical path.`,
-          ]),
-    ],
+    limitations: symlink ? ["Archive symlink target was not read."] : [],
     adapterKey: `zip-entry:${index}`,
   };
 };

src/browser/BrowserScenarioPartialObservation.ts

@@ -57,7 +57,6 @@ const browserScenarioLimitations = (
       ? [
           "CDP attachment cannot recover pre-attach events or guarantee launch-time context options.",
           `Attached locale ${scenario.environment.locale} applies to Intl formatting only; navigator.language(s) and Accept-Language remain caller-controlled. Use launch mode for matching page and request languages.`,
-          "Detaching a CDP page session may clear caller-owned navigator.platform emulation. REA cannot snapshot the caller's complete user-agent/client-hint state before attachment; use launch mode to avoid mutating that external browser.",
         ]
       : []),
   ];

src/browser/PlaywrightBrowserScenarioProvider.test.ts

@@ -78,10 +78,6 @@ const scenario = (
     },
   });
 
-const connectedPlatformEmulationLimitation = expect.stringContaining(
-  "Detaching a CDP page session may clear caller-owned navigator.platform emulation",
-);
-
 type SnapshotKind = BrowserScenario["capture"]["after_each_step"][number];
 
 interface FakeSessionFailures {
@@ -359,9 +355,7 @@ describe("PlaywrightBrowserScenarioProvider", () => {
     expect(session.closeCalls).toBe(1);
     expect(result.value.completeness.equality_eligible).toBe(false);
   });
-});
 
-describe("connected browser scenario captures", () => {
   it("disconnects external CDP sessions and marks pre-attach events missing", async () => {
     const session = new FakeSession("connect");
     const provider = new PlaywrightBrowserScenarioProvider(() =>
@@ -380,37 +374,8 @@ describe("connected browser scenario captures", () => {
       equality_eligible: false,
       missing_sections: ["events"],
     });
-    expect(result.value.limitations).toEqual(
-      expect.arrayContaining([connectedPlatformEmulationLimitation]),
-    );
     expect(session.closeCalls).toBe(1);
   });
-
-  it("retains the attached platform-emulation limitation in partial observations", async () => {
-    const session = new FakeSession("connect", {
-      capture: { call: 1, error: new Error("fixture capture failure") },
-    });
-    const provider = new PlaywrightBrowserScenarioProvider(() =>
-      Promise.resolve(session),
-    );
-    const result = await provider.captureScenario(
-      scenario({ mode: "connect" }),
-    );
-
-    expect(result.ok).toBe(false);
-    if (result.ok) return;
-    expect(projectAnalysisError(result.error)).toMatchObject({
-      details: {
-        partial_observation: {
-          capture: {
-            limitations: expect.arrayContaining([
-              connectedPlatformEmulationLimitation,
-            ]),
-          },
-        },
-      },
-    });
-  });
 });
 
 describe("PlaywrightBrowserScenarioProvider timing", () => {

src/browser/WebSourceMapFetcher.ts

@@ -14,7 +14,6 @@ import { parseJavaScriptSource } from "../domain/javascript/javascriptSourcePars
 import {
   isTypeOnlyExportDeclaration,
   isTypeOnlyImportDeclaration,
-  semanticImportEqualsSpecifier,
 } from "../domain/javascript/javascriptModuleDeclaration.js";
 import { stringValue } from "../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import type {
@@ -1101,11 +1100,16 @@ const originalDependency = (
       : { kind: "require", specifier, requireCallee: node.callee };
   }
   // `import x = require("m")` is only legal at module top level and always
-  // refers to the host loader, so it needs no unbound-`require` check. An
-  // entity-name alias or an erased `import type` declares no dependency.
-  if (t.isTSImportEqualsDeclaration(node)) {
-    const specifier = semanticImportEqualsSpecifier(node);
-    return specifier === null ? null : { kind: "require", specifier };
-  }
+  // refers to the host loader, so it needs no unbound-`require` check. The
+  // `moduleReference` is an entity name for a local alias instead, which
+  // declares no dependency.
+  if (
+    t.isTSImportEqualsDeclaration(node) &&
+    t.isTSExternalModuleReference(node.moduleReference)
+  )
+    return {
+      kind: "require",
+      specifier: node.moduleReference.expression.value,
+    };
   return null;
 };

src/cli/adbCommands.ts

@@ -1,15 +1,16 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { AdbDeviceAnalysisService } from "../application/adb/AdbDeviceAnalysisService.js";
 import type { AdbDeviceAnalysisPort } from "../application/adb/AdbDeviceAnalysisPort.js";
 import { createAdbDeviceAnalysisProvider } from "../composition/adb.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { AdbOperation } from "../domain/adb/adbDeviceAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit ADB requests through one-shot CLI commands. */
 export const registerAdbCommands = (
@@ -23,14 +24,17 @@ export const registerAdbCommands = (
   const service = new AdbDeviceAnalysisService(provider);
   const execute = (name: string, operation: AdbOperation, input: unknown) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          { close: () => provider.close() },
-          "adb",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+          await provider.close();
+        } catch (cause) {
+          if (cause instanceof AnalysisError)
+            return projectAnalysisError(cause);
+          throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+      }),
     );
 
   const serial = z

src/cli/androidCommands.ts

@@ -1,13 +1,14 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
 import { createAndroidAnalysisProvider } from "../composition/android.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { AndroidOperation } from "../domain/android/androidAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit APK requests through one-shot CLI commands. */
 export const registerAndroidCommands = (
@@ -19,14 +20,17 @@ export const registerAndroidCommands = (
   const service = new AndroidAnalysisService(provider);
   const execute = (name: string, operation: AndroidOperation, input: unknown) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          { close: () => provider.close() },
-          "jadx",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+          await provider.close();
+        } catch (cause) {
+          if (cause instanceof AnalysisError)
+            return projectAnalysisError(cause);
+          throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+      }),
     );
   const path = z.string().describe("Local standalone APK path");
   const className = z.string().describe("Exact fully qualified class name");

src/cli/apktoolCommands.ts

@@ -1,9 +1,11 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { ApktoolResourceAnalysisService } from "../application/apktool/ApktoolResourceAnalysisService.js";
 import type { ApktoolResourceAnalysisPort } from "../application/apktool/ApktoolResourceAnalysisPort.js";
 import { createApktoolResourceAnalysisProvider } from "../composition/apktool.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import {
   apktoolInputSchemas,
   type ApktoolOperation,
@@ -11,7 +13,6 @@ import {
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit Apktool requests through one-shot CLI commands. */
 export const registerApktoolCommands = (
@@ -25,14 +26,17 @@ export const registerApktoolCommands = (
   const service = new ApktoolResourceAnalysisService(provider);
   const execute = (name: string, operation: ApktoolOperation, input: unknown) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          { close: () => provider.close() },
-          "apktool",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+          await provider.close();
+        } catch (cause) {
+          if (cause instanceof AnalysisError)
+            return projectAnalysisError(cause);
+          throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+      }),
     );
 
   cli.command(CLI_COMMANDS.inspectApktoolClient, {

src/cli/cutterCommands.ts

@@ -8,7 +8,6 @@ import { logCliCommand } from "../cliLogging.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import type { CliInstance } from "./types.js";
-import { cliIntegerArgument } from "./options.js";
 
 /** Register commands that control an already-running Cutter instance. */
 export const registerCutterCommands = (
@@ -34,9 +33,11 @@ export const registerCutterCommands = (
         .string()
         .uuid()
         .describe("Session ID copied from list-cutter-sessions."),
-      expectedGeneration: cliIntegerArgument(0).describe(
-        "Session generation returned by list-cutter-sessions.",
-      ),
+      expectedGeneration: z.coerce
+        .number()
+        .int()
+        .nonnegative()
+        .describe("Session generation returned by list-cutter-sessions."),
       command: z
         .string()
         .min(1)

src/cli/evmCommands.ts

@@ -1,11 +1,11 @@
 import { z } from "incur";
 import { evmInterfaceModule } from "../composition/evm.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { absoluteCallerPath } from "../filesystem/callerPath.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Resolve operator paths and preserve explicit encoding through the shared workflow. */
 export const registerEvmCommands = (
@@ -23,22 +23,27 @@ export const registerEvmCommands = (
         .describe("Selected carrier representation"),
     }),
     run: ({ args }) =>
-      withCommandCancellation((signal) =>
-        logCliCommand(logger, evmInterfaceModule.cliCommand, () =>
-          finishAnalysisCommand(
-            () =>
-              service.inspect(
+      withCommandCancellation(async (signal) => {
+        try {
+          return await logCliCommand(
+            logger,
+            evmInterfaceModule.cliCommand,
+            async () => {
+              const result = await service.inspect(
                 {
                   path: absoluteCallerPath(args.path),
                   encoding: args.encoding,
                 },
                 { signal },
-              ),
-            service,
-            "evmole-interface",
-            "inspect_evm_interface",
-          ),
-        ),
-      ),
+              );
+              return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+            },
+          );
+        } finally {
+          await service.close();
+        }
+      }),
   });
 };

src/cli/firmwareCommands.ts

@@ -5,12 +5,12 @@ import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { firmwareInputSchemas } from "../domain/firmware/firmwareAnalysis.js";
 import { localPathStringSchema } from "../domain/localPath.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { FirmwareOperation } from "../domain/firmware/firmwareAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { absoluteCallerPath } from "../filesystem/callerPath.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** One-shot firmware CLI commands backed by the same workflows as MCP. */
 export const registerFirmwareCommands = (
@@ -29,14 +29,14 @@ export const registerFirmwareCommands = (
     input: unknown,
   ) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          service,
-          operation === "inspect_firmware_regions" ? "binwalk" : "unblob",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        try {
+          const result = await service.execute(operation, input, { signal });
+          return result.ok ? result.value : projectAnalysisError(result.error);
+        } finally {
+          await service.close();
+        }
+      }),
     );
   const path = localPathStringSchema.describe(
     "Local firmware path; never executed",

src/cli/flutterCommands.ts

@@ -1,14 +1,15 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { FlutterBuildAnalysisService } from "../application/flutter/FlutterBuildAnalysisService.js";
 import type { FlutterBuildAnalysisPort } from "../application/flutter/FlutterBuildAnalysisPort.js";
 import { createFlutterBuildAnalysisProvider } from "../composition/flutter.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { FlutterOperation } from "../domain/flutter/flutterBuildAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** One flutter command: CLI shape and the request it produces. */
 interface FlutterCommandSpec {
@@ -73,19 +74,23 @@ export const registerFlutterCommands = (
         : { args: spec.argumentSchema, options: spec.optionSchema }),
       run: ({ args, options }) =>
         withCommandCancellation((signal) =>
-          logCliCommand(logger, spec.command, () =>
-            finishAnalysisCommand(
-              () =>
-                new FlutterBuildAnalysisService(provider).execute(
-                  spec.operation,
-                  spec.toInput(args, options ?? {}),
-                  { signal },
-                ),
-              { close: () => provider.close() },
-              "flutter",
-              spec.operation,
-            ),
-          ),
+          logCliCommand(logger, spec.command, async () => {
+            const settled = await new FlutterBuildAnalysisService(
+              provider,
+            ).execute(spec.operation, spec.toInput(args, options ?? {}), {
+              signal,
+            });
+            try {
+              await provider.close();
+            } catch (cause) {
+              if (cause instanceof AnalysisError)
+                return projectAnalysisError(cause);
+              throw cause;
+            }
+            return settled.ok
+              ? settled.value
+              : projectAnalysisError(settled.error);
+          }),
         ),
     });
   }

src/cli/javascriptRecoveryCommands.ts

@@ -3,10 +3,10 @@ import { JavaScriptRecoveryService } from "../application/javascript/JavaScriptR
 import { createJavaScriptRecoveryProvider } from "../composition/javascriptRecovery.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Share source recovery with MCP while keeping CLI spelling at this boundary. */
 export const registerJavaScriptRecoveryCommands = (
@@ -47,11 +47,13 @@ export const registerJavaScriptRecoveryCommands = (
         ),
     }),
     run: ({ args, options }) =>
-      withCommandCancellation((signal) =>
-        logCliCommand(logger, CLI_COMMANDS.recoverJavaScriptSources, () =>
-          finishAnalysisCommand(
-            () =>
-              service.recover(
+      withCommandCancellation(async (signal) => {
+        try {
+          return await logCliCommand(
+            logger,
+            CLI_COMMANDS.recoverJavaScriptSources,
+            async () => {
+              const result = await service.recover(
                 {
                   path: args.path,
                   output_directory: args.outputDirectory,
@@ -66,12 +68,15 @@ export const registerJavaScriptRecoveryCommands = (
                     : { rewrite_level: options.rewriteLevel }),
                 },
                 { signal },
-              ),
-            service,
-            "wakaru",
-            "recover_javascript_sources",
-          ),
-        ),
-      ),
+              );
+              return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+            },
+          );
+        } finally {
+          await service.close();
+        }
+      }),
   });
 };

src/cli/jebCommands.ts

@@ -1,14 +1,15 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { JebAnalysisService } from "../application/jeb/JebAnalysisService.js";
 import type { JebAnalysisPort } from "../application/jeb/JebAnalysisPort.js";
 import { createJebAnalysisProvider } from "../composition/jeb.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { JebOperation } from "../domain/jeb/jebAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit JEB requests through one-shot CLI commands. */
 export const registerJebCommands = (
@@ -20,14 +21,17 @@ export const registerJebCommands = (
   const service = new JebAnalysisService(provider);
   const execute = (name: string, operation: JebOperation, input: unknown) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          { close: () => provider.close() },
-          "jeb",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+          await provider.close();
+        } catch (cause) {
+          if (cause instanceof AnalysisError)
+            return projectAnalysisError(cause);
+          throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+      }),
     );
 
   cli.command(CLI_COMMANDS.inspectJebClient, {

src/cli/options.ts

@@ -1,5 +1,3 @@
-import { z } from "incur";
-
 import {
   executableFormatHintSchema,
   type ExecutableFormatHint,
@@ -13,13 +11,6 @@ import { analysisProviderSelectorSchema } from "../contracts/providerSelection.j
 import type { AnalysisProviderSelector } from "../contracts/providerSelection.js";
 import type { Logger } from "pino";
 
-/** Parse decimal integer tokens before Number coercion can erase their syntax. */
-export const cliIntegerArgument = (min: number) =>
-  z
-    .string()
-    .regex(/^[0-9]+$/u, "Expected a decimal integer")
-    .pipe(z.coerce.number<string>().safe().min(min));
-
 export const providerSelectionOption = analysisProviderSelectorSchema
   .optional()
   .describe(

src/cli/pcapCommands.ts

@@ -1,14 +1,16 @@
 import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { PcapAnalysisService } from "../application/pcap/PcapAnalysisService.js";
 import type { PcapAnalysisPort } from "../application/pcap/PcapAnalysisPort.js";
 import { createPcapAnalysisProvider } from "../composition/pcap.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { PcapOperation } from "../domain/pcap/pcapAnalysis.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit pcap requests through one-shot CLI commands. */
 export const registerPcapCommands = (
@@ -20,14 +22,27 @@ export const registerPcapCommands = (
   const service = new PcapAnalysisService(provider);
   const execute = (name: string, operation: PcapOperation, input: unknown) =>
     withCommandCancellation((signal) =>
-      logCliCommand(logger, name, () =>
-        finishAnalysisCommand(
-          () => service.execute(operation, input, { signal }),
-          { close: () => provider.close() },
-          "pcap",
-          operation,
-        ),
-      ),
+      logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+          await provider.close();
+        } catch (cause) {
+          if (cause instanceof AnalysisError) {
+            if (result.ok) cause.retainPartialObservation(result.value);
+            return projectAnalysisError(
+              result.ok
+                ? cause
+                : analysisErrorWithCleanupFailure(
+                    result.error,
+                    cause,
+                    operation,
+                  ),
+            );
+          }
+          throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+      }),
     );
 
   cli.command(CLI_COMMANDS.inspectPcapClient, {

src/cli/sqliteCommands.ts

@@ -2,11 +2,13 @@ import { z } from "incur";
 import { createSqliteDatabaseService } from "../composition/sqlite.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { absoluteCallerPath } from "../filesystem/callerPath.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Resolve an operator-selected SQLite snapshot through the shared inspection workflow. */
 export const registerSqliteCommands = (
@@ -49,32 +51,61 @@ export const registerSqliteCommands = (
     }),
     run: ({ args, options }) =>
       withCommandCancellation((signal) =>
-        logCliCommand(logger, CLI_COMMANDS.inspectSqliteDatabase, () =>
-          finishAnalysisCommand(
-            () =>
-              service.inspect(
-                {
-                  path: absoluteCallerPath(args.path),
-                  ...(options.table === undefined
-                    ? {}
-                    : { table: options.table }),
-                  ...(options.rowLimit === undefined
-                    ? {}
-                    : { row_limit: options.rowLimit }),
-                  ...(options.column === undefined
-                    ? {}
-                    : { columns: options.column }),
-                  ...(options.schemaScope === undefined
-                    ? {}
-                    : { schema_scope: options.schemaScope }),
-                },
-                { signal },
-              ),
-            service,
-            "sqlite",
-            "inspect_sqlite_database",
-          ),
-        ),
+        logCliCommand(logger, CLI_COMMANDS.inspectSqliteDatabase, async () => {
+          const inspection = await service
+            .inspect(
+              {
+                path: absoluteCallerPath(args.path),
+                ...(options.table === undefined
+                  ? {}
+                  : { table: options.table }),
+                ...(options.rowLimit === undefined
+                  ? {}
+                  : { row_limit: options.rowLimit }),
+                ...(options.column === undefined
+                  ? {}
+                  : { columns: options.column }),
+                ...(options.schemaScope === undefined
+                  ? {}
+                  : { schema_scope: options.schemaScope }),
+              },
+              { signal },
+            )
+            .then(
+              (result) => ({ result }),
+              (cause: unknown) => ({ cause }),
+            );
+          try {
+            await service.close();
+          } catch (cause: unknown) {
+            const primary =
+              "cause" in inspection
+                ? inspection.cause
+                : inspection.result.ok
+                  ? undefined
+                  : inspection.result.error;
+            if (
+              primary instanceof AnalysisError &&
+              cause instanceof AnalysisError
+            )
+              throw analysisErrorWithCleanupFailure(
+                primary,
+                cause,
+                "inspect_sqlite_database",
+              );
+            if ("cause" in inspection)
+              throw new AggregateError(
+                [inspection.cause, cause],
+                "SQLite inspection and provider cleanup both failed",
+                { cause: inspection.cause },
+              );
+            throw cause;
+          }
+          if ("cause" in inspection) throw inspection.cause;
+          return inspection.result.ok
+            ? inspection.result.value
+            : projectAnalysisError(inspection.result.error);
+        }),
       ),
   });
 };

src/cli/wasmCommands.ts

@@ -9,7 +9,6 @@ import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { absoluteCallerPath } from "../filesystem/callerPath.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Resolve all caller-selected artifact paths through the shared workflow. */
 export const registerWasmCommands = (
@@ -57,11 +56,13 @@ export const registerWasmCommands = (
         .describe("Explicit local WASM candidates"),
     }),
     run: ({ args, options }) =>
-      withCommandCancellation((signal) =>
-        logCliCommand(logger, wasmArtifactModule.cliCommand, () =>
-          finishAnalysisCommand(
-            () =>
-              service.inspect(
+      withCommandCancellation(async (signal) => {
+        try {
+          return await logCliCommand(
+            logger,
+            wasmArtifactModule.cliCommand,
+            async () => {
+              const result = await service.inspect(
                 {
                   path: absoluteCallerPath(args.path),
                   glue_paths: options.glue_paths?.map((path) =>
@@ -72,12 +73,15 @@ export const registerWasmCommands = (
                   ),
                 },
                 { signal },
-              ),
-            service,
-            "wabt-artifact",
-            "inspect_wasm_artifact",
-          ),
-        ),
-      ),
+              );
+              return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+            },
+          );
+        } finally {
+          await service.close();
+        }
+      }),
   });
 };

src/cli/webModuleCommands.ts

@@ -2,12 +2,11 @@ import { z } from "incur";
 import { createWebModuleTraceService } from "../composition/webModules.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { webModuleTraceInputSchema } from "../domain/webModuleTrace.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
-import { cliIntegerArgument } from "./options.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 const importMapInputSchema =
   webModuleTraceInputSchema.shape.import_map.unwrap();
@@ -24,9 +23,11 @@ export const registerWebModuleCommands = (
       "Trace one captured script's native imports to URLs and captured source candidates",
     args: z.object({
       manifestPath: webModuleTraceInputSchema.shape.manifest_path,
-      scriptIndex: cliIntegerArgument(0).describe(
-        "Zero-based manifest script index",
-      ),
+      scriptIndex: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .describe("Zero-based manifest script index"),
     }),
     options: z.object({
       importerUrl: webModuleTraceInputSchema.shape.importer_url,
@@ -40,11 +41,13 @@ export const registerWebModuleCommands = (
         .describe("HTTP(S) import-map base URL; requires --import-map-path"),
     }),
     run: ({ args, options }) =>
-      withCommandCancellation((signal) =>
-        logCliCommand(logger, CLI_COMMANDS.traceWebModuleImports, () =>
-          finishAnalysisCommand(
-            () =>
-              service.trace(
+      withCommandCancellation(async (signal) => {
+        try {
+          return await logCliCommand(
+            logger,
+            CLI_COMMANDS.traceWebModuleImports,
+            async () => {
+              const result = await service.trace(
                 {
                   manifest_path: args.manifestPath,
                   script_index: args.scriptIndex,
@@ -62,12 +65,15 @@ export const registerWebModuleCommands = (
                       }),
                 },
                 { signal },
-              ),
-            service,
-            "web-module-trace",
-            "trace_web_module_imports",
-          ),
-        ),
-      ),
+              );
+              return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+            },
+          );
+        } finally {
+          await service.close();
+        }
+      }),
   });
 };

src/cli/webNetworkCaptureCommands.ts

@@ -5,7 +5,6 @@ import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
-import { cliIntegerArgument } from "./options.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
@@ -27,7 +26,7 @@ export const registerWebNetworkCaptureCommands = (
     }),
     options: z.object({
       record: z
-        .array(cliIntegerArgument(0))
+        .array(z.coerce.number().int().nonnegative())
         .optional()
         .describe("Zero-based producer ordinals; repeat to select several"),
       sensitiveValue: z

src/cli/webSourceLocationCommands.ts

@@ -2,11 +2,10 @@ import { z } from "incur";
 import { createWebSourceLocationService } from "../composition/webSourceLocations.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import type { Logger } from "pino";
 import type { CliInstance } from "./types.js";
-import { cliIntegerArgument } from "./options.js";
 import { withCommandCancellation } from "./commandCancellation.js";
-import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 
 /** Expose the same explicit selected map/point contract through the CLI. */
 export const registerWebSourceLocationCommands = (
@@ -22,24 +21,30 @@ export const registerWebSourceLocationCommands = (
       manifestPath: z
         .string()
         .describe("Absolute export_web_scripts manifest path"),
-      scriptIndex: cliIntegerArgument(0).describe(
-        "Zero-based manifest script index",
-      ),
+      scriptIndex: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .describe("Zero-based manifest script index"),
       sourceMapPath: z.string().describe("Absolute local source-map path"),
       sourceMapUrl: z
         .string()
         .describe("Absolute source-map URL context; no fetch"),
-      line: cliIntegerArgument(1).describe("One-based generated line"),
-      column: cliIntegerArgument(0).describe(
-        "Zero-based UTF-16 generated column",
-      ),
+      line: z.coerce.number().int().min(1).describe("One-based generated line"),
+      column: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .describe("Zero-based UTF-16 generated column"),
     }),
     run: ({ args }) =>
-      withCommandCancellation((signal) =>
-        logCliCommand(logger, CLI_COMMANDS.traceWebSourceLocation, () =>
-          finishAnalysisCommand(
-            () =>
-              service.trace(
+      withCommandCancellation(async (signal) => {
+        try {
+          return await logCliCommand(
+            logger,
+            CLI_COMMANDS.traceWebSourceLocation,
+            async () => {
+              const result = await service.trace(
                 {
                   manifest_path: args.manifestPath,
                   script_index: args.scriptIndex,
@@ -50,12 +55,15 @@ export const registerWebSourceLocationCommands = (
                   generated_position: { line: args.line, column: args.column },
                 },
                 { signal },
-              ),
-            service,
-            "web-source-location",
-            "trace_web_source_location",
-          ),
-        ),
-      ),
+              );
+              return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+            },
+          );
+        } finally {
+          await service.close();
+        }
+      }),
   });
 };

src/config/parseConfig.ts

@@ -43,12 +43,7 @@ export const defaultHopperLauncherPath = (
 export const parseConfig = (
   environment: Readonly<Record<string, string | undefined>>,
 ): Result<AppConfig, ConfigurationError> => {
-  // JEB validates its own timeout during optional provider composition. It is
-  // not an AppConfig setting and must not prevent unrelated CLI/MCP startup.
-  // Registration validation still checks the complete environment directly.
-  const { REA_JEB_MCP_TIMEOUT_MS: _jebTimeout, ...appEnvironment } =
-    environment;
-  const parsed = parseEnvironment(appEnvironment);
+  const parsed = parseEnvironment(environment);
   if (!parsed.ok) return parsed;
   const env = parsed.value;
   return ok({

src/contracts/inputSchemaPresentation.ts

@@ -146,195 +146,6 @@ const inputGroup = (branch: Readonly<Record<string, unknown>>): string => {
   return [...required, ...optional].join(" + ");
 };
 
-type SchemaNormalization = {
-  readonly schema: unknown;
-  readonly changed: boolean;
-};
-
-const isBooleanLiteralSchema = (schema: unknown): boolean =>
-  isObject(schema) &&
-  (typeof schema.const === "boolean" ||
-    (Array.isArray(schema.enum) &&
-      schema.enum.length > 0 &&
-      schema.enum.every((value) => typeof value === "boolean")));
-
-const isBooleanSchema = (schema: unknown): boolean =>
-  isObject(schema) &&
-  (schema.type === "boolean" || isBooleanLiteralSchema(schema));
-
-const preserveSharedDefault = (
-  schema: Record<string, unknown>,
-  branches: readonly unknown[],
-): void => {
-  if (schema.default !== undefined) return;
-  const defaults = branches
-    .filter(isObject)
-    .map((branch) => branch.default)
-    .filter((value) => value !== undefined);
-  if (
-    defaults.length > 0 &&
-    defaults.every((value) => isDeepStrictEqual(value, defaults[0]))
-  )
-    schema.default = defaults[0];
-};
-
-const normalizeAdvertisedSchema = (value: unknown): SchemaNormalization => {
-  if (!isObject(value)) return { schema: value, changed: false };
-
-  const node: Record<string, unknown> = { ...value };
-  let changed = false;
-  const normalizeMap = (map: Readonly<Record<string, unknown>>) =>
-    Object.fromEntries(
-      Object.entries(map).map(([name, child]) => {
-        const result = normalizeAdvertisedSchema(child);
-        changed ||= result.changed;
-        return [name, result.schema];
-      }),
-    );
-  const normalizeList = (list: readonly unknown[]) =>
-    list.map((child) => {
-      const result = normalizeAdvertisedSchema(child);
-      changed ||= result.changed;
-      return result;
-    });
-
-  for (const [key, child] of Object.entries(value)) {
-    if (schemaMaps.has(key) && isObject(child)) {
-      node[key] = normalizeMap(child);
-    } else if (
-      schemaArrays.has(key) &&
-      key !== "anyOf" &&
-      key !== "oneOf" &&
-      Array.isArray(child)
-    ) {
-      node[key] = normalizeList(child).map((result) => result.schema);
-    } else if (
-      schemaChildren.has(key) &&
-      key !== "not" &&
-      key !== "if" &&
-      key !== "then" &&
-      key !== "else"
-    ) {
-      const results = Array.isArray(child)
-        ? normalizeList(child)
-        : [normalizeAdvertisedSchema(child)];
-      const nestedChanged = results.some((result) => result.changed);
-      if (
-        key === "contains" &&
-        nestedChanged &&
-        value.maxContains !== undefined
-      ) {
-        delete node.contains;
-        delete node.minContains;
-        delete node.maxContains;
-        changed = true;
-      } else {
-        node[key] = Array.isArray(child)
-          ? results.map((result) => result.schema)
-          : results[0]?.schema;
-        changed ||= nestedChanged;
-      }
-    }
-  }
-
-  if (typeof node.const === "boolean") {
-    delete node.const;
-    if (node.type === undefined) node.type = "boolean";
-    changed = true;
-  }
-  if (
-    Array.isArray(node.enum) &&
-    node.enum.length > 0 &&
-    node.enum.every((item) => typeof item === "boolean")
-  ) {
-    delete node.enum;
-    if (node.type === undefined) node.type = "boolean";
-    changed = true;
-  }
-
-  const negated = Object.hasOwn(value, "not")
-    ? normalizeAdvertisedSchema(value.not)
-    : undefined;
-  if (negated?.changed) {
-    // Widening a predicate under `not` narrows the containing schema.
-    changed = true;
-    delete node.not;
-  } else if (negated !== undefined) {
-    node.not = negated.schema;
-  }
-
-  const conditional = Object.hasOwn(value, "if")
-    ? normalizeAdvertisedSchema(value.if)
-    : undefined;
-  const thenBranch = Object.hasOwn(value, "then")
-    ? normalizeAdvertisedSchema(value.then)
-    : undefined;
-  const elseBranch = Object.hasOwn(value, "else")
-    ? normalizeAdvertisedSchema(value.else)
-    : undefined;
-  if (conditional?.changed) {
-    // Changing the predicate can route canonical-valid inputs into a rejecting branch.
-    changed = true;
-    delete node.if;
-    delete node.then;
-    delete node.else;
-  } else {
-    if (conditional !== undefined) node.if = conditional.schema;
-    if (thenBranch !== undefined) {
-      node.then = thenBranch.schema;
-      changed ||= thenBranch.changed;
-    }
-    if (elseBranch !== undefined) {
-      node.else = elseBranch.schema;
-      changed ||= elseBranch.changed;
-    }
-  }
-
-  for (const combinator of ["anyOf", "oneOf"] as const) {
-    const branches = value[combinator];
-    if (!Array.isArray(branches)) continue;
-    const normalized = normalizeList(branches);
-    const schemas = normalized.map((result) => result.schema);
-    const branchesChanged = normalized.some((result) => result.changed);
-    if (combinator === "oneOf" && branchesChanged) {
-      const booleanLiteralsOnly = branches.every(isBooleanLiteralSchema);
-      if (booleanLiteralsOnly) {
-        node.type = "boolean";
-        preserveSharedDefault(node, schemas);
-        delete node.oneOf;
-        changed = true;
-        continue;
-      }
-      // `anyOf` retains branch guidance without allowing widened branches to
-      // reject inputs that were accepted by exactly one canonical branch.
-      delete node.oneOf;
-      if (Array.isArray(node.anyOf)) {
-        const existingAllOf = Array.isArray(node.allOf) ? node.allOf : [];
-        node.allOf = [...existingAllOf, { anyOf: schemas }];
-      } else {
-        node.anyOf = schemas;
-      }
-      changed = true;
-      continue;
-    }
-    if (
-      branchesChanged &&
-      schemas.length > 0 &&
-      schemas.every(isBooleanSchema)
-    ) {
-      node.type = "boolean";
-      preserveSharedDefault(node, schemas);
-      delete node[combinator];
-      changed = true;
-      continue;
-    }
-    node[combinator] = schemas;
-    changed ||= branchesChanged;
-  }
-
-  return { schema: node, changed };
-};
-
 // Anthropic tool input schemas reject anyOf, oneOf, and allOf at the root, and
 // clients then drop the tool or advertise it without parameters. Present a
 // root union of strict object groups as one object whose properties are the
@@ -404,11 +215,7 @@ export const presentInputJsonSchema = (
 ): Record<string, unknown> => {
   const flattened = flattenRootObjectUnion(root);
   const described = describeSchema(flattened, flattened, describeProperty);
-  if (!isObject(described))
-    return normalizeAdvertisedSchema(flattened).schema as Record<
-      string,
-      unknown
-    >;
+  if (!isObject(described)) return flattened;
   const {
     dependencies: _dependencies,
     dependentRequired: _dependentRequired,
@@ -430,19 +237,85 @@ export const presentInputJsonSchema = (
               ]
             : [],
         );
-  if (dependencyGuidance.length === 0)
-    return normalizeAdvertisedSchema(presentation).schema as Record<
-      string,
-      unknown
-    >;
+  if (dependencyGuidance.length === 0) return presentation;
   const description = [
     typeof presentation.description === "string"
       ? presentation.description
       : undefined,
     ...dependencyGuidance,
   ].filter((text) => text !== undefined);
-  return normalizeAdvertisedSchema({
-    ...presentation,
-    description: description.join(" "),
-  }).schema as Record<string, unknown>;
+  return { ...presentation, description: description.join(" ") };
 };
+
+/**
+ * Clients that render advertised inputs into SDK declarations expand
+ * schema-local references with a shared per-input budget: Pi 1.1.0 code-mode
+ * allows 32 expansions and degrades every later reference to `unknown`
+ * (morluto/rea#1632), hiding the fields those references describe. The budget
+ * counts conservatively — every resolvable, non-cyclic reference occurrence
+ * in every schema position — so any reference-resolving client stays within
+ * its measured limit.
+ */
+export const advertisedReferenceExpansionBudget = 32;
+
+const definitionKeys = new Set(["$defs", "definitions"]);
+
+const countReferenceExpansions = (
+  node: unknown,
+  root: Readonly<Record<string, unknown>>,
+  active: ReadonlySet<string>,
+  count: { value: number },
+): void => {
+  if (Array.isArray(node)) {
+    node.forEach((child) =>
+      countReferenceExpansions(child, root, active, count),
+    );
+    return;
+  }
+  if (!isObject(node)) return;
+  if (typeof node.$ref === "string" && !active.has(node.$ref)) {
+    const target = resolveReference(root, node.$ref);
+    if (target !== undefined) {
+      count.value += 1;
+      countReferenceExpansions(
+        target,
+        root,
+        new Set([...active, node.$ref]),
+        count,
+      );
+      return;
+    }
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (definitionKeys.has(key)) continue;
+    if (schemaMaps.has(key) && isObject(value)) {
+      for (const child of Object.values(value))
+        countReferenceExpansions(child, root, active, count);
+    } else if (schemaArrays.has(key) || schemaChildren.has(key)) {
+      countReferenceExpansions(value, root, active, count);
+    }
+  }
+};
+
+/** Conservative client expansion count over every schema position. */
+export const countLocalReferenceExpansions = (
+  schema: Record<string, unknown>,
+): number => {
+  const count = { value: 0 };
+  countReferenceExpansions(schema, schema, new Set(), count);
+  return count.value;
+};
+
+/**
+ * Keep the shared-definition form of an advertised input while clients can
+ * still resolve it. Once rendering would exhaust the reference budget, fall
+ * back to the inline projection, which carries no shared definitions for the
+ * nonrecursive schemas this repository advertises, so every field renders
+ * with complete structure in every reference-resolving client.
+ */
+export const inputSchemaWithinReferenceExpansionBudget = (
+  shared: Record<string, unknown>,
+  inline: () => Record<string, unknown>,
+  budget: number,
+): Record<string, unknown> =>
+  countLocalReferenceExpansions(shared) <= budget ? shared : inline();

src/contracts/toolInputReferences.test.ts

@@ -3,7 +3,12 @@ import { Ajv2020 } from "ajv/dist/2020.js";
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
 
-import { presentInputJsonSchema } from "./inputSchemaPresentation.js";
+import {
+  advertisedReferenceExpansionBudget,
+  countLocalReferenceExpansions,
+  inputSchemaWithinReferenceExpansionBudget,
+  presentInputJsonSchema,
+} from "./inputSchemaPresentation.js";
 import { toolContract } from "./toolContracts.js";
 import {
   toolInputSchemaWithMetadata,
@@ -15,27 +20,27 @@ it.each(["draft-2020-12", "draft-07"] as const)(
   "honors projection options independently of cached wire transformations in %s",
   (target) => {
     const range = z.strictObject({ offset: z.number(), length: z.number() });
-    const canonical = z.strictObject({ before: range, after: range });
+    const canonical = toolInputSchemaWithMetadata({
+      ...toolContract("open_binary"),
+      inputSchema: z.strictObject({ before: range, after: range }),
+    });
     const transform = (schema: Record<string, unknown>) => ({
       ...schema,
       title: "Transformed range inputs",
     });
-    const options = { target, libraryOptions: { reused: "ref" as const } };
-    for (const sharedFirst of [false, true]) {
+    const options = { target, libraryOptions: { reused: "inline" as const } };
+    for (const inlineFirst of [false, true]) {
       const wrapped = transformAdvertisedInputJsonSchema(canonical, transform);
       const project = wrapped["~standard"].jsonSchema.input;
-      if (sharedFirst) project(options);
-      const advertised = project({ target });
-      expect(JSON.stringify(advertised)).not.toContain('"$ref":');
-      expect(advertised).toEqual(
-        transform(canonical["~standard"].jsonSchema.input({ target })),
-      );
-      const shared = project(options);
+      if (inlineFirst) project(options);
+      const shared = project({ target });
       expect(JSON.stringify(shared)).toContain('"$ref":');
-      expect(shared).toEqual(
+      const inline = project(options);
+      expect(inline).toEqual(
         transform(canonical["~standard"].jsonSchema.input(options)),
       );
-      expect(project({ target })).toBe(advertised);
+      expect(JSON.stringify(inline)).not.toContain('"$ref":');
+      expect(project({ target })).toBe(shared);
     }
   },
 );
@@ -234,6 +239,105 @@ describe("advertised schema metadata and validation", () => {
   );
 });
 
+describe("advertised reference expansion budget", () => {
+  it("counts references in keyword-named fields, excluding literals", () => {
+    const fields = ["default", "enum", "examples", "const", "$defs"];
+    const schema = {
+      type: "object",
+      properties: Object.fromEntries(
+        fields.map((name) => [name, { $ref: "#/$defs/value" }]),
+      ),
+      $defs: { value: { type: "string" } },
+      default: { $ref: "#/$defs/value" },
+      examples: [{ $ref: "#/$defs/value" }],
+    };
+    expect(countLocalReferenceExpansions(schema)).toBe(fields.length);
+  });
+  const reusedComponent = z
+    .object({ kind: z.literal("rec"), value: z.string() })
+    .strict();
+  const inputWithReusedFields = (count: number) =>
+    z.strictObject(
+      Object.fromEntries(
+        Array.from({ length: count }, (_, index) => [
+          `field_${String(index).padStart(2, "0")}`,
+          reusedComponent,
+        ]),
+      ),
+    );
+  const advertisedInput = (
+    canonical: z.ZodType<Readonly<Record<string, unknown>>>,
+  ) =>
+    toolInputSchemaWithMetadata({
+      ...toolContract("open_binary"),
+      inputSchema: canonical,
+    })["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+
+  it("keeps shared definitions while every client can resolve them", () => {
+    const advertised = advertisedInput(inputWithReusedFields(8));
+    expect(advertised.$defs).toBeDefined();
+    expect(countLocalReferenceExpansions(advertised)).toBe(8);
+  });
+
+  it("keeps shared definitions exactly at the budget", () => {
+    const advertised = advertisedInput(
+      inputWithReusedFields(advertisedReferenceExpansionBudget),
+    );
+    expect(advertised.$defs).toBeDefined();
+    expect(countLocalReferenceExpansions(advertised)).toBe(
+      advertisedReferenceExpansionBudget,
+    );
+  });
+
+  it("re-projects without shared definitions once the budget is exceeded", () => {
+    const advertised = advertisedInput(
+      inputWithReusedFields(advertisedReferenceExpansionBudget + 1),
+    );
+    expect(advertised.$defs).toBeUndefined();
+    expect(countLocalReferenceExpansions(advertised)).toBe(0);
+    const properties = advertised.properties as Record<string, unknown>;
+    expect(properties.field_00).toMatchObject({
+      type: "object",
+      properties: { kind: { const: "rec" }, value: { type: "string" } },
+      required: ["kind", "value"],
+    });
+  });
+
+  it("keeps the shared form untouched when it fits and swaps it when not", () => {
+    const shared = {
+      type: "object",
+      properties: { value: { $ref: "#/$defs/shared" } },
+      $defs: { shared: { type: "string" } },
+    };
+    const inlined = {
+      type: "object",
+      properties: { value: { type: "string" } },
+    };
+    expect(
+      inputSchemaWithinReferenceExpansionBudget(
+        shared,
+        () => inlined,
+        advertisedReferenceExpansionBudget,
+      ),
+    ).toBe(shared);
+    expect(
+      inputSchemaWithinReferenceExpansionBudget(
+        {
+          ...shared,
+          properties: Object.fromEntries(
+            Array.from({ length: 33 }, (_, index) => [
+              `field_${index}`,
+              { $ref: "#/$defs/shared" },
+            ]),
+          ),
+        },
+        () => inlined,
+        advertisedReferenceExpansionBudget,
+      ),
+    ).toBe(inlined);
+  });
+});
+
 describe("root input presentation", () => {
   it("preserves prototype-named properties in object-root presentation", () => {
     const fields = Object.fromEntries([
@@ -379,193 +483,3 @@ describe("root input presentation", () => {
     });
   });
 });
-
-describe("advertised Boolean literals", () => {
-  it("keeps canonical boolean-literal inputs accepted after advertisement", () => {
-    const canonical = {
-      type: "object",
-      properties: {
-        enabled: { type: "boolean", const: false },
-      },
-      required: ["enabled"],
-      additionalProperties: false,
-    };
-    const advertised = presentInputJsonSchema(canonical, () => undefined);
-    const canonicalValidate = new Ajv2020({ strict: false }).compile(canonical);
-    const advertisedValidate = new Ajv2020({ strict: false }).compile(
-      advertised,
-    );
-
-    expect(canonicalValidate({ enabled: false })).toBe(true);
-    expect(canonicalValidate({ enabled: true })).toBe(false);
-    expect(advertisedValidate({ enabled: false })).toBe(true);
-    expect(advertisedValidate({ enabled: true })).toBe(true);
-    expect(advertised.properties).toEqual({ enabled: { type: "boolean" } });
-  });
-
-  it("drops affected negation and conditional groups without rejecting canonical inputs", () => {
-    const negated = {
-      type: "object",
-      properties: {
-        flag: { type: "boolean", not: { const: false } },
-      },
-    };
-    const negatedAdvertisement = presentInputJsonSchema(
-      negated,
-      () => undefined,
-    );
-    const canonicalNegated = new Ajv2020({ strict: false }).compile(negated);
-    const advertisedNegated = new Ajv2020({ strict: false }).compile(
-      negatedAdvertisement,
-    );
-    expect(canonicalNegated({ flag: true })).toBe(true);
-    expect(canonicalNegated({ flag: false })).toBe(false);
-    expect(advertisedNegated({ flag: true })).toBe(true);
-
-    const conditional = {
-      type: "object",
-      properties: {
-        choice: {
-          if: { const: false },
-          then: { type: "string" },
-          else: { type: "boolean" },
-        },
-      },
-    };
-    const conditionalAdvertisement = presentInputJsonSchema(
-      conditional,
-      () => undefined,
-    );
-    const canonicalConditional = new Ajv2020({ strict: false }).compile(
-      conditional,
-    );
-    const advertisedConditional = new Ajv2020({ strict: false }).compile(
-      conditionalAdvertisement,
-    );
-    expect(canonicalConditional({ choice: true })).toBe(true);
-    expect(advertisedConditional({ choice: true })).toBe(true);
-    expect(conditionalAdvertisement.properties).toEqual({
-      choice: {},
-    });
-  });
-});
-
-describe("advertised Boolean schema composition", () => {
-  it("widens an affected oneOf to anyOf when branches could overlap", () => {
-    const canonical = {
-      type: "object",
-      properties: {
-        flag: {
-          oneOf: [{ type: "boolean", const: false }, {}],
-        },
-      },
-    };
-    const advertised = presentInputJsonSchema(canonical, () => undefined);
-    const canonicalValidate = new Ajv2020({ strict: false }).compile(canonical);
-    const advertisedValidate = new Ajv2020({ strict: false }).compile(
-      advertised,
-    );
-    expect(canonicalValidate({ flag: true })).toBe(true);
-    expect(canonicalValidate({ flag: false })).toBe(false);
-    expect(advertisedValidate({ flag: true })).toBe(true);
-    expect(advertised).toHaveProperty(["properties", "flag", "anyOf"]);
-  });
-
-  it("retains nested branch guidance when widening oneOf to anyOf", () => {
-    const canonical = {
-      type: "object",
-      properties: {
-        selection: {
-          oneOf: [
-            {
-              type: "object",
-              properties: {
-                source: { type: "string" },
-                mode: { type: "boolean", const: false },
-              },
-              required: ["source", "mode"],
-              additionalProperties: false,
-            },
-            {
-              type: "object",
-              properties: {
-                target: { type: "string" },
-                mode: { type: "boolean", const: true },
-              },
-              required: ["target", "mode"],
-              additionalProperties: false,
-            },
-          ],
-        },
-      },
-    };
-    const advertised = presentInputJsonSchema(canonical, () => undefined);
-    const canonicalValidate = new Ajv2020({ strict: false }).compile(canonical);
-    const advertisedValidate = new Ajv2020({ strict: false }).compile(
-      advertised,
-    );
-    const example = { selection: { source: "capture.json", mode: false } };
-    expect(canonicalValidate(example)).toBe(true);
-    expect(advertisedValidate(example)).toBe(true);
-    expect(advertised).toMatchObject({
-      properties: {
-        selection: {
-          anyOf: [
-            { properties: { source: { type: "string" } } },
-            { properties: { target: { type: "string" } } },
-          ],
-        },
-      },
-    });
-  });
-
-  it("removes a nested not when widening a boolean item predicate", () => {
-    const canonical = {
-      type: "object",
-      properties: {
-        values: {
-          type: "array",
-          not: { items: { type: "boolean", const: false } },
-        },
-      },
-    };
-    const advertised = presentInputJsonSchema(canonical, () => undefined);
-    const canonicalValidate = new Ajv2020({ strict: false }).compile(canonical);
-    const advertisedValidate = new Ajv2020({ strict: false }).compile(
-      advertised,
-    );
-    expect(canonicalValidate({ values: [true] })).toBe(true);
-    expect(advertisedValidate({ values: [true] })).toBe(true);
-    expect(advertised).toHaveProperty(["properties", "values"], {
-      type: "array",
-    });
-  });
-
-  it("normalizes schema keywords only and preserves literal payloads", () => {
-    const literal = {
-      const: false,
-      enum: [false],
-      properties: { nested: { const: true } },
-    };
-    const presented = presentInputJsonSchema(
-      {
-        type: "object",
-        properties: {
-          default: { type: "boolean", const: false },
-          allowed: { enum: [false, true] },
-          kind: { type: "string", const: "exact" },
-        },
-        default: literal,
-        examples: [literal],
-      },
-      () => undefined,
-    );
-    expect(presented.properties).toEqual({
-      default: { type: "boolean" },
-      allowed: { type: "boolean" },
-      kind: { type: "string", const: "exact" },
-    });
-    expect(presented.default).toEqual(literal);
-    expect(presented.examples).toEqual([literal]);
-  });
-});

src/contracts/toolOutputSchemaPrimitives.ts

@@ -463,7 +463,6 @@ export const expandToolAvailability = (
 
 export const sessionProvider = z
   .object({
-    cleanup_pending: z.boolean(),
     capabilities: z.array(providerCapabilitySet),
     analysis_run: analysisRun,
     analysis_activity: analysisActivity,

src/contracts/toolSchemaMetadata.ts

@@ -2,7 +2,11 @@ import { z } from "zod";
 
 import type { ToolContract } from "./toolContractTypes.js";
 import { advertisedInputExamples } from "./advertisedInputExamples.js";
-import { presentInputJsonSchema } from "./inputSchemaPresentation.js";
+import {
+  advertisedReferenceExpansionBudget,
+  inputSchemaWithinReferenceExpansionBudget,
+  presentInputJsonSchema,
+} from "./inputSchemaPresentation.js";
 import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 
 const PROPERTY_DESCRIPTIONS: Readonly<Record<string, string>> = {
@@ -60,16 +64,31 @@ export const toolInputSchemaWithMetadata = <Contract extends ToolContract>(
     contract.inputSchema,
     "input",
     (project) => (options) => {
-      const inline = project({
+      const shared = project({
         ...options,
-        libraryOptions: { ...options.libraryOptions, reused: "inline" },
+        libraryOptions: { reused: "ref", ...options.libraryOptions },
       });
       const examples = advertisedInputExamples(contract);
       return {
-        // Keep advertised parameters self-contained for clients that do not
-        // resolve local references. The registered canonical schema remains
-        // responsible for runtime validation.
-        ...presentInputJsonSchema(inline, fallbackPropertyDescription),
+        // Sharing definitions only helps clients that resolve them. A client
+        // rendering declarations from a shared expansion budget degrades
+        // every reference past it to `unknown`, so an input whose shared form
+        // exceeds the budget is re-projected without shared definitions.
+        ...inputSchemaWithinReferenceExpansionBudget(
+          presentInputJsonSchema(shared, fallbackPropertyDescription),
+          () =>
+            presentInputJsonSchema(
+              project({
+                ...options,
+                libraryOptions: {
+                  ...options.libraryOptions,
+                  reused: "inline",
+                },
+              }),
+              fallbackPropertyDescription,
+            ),
+          advertisedReferenceExpansionBudget,
+        ),
         ...(examples.length === 0 ? {} : { examples }),
       };
     },

src/domain/analysisErrorCleanup.ts

@@ -19,7 +19,6 @@ export const analysisErrorWithCleanupFailure = (
         { cause: primary },
       ),
       userMessage: projectAnalysisError(primary).message,
-      remediationAction: projected.remediation.action,
       ...(primary.capturedOutput === undefined
         ? {}
         : { capturedOutput: primary.capturedOutput }),

src/domain/analysisErrorPresentation.ts

@@ -27,7 +27,6 @@ import {
   HopperTimeoutError,
 } from "./hopperErrors.js";
 import { ProviderSelectionError } from "./providerSelectionError.js";
-import { ProviderAdapterError } from "./providerAdapterError.js";
 import { UnknownRegistryError } from "./unknownRegistryError.js";
 import { providerRetryAction } from "./providerOperationHealth.js";
 import type { AnalysisError, AnalysisErrorTag } from "./analysisErrorBase.js";
@@ -36,11 +35,6 @@ import type { AnalysisErrorProjection } from "./analysisErrorProjection.js";
 export const analysisErrorRemediationAction = (
   error: AnalysisError,
 ): string => {
-  if (
-    error instanceof ProviderAdapterError &&
-    error.remediationAction !== undefined
-  )
-    return error.remediationAction;
   if (
     error instanceof BrowserObservationError &&
     error.reason === "service_worker_blocked"
@@ -72,7 +66,7 @@ export const analysisErrorRemediationAction = (
     );
   if (error instanceof HopperTimeoutError)
     return error.operation === undefined
-      ? "Review details.launcher and inspect Hopper for ongoing initial analysis or a pending loader, demo, or license dialog. For a large target, increase REA_HOPPER_STARTUP_TIMEOUT_MS in the environment that starts REA and allow at least that long in the MCP client. Resolve retained cleanup before reopening."
+      ? "Inspect Hopper for a loader or license dialog and review details.launcher. Correct the loader configuration or complete Hopper setup, then open the target again."
       : error.providerState === "busy"
         ? "Check binary_session.analysis_activity, wait for the active Hopper request to finish, then retry."
         : "Check binary_session for Hopper health, then retry the operation.";
@@ -293,7 +287,7 @@ export const analysisErrorUserMessage = (error: AnalysisError): string => {
 const hopperErrorUserMessage = (error: AnalysisError): string | undefined => {
   if (error instanceof HopperTimeoutError) {
     if (error.operation === undefined)
-      return "REA timed out waiting for Hopper bridge readiness, which includes initial analysis. Hopper may still be analyzing the target or waiting for a loader, demo, or license dialog. Review the captured launcher outcome and resolve retained cleanup before retrying.";
+      return "REA timed out waiting for Hopper bridge readiness. Hopper may be waiting for a loader or license dialog; inspect its window and the captured launcher outcome before retrying.";
     const request = error.operation;
     return error.providerState === "busy"
       ? `Hopper timed out during ${request} while the provider remained busy. Check binary_session.analysis_activity, wait for the active request to finish, then retry.`

src/domain/apple/interfaceBuilderGraph.test.ts

@@ -481,93 +481,6 @@ describe("Interface Builder hierarchy completeness", () => {
   });
 });
 
-describe("Interface Builder hierarchy record limits", () => {
-  const analyze = (
-    hierarchy: unknown[],
-    maxObjects?: number,
-    objects: Record<string, unknown> = {},
-  ) =>
-    buildInterfaceBuilderAnalysis({
-      targetSha256: hash,
-      toolVersion: "test",
-      documents: [
-        {
-          relativePath: "Main.nib",
-          archiveSha256: hash,
-          documentKind: "nib",
-          raw: {
-            "com.apple.ibtool.document.objects": objects,
-            "com.apple.ibtool.document.hierarchy": hierarchy,
-          },
-        },
-      ],
-      limits: interfaceBuilderLimitsSchema.parse(
-        maxObjects === undefined ? {} : { max_objects: maxObjects },
-      ),
-    });
-  const hierarchyFacet = (result: ReturnType<typeof analyze>) =>
-    result.graph.coverage.find(({ facet }) => facet === "hierarchy:Main.nib");
-
-  it("keeps an identified record after more than 20,000 structural records", () => {
-    const hierarchy: unknown[] = Array.from({ length: 20_001 }, () => ({
-      children: [],
-    }));
-    hierarchy[20_000] = { objectID: "tail", children: [] };
-
-    const result = analyze(hierarchy);
-
-    expect(
-      result.graph.nodes.map(
-        ({ attributes }) => attributes.interface_builder_object_id,
-      ),
-    ).toContain("tail");
-    expect(result.graph.edges).toHaveLength(1);
-    expect(result.graph.truncated).toBe(false);
-    expect(hierarchyFacet(result)).toMatchObject({
-      status: "complete",
-      examined: 1,
-      omitted: 0,
-    });
-  });
-
-  it("counts identified records beyond the object limit as omitted", () => {
-    const result = analyze(
-      ["a", "b", "c", "d"].map((objectID) => ({ objectID, children: [] })),
-      2,
-    );
-
-    expect(result.documents[0]?.hierarchy_complete).toBe(false);
-    expect(result.graph.truncated).toBe(true);
-    expect(hierarchyFacet(result)).toMatchObject({
-      status: "partial",
-      reason: "graph_limit_reached",
-      examined: 2,
-      omitted: 2,
-    });
-  });
-
-  it("stays complete when the identified records exactly reach the object limit", () => {
-    // The root and both objects fill the three graph nodes; the third
-    // hierarchy record reaches the hierarchy limit and has a structural child.
-    const result = analyze(
-      [
-        { objectID: "a", children: [{ objectID: "b", children: [] }] },
-        { objectID: "b", children: [{ children: [] }] },
-      ],
-      3,
-      { a: { class: "UIView" }, b: { class: "UIView" } },
-    );
-
-    expect(result.documents[0]?.hierarchy_complete).toBe(true);
-    expect(result.graph.truncated).toBe(false);
-    expect(hierarchyFacet(result)).toMatchObject({
-      status: "complete",
-      examined: 3,
-      omitted: 0,
-    });
-  });
-});
-
 describe("keyed archive object references", () => {
   it("keeps referenced objects as stubs so shared and cyclic references stay finite", () => {
     // Each view references its window, superview, and next key view, so

src/domain/apple/interfaceBuilderGraph.ts

@@ -211,7 +211,6 @@ export const buildInterfaceBuilderAnalysis = (input: {
       );
     };
     let hierarchyCount = 0;
-    let documentOmittedHierarchyNodes = 0;
     const visitHierarchy = (
       initial: unknown,
       initialParentId: string,
@@ -219,6 +218,11 @@ export const buildInterfaceBuilderAnalysis = (input: {
       const pending: { readonly value: unknown; readonly parentId: string }[] =
         [{ value: initial, parentId: initialParentId }];
       while (pending.length > 0) {
+        if (hierarchyCount >= input.limits.max_objects) {
+          truncated = true;
+          hierarchyTruncated = true;
+          return;
+        }
         const entry = pending.pop();
         if (entry === undefined) break;
         const { value, parentId } = entry;
@@ -238,13 +242,7 @@ export const buildInterfaceBuilderAnalysis = (input: {
           typeof item.archiveUID === "number" ? String(item.archiveUID) : null,
         );
         let nextParent = parentId;
-        if (objectId !== null && hierarchyCount >= input.limits.max_objects) {
-          // The walk continues over the decoded records so the omission is
-          // counted rather than reported as an unknown remainder.
-          truncated = true;
-          hierarchyTruncated = true;
-          documentOmittedHierarchyNodes += 1;
-        } else if (objectId !== null) {
+        if (objectId !== null) {
           const known = objectIds.has(objectId);
           const childId = known
             ? objectNodeId(objectId)
@@ -506,7 +504,6 @@ export const buildInterfaceBuilderAnalysis = (input: {
                   : null,
         examined: hierarchyCount,
         omitted:
-          documentOmittedHierarchyNodes +
           documentOmittedHierarchyEdges +
           parserOmittedHierarchyReferences +
           omittedSerializedHierarchyReferences,

src/domain/apple/interfaceBuilderKeyedArchive.ts

@@ -131,7 +131,7 @@ export const parseInterfaceBuilderRecords = (
   return {
     objects,
     connections,
-    hierarchy: Array.isArray(hierarchyRaw) ? hierarchyRaw : [],
+    hierarchy: Array.isArray(hierarchyRaw) ? hierarchyRaw.slice(0, 20_000) : [],
     classes: classesRaw,
     objectCount: objectEntries.length,
     omittedObjects: Math.max(0, objectEntries.length - 20_000),

src/domain/javascript/javascriptModuleDeclaration.ts

@@ -16,19 +16,6 @@ export const isTypeOnlyExportDeclaration = (
       t.isTSTypeAliasDeclaration(node.declaration) ||
       t.isTSDeclareFunction(node.declaration)));
 
-/**
- * Runtime external-module target for a value import-equals declaration;
- * `import type X = require("m")` is erased and declares no dependency.
- */
-export const semanticImportEqualsSpecifier = (
-  node: t.TSImportEqualsDeclaration,
-): string | null =>
-  node.importKind !== "type" &&
-  t.isTSExternalModuleReference(node.moduleReference) &&
-  t.isStringLiteral(node.moduleReference.expression)
-    ? node.moduleReference.expression.value
-    : null;
-
 /** Whether this import binding is explicitly type-only. */
 export const isTypeOnlyImportSpecifier = (node: t.ImportSpecifier): boolean =>
   node.importKind === "type" || node.importKind === "typeof";

src/domain/javascript/javascriptNativeHandoff.ts

@@ -14,21 +14,15 @@ export const buildJavaScriptNativeHandoffs = (
   edges: readonly ApplicationEdge[],
   nativeEvidence: readonly Evidence[],
 ): NativeHandoff[] => {
-  let nodeById: Map<string, ApplicationNode> | undefined;
+  const nodeById = new Map(nodes.map((node) => [node.node_id, node]));
   return nodes
     .filter(({ kind }) => kind === "native-addon")
     .flatMap((node) => {
-      // Observations may describe only a containing archive. A native target
-      // requires the node owner's exact byte identity, independently of its
-      // path, availability labels or the artifact supporting an observation.
-      if (node.identity.strategy !== "content-digest") return [];
-      const digest = node.identity.sha256;
+      const digest = artifactDigest(node);
+      if (digest === null) return [];
       const linked = nativeEvidence.filter(
         ({ subject }) => subject?.digest.sha256 === digest,
       );
-      nodeById ??= new Map(
-        nodes.map((candidate) => [candidate.node_id, candidate]),
-      );
       const exportNodes = nativeExportNodes(node, edges, nodeById);
       return [
         {
@@ -60,6 +54,16 @@ export const buildJavaScriptNativeHandoffs = (
     );
 };
 
+const artifactDigest = (node: ApplicationNode): string | null => {
+  if (node.identity.strategy === "content-digest") return node.identity.sha256;
+  const observation = node.observations.find(
+    ({ evidence }) => evidence.artifact.available,
+  );
+  return observation?.evidence.artifact.available === true
+    ? observation.evidence.artifact.sha256
+    : null;
+};
+
 const artifactPath = (node: ApplicationNode): string | null => {
   for (const { evidence } of node.observations)
     if (