Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
test(native): verify real PE and DOS entry views
Ysopwnable1770f38cfc6c
diff --git a/experiments/analysis-efficiency/README.md b/experiments/analysis-efficiency/README.mdindex 9a09e9d36..834d717cd 100644--- a/experiments/analysis-efficiency/README.md+++ b/experiments/analysis-efficiency/README.md@@ -7,6 +7,10 @@ JSON measurements belong outside the checkout. This document keeps the measuredfindings, verification scope and revision references; the scripts and `corpus.json`keep the reproduction inputs. Generated `results/` is ignored.+Follow-up: [native PE/DOS entry views and real model verification](native-entry-views.md)+records the post-merge native continuation, including a small-function case where+four selected replies cost more bytes than the complete dossier.+The 12 detailed checkpoint receipts were archived byte-for-byte before removalfrom the final PR tree. The archive `review-receipts-00d51e0fc-20261012` is in theprivate experiment lab outside the checkout; its `archive-index.json` recordsdiff --git a/experiments/analysis-efficiency/compare.mjs b/experiments/analysis-efficiency/compare.mjsindex 8c386a4d9..b6ba1a552 100644--- a/experiments/analysis-efficiency/compare.mjs+++ b/experiments/analysis-efficiency/compare.mjs@@ -30,6 +30,7 @@ const sameSettings = ["provider_search_path_sha256","provider_environment_policy_sha256","measure_source_sha256",+ "native_workflow_source_sha256","package_lock_sha256","node_version","sdk_client_version",@@ -40,7 +41,9 @@ const sameSettings = [const settingDifferences = sameSettings.filter((key) =>!isDeepStrictEqual(left[key], right[key]) ||- (key === "provider_search_path_sha256" &&+ ((key === "provider_search_path_sha256" ||+ (key === "native_workflow_source_sha256" &&+ typeof left.native_question === "string")) &&!/^[a-f0-9]{64}$/.test(left[key] ?? "")),);// Producer/view IDs identify different delivery observations; a named recovery@@ -54,6 +57,17 @@ const facts = (answer) =>const a = facts(leftAnswer);const b = facts(rightAnswer);const runSpecific = [];+for (const [side, answer] of [+ ["left", leftAnswer],+ ["right", rightAnswer],+]) {+ if (Object.hasOwn(answer, "evidence_ids"))+ runSpecific.push({+ side,+ path: ["evidence_ids"],+ value: answer.evidence_ids,+ });+}// Binwalk assigns a new opaque region UUID in each invocation. Preserve both// original lookup values in this report; compare the observed region facts// separately. The product and original replies retain those IDs unchanged.diff --git a/experiments/analysis-efficiency/corpus.json b/experiments/analysis-efficiency/corpus.jsonindex 911fa88f5..5d2ad531d 100644--- a/experiments/analysis-efficiency/corpus.json+++ b/experiments/analysis-efficiency/corpus.json@@ -116,6 +116,36 @@"derivation": "selected regular ZIP member ShareX.HelpersLib.dll; no target execution"}},+ {+ "id": "sharex.exe",+ "file": "ShareX.exe",+ "bytes": 198656,+ "sha256": "46af1ccc514b395cb703633abb5a505a771942b7db9b1915f31aeea541b3685f",+ "provenance": {+ "project": "ShareX native executable component",+ "version": "19.0.2",+ "upstreamFile": "ShareX-19.0.2-portable.zip",+ "url": "https://github.com/ShareX/ShareX/releases/download/v19.0.2/ShareX-19.0.2-portable.zip",+ "transport_sha256": "967b5d838df5ce25fb5fd7cbd16f1bd797427e2df16907b022b74a4bc0fb9d54",+ "transport_bytes": 168796487,+ "derivation": "selected regular ZIP member ShareX.exe; PE32+ x86-64 with no CLR directory; no target execution"+ }+ },+ {+ "id": "freedos.edlin.exe",+ "file": "EDLIN.EXE",+ "bytes": 31492,+ "sha256": "96b2b6d543e2d8bdc83e313756444e103339eb5ee2c1229abe3607539b31ad6e",+ "provenance": {+ "project": "FreeDOS EDLIN",+ "version": "2.24",+ "upstreamFile": "edlin.zip",+ "url": "https://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/repositories/1.4/base/edlin.zip",+ "transport_sha256": "9db8a0b50bc4be5c2358cd0fa1fb6fc77342c6d5175a6b1084547c370e428f8a",+ "transport_bytes": 377009,+ "derivation": "selected regular ZIP member BIN/EDLIN.EXE; original UPX-compressed DOS MZ; APPINFO/EDLIN.LSM reports version; no execution or unpacking"+ }+ },{"id": "vscode.tree-sitter.wasm","file": "tree-sitter.wasm",diff --git a/experiments/analysis-efficiency/measure.mjs b/experiments/analysis-efficiency/measure.mjsindex 348bf02c2..0bfd6da52 100644--- a/experiments/analysis-efficiency/measure.mjs+++ b/experiments/analysis-efficiency/measure.mjs@@ -1,16 +1,14 @@import { createHash } from "node:crypto";import { createReadStream } from "node:fs";-import {- mkdir,- open,- readFile,- readdir,- stat,- writeFile,-} from "node:fs/promises";+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";import { dirname, isAbsolute, resolve } from "node:path";import { fileURLToPath, pathToFileURL } from "node:url";import { parseArgs } from "node:util";+import {+ NATIVE_ARTIFACTS,+ measureNativeEntry,+ nativeEntrySeed,+} from "./native-entry.mjs";import { Client } from "@modelcontextprotocol/client";import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";import { Ajv2020 } from "ajv/dist/2020.js";@@ -38,10 +36,15 @@ if (!isAbsolute(values.path) ||!isAbsolute(values.output) ||!["complete", "summary"].includes(values.delivery) ||- !["entry", "entry-and-main"].includes(values["native-question"]) ||+ !["entry", "entry-and-main", "entry-views"].includes(+ values["native-question"],+ ) ||!["inventory", "selected"].includes(values["javascript-question"]) ||!["default", "selected"].includes(values.schemas) ||- (values.artifact !== "jq" && values["native-question"] !== "entry") ||+ (!NATIVE_ARTIFACTS.includes(values.artifact) &&+ values["native-question"] !== "entry") ||+ (values.artifact !== "jq" &&+ values["native-question"] === "entry-and-main") ||(values.artifact !== "obsidian.asar" &&values["javascript-question"] !== "inventory"))@@ -118,6 +121,9 @@ await writeFile();const fingerprints = {measure_source_sha256: await fileSha(fileURLToPath(import.meta.url)),+ native_workflow_source_sha256: await fileSha(+ fileURLToPath(new URL("./native-entry.mjs", import.meta.url)),+ ),runtime_files_sha256: sha(JSON.stringify(runtimeFiles)),runtime_dispatcher_sha256: await fileSha(resolve(values["runtime-root"], "scripts/rea.mjs"),@@ -545,111 +551,19 @@ const workflows = {evidence_ids: [info.evidence_id],};},- jq: async () => {- const file = await open(values.path, "r");- let header;- try {- header = (await file.read(Buffer.alloc(32), 0, 32, 0)).buffer;- } finally {- await file.close();- }- if (header.subarray(0, 6).toString("hex") !== "7f454c460201")- throw new Error("Expected ELF64 little endian entry seed");- const address = `0x${header.readBigUInt64LE(24).toString(16)}`;- await call("open_binary", { path: values.path, provider_id: "ghidra" });- try {- const containing = await call("resolve_containing_procedure", {- address,- });- const info = await call("analyze_function", { procedure: address });- const n = normalized(info);- // This exact application entry is materialized in the pinned jq entry's- // observed MOV RDI, 0x401f00 instruction, not an original-source claim.- let main;- const mainEvidenceIds = [];- if (values["native-question"] === "entry-and-main") {- let sourceId;- try {- const completed = await call("analyze_function", {- procedure: "0x401f00",- });- sourceId = completed.evidence_id;- } catch (error) {- const reference =- error instanceof ToolFailure &&- error.value?.error?.code === "resource_constraint"- ? error.value.error.details?.reported_limits?.evidence_reference- : undefined;- if (reference?.kind !== "retained-evidence") throw error;- sourceId = reference.evidence_id;- }- mainEvidenceIds.push(sourceId);- main = {};- for (const facet of [- "procedure",- "pseudocode",- "referenced_strings",- "callees",- "callers",- "basic_blocks",- ]) {- let offset = 0;- const items = [];- const pages = [];- do {- const selected = await call("inspect_analysis_view", {- source: { kind: "retained-evidence", evidence_id: sourceId },- view: {- kind: "native",- facet,- offset,- limit:- facet === "pseudocode"- ? 65536- : facet === "basic_blocks"- ? 1- : 64,- },- });- mainEvidenceIds.push(selected.evidence_id);- const v = normalized(selected);- items.push(v.item);- pages.push({- coverage: v.coverage,- limitations: v.limitations,- unknowns: v.unknowns,- });- if (v.coverage.exhausted || facet === "basic_blocks") break;- if (- v.coverage.next_offset === null ||- v.coverage.next_offset <= offset- )- throw new Error("Native view did not advance");- offset = v.coverage.next_offset;- } while (true);- main[facet] = { items, pages };- }- }- return {- artifact_sha256: targetSha(info),- entry_address: address,- containing_procedure: normalized(containing),- procedure: n.procedure,- pseudocode_prefix: n.pseudocode.slice(0, 512),- caller_count: n.callers.length,- callee_count: n.callees.length,- ...(main === undefined ? {} : { main }),- analysis_profile: info.analysis_profile,- evidence_ids: [- containing.evidence_id,- info.evidence_id,- ...mainEvidenceIds,- ],- };- } finally {- await call("close_binary", {});- }- },+ ...Object.fromEntries(+ NATIVE_ARTIFACTS.map((artifact) => [+ artifact,+ async () =>+ measureNativeEntry({+ seed: await nativeEntrySeed(artifact, values.path),+ values,+ call,+ inputSha,+ ToolFailure,+ }),+ ]),+ ),};try {@@ -740,7 +654,9 @@ const report = {artifact_sha256_after: finalInputSha,delivery: values.delivery,sdk_schema_mode: values.schemas,- native_question: values.artifact === "jq" ? values["native-question"] : null,+ native_question: NATIVE_ARTIFACTS.includes(values.artifact)+ ? values["native-question"]+ : null,javascript_question:values.artifact === "obsidian.asar" ? values["javascript-question"] : null,provider_settings_sha256: sha(JSON.stringify(selectedProviders)),diff --git a/experiments/analysis-efficiency/native-entry-views.md b/experiments/analysis-efficiency/native-entry-views.mdnew file mode 100644index 000000000..1c02fbfd1--- /dev/null+++ b/experiments/analysis-efficiency/native-entry-views.md@@ -0,0 +1,178 @@+# Native PE and DOS entry-view checkpoint++Continuation of [#2016](https://github.com/morluto/rea/issues/2016) after+#2122 and #2193 merged. Real Ghidra observations and real Codex CLI answers+support the selected native facets on these shipped inputs. They do not justify+an automatic native summary policy: the four selected replies are larger than+the complete dossier for the small PE entry, and smaller for the DOS entry.+The initial complete analysis still runs and is delivered in both cases.++This checkpoint changes experiment scripts, corpus inputs and grading only.+Existing production CLI/MCP contracts, defaults and session behavior are unchanged.++## Inputs and runtime++Production runtime: main `10400fdb57e4226c5ce15af17968a664f35498ce`,+including the merged WASM summary work and subsequent main changes. Node+24.18.0/npm 11.16.0, locked dependencies, actual Ghidra 12.1.4 on Linux.+Default auto-analysis remains enabled, with a 768 MiB JVM ceiling and one+active processor. The whole process family uses the existing one-CPU,+4 GiB hard/3 GiB early-stop, no-swap, bounded-task resource scope.++| Shipped artifact | Selected bytes | SHA-256 | Static scope |+| ---------------------------------- | -------------: | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------- |+| ShareX 19.0.2 `ShareX.exe` | 198,656 | `46af1ccc514b395cb703633abb5a505a771942b7db9b1915f31aeea541b3685f` | Native PE32+ x86-64 component with no CLR directory; entry `0x1400125c0` derived from original image base/RVA |+| FreeDOS EDLIN 2.24 `BIN/EDLIN.EXE` | 31,492 | `96b2b6d543e2d8bdc83e313756444e103339eb5ee2c1229abe3607539b31ad6e` | Original UPX-compressed DOS MZ; admitted entry `0x10000`, independently verified static load image |++Acquisition URLs, archive sizes/digests and exact regular ZIP members are in+[corpus.json](corpus.json). EDLIN's package `APPINFO/EDLIN.LSM` reports its+version and UPX compression. No binary was executed, unpacked or committed.+The independent PE header does not establish Windows runtime behavior.+DOS load-image verification and unpacking-stub pseudocode do not recover the+editor's application logic or establish DOS execution. DOS COM is still untested.++The SDK and frozen model runtime share the exact `dist/` and `bridge/` file+table digest:+`e2b67eb0966072fd8b159edfab074cbaf1db9bfc0ac9c57d25ba1435cc0fdbcf`.+The model copy was independently checked against all 1,375 compiled files and+30 bridge files. Runtime copies and detailed receipts remain outside Git.++## Public SDK observations++The workflow opens the selected target with Ghidra, resolves the entry,+calls `analyze_function` once, reads retained procedure/pseudocode/callers/callees+facets, and closes the ephemeral session. DOS obtains its address from+`inspect_native_load_image` before resolving the procedure. Each facet is checked+against the complete producer facts, original parent ID, target digest and distinct+derived Evidence ID. The actual SDK validates named advertised output contracts.++| Entry | Complete dossier JSON bytes | Four facet replies combined | Workflow seconds | First provider query seconds | Last-observed family CPU seconds | Sampled family peak MiB |+| ------------ | --------------------------: | --------------------------: | ---------------: | ---------------------------: | -------------------------------: | ----------------------: |+| ShareX PE | 50,936 | 68,257 | 63.123 | 57.490 | 63.660 | 1,197.85 |+| EDLIN DOS MZ | 224,670 | 70,539 | 26.436 | 21.366 | 26.899 | 939.25 |++These are exploratory observations, not a paired implementation performance+cohort. JSON byte counts include the SDK tool-result representations, excluding+catalog discovery and wire framing; they are not model token counts. Four PE+facets cost about 34% more bytes than that dossier. The DOS facets cost about+69% fewer bytes **when reading already-retained Evidence**. Their first analysis+still returned the full dossier; summing both paths increases first-task traffic.+The first provider query includes the observable wait for the imported Program+and its analysis, not an independently measured engine-only stage.++The observed PE entry contains 18 analyzed bytes, zero recorded callers and two+resolved callees. Ghidra's terminal-call caveat remains explicit. The DOS entry+contains 53 analyzed bytes and zero recorded callers/callees; overlapping+instruction and abnormal stack-frame warnings remain in the pseudocode.+Neither zero count establishes absence of unresolved runtime calls.++An earlier PE probe completed production analysis and two facets, then failed+its harness assertion: a pseudocode page is `{text, unit}`, not a string. That+failed attempt remains archived and is excluded from successful workflow figures.+The corrected exploratory SDK driver fingerprints are+`4876c0ecaa84069ddc508e29649715c6c914bd3c4960a76fa9724b5992123699`+and native-helper `76023ad45cd1edab57dcd4a8ccf29a9b8a8378029ff2d9711ae35c73940e80d6`.+The published helper in `6d7f6885c` removes redundant scopes; replaying the actual+PE/DOS replies reproduces every answer field and the same 9/10 calls. Recorded+real jq entry and entry/main replies also preserve their selected facts, profile+and 4/12-call ordering. These replays are driver regression checks, not fresh+provider runs or timing measurements.++## Real Codex CLI observations++Three serial runs used Codex CLI 0.161.0, requested alias `gpt-5.6-terra`, high+reasoning, temporary isolated profiles and the frozen modified REA MCP runtime.+Resolved server-side model identity is not inferred. The same explicit seven-tool+subset was enabled: open, containing-procedure resolution, dossier, analysis view,+load image, retained Evidence discovery and close. This is not full-catalog tool+selection verification. Questions are [PE](questions/native-pe.txt) and+[DOS](questions/native-dos.txt).++| Trial | Total input | Cached input | Uncached input | Output | Seconds | Calls / failed |+| ----- | ----------: | -----------: | -------------: | -----: | ------: | -------------: |+| PE 1 | 451,337 | 399,616 | 51,721 | 3,820 | 130.073 | 12 / 2 |+| DOS 1 | 730,578 | 658,944 | 71,634 | 3,310 | 134.435 | 9 / 0 |+| PE 2 | 498,322 | 429,056 | 69,266 | 3,038 | 192.373 | 9 / 1 |++All three answers match the selected original digest, address, procedure+classification/signature/locals, inclusive body ranges, body byte count,+pseudocode prefix and relationship counts. Actual Evidence references were+observed in the responses; target bytes remained unchanged, close completed and+the copied profiles were removed. DOS additionally matches the verified load+status and every supplied load-image metadata field. Manual review preserves+static/packed-target and terminal-flow qualifications.++The first grader expected only particular nested JSON shapes. It rejected PE's+equivalent text-page object/inclusive-range label and could not grade DOS's+explicit `entry @ 0x10000` display. The updated grader compares exact source+values for those representations without parsing displays into lookup identities.+It still rejects wrong text units, returned lengths, body endpoints and missing+facts. Original answers and first grading attempts remain archived; regrading+does not repeat model calls or change their tokens/times.++The PE agent hit the advertised-but-unimplemented native summary recipe: both+trials attempted `view: {kind: "summary"}`; the first also tried the invalid+native facet `summary`. Those failed calls and all subsequent recovery/repeated+reads remain included. The public SDK independently reproduced `invalid_request`+for native summary on both inputs. This pre-existing contract-description mismatch+is recorded in `/tmp/rea-analysis-efficiency-bugs-20261012.md` for team repair,+as requested; this branch does not repair it.++Model sampled peaks were 1,318.74 / 1,017.70 / 1,234.92 MiB, with last-observed+family CPU 72.956 / 71.534 / 74.089 seconds. SDK/model scopes did not abort and+their last-observed limit-event counters were zero. Final cgroup counters remained+unavailable after scope teardown: the strict resource-qualified overall grades+remain unverified. The selected fact/lifecycle checks pass; no universal latency,+OOM absence or CPU/memory saving is inferred from these samples.++## Reproduction and next decision++Use the pinned toolchain and build the selected production revision. Keep its+runtime copy, matching dependencies, provider settings, binaries and receipts+outside the checkout, as described in [README.md](README.md).++```sh+python3 experiments/analysis-efficiency/resource-run.py -- \+ node experiments/analysis-efficiency/measure.mjs \+ --runtime-root /absolute/frozen-runtime --revision EXACT_PRODUCTION_SHA \+ --artifact sharex.exe --path /absolute/ShareX.exe \+ --providers /absolute/explicit-providers.json \+ --native-question entry-views --schemas selected \+ --output /absolute/new-native-measurement+```++For DOS select `--artifact freedos.edlin.exe` and the original extracted+`EDLIN.EXE`. `--native-question entry` retains the existing compact experimental+answer; `entry-views` performs additional verification reads and the explicit+summary refusal probe. It does not select summary delivery from `analyze_function`.+The helper fingerprint participates in comparison, and missing native helper+fingerprints are not treated as a comparable current driver.++The reviewed `entry-views` answer separates selected facet facts from run-specific+references: `evidence_ids.retained_views` retains each facet's original view and+parent ID, while `retained_views` holds its item, coverage, limitations and unknowns.+DOS load-image facts retain their source ID and must match the selected carrier+digest before their entry address can be used; a stale result closes the session+without querying a procedure.+Derived view IDs are checked against every prior producer reference as well as+other derived views. DOS model grades require the actual completed load-image+response and its reported source ID; status, digest, entry and supplied metadata+are checked against that observation. Missing, failed or unreferenced responses+cannot establish load-image verification.+The comparator preserves both runs' reference maps and compares the facts. Existing+`entry`/`entry-and-main` answers keep their ID arrays. Historical SDK receipts above+retain their original pre-review representation; no replies or measurements were+rewritten, and no provider/model runs were repeated for this representation fix.++Relevant validation includes the real workflows above, recorded-reply regression,+grader negative probes, JavaScript/Python syntax, formatting/diff checks and+`npm run check:fast`. The cold type/lint gate passed in 112.602 seconds with+sampled peak 3,220,914,176 bytes and five last-observed `memory.high` events;+this gate is not a performance-qualified experiment. Unrelated domain suites,+packaging and earlier model cohorts were not rerun for this experiment-only change.++The next useful comparison is question-specific native primitives versus a+complete dossier, with identical requested facts and actual model trials.+Larger PE functions and another unpacked DOS/COM application can extend the+coverage progressively. Preserve existing complete defaults and solve the+summary-description bug separately before recommending a native summary route.diff --git a/experiments/analysis-efficiency/native-entry.mjs b/experiments/analysis-efficiency/native-entry.mjsnew file mode 100644index 000000000..84bc934ff--- /dev/null+++ b/experiments/analysis-efficiency/native-entry.mjs@@ -0,0 +1,272 @@+import { open, readFile } from "node:fs/promises";+import { isDeepStrictEqual } from "node:util";++export const NATIVE_ARTIFACTS = ["jq", "sharex.exe", "freedos.edlin.exe"];+const normalized = (value) => value.normalized_result;++const retainedEntryViews = async (+ call,+ info,+ inputSha,+ ToolFailure,+ sourceEvidenceIds,+) => {+ const n = normalized(info);+ const retainedViews = [];+ const retainedViewEvidence = [];+ const observedEvidenceIds = new Set([info.evidence_id, ...sourceEvidenceIds]);+ let nativeSummaryOutcome, summaryEvidenceId;+ for (const facet of ["procedure", "pseudocode", "callers", "callees"]) {+ const selected = await call("inspect_analysis_view", {+ source: { kind: "retained-evidence", evidence_id: info.evidence_id },+ view: {+ kind: "native",+ facet,+ offset: 0,+ limit: facet === "pseudocode" ? 512 : 64,+ },+ });+ const view = normalized(selected);+ if (observedEvidenceIds.has(selected.evidence_id))+ throw new Error("Retained native view reused an Evidence identity");+ const expected =+ facet === "procedure"+ ? n.procedure+ : facet === "pseudocode"+ ? { text: n.pseudocode.slice(0, 512), unit: "utf16-code-units" }+ : n[facet].slice(0, 64);+ if (+ !isDeepStrictEqual(view.item, expected) ||+ view.parent_evidence_id !== info.evidence_id ||+ view.artifact.sha256 !== inputSha+ )+ throw new Error(+ "Retained native view changed the selected source facts or identity",+ );+ observedEvidenceIds.add(selected.evidence_id);+ retainedViews.push({+ facet,+ item: view.item,+ coverage: view.coverage,+ limitations: view.limitations,+ unknowns: view.unknowns,+ });+ retainedViewEvidence.push({+ facet,+ evidence_id: selected.evidence_id,+ parent_evidence_id: view.parent_evidence_id,+ });+ }+ // Exercise the advertised summary recipe separately. A known refusal+ // is recorded as such; it does not validate a nonexistent capability.+ try {+ const summary = await call("inspect_analysis_view", {+ source: { kind: "retained-evidence", evidence_id: info.evidence_id },+ view: { kind: "summary" },+ });+ if (observedEvidenceIds.has(summary.evidence_id))+ throw new Error("Native summary reused an Evidence identity");+ nativeSummaryOutcome = { status: "supported" };+ summaryEvidenceId = summary.evidence_id;+ } catch (error) {+ if (+ !(error instanceof ToolFailure) ||+ error.value?.error?.code !== "invalid_request"+ )+ throw error;+ nativeSummaryOutcome = {+ status: "unsupported",+ error: error.value.error,+ };+ }+ return {+ retainedViews,+ retainedViewEvidence,+ nativeSummaryOutcome,+ summaryEvidenceId,+ };+};++const retainedJqMain = async (call, ToolFailure) => {+ // This exact application entry is materialized in the pinned jq entry's+ // observed MOV RDI, 0x401f00 instruction, not an original-source claim.+ let main;+ const mainEvidenceIds = [];+ let sourceId;+ try {+ const completed = await call("analyze_function", {+ procedure: "0x401f00",+ });+ sourceId = completed.evidence_id;+ } catch (error) {+ const reference =+ error instanceof ToolFailure &&+ error.value?.error?.code === "resource_constraint"+ ? error.value.error.details?.reported_limits?.evidence_reference+ : undefined;+ if (reference?.kind !== "retained-evidence") throw error;+ sourceId = reference.evidence_id;+ }+ mainEvidenceIds.push(sourceId);+ main = {};+ for (const facet of [+ "procedure",+ "pseudocode",+ "referenced_strings",+ "callees",+ "callers",+ "basic_blocks",+ ]) {+ let offset = 0;+ const items = [];+ const pages = [];+ do {+ const selected = await call("inspect_analysis_view", {+ source: { kind: "retained-evidence", evidence_id: sourceId },+ view: {+ kind: "native",+ facet,+ offset,+ limit:+ facet === "pseudocode" ? 65536 : facet === "basic_blocks" ? 1 : 64,+ },+ });+ mainEvidenceIds.push(selected.evidence_id);+ const v = normalized(selected);+ items.push(v.item);+ pages.push({+ coverage: v.coverage,+ limitations: v.limitations,+ unknowns: v.unknowns,+ });+ if (v.coverage.exhausted || facet === "basic_blocks") break;+ if (v.coverage.next_offset === null || v.coverage.next_offset <= offset)+ throw new Error("Native view did not advance");+ offset = v.coverage.next_offset;+ } while (true);+ main[facet] = { items, pages };+ }+ return { main, mainEvidenceIds };+};++export const measureNativeEntry = async ({+ seed,+ values,+ call,+ inputSha,+ ToolFailure,+}) => {+ await call("open_binary", { path: values.path, provider_id: "ghidra" });+ try {+ // DOS addresses follow the actual admitted load image. A file header+ // offset is not a provider address or proof of runtime execution.+ let loadImage, loadImageEvidenceId;+ if (seed === undefined) {+ const imageEvidence = await call("inspect_native_load_image", {});+ loadImage = normalized(imageEvidence);+ if (loadImage.status !== "verified")+ throw new Error(+ "The shipped DOS load image was not independently verified",+ );+ if (loadImage.target_sha256 !== inputSha)+ throw new Error("The DOS load image belongs to a different target");+ loadImageEvidenceId = imageEvidence.evidence_id;+ seed = loadImage.entry.linear_address;+ }+ const address = seed;+ const containing = await call("resolve_containing_procedure", {+ address,+ });+ const info = await call("analyze_function", { procedure: address });+ const n = normalized(info);+ const selected =+ values["native-question"] === "entry-views"+ ? await retainedEntryViews(call, info, inputSha, ToolFailure, [+ containing.evidence_id,+ ...(loadImageEvidenceId === undefined ? [] : [loadImageEvidenceId]),+ ])+ : {};+ const { main, mainEvidenceIds = [] } =+ values["native-question"] === "entry-and-main"+ ? await retainedJqMain(call, ToolFailure)+ : {};+ return {+ artifact_sha256: info.subject?.digest.sha256,+ entry_address: address,+ containing_procedure: normalized(containing),+ procedure: n.procedure,+ pseudocode_prefix: n.pseudocode.slice(0, 512),+ caller_count: n.callers.length,+ callee_count: n.callees.length,+ ...(main === undefined ? {} : { main }),+ analysis_profile: info.analysis_profile,+ ...(loadImage === undefined ? {} : { load_image: loadImage }),+ ...(selected.retainedViews === undefined+ ? {}+ : {+ retained_views: selected.retainedViews,+ native_summary_outcome: selected.nativeSummaryOutcome,+ }),+ evidence_ids:+ selected.retainedViews === undefined+ ? [+ containing.evidence_id,+ info.evidence_id,+ ...mainEvidenceIds,+ ...(loadImageEvidenceId === undefined+ ? []+ : [loadImageEvidenceId]),+ ]+ : {+ containing_procedure: containing.evidence_id,+ function_dossier: info.evidence_id,+ ...(loadImageEvidenceId === undefined+ ? {}+ : { native_load_image: loadImageEvidenceId }),+ retained_views: selected.retainedViewEvidence,+ ...(selected.summaryEvidenceId === undefined+ ? {}+ : { native_summary: selected.summaryEvidenceId }),+ },+ };+ } finally {+ await call("close_binary", {});+ }+};++export const nativeEntrySeed = async (artifact, path) => {+ if (artifact === "jq") {+ const file = await open(path, "r");+ let header;+ try {+ header = (await file.read(Buffer.alloc(32), 0, 32, 0)).buffer;+ } finally {+ await file.close();+ }+ if (header.subarray(0, 6).toString("hex") !== "7f454c460201")+ throw new Error("Expected ELF64 little endian entry seed");+ return `0x${header.readBigUInt64LE(24).toString(16)}`;+ }+ if (artifact === "sharex.exe") {+ const bytes = await readFile(path);+ const pe = bytes.readUInt32LE(0x3c);+ const optional = pe + 24;+ if (+ bytes.subarray(pe, pe + 4).toString("hex") !== "50450000" ||+ bytes.readUInt16LE(pe + 4) !== 0x8664 ||+ bytes.readUInt16LE(optional) !== 0x20b ||+ bytes.readUInt32LE(optional + 108) <= 14 ||+ bytes.readUInt32LE(optional + 112 + 14 * 8) !== 0 ||+ bytes.readUInt32LE(optional + 116 + 14 * 8) !== 0+ )+ throw new Error(+ "Expected the pinned native PE32+ entry seed without CLR metadata",+ );+ const address =+ bytes.readBigUInt64LE(optional + 24) ++ BigInt(bytes.readUInt32LE(optional + 16));+ return `0x${address.toString(16)}`;+ }+ if (artifact === "freedos.edlin.exe") return undefined;+ throw new Error("Select a pinned native artifact");+};diff --git a/experiments/analysis-efficiency/questions/native-dos.txt b/experiments/analysis-efficiency/questions/native-dos.txtnew file mode 100644index 000000000..48c52a9ec--- /dev/null+++ b/experiments/analysis-efficiency/questions/native-dos.txt@@ -0,0 +1 @@+Statically inspect {{artifact_path}} using only the registered REA tools and Ghidra. This is the original UPX-compressed FreeDOS EDLIN 2.24 DOS MZ executable; inspect its admitted load image and entry stub, without running or unpacking it. Keep default auto-analysis enabled. Open the target with provider_id ghidra, call inspect_native_load_image, and use its verified entry.linear_address as the seed. Resolve the containing procedure, analyze that procedure once, and close the ephemeral session after obtaining the facts. If a result is clipped, use retained native facets without reanalysis. Report exact target SHA-256, entry_address, containing_procedure, complete procedure metadata including classification, signature, locals and inclusive body ranges, the first 512 UTF-16 units of pseudocode, caller_count, callee_count, real Evidence IDs and limitations. Preserve missing/partial facts and terminal-flow caveats. Verified static import and unpacking-stub pseudocode do not prove DOS execution or recovery of the editor's application logic. Do not execute targets, launch a GUI, or use shell/file tools/network or other agents. Final JSON fields: artifact_sha256, load_image_status, entry_address, containing_procedure, procedure, pseudocode_prefix, caller_count, callee_count, evidence_ids, limitations. Stop when these facts and cleanup are supported; report unsupported outcomes explicitly.diff --git a/experiments/analysis-efficiency/questions/native-pe.txt b/experiments/analysis-efficiency/questions/native-pe.txtnew file mode 100644index 000000000..749e96200--- /dev/null+++ b/experiments/analysis-efficiency/questions/native-pe.txt@@ -0,0 +1 @@+Statically inspect {{artifact_path}} using only the registered REA tools and Ghidra. The independently read, pinned PE32+ header reports image base 0x140000000 and entry RVA 0x125c0, so use address 0x1400125c0 as the analyst seed. This is a native x86-64 Windows PE component with no CLR directory, inspected on Linux; do not claim Windows runtime behavior. Keep default auto-analysis enabled. Open the target with provider_id ghidra, resolve the containing procedure, analyze that procedure once, and close the ephemeral session after obtaining the facts. If a result is clipped, use retained native facets without reanalysis. Report exact target SHA-256, entry_address, containing_procedure, complete procedure metadata including classification, signature, locals and inclusive body ranges, the first 512 UTF-16 units of pseudocode, caller_count, callee_count, real Evidence IDs and limitations. Preserve terminal-flow caveats and unresolved static edges; recovered pseudocode is not original source. Do not execute targets, launch a GUI, or use shell/file tools/network or other agents. Final JSON fields: artifact_sha256, entry_address, containing_procedure, procedure, pseudocode_prefix, caller_count, callee_count, evidence_ids, limitations. The seed applies only to the pinned ShareX.exe in corpus.json. Stop when these facts and cleanup are supported.diff --git a/experiments/analysis-efficiency/review-model.py b/experiments/analysis-efficiency/review-model.pyindex 22d6dd766..c31a01290 100644--- a/experiments/analysis-efficiency/review-model.py+++ b/experiments/analysis-efficiency/review-model.py@@ -182,18 +182,61 @@ def main():} for row in rows], key=lambda row: row['node_id'])check('all_selected_module_identities', select(answer.get('modules', [])), select(reference['modules']))elif domain == 'native':- for key in ['entry_address', 'pseudocode_prefix', 'caller_count', 'callee_count']:+ for key in ['entry_address', 'caller_count', 'callee_count']:check(key, answer.get(key), reference[key])- containing = answer['containing_procedure']+ prefix = answer.get('pseudocode_prefix')+ if isinstance(prefix, dict) and prefix.get('unit') == 'utf16-code-units':+ text = prefix.get('text')+ if 'requested' in prefix:+ check('pseudocode_prefix.requested', prefix['requested'], 512)+ if 'returned' in prefix:+ check('pseudocode_prefix.returned', prefix['returned'], len(reference['pseudocode_prefix'].encode('utf-16-le')) // 2)+ prefix = text+ check('pseudocode_prefix', prefix, reference['pseudocode_prefix'])+ containing = answer.get('containing_procedure')expected_containing = reference['containing_procedure']['procedure']- for key in ['address', 'name']:- check('containing_procedure.' + key, containing.get(key, containing.get('procedure', {}).get(key)), expected_containing[key])- procedure = answer['procedure']+ if isinstance(containing, str):+ # Compare the explicitly reported display to the known source;+ # never parse a display name into a canonical lookup identity.+ check('containing_procedure.display', containing,+ expected_containing['name'] + ' @ ' + expected_containing['address'])+ else:+ containing = containing if isinstance(containing, dict) else {}+ nested = containing.get('procedure')+ nested = nested if isinstance(nested, dict) else {}+ for key in ['address', 'name']:+ check('containing_procedure.' + key, containing.get(key, nested.get(key)), expected_containing[key])+ procedure = answer.get('procedure')+ procedure = procedure if isinstance(procedure, dict) else {}expected = reference['procedure']for key in ['address', 'name', 'classification', 'signature', 'locals']:check('procedure.' + key, procedure.get(key), expected[key])- check('procedure.body_ranges', procedure.get('body_ranges', procedure.get('body', {}).get('ranges')), expected['body']['ranges'])- check('procedure.total_bytes', procedure.get('total_bytes', procedure.get('body', {}).get('total_bytes')), expected['body']['total_bytes'])+ body = procedure.get('body')+ body = body if isinstance(body, dict) else {}+ check('procedure.body_ranges', procedure.get('body_ranges', body.get('ranges', body.get('ranges_inclusive'))), expected['body']['ranges'])+ check('procedure.total_bytes', procedure.get('total_bytes', body.get('total_bytes')), expected['body']['total_bytes'])+ if 'load_image' in reference:+ sources = [source for source in producer_results.get('inspect_native_load_image', [])+ if isinstance(source, dict)+ and source.get('operation') == 'inspect_native_load_image'+ and isinstance(source.get('evidence_id'), str)+ and source.get('evidence_id') in reported_ids+ and isinstance(source.get('normalized_result'), dict)]+ checks['load_image_source_observed_and_referenced'] = bool(sources)+ load = sources[-1]['normalized_result'] if sources else {}+ entry = load.get('entry')+ entry = entry if isinstance(entry, dict) else {}+ check('load_image.target_sha256', load.get('target_sha256'), reference['artifact_sha256'])+ check('load_image.source_status', load.get('status'), reference['load_image']['status'])+ check('load_image.source_entry', entry.get('linear_address'), reference['entry_address'])+ status = answer.get('load_image_status')+ check('load_image_status', status.get('status') if isinstance(status, dict) else status, load.get('status'))+ if isinstance(status, dict):+ for key in ['format', 'load_segment', 'header_bytes', 'module_bytes', 'overlay_bytes']:+ if key in status:+ check('load_image.' + key, status[key], load.get(key))+ if 'entry_linear_address' in status:+ check('load_image.entry_linear_address', status['entry_linear_address'], entry.get('linear_address'))calls = summary['completed_mcp_calls']checks['default_analysis_not_disabled'] = all(not call['arguments'].get('skip_auto_analysis', False) for call in calls if call['tool'] == 'open_binary')checks['session_close_completed'] = any(call['tool'] == 'close_binary' and call['status'] == 'completed' for call in calls)@@ -248,6 +291,7 @@ def main():and events['memory.events'].get('high') == 0)report = {+ 'review_source_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'domain': domain, 'checks': checks, 'all_selected_checks_pass': all(checks.values()),'differences': differences, 'tool_errors': tool_errors, 'summary': summary,'fingerprints': {key: value for key, value in settings.items() if 'sha256' in key or key in ['runtime_revision', 'enabled_tools', 'authority']},diff --git a/tests/boundary/cli/nativeEfficiencyComparison.test.ts b/tests/boundary/cli/nativeEfficiencyComparison.test.tsnew file mode 100644index 000000000..65542f0ea--- /dev/null+++ b/tests/boundary/cli/nativeEfficiencyComparison.test.ts@@ -0,0 +1,336 @@+import { execFile } from "node:child_process";+import { mkdir, readFile, writeFile } from "node:fs/promises";+import { join, resolve } from "node:path";+import { promisify } from "node:util";++import { expect, it } from "vitest";++import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";++const execute = promisify(execFile);++// A recording port checks the experimental producer/consumer representation.+// Real provider verification remains in the separate native experiment receipts.+const generate = `+import {measureNativeEntry} from './experiments/analysis-efficiency/native-entry.mjs';+const sha='0'.repeat(64);+const duplicate=process.argv[1]==='duplicate';+const stale=process.argv[1]==='stale-dos';+const collision=process.argv[1];+const dos=process.argv[1]==='dos'||stale||collision==='load-collision';+const dossier={procedure:{address:'0x1000'},pseudocode:'return;',callers:[],callees:[]};+class ToolFailure extends Error {}+const build=async digit=>{+ const parent='ev_'+digit.repeat(63)+'0';+ let ordinal=0;+ const call=async(name,args)=>{+ if(stale)process.stdout.write(name+'\\n');+ if(name==='open_binary'||name==='close_binary')return {};+ if(name==='inspect_native_load_image')return {evidence_id:'ev_'+digit.repeat(63)+'6',normalized_result:{status:'verified',target_sha256:stale?'f'.repeat(64):sha,entry:{linear_address:'0x1000'}}};+ if(name==='resolve_containing_procedure')return {evidence_id:'ev_'+digit.repeat(63)+'7',normalized_result:{found:true}};+ if(name==='analyze_function')return {evidence_id:parent,subject:{digest:{sha256:sha}},normalized_result:dossier};+ const id='ev_'+digit.repeat(63)+(collision==='containing-collision'?7:collision==='load-collision'?6:duplicate?1:++ordinal);+ if(args.view.kind==='summary')return {evidence_id:id};+ const facet=args.view.facet;+ const item=facet==='pseudocode'?{text:dossier.pseudocode,unit:'utf16-code-units'}:dossier[facet];+ return {evidence_id:id,normalized_result:{parent_evidence_id:parent,artifact:{sha256:sha},item,coverage:{exhausted:true},limitations:[],unknowns:[]}};+ };+ return measureNativeEntry({seed:dos?undefined:'0x1000',values:{path:'/selected/input','native-question':'entry-views'},call,inputSha:sha,ToolFailure});+};+process.stdout.write(JSON.stringify([await build('1'),await build('2')]));+`;++it.each([+ "observed",+ "missing",+ "errored",+ "wrong-target",+ "wrong-entry",+ "unreferenced",+])(+ "binds the DOS model grade to its observed load image: %s",+ async (scenario) => {+ // Synthetic transcripts exercise grading; they are not real-provider or+ // resource measurements. Real DOS transcripts are replayed separately.+ const root = await createTestTempDirectory("rea-dos-grader-");+ const trial = join(root, "trial");+ const referenceDirectory = join(root, "reference");+ await mkdir(trial);+ await mkdir(referenceDirectory);+ const sha = "0".repeat(64);+ const imageId = "ev_" + "1".repeat(64);+ const procedureId = "ev_" + "2".repeat(64);+ const procedure = {+ address: "0x1000",+ name: "entry",+ classification: "observed",+ signature: null,+ locals: [],+ body: { ranges: [], total_bytes: 0 },+ };+ const loadImage = {+ status: "verified",+ target_sha256: sha,+ entry: { linear_address: "0x1000" },+ };+ const reference = {+ artifact_sha256: sha,+ entry_address: "0x1000",+ caller_count: 0,+ callee_count: 0,+ pseudocode_prefix: "return;",+ containing_procedure: { procedure },+ procedure,+ load_image: loadImage,+ };+ const answer = {+ ...reference,+ load_image_status: "verified",+ evidence_ids: [+ procedureId,+ ...(["missing", "errored", "unreferenced"].includes(scenario)+ ? []+ : [imageId]),+ ],+ };+ const event = (tool: string, status: string, value: unknown) => ({+ type: "item.completed",+ item: {+ type: "mcp_tool_call",+ tool,+ status,+ arguments: {},+ result: { structured_content: value },+ },+ });+ const events = [+ event("analyze_function", "completed", { evidence_id: procedureId }),+ ];+ if (scenario !== "missing")+ events.push(+ event(+ "inspect_native_load_image",+ scenario === "errored" ? "failed" : "completed",+ scenario === "errored"+ ? { error: { code: "unsupported_target" } }+ : {+ operation: "inspect_native_load_image",+ evidence_id: imageId,+ normalized_result: {+ ...loadImage,+ target_sha256:+ scenario === "wrong-target" ? "f".repeat(64) : sha,+ entry: {+ linear_address:+ scenario === "wrong-entry" ? "0x2000" : "0x1000",+ },+ },+ },+ ),+ );+ const resourceLog = join(root, "resource.log");+ const output = join(root, "review.json");+ for (const [path, value] of [+ [+ join(trial, "summary.json"),+ {+ completed_mcp_calls: [+ { tool: "close_binary", status: "completed", arguments: {} },+ ],+ },+ ],+ [join(trial, "trial-settings.json"), {}],+ [join(trial, "cleanup.json"), { profile_removed: true }],+ [join(trial, "answer.txt"), answer],+ [join(referenceDirectory, "answer.json"), reference],+ [+ resourceLog,+ {+ resource_scope: "synthetic-grader-fixture",+ abort: null,+ resource_counters_verified: true,+ resource_events_final: {+ "memory.events": { high: 0, max: 0, oom: 0, oom_kill: 0 },+ "pids.events": { max: 0 },+ },+ },+ ],+ ] as const)+ await writeFile(path, JSON.stringify(value));+ await writeFile(+ join(trial, "events.jsonl"),+ events.map((value) => JSON.stringify(value)).join("\n"),+ );+ const command = execute("python3", [+ resolve("experiments/analysis-efficiency/review-model.py"),+ "--domain",+ "native",+ "--trial",+ trial,+ "--reference",+ referenceDirectory,+ "--resource-log",+ resourceLog,+ "--output",+ output,+ ]);+ if (scenario === "observed") await command;+ else await expect(command).rejects.toMatchObject({ code: 1 });+ const report = JSON.parse(await readFile(output, "utf8"));+ expect(report.all_selected_checks_pass).toBe(scenario === "observed");+ if (["missing", "errored", "unreferenced"].includes(scenario))+ expect(report.checks.load_image_source_observed_and_referenced).toBe(+ false,+ );+ if (scenario === "wrong-target")+ expect(report.checks["load_image.target_sha256"]).toBe(false);+ if (scenario === "wrong-entry")+ expect(report.checks["load_image.source_entry"]).toBe(false);+ },+);++it("retains the DOS load-image source for its facts and derived entry seed", async () => {+ const { stdout } = await execute(process.execPath, [+ "--input-type=module",+ "-e",+ generate,+ "dos",+ ]);+ const [answer] = JSON.parse(stdout);+ expect(answer).toMatchObject({+ entry_address: "0x1000",+ load_image: { status: "verified", entry: { linear_address: "0x1000" } },+ evidence_ids: { native_load_image: "ev_" + "1".repeat(63) + "6" },+ });+});++it("rejects a stale DOS load image before using its entry and closes the session", async () => {+ await expect(+ execute(process.execPath, [+ "--input-type=module",+ "-e",+ generate,+ "stale-dos",+ ]),+ ).rejects.toMatchObject({+ stdout: "open_binary\ninspect_native_load_image\nclose_binary\n",+ stderr: expect.stringContaining(+ "The DOS load image belongs to a different target",+ ),+ });+});++it.each(["containing-collision", "load-collision"])(+ "rejects a retained view that reuses an earlier producer identity: %s",+ async (collision) => {+ await expect(+ execute(process.execPath, [+ "--input-type=module",+ "-e",+ generate,+ collision,+ ]),+ ).rejects.toMatchObject({+ stderr: expect.stringContaining(+ "Retained native view reused an Evidence identity",+ ),+ });+ },+);++it("rejects a producer that reuses a view identity across facets", async () => {+ await expect(+ execute(process.execPath, [+ "--input-type=module",+ "-e",+ generate,+ "duplicate",+ ]),+ ).rejects.toMatchObject({+ stderr: expect.stringContaining(+ "Retained native view reused an Evidence identity",+ ),+ });+});++it.each(["references", "item", "coverage", "limitations", "unknowns"])(+ "separates native references while comparing %s exactly",+ async (change) => {+ const { stdout: generated } = await execute(process.execPath, [+ "--input-type=module",+ "-e",+ generate,+ ]);+ const [leftAnswer, rightAnswer] = JSON.parse(generated);+ if (change === "item")+ rightAnswer.retained_views[0].item.address = "0x1001";+ if (change === "coverage")+ rightAnswer.retained_views[0].coverage.exhausted = false;+ if (change === "limitations")+ rightAnswer.retained_views[0].limitations.push("partial");+ if (change === "unknowns")+ rightAnswer.retained_views[0].unknowns.push("unresolved");++ const root = await createTestTempDirectory("rea-native-comparison-");+ const left = join(root, "left");+ const right = join(root, "right");+ const summary = {+ artifact: "sharex.exe",+ native_question: "entry-views",+ provider_search_path_sha256: "0".repeat(64),+ native_workflow_source_sha256: "1".repeat(64),+ calls: [],+ failure: null,+ };+ for (const [directory, answer] of [+ [left, leftAnswer],+ [right, rightAnswer],+ ]) {+ await mkdir(directory);+ await writeFile(join(directory, "summary.json"), JSON.stringify(summary));+ await writeFile(join(directory, "answer.json"), JSON.stringify(answer));+ }+ const output = join(root, "comparison.json");+ const command = execute(process.execPath, [+ resolve("experiments/analysis-efficiency/compare.mjs"),+ "--left",+ left,+ "--right",+ right,+ "--output",+ output,+ ]);+ if (change !== "references") {+ await expect(command).rejects.toMatchObject({+ code: 1,+ stdout: expect.stringContaining('"retained_views"'),+ });+ return;+ }+ const { stdout } = await command;+ expect(JSON.parse(stdout)).toMatchObject({+ settings_match: true,+ facts_match: true,+ preserved_run_specific_values: [+ {+ side: "left",+ path: ["evidence_ids"],+ value: leftAnswer.evidence_ids,+ },+ {+ side: "right",+ path: ["evidence_ids"],+ value: rightAnswer.evidence_ids,+ },+ ],+ });+ expect(leftAnswer.evidence_ids).not.toEqual(rightAnswer.evidence_ids);+ expect(leftAnswer.evidence_ids.retained_views[0]).toMatchObject({+ evidence_id: "ev_" + "1".repeat(64),+ parent_evidence_id: "ev_" + "1".repeat(63) + "0",+ });+ expect(leftAnswer.evidence_ids.native_summary).toBe(+ "ev_" + "1".repeat(63) + "5",+ );+ },+);