rea-agents 3.2.1 → 4.0.0

package/dist/contracts/applicationToolContracts.js

@@ -4,12 +4,9 @@ import { javaScriptSemanticTraceResultSchema } from "../domain/javascriptSemanti
 import { javaScriptExportShapeComparisonResultSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
 import { sourceToBundleComparisonResultSchema } from "../domain/sourceToBundleComparisonSchemas.js";
 import { compareApplicationVersionsRequestSchema, compareJavaScriptExportShapesRequestSchema, compareSourceToBundleRequestSchema, traceApplicationFeatureRequestSchema, traceJavaScriptSemanticsRequestSchema, } from "./applicationWorkflowInputContracts.js";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../domain/javascriptReplay.js";
-import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../domain/nodeRuntimeCharacterization.js";
 import { reconstructionCoverageEvaluationInputSchema } from "../application/ReconstructionCoverageService.js";
 import { reconstructionClosureResultSchema } from "../domain/reconstructionCoverage.js";
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
-import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
 import { JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE, JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE, JAVASCRIPT_FEATURE_TRACE_EXAMPLE, SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE, } from "./javascriptApplicationWorkflowExamples.js";
@@ -20,37 +17,6 @@ const sourceToBundleOutputSchema = evidenceResultOf(sourceToBundleComparisonResu
 const exportShapeComparisonOutputSchema = evidenceResultOf(javaScriptExportShapeComparisonResultSchema);
 const reconstructionObligationLedgerOutputSchema = evidenceResultOf(reconstructionObligationLedgerSchema);
 const HASH = "0".repeat(64);
-const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
-    selected_alias: "bundle",
-    expected_effect: "pure",
-    instrumentation: {
-        artifact_path: "/tmp/example/bundle.js",
-        artifact_sha256: HASH,
-        selection: {
-            byte_start: 100,
-            byte_end: 120,
-            selected_sha256: HASH,
-            export_name: "selected",
-        },
-    },
-    replay: {
-        mode: "plan",
-        left: {
-            modules: [
-                {
-                    alias: "bundle",
-                    path: "/tmp/example/bundle.js",
-                    format: "commonjs-factory",
-                    role: "module",
-                    dependencies: {},
-                },
-            ],
-            entry_alias: "bundle",
-            entry_export: "selected",
-        },
-        cases: [{ case_id: "empty", arguments: [""] }],
-    },
-});
 /** Provider-neutral graph workflow contracts shared by MCP and CLI adapters. */
 export const APPLICATION_TOOL_CONTRACTS = [
     {
@@ -82,7 +48,6 @@ export const APPLICATION_TOOL_CONTRACTS = [
                     query: {
                         seed: { kind: "semantic-node", node_id: `jsrg_node_${HASH}` },
                         direction: "backward-provenance",
-                        source_map_authority: { authority: "none" },
                     },
                 },
             },
@@ -119,7 +84,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "compare_javascript_export_shapes",
         ...toolContractMetadata("compare_javascript_export_shapes"),
-        description: "Compare static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph supplied as inline Evidence. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes and recommends controlled replay separately without executing JavaScript.",
+        description: "Compare static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph supplied as inline Evidence. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes without executing JavaScript; runtime behavior requires a separate agent-run probe.",
         kind: "application",
         inputSchema: compareJavaScriptExportShapesRequestSchema,
         outputSchema: exportShapeComparisonOutputSchema,
@@ -130,88 +95,6 @@ export const APPLICATION_TOOL_CONTRACTS = [
             },
         ],
     },
-    {
-        name: "run_controlled_replay",
-        ...toolContractMetadata("run_controlled_replay"),
-        description: "Plan or execute a content-bound extracted-module JavaScript replay inside the Linux Bubblewrap, seccomp, and cgroup boundary. Execution requires the exact plan digest. Supports deterministic boundary cases and optional left/right differential comparison; observations have controlled-replay authority and do not claim real application runtime behavior.",
-        kind: "application",
-        inputSchema: controlledReplayInputSchema,
-        outputSchema: controlledReplayOutputSchema,
-        examples: [
-            {
-                title: "Plan one extracted ESM parser replay",
-                input: {
-                    mode: "plan",
-                    left: {
-                        modules: [
-                            {
-                                alias: "parser",
-                                path: "/tmp/example/parser.mjs",
-                                format: "esm",
-                                role: "module",
-                                dependencies: {},
-                            },
-                        ],
-                        entry_alias: "parser",
-                        entry_export: "default",
-                    },
-                    cases: [{ case_id: "empty", arguments: [""] }],
-                    determinism: {
-                        clock_iso: "2000-01-01T00:00:00.000Z",
-                        random_seed: 0,
-                        locale: "en-US",
-                        timezone: "UTC",
-                        platform: "linux",
-                    },
-                    limits: {
-                        wall_time_ms: 3000,
-                        memory_bytes: 134217728,
-                        tasks: 8,
-                        cpu_quota_percent: 50,
-                        tmpfs_bytes: 16777216,
-                        module_bytes: 4194304,
-                        input_bytes: 262144,
-                        protocol_bytes: 16777216,
-                        output_bytes: 524288,
-                        stderr_bytes: 32768,
-                        result_depth: 16,
-                        result_nodes: 10000,
-                    },
-                },
-            },
-        ],
-    },
-    {
-        name: "prepare_node_characterization",
-        ...toolContractMetadata("prepare_node_characterization"),
-        description: "Prepare a hash-bound Node/JavaScript characterization plan and deterministic reversible export transformation without executing target code. The exact source, selected byte range, runtime closure, sandbox profile, cases, and limits are committed for later execution.",
-        kind: "application",
-        inputSchema: nodeCharacterizationPreparationInputSchema,
-        outputSchema: nodeCharacterizationPreparationOutputSchema,
-        examples: [
-            {
-                title: "Prepare one exact bundled callable characterization",
-                input: NODE_PREPARATION_EXAMPLE,
-            },
-        ],
-    },
-    {
-        name: "execute_node_characterization",
-        ...toolContractMetadata("execute_node_characterization"),
-        description: "Recompute and execute one exact Node characterization plan in the owned controlled-replay boundary. Returns transformation, replay, cleanup, and provider-neutral characterization Evidence; stale plans fail before execution.",
-        kind: "application",
-        inputSchema: nodeCharacterizationExecutionInputSchema,
-        outputSchema: nodeCharacterizationExecutionOutputSchema,
-        examples: [
-            {
-                title: "Execute one exact characterization plan",
-                input: {
-                    approved_plan_sha256: HASH,
-                    preparation: NODE_PREPARATION_EXAMPLE,
-                },
-            },
-        ],
-    },
     {
         name: "build_reconstruction_obligation_ledger",
         ...toolContractMetadata("build_reconstruction_obligation_ledger"),

package/dist/contracts/artifactToolContracts.js

@@ -3,27 +3,15 @@ import { artifactOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
-const integrityInput = {
-    fail: {
-        integrity_policy: z.literal("fail").default("fail"),
-        integrity_continue_approved: z.literal(false).default(false),
-    },
-    continue: {
-        integrity_policy: z.literal("record-and-continue"),
-        integrity_continue_approved: z.literal(true),
-    },
-};
-const artifactInventoryFacts = {
-    native_mount_approved: z.boolean().default(false),
-};
+import { appleAssetCatalogInputSchema } from "../domain/appleAssetCatalog.js";
+import { keyedArchiveInputSchema } from "../domain/keyedArchive.js";
 /** Exact caller boundary for deterministic artifact inventory. */
-export const artifactInventoryInputSchema = z.union([
-    z.object({ ...artifactInventoryFacts, ...integrityInput.fail }),
-    z.object({ ...artifactInventoryFacts, ...integrityInput.continue }),
-]);
+export const artifactInventoryInputSchema = z.strictObject({
+    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+});
 /** Extraction needs no selector: it materializes every regular child file. */
 export const artifactExtractionInputSchema = z.strictObject({});
-/** Provider input after the local permission boundary chooses its destination. */
+/** Provider input containing the destination chosen by the local adapter. */
 export const artifactExtractionExecutionSchema = z.strictObject({
     output_root: z.string().min(1),
 });
@@ -32,6 +20,8 @@ const examples = {
     inspect_artifact: {},
     extract_artifact: {},
     decode_interface_builder: {},
+    inspect_asset_catalog: { offset: 0, limit: 1000 },
+    inspect_keyed_archive: { path: "Contents/Resources/Model.plist" },
 };
 const artifact = (name, description, inputSchema) => {
     const outputSchema = requireOutputSchema(artifactOutputSchemas, name);
@@ -52,13 +42,15 @@ 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. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
+    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("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),
         max_connections: z.number().int().min(1).max(40_000).default(40_000),
     })),
+    artifact("inspect_keyed_archive", "Inspect one Foundation NSKeyedArchiver plist in the active app bundle as original object-table nodes, class descriptors, named roots, and UID edges. Preserves shared and cyclic references without instantiating classes. The path is relative to the bundle; root selection and object pagination preserve original identities.", keyedArchiveInputSchema),
+    artifact("inspect_asset_catalog", "Inspect compiled Assets.car metadata in an active Apple app bundle. Returns stable paginated catalog and rendition records with raw assetutil metadata and catalog digests; rendition bytes are not extracted.", appleAssetCatalogInputSchema),
 ];
 /** Provider operations; inventory remains an internal primitive of inspection. */
 export const ARTIFACT_ANALYSIS_OPERATIONS = [

package/dist/contracts/browserScenarioToolContracts.js

@@ -6,12 +6,8 @@ const example = {
     browser: {
         mode: "launch",
         executable_path: "/opt/chromium/chrome",
-        headless: true,
-        user_data: "temporary-owned",
-        cleanup: "close-and-delete-profile",
     },
     start_url: { url: "https://app.example.test/", query: [] },
-    allowed_origins: ["https://app.example.test"],
     actions: [
         {
             step_id: "settle",
@@ -25,7 +21,7 @@ export const BROWSER_SCENARIO_TOOL_CONTRACTS = [
     {
         name: "capture_browser_scenario",
         ...toolContractMetadata("capture_browser_scenario"),
-        description: "Run a controlled browser scenario when passive observation cannot exercise the application. Launch an approved executable or connect to an approved loopback CDP target, declare the allowed origins, and provide actions. Environment, empty storage, disabled request replay, redaction, and a URL-only final capture are defaults; provide secrets, initial storage, request replay, or additional artifacts when needed. Actions run until completion or cancellation unless timeout_ms is set. Results are returned inline.",
+        description: "Run a controlled browser scenario when passive observation cannot exercise the application. Launch the selected executable or connect to a loopback CDP target, provide a start URL and actions, and select storage or artifacts when needed. Environment, empty storage, and a URL-only final capture are defaults; provide initial storage or additional artifacts when needed. Agents can run their own local fixture servers to control application responses. Actions run until completion or cancellation unless timeout_ms is set. Results are returned inline.",
         kind: "browser-provider",
         inputSchema: browserScenarioInputSchema,
         outputSchema: evidenceResultOf(browserScenarioCaptureSchema),

package/dist/contracts/browserToolContracts.js

@@ -47,7 +47,6 @@ const exampleScenarioCapture = () => ({
     },
     scenario: {
         start_origin: origin,
-        allowed_origins: [origin],
         action_count: 1,
         secret_references: [],
     },
@@ -86,21 +85,20 @@ const exampleScenarioCapture = () => ({
     completeness: scenarioCompleteness,
     limitations: [],
 });
-/** Origin-scoped, passive browser reverse-engineering contracts. */
+/** Passive browser reverse-engineering contracts. */
 export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "list_browser_targets",
         ...toolContractMetadata("list_browser_targets"),
-        description: "List every page target from an approved user-owned loopback Chrome DevTools Protocol endpoint whose current URL matches an approved exact origin. URL credentials, query values, and fragments are redacted.",
+        description: "List page targets exposed by the selected loopback Chrome DevTools Protocol endpoint. Optionally filter by exact origin. URLs preserve query values and fragments; only URL userinfo credentials are removed.",
         kind: "browser-provider",
         inputSchema: listBrowserTargetsInputSchema,
         outputSchema: listOutputSchema,
         examples: [
             {
-                title: "List approved browser page targets",
+                title: "List browser page targets",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                 },
             },
         ],
@@ -108,16 +106,15 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "inspect_web_page",
         ...toolContractMetadata("inspect_web_page"),
-        description: "Passively inspect one approved page target through CDP without evaluating JavaScript, navigating, clicking, closing, or mutating the page. Returns DOM structure, accessibility, scripts, resources, attach-window network and console metadata, workers, and redacted storage inventory as Evidence.",
+        description: "Passively inspect one selected page target through CDP without evaluating JavaScript, navigating, clicking, closing, or mutating the page. If no origin filter is supplied, capture is scoped to the target's current origin. Returns DOM structure, accessibility, scripts, resources, attach-window network and console metadata, workers, and redacted storage inventory as Evidence.",
         kind: "browser-provider",
         inputSchema: inspectWebPageInputSchema,
         outputSchema: inspectionOutputSchema,
         examples: [
             {
-                title: "Inspect one approved browser page",
+                title: "Inspect one browser page",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                     target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
                 },
             },
@@ -126,16 +123,15 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "analyze_web_bundle",
         ...toolContractMetadata("analyze_web_bundle"),
-        description: "Capture JavaScript source from one configured CDP page and statically derive a chunk graph, route and endpoint candidates, vendor fingerprints, page-declared WebMCP metadata, and optionally fetch source maps from allowed origins. JavaScript is parsed but never executed.",
+        description: "Capture JavaScript source from one selected CDP page and statically derive a chunk graph, route and endpoint candidates, vendor fingerprints, page-declared WebMCP metadata, and optionally fetch source maps from the selected target origin or explicitly requested origins. JavaScript is parsed but never executed.",
         kind: "browser-provider",
         inputSchema: analyzeWebBundleInputSchema,
         outputSchema: bundleOutputSchema,
         examples: [
             {
-                title: "Analyze an approved page bundle",
+                title: "Analyze a page bundle",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                     target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
                     observation_ms: 500,
                     include_accessibility_text: false,
@@ -149,7 +145,7 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "observe_web_session",
         ...toolContractMetadata("observe_web_session"),
-        description: "Arm a CDP observation window of the requested duration while the user operates the page. Allows approved same-origin reload and SPA navigation, records every observed navigation, redirect, lifecycle, and failure event, and stops before retaining an out-of-policy destination.",
+        description: "Arm a CDP observation window of the requested duration while the user operates the page. By default it follows the selected target's current origin; an explicit origin list controls which origins may be retained. Records navigation, redirect, lifecycle, and failure events.",
         kind: "browser-provider",
         inputSchema: observeWebSessionInputSchema,
         outputSchema: observationSessionOutputSchema,
@@ -158,7 +154,6 @@ export const BROWSER_TOOL_CONTRACTS = [
                 title: "Observe one external user action",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                     target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
                     observation_ms: 10_000,
                 },
@@ -177,7 +172,6 @@ export const BROWSER_TOOL_CONTRACTS = [
                 title: "Discover current WebMCP declarations",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                     target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
                     observation_ms: 100,
                 },
@@ -220,10 +214,9 @@ export const BROWSER_TOOL_CONTRACTS = [
         outputSchema: screenshotOutputSchema,
         examples: [
             {
-                title: "Capture an approved viewport",
+                title: "Capture a viewport",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_origins: [origin],
                     target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
                 },
             },

package/dist/contracts/electronToolContracts.js

@@ -13,22 +13,21 @@ const endpoint = "http://127.0.0.1:9223";
 const activeExample = {
     executable_path: "/Applications/Electron.app/Contents/MacOS/Electron",
     application_path: "/Applications/Example.app/Contents/Resources/main.js",
-    application_root: "/Applications/Example.app/Contents/Resources",
     args: [],
     actions: [{ step_id: "exercise-ipc", kind: "click", selector: "#run" }],
 };
-/** Root-confined Electron file-page discovery and inspection contracts. */
+/** Endpoint-scoped Electron file-page discovery and inspection contracts. */
 export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "list_electron_targets",
         ...toolContractMetadata("list_electron_targets"),
-        description: "List every Electron file:// page target from an approved user-owned loopback CDP endpoint. Every path is canonicalized and must remain contained by an approved filesystem root, including after symlink resolution.",
+        description: "List every Electron file:// page target from a selected loopback CDP endpoint. Local file paths are canonicalized after symlink resolution. Selecting an endpoint exposes every eligible target and its local path metadata.",
         kind: "electron-provider",
         inputSchema: listElectronTargetsInputSchema,
         outputSchema: listOutputSchema,
         examples: [
             {
-                title: "List approved Electron file pages",
+                title: "List Electron file pages",
                 input: {
                     cdp_endpoint: endpoint,
                 },
@@ -44,7 +43,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
         outputSchema: inspectionOutputSchema,
         examples: [
             {
-                title: "Inspect an approved Electron page",
+                title: "Inspect an Electron page",
                 input: {
                     cdp_endpoint: endpoint,
                     target_id: "TARGET_ID_FROM_LIST_ELECTRON_TARGETS",
@@ -86,7 +85,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "capture_electron_scenario",
         ...toolContractMetadata("capture_electron_scenario"),
-        description: "Use this for an explicitly approved, provider-owned Electron run when passive CDP or Inspector observation cannot exercise application behavior. REA owns startup and teardown, accepts caller-defined click/wait actions plus window-targeted renderer reload/crash and synthetic open-url/second-instance delivery, and returns correlated window/WebContents/process/preload/session/navigation/shell/IPC evidence without retaining payload values. Results identify observed and unavailable event families, coverage status, action targets, and truncation. External shell, navigation, permission, download, popup, updater, and OS-integration effects are blocked and recorded. Use passive Electron tools for observation-only work.",
+        description: "Use this for a provider-owned Electron run when passive CDP or Inspector observation cannot exercise application behavior. REA owns startup and teardown, accepts caller-defined click/wait actions plus window-targeted renderer reload/crash and synthetic open-url/second-instance delivery, and returns correlated window/WebContents/process/preload/session/navigation/shell/IPC evidence without retaining payload values. Results identify observed and unavailable event families, coverage status, action targets, and truncation. External shell, navigation, permission, download, popup, updater, and OS-integration effects are blocked and recorded. Use passive Electron tools for observation-only work.",
         kind: "electron-provider",
         inputSchema: electronActiveObservationInputSchema,
         outputSchema: evidenceResultOf(electronActiveObservationResultSchema),

package/dist/contracts/enhancedInputs.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
+import { nativeValueTraceInputSchema } from "../domain/nativeValueTrace.js";
 const traceLiteralInputSchema = z.strictObject({
     query: z.string().min(1),
     case_sensitive: z.boolean().default(false),
 });
 /** Input schemas shared by MCP registration and enhanced application dispatch. */
 export const enhancedInputSchemas = {
+    trace_native_values: nativeValueTraceInputSchema,
     inspect_native_dispatch_metadata: z.strictObject({
         max_records: z.number().int().min(1).max(20_000).default(5_000),
     }),
@@ -38,7 +40,6 @@ export const enhancedInputSchemas = {
         procedure: z.string().describe("A procedure name or address"),
     }),
     trace_feature: traceLiteralInputSchema,
-    find_code_for_string: traceLiteralInputSchema,
     trace_call_path: z.strictObject({
         start: z.string().describe("A provider-normalized procedure address"),
         goal: z
@@ -51,7 +52,7 @@ export const enhancedInputSchemas = {
         action: z
             .string()
             .min(1)
-            .describe("A unique compiled UI action selector or interface object ID"),
+            .describe("A unique compiled UI action selector, interface object ID, native symbol or exact function address"),
         max_depth: z.number().int().min(0).max(32).default(8),
         max_nodes: z.number().int().min(1).max(2_000).default(250),
         max_edges: z.number().int().min(1).max(5_000).default(500),

package/dist/contracts/errorSchemas.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 const categorySchema = z.enum([
     "invalid_input",
-    "permission_required",
     "unsupported_provider",
     "integrity_mismatch",
     "truncated",
@@ -13,8 +12,6 @@ const categorySchema = z.enum([
 const remediationSchema = z
     .object({
     action: z.string().min(1),
-    restart_required: z.boolean(),
-    elicitation_supported: z.boolean().optional(),
 })
     .strict();
 const common = {
@@ -27,27 +24,6 @@ const genericDetails = z.record(z.string(), z.json()).optional();
 const generic = (code) => z
     .object({ code: z.literal(code), ...common, details: genericDetails })
     .strict();
-const scopeSchema = z
-    .object({
-    capability: z.string(),
-    roots: z.array(z.string()),
-    executables: z.array(z.string()),
-    environment_names: z.array(z.string()),
-    origins: z.array(z.string()).optional(),
-    network: z.enum(["none", "loopback", "external"]),
-    mount: z.boolean(),
-})
-    .strict();
-const missingScopeSchema = z
-    .object({
-    roots: z.array(z.string()).optional(),
-    executables: z.array(z.string()).optional(),
-    environment_names: z.array(z.string()).optional(),
-    origins: z.array(z.string()).optional(),
-    network: z.enum(["none", "loopback", "external"]).optional(),
-    mount: z.literal(true).optional(),
-})
-    .strict();
 /** Stable discriminated schema shared by every CLI and MCP error surface. */
 export const analysisErrorProjectionSchema = z.discriminatedUnion("code", [
     generic("invalid_request"),
@@ -73,28 +49,28 @@ export const analysisErrorProjectionSchema = z.discriminatedUnion("code", [
     generic("artifact_operation_failed"),
     generic("evidence_integrity_mismatch"),
     generic("truncated"),
-    z
-        .object({
-        code: z.literal("permission_required"),
-        ...common,
-        details: z
-            .object({
-            capability: z.string(),
-            requested: scopeSchema,
-            missing: missingScopeSchema,
-            ceiling: scopeSchema.nullable(),
-        })
-            .strict()
-            .optional(),
-    })
-        .strict(),
     generic("process_capture_failed"),
     generic("cleanup_incomplete"),
     generic("revision_conflict"),
     generic("configuration_invalid"),
     generic("target_unavailable"),
     generic("execution_failure"),
-    generic("plan_stale"),
 ]);
+/** Legacy CLI envelope: a human label plus the canonical projected error fields. */
+export const analysisCliErrorEnvelopeSchema = z
+    .object({
+    error: z.string().min(1),
+})
+    .passthrough()
+    .superRefine((value, context) => {
+    const { error: _label, ...projection } = value;
+    const parsed = analysisErrorProjectionSchema.safeParse(projection);
+    if (!parsed.success) {
+        context.addIssue({
+            code: "custom",
+            message: "CLI error envelope must contain a canonical analysis error projection",
+        });
+    }
+});
 /** JSON Schema document used by generated API documentation and clients. */
 export const analysisErrorJsonSchema = z.toJSONSchema(analysisErrorProjectionSchema);

package/dist/contracts/functionWorkflowToolContracts.js

@@ -24,6 +24,6 @@ const functionWorkflow = (name, description) => {
 };
 /** Function dossier and native API reconstruction workflow contracts. */
 export const FUNCTION_WORKFLOW_TOOL_CONTRACTS = [
-    functionWorkflow("analyze_function", "Build a dossier for one native function identified by symbol or provider-returned address. Returns identity, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations."),
-    functionWorkflow("inspect_native_api", "Analyze a native API boundary in one function identified by symbol or provider-returned address. Returns confidence, evidence, jump-table dispatch/data/target mappings, unsupported branches, and residual unknowns."),
+    functionWorkflow("analyze_function", "Build a dossier for one native function identified by symbol or provider-returned address. Returns identity with complete inclusive body ranges or explicit unknown, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations."),
+    functionWorkflow("inspect_native_api", "Analyze a native API boundary in one function identified by symbol or provider-returned address. Returns confidence, evidence, jump-table dispatch/data/case mappings, separately evidenced default targets, unsupported branches, and residual unknowns. Null case values mean unresolved cases, never a known default."),
 ];

package/dist/contracts/javascriptApplicationWorkflowExamples.js

@@ -11,8 +11,8 @@ const reconciliationEvidence = createEvidence(undefined, {
     predicateType: "rea.javascript-runtime-reconciliation",
     operation: "reconcile_javascript_runtime",
     parameters: {
-        static_layers: JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers.map(({ role, analysis }) => ({
-            role,
+        static_layers: JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers.map(({ analysis }) => ({
+            role: "application",
             evidence_id: analysis.evidence_id,
             runtime_mappings: [],
         })),

package/dist/contracts/javascriptRuntimeObservationToolContracts.js

@@ -7,13 +7,13 @@ export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
     {
         name: "list_javascript_runtime_targets",
         ...toolContractMetadata("list_javascript_runtime_targets"),
-        description: "List every attachable Node/Electron V8 Inspector target from an explicit literal-loopback endpoint. Every returned target and script location exposed by that Inspector endpoint is eligible for Evidence.",
+        description: "List every eligible Node/Electron V8 Inspector target from an explicit literal-loopback endpoint. Node discovery file locations that cannot be verified are preserved as unresolved reported URLs; they do not prove filesystem identity. Listing does not attach to targets.",
         kind: "runtime-provider",
         inputSchema: listJavaScriptRuntimeTargetsInputSchema,
         outputSchema: evidenceResultOf(javascriptRuntimeTargetListSchema),
         examples: [
             {
-                title: "List approved Node Inspector targets",
+                title: "List Node Inspector targets",
                 input: {
                     inspector_endpoint: endpoint,
                 },
@@ -23,13 +23,13 @@ export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
     {
         name: "observe_javascript_runtime",
         ...toolContractMetadata("observe_javascript_runtime"),
-        description: "Attach passively to one Node/Electron V8 Inspector target by supplying its loopback Inspector endpoint and target ID. The provider rechecks that the target currently exists at that endpoint and is an attachable file or URL target. Captures Debugger.scriptParsed and Runtime execution-context events. REA never evaluates, pauses, resumes, reads source, or instruments the target; require/import edges, EventEmitter activity, and Electron IPC remain explicit unknowns. Reconcile the result with static Application Graph Evidence using reconcile_javascript_runtime. The selected endpoint exposes every target it serves to this tool.",
+        description: "Attach passively to one Node/Electron V8 Inspector target by supplying its loopback Inspector endpoint and target ID. The provider rechecks target presence and attachability; a Node discovery file location may remain unresolved. Loaded script locations are validated independently from Debugger.scriptParsed. Captures script and Runtime execution-context metadata. REA never evaluates, pauses, resumes, reads source, or instruments the target; require/import edges, EventEmitter activity, and Electron IPC remain explicit unknowns. Reconcile the result with static Application Graph Evidence using reconcile_javascript_runtime. The selected endpoint exposes every target it serves to this tool.",
         kind: "runtime-provider",
         inputSchema: observeJavaScriptRuntimeInputSchema,
         outputSchema: evidenceResultOf(javascriptRuntimeObservationSchema),
         examples: [
             {
-                title: "Observe one approved Node runtime",
+                title: "Observe one Node runtime",
                 input: {
                     inspector_endpoint: endpoint,
                     target_id: "TARGET_ID_FROM_LIST_JAVASCRIPT_RUNTIME_TARGETS",

package/dist/contracts/javascriptRuntimeReconciliationExample.js

@@ -215,7 +215,7 @@ const runtimeEvidence = createEvidence(undefined, {
 });
 /** Compact valid Evidence pair used by the public reconciliation contract. */
 export const JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE = {
-    static_layers: [{ role: "application", analysis: staticEvidence }],
+    static_layers: [{ analysis: staticEvidence }],
     runtime_observations: [runtimeEvidence],
 };
 function browserCompleteness() {

package/dist/contracts/managedToolContracts.js

@@ -3,17 +3,18 @@ import { managedOutputSchemas } from "./toolOutputSchemas.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 /** Exact caller boundary for execution-free PE/CLI triage and identity. */
-export const managedArtifactInputSchema = z.object({
+const managedTargetInputSchema = z.object({
     path: z
         .string()
         .min(1)
         .optional()
-        .describe("Managed PE/CLI path to open before inspection; omit only when a managed target is already active"),
+        .describe("Explicit managed PE/CLI path; omit to reuse the previously selected managed target"),
 });
+export const managedArtifactInputSchema = managedTargetInputSchema;
 /** Exact caller boundary for execution-free metadata/signature/IL inspection. */
-export const managedMemberInputSchema = z.object({});
+export const managedMemberInputSchema = managedTargetInputSchema;
 /** Exact caller boundary for execution-free managed/native boundary inspection. */
-export const managedNativeBoundaryInputSchema = z.object({});
+export const managedNativeBoundaryInputSchema = managedTargetInputSchema;
 const outputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_artifact");
 const memberOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_members");
 const nativeBoundaryOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_native_boundaries");
@@ -62,3 +63,5 @@ export const MANAGED_TOOL_CONTRACTS = [
         ],
     },
 ];
+/** Parse whether an analysis operation belongs to the managed static tools. */
+export const isManagedToolName = (name) => MANAGED_TOOL_CONTRACTS.some((contract) => contract.name === name);

package/dist/contracts/managedWorkflowExamples.js

@@ -274,25 +274,3 @@ export const MANAGED_NATIVE_VERIFICATION_EXAMPLE = {
     managed_boundaries: boundaryEvidence(),
     native_observations: [nativeExportEvidence()],
 };
-/** Minimal valid managed runtime-correlation planning request. */
-export const MANAGED_RUNTIME_CORRELATION_EXAMPLE = {
-    static_members: runtimeExampleEvidence,
-    method: {
-        token: "0x06000001",
-        signature_sha256: "3".repeat(64),
-        normalized_il_sha256: "5".repeat(64),
-    },
-    requested_effect: "attach",
-    host: {
-        os: "linux",
-        clr_family: "dotnet",
-        architecture: "x86_64",
-    },
-    bounds: {
-        timeout_ms: 5_000,
-        max_threads: 32,
-        max_output_bytes: 65_536,
-        allow_network: false,
-        allow_ui: false,
-    },
-};