rea-agents 6.3.0 → 6.4.0

package/dist/contracts/adb/adbToolContracts.js

@@ -0,0 +1,353 @@
+import { adbInputSchemas, adbResultSchemas, } from "../../domain/adb/adbDeviceAnalysis.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "../toolEffects.js";
+/** ADB device inspection and acquisition over a caller-supplied binary. */
+export const ADB_TOOL_CONTRACTS = [
+    {
+        name: "inspect_adb_client",
+        ...toolContractMetadata("inspect_adb_client"),
+        description: "Inspect the caller-selected adb client: resolved binary, version, and install path. Never contacts devices and never starts the adb server. REA never installs platform tools; select a binary with REA_ADB_PATH (absolute) or adb on PATH.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.inspect_adb_client,
+        outputSchema: evidenceResultOf(adbResultSchemas.inspect_adb_client),
+        examples: [{ title: "Check the adb client", input: {} }],
+    },
+    {
+        name: "list_adb_devices",
+        ...toolContractMetadata("list_adb_devices"),
+        description: "List attached devices exactly as `adb devices -l` reports them: serial, state, transport, model metadata, and an inferred emulator/physical kind with its evidence basis. Emulators and USB or network devices appear alike; REA neither starts nor manages them. May start the local adb server on first use.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_devices,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_devices),
+        examples: [{ title: "List attached devices", input: {} }],
+    },
+    {
+        name: "inspect_adb_device",
+        ...toolContractMetadata("inspect_adb_device"),
+        description: "Inspect one device's build identity through a fixed `getprop` whitelist: Android and SDK versions, security patch, fingerprint, product identity, CPU ABIs, and debuggable flag, plus the observed emulator indicator ro.kernel.qemu. Read-only with respect to the device.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.inspect_adb_device,
+        outputSchema: evidenceResultOf(adbResultSchemas.inspect_adb_device),
+        examples: [
+            { title: "Inspect one device", input: { serial: "emulator-5554" } },
+        ],
+    },
+    {
+        name: "list_adb_packages",
+        ...toolContractMetadata("list_adb_packages"),
+        description: "List installed packages on one device with each base APK's device path, optionally scoped to third-party or system packages. Paths are device filesystem paths, not host-local. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_packages,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_packages),
+        examples: [
+            {
+                title: "List third-party packages",
+                input: { serial: "emulator-5554", scope: "third_party" },
+            },
+        ],
+    },
+    {
+        name: "pull_adb_package",
+        ...toolContractMetadata("pull_adb_package"),
+        description: "Pull one installed package's complete APK set (base plus every split, as `pm path` reports) from the device into a caller-selected output directory, creating a package-named subdirectory that must not already exist. Every pulled file is digested with SHA-256; partial pulls keep successful artifacts and per-file failure reasons. The device keeps the originals.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.pull_adb_package,
+        outputSchema: evidenceResultOf(adbResultSchemas.pull_adb_package),
+        examples: [
+            {
+                title: "Pull a package APK set",
+                input: {
+                    serial: "emulator-5554",
+                    package: "com.example.app",
+                    output_directory: "/tmp/rea-pulls",
+                },
+            },
+        ],
+    },
+    {
+        name: "read_adb_logcat",
+        ...toolContractMetadata("read_adb_logcat"),
+        description: "Read a bounded dump of the device log (`logcat -d -t`) for one buffer, optionally restricted to a process id. No streaming, no clearing; the newest lines are kept when the count cap trims. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.read_adb_logcat,
+        outputSchema: evidenceResultOf(adbResultSchemas.read_adb_logcat),
+        examples: [
+            {
+                title: "Read the last 200 main-buffer lines",
+                input: { serial: "emulator-5554", count: 200, buffer: "main" },
+            },
+        ],
+    },
+    {
+        name: "inspect_adb_package",
+        ...toolContractMetadata("inspect_adb_package"),
+        description: "Inspect one installed package through `dumpsys package`: version name/code, install and update times, installer, user id, flags, and the requested-permission count. A fixed projection of version-dependent output; unknown sections are ignored rather than guessed. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.inspect_adb_package,
+        outputSchema: evidenceResultOf(adbResultSchemas.inspect_adb_package),
+        examples: [
+            {
+                title: "Inspect an installed package",
+                input: { serial: "emulator-5554", package: "com.example.app" },
+            },
+        ],
+    },
+    {
+        name: "pull_adb_file",
+        ...toolContractMetadata("pull_adb_file"),
+        description: "Pull one absolute device path (a database, shared-preferences XML, or any readable file) into a caller-selected output directory, digesting it with SHA-256. The local copy must not already exist. Read-only with respect to the device.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.pull_adb_file,
+        outputSchema: evidenceResultOf(adbResultSchemas.pull_adb_file),
+        examples: [
+            {
+                title: "Pull an app database",
+                input: {
+                    serial: "emulator-5554",
+                    device_path: "/data/data/com.example.app/databases/app.db",
+                    output_directory: "/tmp/rea-pulls",
+                },
+            },
+        ],
+    },
+    {
+        name: "push_adb_file",
+        ...toolContractMetadata("push_adb_file"),
+        description: "Push one local file to an absolute device path. The only device-mutating ADB tool: existing device files are refused unless overwrite is explicitly requested, and the transfer is verified by comparing the local digest with the device's own sha256sum when the device provides one.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.push_adb_file,
+        outputSchema: evidenceResultOf(adbResultSchemas.push_adb_file),
+        examples: [
+            {
+                title: "Push a script to tmp",
+                input: {
+                    serial: "emulator-5554",
+                    local_path: "/tmp/frida-server",
+                    device_path: "/data/local/tmp/frida-server",
+                },
+            },
+        ],
+    },
+    {
+        name: "capture_adb_screen",
+        ...toolContractMetadata("capture_adb_screen"),
+        description: "Capture one frame of the device screen as a PNG (`screencap -p` through exec-out, no device-side file) into a caller-selected output directory, digesting it and reporting its dimensions. No recording or interaction.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.capture_adb_screen,
+        outputSchema: evidenceResultOf(adbResultSchemas.capture_adb_screen),
+        examples: [
+            {
+                title: "Capture the current screen",
+                input: {
+                    serial: "emulator-5554",
+                    output_directory: "/tmp/rea-captures",
+                },
+            },
+        ],
+    },
+    {
+        name: "list_adb_processes",
+        ...toolContractMetadata("list_adb_processes"),
+        description: "List running processes exactly as `ps -A` reports them: user, pid, ppid, rss, state, and name. Useful for pairing with instrumentation lanes. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_processes,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_processes),
+        examples: [{ title: "List processes", input: { serial: "emulator-5554" } }],
+    },
+    {
+        name: "list_adb_directory",
+        ...toolContractMetadata("list_adb_directory"),
+        description: "List one absolute device directory (`ls -la`): names, kinds, permissions, owner, group, sizes, dates, and symlink targets. Recognizes the standard errors for absent paths and denied reads. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_directory,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_directory),
+        examples: [
+            {
+                title: "List an app's data directory",
+                input: {
+                    serial: "emulator-5554",
+                    device_path: "/data/data/com.example.app",
+                },
+            },
+        ],
+    },
+    {
+        name: "list_adb_features",
+        ...toolContractMetadata("list_adb_features"),
+        description: "List the device's declared hardware and software features (`pm list features`) for device fingerprinting. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_features,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_features),
+        examples: [{ title: "List features", input: { serial: "emulator-5554" } }],
+    },
+    {
+        name: "list_adb_services",
+        ...toolContractMetadata("list_adb_services"),
+        description: "List the device's binder services with their interfaces (`service list`). Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.list_adb_services,
+        outputSchema: evidenceResultOf(adbResultSchemas.list_adb_services),
+        examples: [{ title: "List services", input: { serial: "emulator-5554" } }],
+    },
+    {
+        name: "inspect_adb_display",
+        ...toolContractMetadata("inspect_adb_display"),
+        description: "Report the display's physical and any overridden size (`wm size`) and density (`wm density`) as the device declares them. Read-only; setting values is not exposed.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.inspect_adb_display,
+        outputSchema: evidenceResultOf(adbResultSchemas.inspect_adb_display),
+        examples: [
+            { title: "Inspect the display", input: { serial: "emulator-5554" } },
+        ],
+    },
+    {
+        name: "inspect_adb_window",
+        ...toolContractMetadata("inspect_adb_window"),
+        description: "Report the window manager's current focus declarations (`dumpsys window windows`: mCurrentFocus and mFocusedApp) — what is on screen at read time without any interaction. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.inspect_adb_window,
+        outputSchema: evidenceResultOf(adbResultSchemas.inspect_adb_window),
+        examples: [
+            { title: "Inspect window focus", input: { serial: "emulator-5554" } },
+        ],
+    },
+    {
+        name: "read_adb_setting",
+        ...toolContractMetadata("read_adb_setting"),
+        description: "Read one settings value (`settings get`) from the system, secure, or global namespace. Absent keys report the device's own null observation. Read-only; writing settings is not exposed.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.read_adb_setting,
+        outputSchema: evidenceResultOf(adbResultSchemas.read_adb_setting),
+        examples: [
+            {
+                title: "Read the ADB-enabled setting",
+                input: {
+                    serial: "emulator-5554",
+                    namespace: "secure",
+                    key: "adb_enabled",
+                },
+            },
+        ],
+    },
+    {
+        name: "collect_adb_bugreport",
+        ...toolContractMetadata("collect_adb_bugreport"),
+        description: "Collect one device-generated bugreport archive (`adb bugreport`) into a caller-selected output directory, digesting the zip. The archive contains the device's own dumpstate, dumpsys, and logcat report; collection can take minutes. Read-only with respect to configuration.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.collect_adb_bugreport,
+        outputSchema: evidenceResultOf(adbResultSchemas.collect_adb_bugreport),
+        examples: [
+            {
+                title: "Collect a bugreport",
+                input: {
+                    serial: "emulator-5554",
+                    output_directory: "/tmp/rea-bugreports",
+                },
+            },
+        ],
+    },
+    {
+        name: "resolve_adb_packages",
+        ...toolContractMetadata("resolve_adb_packages"),
+        description: "Find installed packages by case-insensitive substring of the package name (e.g. `whatsapp` → `com.whatsapp`), returning each match's base APK device path. The first step of an easy get: resolve, then pull_adb_package the exact name. Read-only.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.resolve_adb_packages,
+        outputSchema: evidenceResultOf(adbResultSchemas.resolve_adb_packages),
+        examples: [
+            {
+                title: "Find a package by partial name",
+                input: { serial: "emulator-5554", query: "whatsapp" },
+            },
+        ],
+    },
+    {
+        name: "install_adb_package",
+        ...toolContractMetadata("install_adb_package"),
+        description: "Install one local APK on the device (`adb install [-r]`), recording the APK's host digest and byte size. A device-mutating tool: `replace` re-installs over an existing package while keeping its data; the device's own Success/Failure verdict is preserved with its reason.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.install_adb_package,
+        outputSchema: evidenceResultOf(adbResultSchemas.install_adb_package),
+        examples: [
+            {
+                title: "Install an APK",
+                input: { serial: "emulator-5554", apk_path: "/tmp/app.apk" },
+            },
+            {
+                title: "Replace an existing install keeping data",
+                input: {
+                    serial: "emulator-5554",
+                    apk_path: "/tmp/app.apk",
+                    replace: true,
+                },
+            },
+        ],
+    },
+    {
+        name: "uninstall_adb_package",
+        ...toolContractMetadata("uninstall_adb_package"),
+        description: "Uninstall one package from the device (`adb uninstall`), removing its data for user 0. A device-mutating tool; absent packages report the device's own refusal reason.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.uninstall_adb_package,
+        outputSchema: evidenceResultOf(adbResultSchemas.uninstall_adb_package),
+        examples: [
+            {
+                title: "Uninstall a package",
+                input: { serial: "emulator-5554", package: "com.example.app" },
+            },
+        ],
+    },
+    {
+        name: "start_adb_app",
+        ...toolContractMetadata("start_adb_app"),
+        description: "Start one installed app by launching its declared launcher activity: the component is resolved through `cmd package resolve-activity --brief`, then started with `am start -n`. A device-mutating tool for dynamic-analysis workflows; pair with `read_adb_logcat` (pid filter) and `list_adb_processes` to observe the started app, and `stop_adb_app` to end the run.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.start_adb_app,
+        outputSchema: evidenceResultOf(adbResultSchemas.start_adb_app),
+        examples: [
+            {
+                title: "Start an app",
+                input: { serial: "emulator-5554", package: "com.example.app" },
+            },
+        ],
+    },
+    {
+        name: "start_adb_activity",
+        ...toolContractMetadata("start_adb_activity"),
+        description: "Start an intent with `am start`: one action, optional data URI, optional explicit component, and up to 16 typed extras (string, boolean, int, long, float). A device-mutating tool; the activity manager's Starting/Error verdict is preserved verbatim.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.start_adb_activity,
+        outputSchema: evidenceResultOf(adbResultSchemas.start_adb_activity),
+        examples: [
+            {
+                title: "Open a deep link",
+                input: {
+                    serial: "emulator-5554",
+                    action: "android.intent.action.VIEW",
+                    data_uri: "https://example.com/path",
+                },
+            },
+            {
+                title: "Start with typed extras",
+                input: {
+                    serial: "emulator-5554",
+                    action: "com.example.APP_ACTION",
+                    extras: [{ key: "level", type: "int", value: "3" }],
+                },
+            },
+        ],
+    },
+    {
+        name: "stop_adb_app",
+        ...toolContractMetadata("stop_adb_app"),
+        description: "Force-stop every process of one package (`am force-stop`), ending a dynamic-analysis run. A device-mutating tool; it succeeds whether or not the package had running processes.",
+        kind: "adb-provider",
+        inputSchema: adbInputSchemas.stop_adb_app,
+        outputSchema: evidenceResultOf(adbResultSchemas.stop_adb_app),
+        examples: [
+            {
+                title: "Stop an app",
+                input: { serial: "emulator-5554", package: "com.example.app" },
+            },
+        ],
+    },
+];

package/dist/contracts/advertisedInputExamples.js

@@ -0,0 +1,48 @@
+import { evidenceSchema } from "../domain/evidence.js";
+/** The Evidence identifier of a complete Evidence record, or undefined. */
+const evidenceRecordId = (value) => typeof value.evidence_id === "string" &&
+    Object.hasOwn(value, "normalized_result") &&
+    evidenceSchema.safeParse(value).success
+    ? value.evidence_id
+    : undefined;
+/** Replace each embedded complete Evidence record with its exact retained reference. */
+const referenceEmbeddedEvidence = (value) => {
+    if (Array.isArray(value)) {
+        const items = value.map(referenceEmbeddedEvidence);
+        return {
+            value: items.map((item) => item.value),
+            embedsEvidence: items.some((item) => item.embedsEvidence),
+        };
+    }
+    if (value === null || typeof value !== "object")
+        return { value, embedsEvidence: false };
+    const evidenceId = evidenceRecordId(value);
+    if (evidenceId !== undefined)
+        return {
+            value: { kind: "retained-evidence", evidence_id: evidenceId },
+            embedsEvidence: true,
+        };
+    const entries = Object.entries(value).map(([key, child]) => [key, referenceEmbeddedEvidence(child)]);
+    return {
+        value: Object.fromEntries(entries.map(([key, child]) => [key, child.value])),
+        embedsEvidence: entries.some(([, child]) => child.embedsEvidence),
+    };
+};
+/**
+ * Examples advertised in a tool's input schema. Embedded complete Evidence is
+ * shown as its exact same-session retained reference when the canonical input
+ * schema accepts that form; an example that can only carry inline Evidence
+ * stays in the canonical contract and its executable tests but leaves the
+ * advertisement. Every advertised example is a distinct valid canonical input.
+ */
+export const advertisedInputExamples = (contract) => {
+    const advertised = new Map();
+    for (const { input } of contract.examples) {
+        const projection = referenceEmbeddedEvidence(input);
+        if (projection.embedsEvidence &&
+            !contract.inputSchema.safeParse(projection.value).success)
+            continue;
+        advertised.set(JSON.stringify(projection.value), projection.value);
+    }
+    return [...advertised.values()];
+};

package/dist/contracts/analysisDetail.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { analysisViewResultSchema } from "../domain/analysisView/analysisView.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+/** Caller-selected delivery of completed analysis Evidence that supports retained views. */
+export const analysisDetailSchema = z
+    .enum(["complete", "summary"])
+    .default("complete")
+    .describe("complete returns the complete analysis Evidence inline. summary retains that complete Evidence in this session and returns its inspect_analysis_view summary; inspect pages, items or facets through normalized_result.parent_evidence_id.");
+/** Complete analysis Evidence, or the summary view of its retained record. */
+export const analysisDetailOutputSchemaOf = (analysis) => evidenceResultOf(z.union([analysis, analysisViewResultSchema]));

package/dist/contracts/analysisViewToolContracts.js

@@ -2,13 +2,13 @@ import { analysisViewResultSchema, inspectAnalysisViewInputSchema, } from "../do
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 const RETAINED_EXAMPLE_ID = `ev_${"a".repeat(64)}`;
-/** Selected views of already completed layout and JavaScript analysis Evidence. */
+/** Selected views of already completed layout, JavaScript and native function Evidence. */
 export const ANALYSIS_VIEW_TOOL_CONTRACTS = [
     {
         name: "inspect_analysis_view",
         ...toolContractMetadata("inspect_analysis_view"),
         kind: "application",
-        description: "Inspect a selected view of completed binary-layout or JavaScript application Evidence without repeating analysis. Use an exact same-session retained evidence_id or portable inline Evidence. Select a summary, layout mitigations/linkage facet, one section/symbol/module, or a stable page with a positive limit. Module pages contain JavaScript assets, bundled modules and source modules; use node_id when paths are ambiguous or unavailable. Returns selected facts inline with artifact identity, parent Evidence ID, a distinct view digest, coverage, limitations and unknowns. Actual serialized size determines MCP transport admission; choose a smaller page or export the retained Evidence when needed.",
+        description: "Inspect selected views of completed binary-layout, JavaScript application or native analyze_function Evidence without repeating analysis. Use an exact same-session retained evidence_id or portable inline Evidence. Select a summary, layout mitigations/linkage facet, one section/symbol/module, or a stable page. Module pages include assets, bundled and source modules; use node_id for ambiguous or unavailable paths. Native views select procedure, pseudocode, assembly, basic blocks, comments, callers/callees, references, unresolved calls, referenced strings/names, native API and high-pcode. Use nonnegative offset and a positive caller-selected limit (defaults 0 and 64); pseudocode uses UTF-16 code units, other native pages use rows. Returns artifact identity, parent Evidence ID, a distinct view digest, coverage, limitations and unknowns. Actual serialized size determines MCP transport admission; choose a smaller page or export the complete retained Evidence if needed.",
         inputSchema: inspectAnalysisViewInputSchema,
         outputSchema: evidenceResultOf(analysisViewResultSchema),
         examples: [
@@ -36,6 +36,21 @@ export const ANALYSIS_VIEW_TOOL_CONTRACTS = [
                     },
                 },
             },
+            {
+                title: "Page native high-pcode operations from retained Evidence",
+                input: {
+                    source: {
+                        kind: "retained-evidence",
+                        evidence_id: RETAINED_EXAMPLE_ID,
+                    },
+                    view: {
+                        kind: "native",
+                        facet: "value_flow_operations",
+                        offset: 0,
+                        limit: 32,
+                    },
+                },
+            },
             {
                 title: "Page module identities from retained application Evidence",
                 input: {

package/dist/contracts/apktool/apktoolToolContracts.js

@@ -0,0 +1,33 @@
+import { apktoolInputSchemas, apktoolResultSchemas, } from "../../domain/apktool/apktoolResourceAnalysis.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "../toolEffects.js";
+/** Apktool resource decoding served by a caller-supplied launcher. */
+export const APKTOOL_TOOL_CONTRACTS = [
+    {
+        name: "inspect_apktool_client",
+        ...toolContractMetadata("inspect_apktool_client"),
+        description: "Inspect the caller-selected apktool launcher: resolved command, selection source, and version. Decodes nothing. REA never installs Apktool or Java; select a launcher with REA_APKTOOL_COMMAND (absolute) or apktool on PATH.",
+        kind: "apktool-provider",
+        inputSchema: apktoolInputSchemas.inspect_apktool_client,
+        outputSchema: evidenceResultOf(apktoolResultSchemas.inspect_apktool_client),
+        examples: [{ title: "Check the Apktool launcher", input: {} }],
+    },
+    {
+        name: "decode_android_resources",
+        ...toolContractMetadata("decode_android_resources"),
+        description: "Decode one local APK's resources with `apktool d --no-src` in a provider-owned workspace that is removed after projection: the readable AndroidManifest.xml, apktool.yml version and SDK facts, the app's string resources (default or one locale, bounded to 2000 entries), available string locales, and the decoded file count. The target APK is digest with SHA-256 before decoding; smali is skipped because Java-source recovery belongs to the JADX family.",
+        kind: "apktool-provider",
+        inputSchema: apktoolInputSchemas.decode_android_resources,
+        outputSchema: evidenceResultOf(apktoolResultSchemas.decode_android_resources),
+        examples: [
+            {
+                title: "Decode an APK's resources",
+                input: { path: "/targets/Example.apk" },
+            },
+            {
+                title: "Decode one locale's strings",
+                input: { path: "/targets/Example.apk", locale: "de" },
+            },
+        ],
+    },
+];

package/dist/contracts/artifactToolContracts.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { artifactOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { artifactIntegrityPolicySchema } from "../domain/artifactIntegrityPolicy.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
@@ -8,12 +9,14 @@ import { dylibResolutionInputSchema } from "../domain/apple/dylibResolution.js";
 import { keyedArchiveInputSchema } from "../domain/apple/keyedArchive.js";
 /** Exact caller boundary for deterministic artifact inventory. */
 export const artifactInventoryInputSchema = z.strictObject({
-    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrity_policy: artifactIntegrityPolicySchema,
 });
 /** Extraction needs no selector: it materializes every regular child file. */
-export const artifactExtractionInputSchema = z.strictObject({});
+export const artifactExtractionInputSchema = z.strictObject({
+    integrity_policy: artifactIntegrityPolicySchema,
+});
 /** Provider input containing the destination chosen by the local adapter. */
-export const artifactExtractionExecutionSchema = z.strictObject({
+export const artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({
     output_root: z.string().min(1),
 });
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
@@ -47,8 +50,8 @@ const artifact = (name, description, inputSchema) => {
 };
 /** Artifact-graph inventory and safe extraction contracts. */
 export const ARTIFACT_TOOL_CONTRACTS = [
-    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph, source Evidence, observations, relationships, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
-    artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, enforces archive integrity checks, and verifies cleanup.", artifactExtractionInputSchema),
+    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph once, as the nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
+    artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, and verifies cleanup. Integrity mismatches fail by default; record-and-continue extracts the observed bytes and returns each mismatch as an explicitly untrusted integrity contradiction.", artifactExtractionInputSchema),
     artifact("decode_interface_builder", "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns.", z.strictObject({
         max_documents: z.number().int().min(1).max(64).default(64),
         max_objects: z.number().int().min(1).max(20_000).default(20_000),

package/dist/contracts/browserToolContracts.js

@@ -186,7 +186,7 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
+        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Network comparison includes observed HTTP requests and WebSocket frame streams; same-URL connections are compared as an unordered collection of ordered streams, retaining connection counts without claiming stable identity between individual connections. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
         inputSchema: browserCaptureComparisonInputSchema,
         outputSchema: captureDiffOutputSchema,