rea-agents 2.5.0 → 3.1.0

package/dist/contracts/applicationWorkflowInputContracts.js

@@ -9,21 +9,7 @@ const evidenceIdSchema = z
     .string()
     .regex(/^ev_[a-f0-9]{64}$/u)
     .describe("Evidence ID returned earlier in this session");
-const requireExactlyOne = (context, fields) => {
-    const [leftName, left, rightName, right] = fields;
-    if ((left === undefined) !== (right === undefined))
-        return;
-    context.addIssue({
-        code: "custom",
-        path: [left === undefined ? leftName : rightName],
-        message: `Supply exactly one of ${leftName} or ${rightName}`,
-    });
-};
-/** MCP/CLI trace request accepting full Evidence or a ledger reference. */
-export const traceApplicationFeatureRequestSchema = z
-    .strictObject({
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
+const traceApplicationFeatureFacts = {
     native_observations: traceApplicationFeatureInputSchema.shape.native_observations,
     native_observation_evidence_ids: z
         .array(evidenceIdSchema)
@@ -32,37 +18,30 @@ export const traceApplicationFeatureRequestSchema = z
     seed: traceApplicationFeatureInputSchema.shape.seed,
     direction: traceApplicationFeatureInputSchema.shape.direction,
     limits: traceApplicationFeatureInputSchema.shape.limits,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
-});
+};
+/** MCP/CLI trace request accepting full Evidence or a ledger reference. */
+export const traceApplicationFeatureRequestSchema = z.union([
+    z.strictObject({
+        ...traceApplicationFeatureFacts,
+        application: evidenceSchema,
+    }),
+    z.strictObject({
+        ...traceApplicationFeatureFacts,
+        application_evidence_id: evidenceIdSchema,
+    }),
+]);
 /** MCP/CLI semantic trace request accepting full Evidence or a ledger reference. */
-export const traceJavaScriptSemanticsRequestSchema = z
-    .strictObject({
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
-    query: javaScriptSemanticQueryInputSchema,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
-});
-/** MCP/CLI comparison request accepting full Evidence or ledger references. */
-export const compareApplicationVersionsRequestSchema = z
-    .strictObject({
-    left: evidenceSchema.optional(),
-    left_evidence_id: evidenceIdSchema.optional(),
-    right: evidenceSchema.optional(),
-    right_evidence_id: evidenceIdSchema.optional(),
+export const traceJavaScriptSemanticsRequestSchema = z.union([
+    z.strictObject({
+        application: evidenceSchema,
+        query: javaScriptSemanticQueryInputSchema,
+    }),
+    z.strictObject({
+        application_evidence_id: evidenceIdSchema,
+        query: javaScriptSemanticQueryInputSchema,
+    }),
+]);
+const compareApplicationVersionsFacts = {
     left_native_observations: compareApplicationVersionsInputSchema.shape.left_native_observations,
     left_native_observation_evidence_ids: z
         .array(evidenceIdSchema)
@@ -75,63 +54,74 @@ export const compareApplicationVersionsRequestSchema = z
         .default([]),
     limits: compareApplicationVersionsInputSchema.shape.limits,
     unknown_registry_approved: compareApplicationVersionsInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "left",
-        input.left,
-        "left_evidence_id",
-        input.left_evidence_id,
-    ]);
-    requireExactlyOne(context, [
-        "right",
-        input.right,
-        "right_evidence_id",
-        input.right_evidence_id,
-    ]);
-});
-/** Historical-source comparison accepting full application Evidence or a ledger reference. */
-export const compareSourceToBundleRequestSchema = z
-    .strictObject({
+};
+/** MCP/CLI comparison request accepting full Evidence or ledger references. */
+export const compareApplicationVersionsRequestSchema = z.union([
+    z.strictObject({
+        ...compareApplicationVersionsFacts,
+        left: evidenceSchema,
+        right: evidenceSchema,
+    }),
+    z.strictObject({
+        ...compareApplicationVersionsFacts,
+        left: evidenceSchema,
+        right_evidence_id: evidenceIdSchema,
+    }),
+    z.strictObject({
+        ...compareApplicationVersionsFacts,
+        left_evidence_id: evidenceIdSchema,
+        right: evidenceSchema,
+    }),
+    z.strictObject({
+        ...compareApplicationVersionsFacts,
+        left_evidence_id: evidenceIdSchema,
+        right_evidence_id: evidenceIdSchema,
+    }),
+]);
+const compareSourceToBundleFacts = {
     reference: compareSourceToBundleInputSchema.shape.reference,
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
     limits: compareSourceToBundleInputSchema.shape.limits,
     unknown_registry_approved: compareSourceToBundleInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
-});
-/** MCP/CLI export-shape request accepting full Evidence or ledger references. */
-export const compareJavaScriptExportShapesRequestSchema = z
-    .strictObject({
-    left: evidenceSchema.optional(),
-    left_evidence_id: evidenceIdSchema.optional(),
-    right: evidenceSchema.optional(),
-    right_evidence_id: evidenceIdSchema.optional(),
+};
+/** Historical-source comparison accepting full application Evidence or a ledger reference. */
+export const compareSourceToBundleRequestSchema = z.union([
+    z.strictObject({
+        ...compareSourceToBundleFacts,
+        application: evidenceSchema,
+    }),
+    z.strictObject({
+        ...compareSourceToBundleFacts,
+        application_evidence_id: evidenceIdSchema,
+    }),
+]);
+const compareJavaScriptExportShapesFacts = {
     left_module_path: compareJavaScriptExportShapesInputSchema.shape.left_module_path,
     left_export_name: compareJavaScriptExportShapesInputSchema.shape.left_export_name,
     right_module_path: compareJavaScriptExportShapesInputSchema.shape.right_module_path,
     right_export_name: compareJavaScriptExportShapesInputSchema.shape.right_export_name,
     limits: compareJavaScriptExportShapesInputSchema.shape.limits,
     unknown_registry_approved: compareJavaScriptExportShapesInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "left",
-        input.left,
-        "left_evidence_id",
-        input.left_evidence_id,
-    ]);
-    requireExactlyOne(context, [
-        "right",
-        input.right,
-        "right_evidence_id",
-        input.right_evidence_id,
-    ]);
-});
+};
+/** MCP/CLI export-shape request accepting full Evidence or ledger references. */
+export const compareJavaScriptExportShapesRequestSchema = z.union([
+    z.strictObject({
+        ...compareJavaScriptExportShapesFacts,
+        left: evidenceSchema,
+        right: evidenceSchema,
+    }),
+    z.strictObject({
+        ...compareJavaScriptExportShapesFacts,
+        left: evidenceSchema,
+        right_evidence_id: evidenceIdSchema,
+    }),
+    z.strictObject({
+        ...compareJavaScriptExportShapesFacts,
+        left_evidence_id: evidenceIdSchema,
+        right: evidenceSchema,
+    }),
+    z.strictObject({
+        ...compareJavaScriptExportShapesFacts,
+        left_evidence_id: evidenceIdSchema,
+        right_evidence_id: evidenceIdSchema,
+    }),
+]);

package/dist/contracts/artifactToolContracts.js

@@ -1,7 +1,9 @@
+import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { artifactOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 import { artifactInspectionLimitsSchema } from "../domain/artifactInspection.js";
 const pageInput = {
     node_offset: z.number().int().min(0).default(0),
@@ -29,29 +31,36 @@ const traversalLimitsInput = {
     max_depth: z.number().int().min(0).max(100).default(20),
     max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
 };
-/** Exact caller boundary for deterministic artifact inventory. */
-export const artifactInventoryInputSchema = z
-    .object({
+const integrityInput = {
+    fail: {
+        integrity_policy: z.literal("fail").default("fail"),
+        integrity_continue_approved: z.literal(false).default(false),
+        max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
+    },
+    continue: {
+        integrity_policy: z.literal("record-and-continue"),
+        integrity_continue_approved: z.literal(true),
+        max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
+    },
+};
+const artifactInventoryFacts = {
     native_mount_approved: z.boolean().default(false),
-    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
-    integrity_continue_approved: z.boolean().default(false),
-    max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
     ...pageInput,
     ...traversalLimitsInput,
-})
-    .superRefine((input, context) => {
-    if (input.integrity_policy === "record-and-continue" &&
-        input.integrity_continue_approved !== true)
-        context.addIssue({
-            code: "custom",
-            path: ["integrity_continue_approved"],
-            message: "record-and-continue requires explicit approval",
-        });
-});
+};
+/** Exact caller boundary for deterministic artifact inventory. */
+export const artifactInventoryInputSchema = z.union([
+    z.object({ ...artifactInventoryFacts, ...integrityInput.fail }),
+    z.object({ ...artifactInventoryFacts, ...integrityInput.continue }),
+]);
 /** Exact caller boundary for approved artifact extraction. */
 export const artifactExtractionInputSchema = z.object({
     approved: z.literal(true),
-    output_root: z.string().min(1).max(4_096),
+    output_root: z
+        .string()
+        .min(1)
+        .max(4_096)
+        .refine(isAbsolute, "Extraction output root must be absolute"),
     occurrence_ids: z
         .array(z.string().regex(/^occ_[a-f0-9]{64}$/u))
         .min(1)
@@ -61,24 +70,15 @@ export const artifactExtractionInputSchema = z.object({
     ...traversalLimitsInput,
 });
 /** Bounded provider-neutral inspection using one atomic inventory substep. */
-export const artifactInspectionInputSchema = z
-    .object({
+const artifactInspectionFacts = {
     native_mount_approved: z.boolean().default(false),
-    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
-    integrity_continue_approved: z.boolean().default(false),
-    max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
     ...artifactInspectionLimitsSchema.shape,
     ...traversalLimitsInput,
-})
-    .superRefine((input, context) => {
-    if (input.integrity_policy === "record-and-continue" &&
-        input.integrity_continue_approved !== true)
-        context.addIssue({
-            code: "custom",
-            path: ["integrity_continue_approved"],
-            message: "record-and-continue requires explicit approval",
-        });
-});
+};
+export const artifactInspectionInputSchema = z.union([
+    z.object({ ...artifactInspectionFacts, ...integrityInput.fail }),
+    z.object({ ...artifactInspectionFacts, ...integrityInput.continue }),
+]);
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
 const examples = {
     inventory_artifact: {},
@@ -90,9 +90,7 @@ const examples = {
     },
 };
 const artifact = (name, description, inputSchema) => {
-    const outputSchema = artifactOutputSchemas[name];
-    if (outputSchema === undefined)
-        throw new Error(`Missing artifact output schema for ${name}`);
+    const outputSchema = requireOutputSchema(artifactOutputSchemas, name);
     return {
         name,
         ...toolContractMetadata(name),
@@ -110,7 +108,7 @@ const artifact = (name, description, inputSchema) => {
 };
 /** Artifact-graph inventory and explicitly approved safe extraction contracts. */
 export const ARTIFACT_TOOL_CONTRACTS = [
-    artifact("inventory_artifact", "Inventory the active application or package as a deterministic, content-addressed artifact graph. Returns bounded node and edge pages without extracting or mounting by default.", artifactInventoryInputSchema),
-    artifact("inspect_artifact", "Inspect the active artifact through one bounded, cancellable inventory substep. Returns the full substep Evidence and its ID, observations, derived relationships, hypotheses, contradictions, unexplored branches, limitations, and format-specific next probes. Any substep failure fails the whole call.", artifactInspectionInputSchema),
+    artifact("inventory_artifact", "After open_binary binds a local archive, application package, or other artifact—or when one is already active—inventory it as a deterministic, content-addressed artifact graph. This tool accepts no path; in a target-free session open the target first. Returns bounded node and edge pages without extracting or mounting by default.", artifactInventoryInputSchema),
+    artifact("inspect_artifact", "After open_binary binds a local archive, application package, or other artifact—or when one is already active—inspect it through one bounded, cancellable inventory substep. This tool accepts no path; in a target-free session open the target first. Returns the full substep Evidence and its ID, observations, derived relationships, hypotheses, contradictions, unexplored branches, limitations, and format-specific next probes. Any substep failure fails the whole call.", artifactInspectionInputSchema),
     artifact("extract_artifact", "Extract selected graph artifacts beneath an explicit output root. Requires approval, rejects traversal and symlink escapes, never overwrites, enforces bomb limits, and verifies cleanup.", artifactExtractionInputSchema),
 ];

package/dist/contracts/browserToolContracts.js

@@ -2,7 +2,7 @@ import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsI
 import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { browserCaptureComparisonWireSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
+import { browserCaptureComparisonInputSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
@@ -248,7 +248,7 @@ export const BROWSER_TOOL_CONTRACTS = [
         ...toolContractMetadata("compare_web_captures"),
         description: "Compare either passive web captures or step-indexed browser scenarios. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and exposes bounded artifact-level changes plus alignment failures. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
-        inputSchema: browserCaptureComparisonWireSchema,
+        inputSchema: browserCaptureComparisonInputSchema,
         outputSchema: captureDiffOutputSchema,
         examples: [
             {

package/dist/contracts/electronToolContracts.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
 import { electronPageInspectionSchema, electronTargetListSchema, inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
+import { electronActiveObservationInputSchema, electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
 import { analyzeJavaScriptApplicationInputSchema, javaScriptApplicationAnalysisResultV1Schema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
 import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "../domain/javascriptApplicationGraphSchemas.js";
 import { applicationCoverageSchema } from "../domain/javascriptApplicationEvidenceSchemas.js";
@@ -78,6 +79,23 @@ const applicationOutputSchema = evidenceResultOf(z.union([
 const reconciliationOutputSchema = evidenceResultOf(javascriptRuntimeReconciliationResultSchema);
 const endpoint = "http://127.0.0.1:9223";
 const root = "/Applications/Example.app/Contents/Resources";
+const activeExample = {
+    schema_version: 1,
+    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" }],
+    limits: {
+        max_duration_ms: 60_000,
+        action_timeout_ms: 5_000,
+        max_actions: 20,
+        max_ipc_events: 2_000,
+        max_processes: 32,
+        max_windows: 32,
+    },
+    approved: true,
+};
 /** Root-confined Electron file-page discovery and inspection contracts. */
 export const ELECTRON_TOOL_CONTRACTS = [
     {
@@ -154,7 +172,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "reconcile_javascript_runtime",
         ...toolContractMetadata("reconcile_javascript_runtime"),
-        description: "Reconcile verified static JavaScript application graphs with existing passive web or Electron CDP Evidence. Exact captured-source digests take priority over caller-declared file/URL mappings; target, frame, script, and worker ambiguity remains explicit, and source-map authority stays separate.",
+        description: "Reconcile verified static JavaScript application graphs with existing passive web/Electron CDP, passive V8 Inspector, or provider-owned active Electron Evidence. Active Electron captures contribute an explicitly partial target-only runtime record; they never invent renderer scripts, frames, workers, or execution claims. Exact captured-source digests take priority over caller-declared file/URL mappings; target, frame, script, and worker ambiguity remains explicit, and source-map authority stays separate.",
         kind: "electron-provider",
         inputSchema: reconcileJavaScriptRuntimeInputSchema,
         outputSchema: reconciliationOutputSchema,
@@ -165,4 +183,15 @@ 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 bounded 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),
+        examples: [
+            { title: "Exercise an owned Electron application", input: activeExample },
+        ],
+    },
 ];

package/dist/contracts/enhancedInputs.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-const traceLiteralInputSchema = z.object({
+const traceLiteralInputSchema = z.strictObject({
     query: z.string().min(1),
     case_sensitive: z.boolean().default(false),
     limit: z.number().int().min(1).max(100).default(20),
@@ -11,27 +11,27 @@ const traceLiteralInputSchema = z.object({
 });
 /** Input schemas shared by MCP registration and enhanced application dispatch. */
 export const enhancedInputSchemas = {
-    swift_classes: z.object({ pattern: z.string().default("") }),
-    get_objc_classes: z.object({ pattern: z.string().default("") }),
-    get_objc_protocols: z.object({}),
-    batch_decompile: z.object({
+    swift_classes: z.strictObject({ pattern: z.string().default("") }),
+    get_objc_classes: z.strictObject({ pattern: z.string().default("") }),
+    get_objc_protocols: z.strictObject({}),
+    batch_decompile: z.strictObject({
         addresses: z
             .array(z.string().describe("A provider-normalized procedure address"))
             .max(20)
             .default([]),
     }),
-    get_call_graph: z.object({
+    get_call_graph: z.strictObject({
         address: z.string().describe("A provider-normalized procedure address"),
         direction: z.enum(["forward", "backward"]).default("forward"),
         depth: z.number().int().min(1).max(5).default(2),
     }),
-    analyze_swift_types: z.object({}),
-    find_xrefs_to_name: z.object({ name: z.string() }),
-    binary_overview: z.object({
+    analyze_swift_types: z.strictObject({}),
+    find_xrefs_to_name: z.strictObject({ name: z.string() }),
+    binary_overview: z.strictObject({
         detail: z.enum(["concise", "detailed"]).default("concise"),
         limit: z.number().int().min(1).max(50).default(10),
     }),
-    analyze_function: z.object({
+    analyze_function: z.strictObject({
         procedure: z.string().describe("A procedure name or address"),
         include_assembly: z.boolean().default(false),
         limit: z.number().int().min(1).max(500).default(100),
@@ -40,7 +40,7 @@ export const enhancedInputSchemas = {
         pseudocode_offset: z.number().int().min(0).default(0),
         assembly_offset: z.number().int().min(0).default(0),
         collection_offset: z
-            .object({
+            .strictObject({
             comments: z.number().int().min(0).default(0),
             callers: z.number().int().min(0).default(0),
             callees: z.number().int().min(0).default(0),
@@ -61,9 +61,18 @@ export const enhancedInputSchemas = {
             basic_blocks: 0,
         }),
     }),
+    inspect_native_api: z.strictObject({
+        procedure: z.string().describe("A procedure name or address"),
+        max_pseudocode_chars: z.number().int().min(1).max(100_000).default(20_000),
+        max_instructions: z.number().int().min(1).max(5_000).default(500),
+        unknown_registry_approved: z
+            .literal(true)
+            .optional()
+            .describe("Explicit approval to record unsupported native API branches durably"),
+    }),
     trace_feature: traceLiteralInputSchema,
     find_code_for_string: traceLiteralInputSchema,
-    trace_call_path: z.object({
+    trace_call_path: z.strictObject({
         start: z.string().describe("A provider-normalized procedure address"),
         goal: z
             .string()
@@ -79,18 +88,3 @@ export const enhancedInputSchemas = {
             .describe("Explicit approval to record bounded residuals durably"),
     }),
 };
-/** Runtime parser for dispatching only the closed enhanced names. */
-export const enhancedToolNameSchema = z.enum([
-    "swift_classes",
-    "get_objc_classes",
-    "get_objc_protocols",
-    "batch_decompile",
-    "get_call_graph",
-    "analyze_swift_types",
-    "find_xrefs_to_name",
-    "binary_overview",
-    "analyze_function",
-    "trace_feature",
-    "find_code_for_string",
-    "trace_call_path",
-]);

package/dist/contracts/functionWorkflowToolContracts.js

@@ -0,0 +1,29 @@
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { enhancedInputSchemas } from "./enhancedInputs.js";
+import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemas.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
+const functionWorkflow = (name, description) => {
+    const inputSchema = enhancedInputSchemas[name];
+    const outputSchema = requireOutputSchema(enhancedOutputSchemas, name);
+    return {
+        name,
+        ...toolContractMetadata(name),
+        description,
+        kind: "enhanced",
+        inputSchema,
+        outputSchema,
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: jsonObjectSchema.parse(inputSchema.parse(TOOL_EXAMPLE_OVERRIDES[name] ?? {})),
+            },
+        ],
+    };
+};
+/** Function dossier and native API reconstruction workflow contracts. */
+export const FUNCTION_WORKFLOW_TOOL_CONTRACTS = [
+    functionWorkflow("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, provider-specific pseudocode, optional assembly, comments, calls, typed-or-explicitly-unavailable references, referenced strings/names, and local CFG blocks with exact truncation metadata. Providers with a structured decompiler model also expose native API boundary types, confidence, evidence, jump-table data/target addresses, and explicit decompiler-artifact labels."),
+    functionWorkflow("inspect_native_api", "Reconstruct one native function boundary through inspectable substeps. Returns structured inferred return/parameter types with confidence and evidence, jump-table dispatch/data/target mappings, explicit decompiler-artifact labels, unsupported branches, and residual unknowns."),
+];

package/dist/contracts/managedToolContracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 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({
     path: z
@@ -102,15 +103,9 @@ export const managedNativeBoundaryInputSchema = z.object({
         .max(16_777_216)
         .default(1_048_576),
 });
-const outputSchema = managedOutputSchemas.inspect_managed_artifact;
-if (outputSchema === undefined)
-    throw new Error("Missing managed output schema for inspect_managed_artifact");
-const memberOutputSchema = managedOutputSchemas.inspect_managed_members;
-if (memberOutputSchema === undefined)
-    throw new Error("Missing managed output schema for inspect_managed_members");
-const nativeBoundaryOutputSchema = managedOutputSchemas.inspect_managed_native_boundaries;
-if (nativeBoundaryOutputSchema === undefined)
-    throw new Error("Missing managed output schema for inspect_managed_native_boundaries");
+const outputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_artifact");
+const memberOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_members");
+const nativeBoundaryOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_native_boundaries");
 /** Read-only managed artifact contracts. */
 export const MANAGED_TOOL_CONTRACTS = [
     {

package/dist/contracts/managedWorkflowExamples.js

@@ -45,15 +45,18 @@ const emptyManagedMembers = (sha256, mvid) => ({
     coverage: { state: "complete", issues: [] },
     limitations: [],
 });
-const emptyPage = (limit) => ({
-    items: [],
-    offset: 0,
-    limit,
-    total: 0,
-    returned: 0,
-    dropped: 0,
-    complete: true,
-});
+const emptyPage = (limit) => {
+    const items = [];
+    return {
+        items,
+        offset: 0,
+        limit,
+        total: 0,
+        returned: 0,
+        dropped: 0,
+        complete: true,
+    };
+};
 const evidence = (result) => createEvidence(undefined, MANAGED_STATIC_EXAMPLE_PROVIDER, {
     operation: "inspect_managed_members",
     parameters: {},