rea-agents 6.0.0 → 6.2.0

package/scripts/electron-active-hook.cjs

@@ -16,9 +16,19 @@ const ipcEventKinds = new Set([
   "ipc-renderer-post-message",
 ]);
 const events = [];
+// Budget serialized data and estimated retained object/array storage together.
+const retentionBudgetBytes = 16 * 1024 * 1024;
+const snapshotEnvelopeReserveBytes = 1024;
+let estimatedRetainedBytes = 0;
+let serializedBytes = 0;
 let observed = 0;
 let observedIpc = 0;
 let observedRuntime = 0;
+let dropped = 0;
+let droppedIpc = 0;
+let droppedRuntime = 0;
+const droppedFamilies = new Map();
+const droppedRoles = new Map();
 let sequence = 0;
 let correlationSequence = 0;
 
@@ -43,6 +53,73 @@ const shape = (value, depth = 0) => {
   }
 };
 
+// Measure JSON strings without allocating an encoded copy of a caller value.
+const jsonStringBytes = (value) => {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c) bytes += 2;
+    else if (
+      code === 0x08 ||
+      code === 0x09 ||
+      code === 0x0a ||
+      code === 0x0c ||
+      code === 0x0d
+    )
+      bytes += 2;
+    else if (code <= 0x1f) bytes += 6;
+    else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 6;
+    } else if (code >= 0xdc00 && code <= 0xdfff) bytes += 6;
+    else if (code <= 0x7f) bytes += 1;
+    else if (code <= 0x7ff) bytes += 2;
+    else bytes += 3;
+    if (bytes > retentionBudgetBytes) return bytes;
+  }
+  return bytes;
+};
+
+const jsonScalarBytes = (value) => {
+  if (value === null) return 4;
+  if (typeof value === "string") return jsonStringBytes(value);
+  if (typeof value === "boolean") return value ? 4 : 5;
+  return String(value).length;
+};
+
+const eventFamily = (kind, processTypeValue) => {
+  if (kind === "preload" && processTypeValue === "main")
+    return "preload-configuration";
+  if (kind.startsWith("ipc-renderer"))
+    return processTypeValue === "renderer" ? "renderer-ipc" : "ipc";
+  return ipcEventKinds.has(kind) ? "ipc" : kind;
+};
+
+const noteDropped = (kind, processTypeValue, isIpc) => {
+  dropped += 1;
+  if (isIpc) droppedIpc += 1;
+  else droppedRuntime += 1;
+  const family = eventFamily(kind, processTypeValue);
+  droppedFamilies.set(family, (droppedFamilies.get(family) ?? 0) + 1);
+  if (typeof processTypeValue === "string")
+    droppedRoles.set(
+      processTypeValue,
+      (droppedRoles.get(processTypeValue) ?? 0) + 1,
+    );
+  if (kind === "window-lifecycle")
+    droppedRoles.set("window", (droppedRoles.get("window") ?? 0) + 1);
+  if (kind === "web-contents-lifecycle" || kind === "navigation")
+    droppedRoles.set(
+      "web_contents",
+      (droppedRoles.get("web_contents") ?? 0) + 1,
+    );
+  if (kind === "preload" && processTypeValue === "preload")
+    droppedRoles.set("preload", (droppedRoles.get("preload") ?? 0) + 1);
+};
+
 const isAllowedNavigation = (value) => {
   if (typeof value !== "string") return true;
   try {
@@ -83,7 +160,8 @@ const frameIdentity = (event) => {
 
 const record = (event) => {
   observed += 1;
-  if (ipcEventKinds.has(event.kind)) observedIpc += 1;
+  const isIpc = ipcEventKinds.has(event.kind);
+  if (isIpc) observedIpc += 1;
   else observedRuntime += 1;
   const raw = {
     sequence: ++sequence,
@@ -109,10 +187,15 @@ const record = (event) => {
     error: false,
     ...event,
   };
-  const argumentShapes = Array.isArray(raw.argument_shapes)
+  const shapeGroups = Array.isArray(raw.argument_shape_value_groups)
+    ? raw.argument_shape_value_groups.filter(Array.isArray)
+    : Array.isArray(raw.argument_shape_values)
+      ? [raw.argument_shape_values]
+      : [];
+  const existingShapes = Array.isArray(raw.argument_shapes)
     ? raw.argument_shapes
     : [];
-  events.push({
+  const retainedEvent = {
     ...raw,
     correlation_id: raw.correlation_id,
     event: typeof raw.event === "string" ? raw.event : null,
@@ -121,9 +204,7 @@ const record = (event) => {
     receiver: typeof raw.receiver === "string" ? raw.receiver : null,
     frame: typeof raw.frame === "string" ? raw.frame : null,
     target: typeof raw.target === "string" ? raw.target : null,
-    argument_shapes: argumentShapes.map((value) =>
-      typeof value === "string" ? value : "unknown",
-    ),
+    argument_shapes: [],
     result_shape:
       typeof raw.result_shape === "string" ? raw.result_shape : null,
     process_type:
@@ -132,8 +213,91 @@ const record = (event) => {
       typeof raw.artifact_path === "string" ? raw.artifact_path : null,
     artifact_sha256:
       typeof raw.artifact_sha256 === "string" ? raw.artifact_sha256 : null,
-  });
-  return events.at(-1);
+  };
+  delete retainedEvent.argument_shape_values;
+  delete retainedEvent.argument_shape_value_groups;
+
+  // All event values are JSON scalars except argument_shapes. Measure them
+  // incrementally so large channels, paths, or shape lists never require a
+  // full JSON.stringify temporary allocation before the budget decision.
+  let eventBytes = 2;
+  let argumentShapeCount = 0;
+  const eventKeys = Object.keys(retainedEvent);
+  for (let index = 0; index < eventKeys.length; index += 1) {
+    const key = eventKeys[index];
+    const value = retainedEvent[key];
+    if (index > 0) eventBytes += 1;
+    eventBytes += jsonStringBytes(key) + 1;
+    if (key === "argument_shapes") {
+      eventBytes += 2;
+      let shapeOverflow = false;
+      const countShape = (argument) => {
+        const encodedShapeBytes = jsonStringBytes(shape(argument));
+        eventBytes += encodedShapeBytes + (argumentShapeCount === 0 ? 0 : 1);
+        argumentShapeCount += 1;
+        shapeOverflow =
+          eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
+          retentionBudgetBytes;
+      };
+      for (const group of shapeGroups)
+        for (const argument of group) {
+          countShape(argument);
+          if (shapeOverflow) break;
+        }
+      if (shapeOverflow) {
+        noteDropped(raw.kind, retainedEvent.process_type, isIpc);
+        return null;
+      }
+      for (const valueShape of existingShapes)
+        if (!shapeOverflow) {
+          eventBytes +=
+            jsonStringBytes(
+              typeof valueShape === "string" ? valueShape : "unknown",
+            ) + (argumentShapeCount++ === 0 ? 0 : 1);
+          shapeOverflow =
+            eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
+            retentionBudgetBytes;
+        }
+      if (shapeOverflow) {
+        noteDropped(raw.kind, retainedEvent.process_type, isIpc);
+        return null;
+      }
+    } else eventBytes += jsonScalarBytes(value);
+    if (
+      eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
+      retentionBudgetBytes
+    ) {
+      noteDropped(raw.kind, retainedEvent.process_type, isIpc);
+      return null;
+    }
+  }
+  // Reserve room for the only fields mutated after recording: result_shape and
+  // error. The shape vocabulary's longest value is "undefined".
+  const reservedMutationBytes = retainedEvent.result_shape === null ? 7 : 0;
+  // Include one byte for the event-array separator and reserve space for the
+  // snapshot's counters and JSON delimiters.
+  // One retained event, one defensive snapshot copy, and up to two serialized
+  // result views (timeline plus IPC), with per-object and per-array-slot costs.
+  const eventEstimateBytes = eventBytes * 3 + 512 + argumentShapeCount * 16;
+  const retainedEventBytes = eventEstimateBytes + reservedMutationBytes + 1;
+  if (
+    estimatedRetainedBytes + retainedEventBytes + snapshotEnvelopeReserveBytes >
+    retentionBudgetBytes
+  ) {
+    noteDropped(raw.kind, retainedEvent.process_type, isIpc);
+    return null;
+  }
+  for (const group of shapeGroups)
+    for (const argument of group)
+      retainedEvent.argument_shapes.push(shape(argument));
+  for (const valueShape of existingShapes)
+    retainedEvent.argument_shapes.push(
+      typeof valueShape === "string" ? valueShape : "unknown",
+    );
+  events.push(retainedEvent);
+  estimatedRetainedBytes += retainedEventBytes;
+  serializedBytes += eventBytes + reservedMutationBytes + 1;
+  return retainedEvent;
 };
 
 const recordRuntime = (kind, event, phase, details = {}) =>
@@ -145,7 +309,7 @@ const recordIpc = (kind, channel, args, details = {}) =>
     return record({
       kind,
       channel: typeof channel === "string" ? channel : null,
-      argument_shapes: values.map((value) => shape(value)),
+      argument_shape_values: values,
       ...details,
     });
   })();
@@ -222,7 +386,7 @@ const patchNavigationMethods = (webContents, contentsId) => {
     webContents[method] = function patchedNavigation(...args) {
       recordRuntime("navigation", method, "attempted", {
         target: contentsId,
-        argument_shapes: args.map((value) => shape(value)),
+        argument_shape_values: args,
       });
       if (method === "loadURL" && !isAllowedNavigation(args[0])) {
         recordRuntime("navigation", method, "blocked", {
@@ -354,7 +518,7 @@ const patchWebContents = (webContents, windowId) => {
         recordRuntime("navigation", event, "blocked", {
           target: contentsId,
           sender: windowId,
-          argument_shapes: args.map((value) => shape(value)),
+          argument_shape_values: args,
           error: true,
         });
         return;
@@ -363,7 +527,7 @@ const patchWebContents = (webContents, windowId) => {
     recordRuntime(kind, event, "observed", {
       target: contentsId,
       sender: windowId,
-      argument_shapes: args.map((value) => shape(value)),
+      argument_shape_values: args,
       error: kind === "error",
     });
     if (event === "did-create-window") {
@@ -379,31 +543,44 @@ const patchWebContents = (webContents, windowId) => {
   boundaries.patchWindowOpenHandler(webContents, contentsId);
 };
 
-const patchBrowserWindow = (electron) => {
-  const original = electron.BrowserWindow;
-  if (typeof original !== "function") return;
-  electron.BrowserWindow = new Proxy(original, {
-    construct(target, args, newTarget) {
-      const window = Reflect.construct(target, args, newTarget);
-      const targetId = identity(window, "window");
-      recordRuntime("window-lifecycle", "created", "completed", {
-        target: targetId,
-        argument_shapes: args.map((value) => shape(value)),
-      });
-      const preload = args[0]?.webPreferences?.preload;
+const patchWindows = (app) => {
+  if (app === null || app === undefined) return;
+  app.on("browser-window-created", (_event, window) => {
+    const targetId = identity(window, "window");
+    recordRuntime("window-lifecycle", "created", "completed", {
+      target: targetId,
+      capture_method: "event-emitter",
+    });
+    try {
+      // Electron 44 separates the preload descriptor from WebPreferences.
+      // Read the engine's descriptor, never infer a path from application code.
+      const preferences = window.webContents.getLastWebPreferences?.();
+      const preload =
+        typeof preferences?.preload === "string"
+          ? preferences.preload
+          : window.webContents._getPreloadScript?.()?.filePath;
       if (typeof preload === "string")
         recordRuntime("preload", "configured", "completed", {
           target: targetId,
           artifact_path: preload,
         });
-      patchEmitter(window, (event) =>
-        recordRuntime("window-lifecycle", event, "observed", {
+    } catch (cause) {
+      recordRuntime(
+        "error",
+        cause instanceof Error ? cause.message : String(cause),
+        "failed",
+        {
           target: targetId,
-        }),
+          error: true,
+        },
       );
-      patchWebContents(window.webContents, targetId);
-      return window;
-    },
+    }
+    patchEmitter(window, (event) =>
+      recordRuntime("window-lifecycle", event, "observed", {
+        target: targetId,
+      }),
+    );
+    patchWebContents(window.webContents, targetId);
   });
 };
 
@@ -427,7 +604,7 @@ try {
       "observed",
       {
         target: "app",
-        argument_shapes: args.map((value) => shape(value)),
+        argument_shape_values: args,
         process_type: "main",
       },
     ),
@@ -435,33 +612,60 @@ try {
   patchIpcMain(electron.ipcMain);
   boundaries.patchIpcRenderer(electron.ipcRenderer);
   boundaries.patchContextBridge(electron.contextBridge);
-  patchBrowserWindow(electron);
+  patchWindows(electron.app);
   boundaries.patchUtilityProcess(electron.utilityProcess);
   boundaries.patchShell(electron.shell);
-  boundaries.patchSessionManager(electron.session);
+  boundaries.patchSessionManager(electron.session, electron.app);
   boundaries.patchApplicationEffects(electron.app);
   boundaries.patchNativeAddonLoading();
   boundaries.patchChildProcess();
   process.once("uncaughtException", (cause, origin) => {
     recordRuntime("process-lifecycle", "uncaught-exception", "observed", {
-      argument_shapes: [shape(cause), shape(origin)],
+      argument_shape_values: [cause, origin],
       error: true,
     });
     throw cause;
   });
   process.once("unhandledRejection", (reason, promise) => {
     recordRuntime("process-lifecycle", "unhandled-rejection", "observed", {
-      argument_shapes: [shape(reason), shape(promise)],
+      argument_shape_values: [reason, promise],
       error: true,
     });
     throw reason;
   });
-} catch {
+} catch (cause) {
   globalThis.__reaElectronActiveHookError = true;
+  recordRuntime(
+    "error",
+    cause instanceof Error ? cause.message : String(cause),
+    "failed",
+    {
+      target: "active-hook-installation",
+      error: true,
+    },
+  );
 }
 
 globalThis.__reaElectronActiveSnapshot = () => ({
-  events: events.slice(),
+  events: events.map((event) => ({
+    ...event,
+    argument_shapes: [...event.argument_shapes],
+  })),
+  retention_budget_bytes: retentionBudgetBytes,
+  estimated_retained_bytes: estimatedRetainedBytes,
+  event_serialized_byte_upper_bound: serializedBytes,
+  retained: events.length,
+  dropped,
+  dropped_ipc: droppedIpc,
+  dropped_runtime: droppedRuntime,
+  dropped_event_families: [...droppedFamilies].map(([family, count]) => ({
+    family,
+    count,
+  })),
+  dropped_event_roles: [...droppedRoles].map(([role, count]) => ({
+    role,
+    count,
+  })),
   observed,
   observed_ipc: observedIpc,
   observed_runtime: observedRuntime,

package/scripts/rea.mjs

@@ -44,7 +44,6 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
   const {
     renderCliOutputArgumentError,
     renderEmptyFilteredCliOutput,
-    sanitizeCliOutput,
     validateCliOutputArguments,
   } = await import("../dist/cliOutput.js");
   const outputArguments = validateCliOutputArguments(args);
@@ -57,13 +56,11 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
     await createCli(process.env, resultOutput).serve(args, {
       stdout: (output) => {
         if (resultOutput?.handled) {
-          if (resultOutput.failed)
-            process.stderr.write(sanitizeCliOutput(output));
+          if (resultOutput.failed) process.stderr.write(output);
           return;
         }
-        const sanitized = sanitizeCliOutput(output);
-        if (sanitized.length > 0) wroteOutput = true;
-        process.stdout.write(sanitized);
+        if (output.length > 0) wroteOutput = true;
+        process.stdout.write(output);
       },
     });
     if (!wroteOutput && !resultOutput?.handled)

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

@@ -2,9 +2,8 @@
 name: reverse-engineer-anything
 description: Reverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.
 metadata:
-  version: "33"
+  version: "34"
   tool_count: 139
-  catalog_digest: "4c5f67d076baf821b5cb6d6fb2cc0f6c274e96b627b85b892577760a6f71ab1a"
 ---
 
 # REA
@@ -33,7 +32,9 @@ When tools are absent or registration is stale:
    `npx -y rea-agents@latest doctor --client codex --json`. Substitute the current
    supported client: `claude_code`, `claude_desktop`, `codex`, `cursor`,
    `gemini_cli`, `windsurf`, `devin`, `opencode`, `antigravity`, `copilot_cli`,
-   `commandcode`, or `vscode`. If the client is unknown, use `doctor --json` and
+   `commandcode`, `vscode`, `grok_build`, or `grok_bot`. `grok_bot` has no local
+   file registration: doctor reports the Grok Bot chat step, and setup does not
+   write `mcp.json`. If the client is unknown, use `doctor --json` and
    inspect its registration results before choosing a setup scope.
 2. Distinguish the reason. Missing, malformed, or stale registration needs a
    scoped configuration repair. An aligned registration with no tools in the
@@ -146,6 +147,14 @@ Start with the default result and use its inline Evidence and graph context.
 Do not repeat an identical tool call. Make a focused follow-up only when the
 returned result leaves a specific question unanswered.
 
+If MCP reports `resource_constraint` with `details.resource: "transport"`, call
+`inspect_analysis_view` with its reported same-session Evidence reference for a
+summary, one section/module, or a stable page. Use `trace_application_feature`
+once a seed is known, or call `export_evidence_bundle` to write the complete
+session to a selected path. The analysis remains complete in the ledger; avoid
+repeating it merely to request the same oversized response. Complete CLI JSON
+output also streams without a single MCP frame.
+
 Every conclusion must distinguish observations, inferences, and unknowns. Cite
 Evidence IDs, preserve limitations and incomplete coverage, and never imply
 that static analysis observed execution. Runtime requests execute the declared

package/skills/reverse-engineer-anything/references/android-applications.md

@@ -19,9 +19,12 @@ can select Java. REA setup does not install or configure that JAR, and doctor
 provider scopes cover Hopper/Ghidra rather than JADX. Use existing tools and
 report missing prerequisites for the Android task specifically.
 
-Real verification covers Linux. macOS has the POSIX launch boundary but no
-claimed real-provider verification; Windows is unsupported. Calls use one
-worker, a bounded JVM heap, and provider deadlines. The APK is never launched,
+Linux and macOS use the POSIX owned-process boundary. Windows x64 requires the
+matching bundled native controls and uses an owned Job Object with bidirectional
+stdio. A full JDK, including `jdk.compiler`, is required on every host; Windows
+`JAVA_HOME` selects `bin\java.exe`. Consult the Android guide for actual host
+verification coverage. Calls use one worker and provider deadlines; optional
+`REA_JADX_HEAP_MIB` selects the JVM heap. The APK is never launched,
 and no emulator is required.
 
 Manifest entries and decompiled text are static observations, not execution or

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

@@ -1,11 +1,15 @@
 # Evidence, comparison, and verification workflows
 
-REA returns Evidence with each result. Read that result directly, cite its
-Evidence ID when another tool or your explanation needs a stable reference, and
-preserve authority, limitations, coverage, and residual unknowns. If a result
+Evidence-producing tools return the complete Evidence record directly in MCP
+`structuredContent` and CLI JSON. Read `normalized_result` for operation data,
+and cite `evidence_id` when another tool or your explanation needs a stable
+reference. Preserve authority, limitations, coverage, and residual unknowns. If a result
 is incomplete or paginated, continue only when the remaining data matters to
 the task; do not fetch a bundle or resource merely to read a result already
-returned inline.
+returned inline. When complete `inspect_binary_layout` or
+`analyze_javascript_application` Evidence is already retained, call
+`inspect_analysis_view` for a summary, one section/symbol/module, or a stable
+page instead of repeating the producer.
 
 Use `record_unknown` to track unresolved questions in the user's investigation
 and name the authority or environment still required. Supply supporting and

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

@@ -2,10 +2,19 @@
 
 Use `analyze_javascript_application` directly on the operator-supplied ASAR or
 extracted tree. The complete result, graph, and Evidence context are returned
-inline. Source-map contents are part of the static analysis. Start from its
+inline when they fit the MCP frame. Source-map contents are part of the static analysis. Start from its
 findings, coverage, unknowns, and graph context, then make a focused follow-up
 only when a specific question remains unanswered.
 
+An oversized response reports `resource_constraint` and
+`details.resource: "transport"`. Reuse
+`details.reported_limits.evidence_reference` with `inspect_analysis_view` for a
+summary, one module, or a stable page of module identities. Use
+`trace_application_feature` once a module, route, or string seed is known.
+`export_evidence_bundle` writes the complete canonical session to a
+caller-selected file. These workflows keep the original Evidence and coverage;
+a broad follow-up can also exceed framing.
+
 BrowserWindow preferences, preload and contextBridge surfaces, IPC
 registrations, utility processes, and native binding requests are static syntax
 observations. Only a unique exact literal IPC channel match supports an inferred
@@ -31,7 +40,13 @@ changed, analyze each version once and then call
 `compare_javascript_export_shapes` with explicit module paths and export names.
 Use the returned IDs on the same connection, or complete inline Evidence
 records, from both analysis calls. Accept variant
-pairing only through the tool's unique exact literal discriminant. Cite the
+pairing only through the tool's unique exact literal discriminant. Read
+`property_inventories` and each change's `presence` before treating `unknown` as
+"the name was not observed": inventories list observed property names even when
+values stay unknown, with a `source_range` for each paired or unpaired variant.
+Array holes and mutation-invalidated slots are not observed properties.
+Complete parent coverage reports presence-only
+`added`/`removed` independently of unresolved values. Cite the
 comparison Evidence and report JSON Pointer changes; dynamic values, ambiguous
 variants, and incomplete parent-property coverage stay unknown. This is static
 inference, not runtime behavior. When runtime semantics are needed, run
@@ -43,7 +58,9 @@ through the available browser, Electron, or process workflows.
 When advertised by the connected server, application trace and compare tools
 accept complete inline Evidence or
 `{"kind":"retained-evidence","evidence_id":"ev_<64 lowercase hex characters>"}`
-for their application input (`application`, or `left`/`right`). This notation is
+for their application input (`application`, or `left`/`right`). `inspect_analysis_view`
+uses the same retained-reference form in `source`, or portable inline Evidence,
+to project a summary, module page, or one module with its recorded observations. This notation is
 a template: replace it with the actual returned ID. Versions before 4.1.0 accept only full
 inline Evidence. Use the exact ID
 returned by the producer on the same MCP connection. Resolution does not run

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

@@ -16,6 +16,15 @@ Requested unavailable context fails with setup guidance. See
 [recorded crashes](https://github.com/morluto/rea/blob/main/docs/recorded-crashes.md)
 for exact upstream profiles, bounds and verification coverage.
 
+## Offline ELF layout
+
+Use `inspect_binary_layout` with an explicit local ELF path for file-backed
+sections, symbols, relocations, linkage names, and static mitigation inferences
+without opening a disassembler target. When that complete record is already
+retained, call `inspect_analysis_view` for a summary, mitigations or linkage
+facet, one section or symbol, or a stable page. Do not re-run the decoder to
+read a single object.
+
 ## Native targets
 
 After `open_binary`, use focused search, procedure, or function tools directly.

package/dist/config.js

@@ -1 +0,0 @@
-export { parseConfig } from "./config/parseConfig.js";

package/dist/contracts/browserCaptureToolInputSchema.js

@@ -1,43 +0,0 @@
-import { browserCaptureComparisonInputSchema } from "../domain/browserCaptureComparison.js";
-import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
-import { captureSnapshotSchema } from "../domain/webCaptureDiffSchemas.js";
-// Captures are complete producer results to pass back unchanged, rather than
-// analyst-authored options. Describe that boundary without embedding the entire
-// inspection result schema in every comparison input. The cloned parser still
-// validates every nested field using the canonical domain schemas.
-const passiveCaptureInputSchema = captureSnapshotSchema.clone(captureSnapshotSchema.def);
-passiveCaptureInputSchema._zod.toJSONSchema = () => ({
-    type: "object",
-    properties: {
-        inspection: {
-            type: "object",
-            description: "Complete result object returned by inspect_web_page. Pass the entire result unchanged, including capture identity, observations, completeness, and limitations. Every nested field is validated by REA.",
-        },
-        webmcp: {
-            anyOf: [{ type: "object" }, { type: "null" }],
-            default: null,
-            description: "Complete result object returned by discover_webmcp_tools for this capture, or null when it was not recorded. Pass the entire result unchanged. Every nested field is validated by REA.",
-        },
-    },
-    required: ["inspection"],
-});
-const scenarioCaptureInputSchema = browserScenarioCaptureSchema.clone(browserScenarioCaptureSchema.def);
-scenarioCaptureInputSchema._zod.toJSONSchema = () => ({
-    type: "object",
-    description: "Complete result object returned by capture_browser_scenario. Pass the entire result unchanged, including browser and scenario identity, steps, events, artifact contents and digests, completeness, and limitations. Every nested field is validated by REA.",
-});
-/** Advertise capture round trips while retaining full runtime validation. */
-export const browserCaptureToolInputSchema = browserCaptureComparisonInputSchema.safeExtend({
-    before: passiveCaptureInputSchema
-        .optional()
-        .describe("Earlier passive web-page capture with complete producer results."),
-    after: passiveCaptureInputSchema
-        .optional()
-        .describe("Later passive web-page capture with complete producer results."),
-    before_scenario: scenarioCaptureInputSchema
-        .optional()
-        .describe("Earlier complete result object returned by capture_browser_scenario."),
-    after_scenario: scenarioCaptureInputSchema
-        .optional()
-        .describe("Later complete result object returned by capture_browser_scenario."),
-});

package/dist/contracts/process/processCaptureExample.js

@@ -1,2 +0,0 @@
-/** Minimal valid process capture retained as a public contract example. */
-export { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../../domain/process/processCaptureExample.js";

package/dist/contracts/toolOutputSchemas.js

@@ -1,2 +0,0 @@
-export * from "./toolOutputSchemaPrimitives.js";
-export * from "./toolOutputSchemaGroups.js";

package/dist/ghidra/GhidraDefaults.js

@@ -1,2 +0,0 @@
-/** Absolute import, analysis, bridge, and health startup deadline. */
-export const GHIDRA_STARTUP_TIMEOUT_MS = 330_000;

package/dist/main/reload.js

@@ -1,12 +0,0 @@
-import { parseConfig } from "../config.js";
-export const registerConfigReload = (input) => {
-    const { dependencies, runtimeState, serverLogger } = input;
-    return (dependencies.registerReload?.(() => {
-        const refreshed = parseConfig(dependencies.env);
-        if (!refreshed.ok) {
-            serverLogger.error("Reloaded REA configuration is invalid");
-            return;
-        }
-        runtimeState.currentConfig = refreshed.value;
-    }) ?? (() => undefined));
-};

package/dist/main/state.js

@@ -1,3 +0,0 @@
-export const createRuntimeState = (config) => ({
-    currentConfig: config,
-});

package/dist/server/sessionToolPolicies.js

@@ -1,2 +0,0 @@
-export { PROCESS_PROVIDER } from "../application/process/ProcessEvidence.js";
-export { ARTIFACT_COMPARISON_PROVIDER, BUNDLE_COMPARISON_PROVIDER, CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, FUNCTION_COMPARISON_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "../application/InvestigationProviders.js";