rea-agents 3.0.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

@@ -3,6 +3,7 @@ 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),
@@ -30,25 +31,28 @@ 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),
@@ -66,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: {},
@@ -95,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),

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,7 +61,7 @@ export const enhancedInputSchemas = {
             basic_blocks: 0,
         }),
     }),
-    inspect_native_api: z.object({
+    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),
@@ -72,7 +72,7 @@ export const enhancedInputSchemas = {
     }),
     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()
@@ -88,19 +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",
-    "inspect_native_api",
-    "trace_feature",
-    "find_code_for_string",
-    "trace_call_path",
-]);

package/dist/contracts/functionWorkflowToolContracts.js

@@ -3,11 +3,10 @@ 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 = enhancedOutputSchemas[name];
-    if (outputSchema === undefined)
-        throw new Error(`Missing function workflow output schema for ${name}`);
+    const outputSchema = requireOutputSchema(enhancedOutputSchemas, name);
     return {
         name,
         ...toolContractMetadata(name),

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: {},

package/dist/contracts/managedWorkflowToolContracts.js

@@ -7,6 +7,7 @@ import { projectManagedApplicationGraphInputSchema } from "../domain/managedAppl
 import { managedWorkflowOutputSchemas } from "./toolOutputSchemas.js";
 import { MANAGED_MEMBER_COMPARISON_EXAMPLE, MANAGED_NATIVE_VERIFICATION_EXAMPLE, MANAGED_APPLICATION_GRAPH_EXAMPLE, MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE, MANAGED_RUNTIME_CORRELATION_EXAMPLE, } from "./managedWorkflowExamples.js";
 import { toolContractMetadata } from "./toolEffects.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const managedEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_managed_members Evidence ID");
 const managedArtifactEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_managed_artifact Evidence ID");
@@ -66,46 +67,48 @@ export const managedNativeVerificationReferenceInputSchema = z
         ids.add(evidenceId);
     }
 });
-/** MCP references for projecting managed Evidence into an application graph. */
-export const managedApplicationGraphReferenceInputSchema = z
-    .strictObject({
-    managed_artifact_evidence_id: managedArtifactEvidenceIdSchema.optional(),
-    managed_members_evidence_id: managedEvidenceIdSchema.optional(),
-    managed_native_boundaries_evidence_id: managedBoundaryEvidenceIdSchema.optional(),
+const managedApplicationGraphReferenceFacts = {
     limits: projectManagedApplicationGraphInputSchema.shape.limits,
-})
+};
+/** MCP references requiring at least one managed Evidence source. */
+export const managedApplicationGraphReferenceInputSchema = z
+    .union([
+    z.strictObject({
+        ...managedApplicationGraphReferenceFacts,
+        managed_artifact_evidence_id: managedArtifactEvidenceIdSchema,
+        managed_members_evidence_id: managedEvidenceIdSchema.optional(),
+        managed_native_boundaries_evidence_id: managedBoundaryEvidenceIdSchema.optional(),
+    }),
+    z.strictObject({
+        ...managedApplicationGraphReferenceFacts,
+        managed_artifact_evidence_id: managedArtifactEvidenceIdSchema.optional(),
+        managed_members_evidence_id: managedEvidenceIdSchema,
+        managed_native_boundaries_evidence_id: managedBoundaryEvidenceIdSchema.optional(),
+    }),
+    z.strictObject({
+        ...managedApplicationGraphReferenceFacts,
+        managed_artifact_evidence_id: managedArtifactEvidenceIdSchema.optional(),
+        managed_members_evidence_id: managedEvidenceIdSchema.optional(),
+        managed_native_boundaries_evidence_id: managedBoundaryEvidenceIdSchema,
+    }),
+])
     .superRefine((input, context) => {
     const ids = [
         input.managed_artifact_evidence_id,
         input.managed_members_evidence_id,
         input.managed_native_boundaries_evidence_id,
     ].filter((id) => id !== undefined);
-    if (ids.length === 0)
-        context.addIssue({
-            code: "custom",
-            message: "At least one managed Evidence ID is required",
-        });
     if (new Set(ids).size !== ids.length)
         context.addIssue({
             code: "custom",
             message: "Managed application graph Evidence IDs must be unique",
         });
 });
-const comparisonOutputSchema = managedWorkflowOutputSchemas.compare_managed_members;
-if (comparisonOutputSchema === undefined)
-    throw new Error("Missing managed workflow output schema for compare_managed_members");
-const runtimeOutputSchema = managedWorkflowOutputSchemas.plan_managed_runtime_correlation;
-if (runtimeOutputSchema === undefined)
-    throw new Error("Missing managed workflow output schema for plan_managed_runtime_correlation");
-const reconstructionOutputSchema = managedWorkflowOutputSchemas.import_managed_reconstruction;
-if (reconstructionOutputSchema === undefined)
-    throw new Error("Missing managed workflow output schema for import_managed_reconstruction");
-const nativeVerificationOutputSchema = managedWorkflowOutputSchemas.verify_managed_native_boundaries;
-if (nativeVerificationOutputSchema === undefined)
-    throw new Error("Missing managed workflow output schema for verify_managed_native_boundaries");
-const managedApplicationGraphOutputSchema = managedWorkflowOutputSchemas.project_managed_application_graph;
-if (managedApplicationGraphOutputSchema === undefined)
-    throw new Error("Missing managed workflow output schema for project_managed_application_graph");
+const comparisonOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "compare_managed_members");
+const runtimeOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "plan_managed_runtime_correlation");
+const reconstructionOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "import_managed_reconstruction");
+const nativeVerificationOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "verify_managed_native_boundaries");
+const managedApplicationGraphOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "project_managed_application_graph");
 /** Provider-neutral managed-code workflow contracts. */
 export const MANAGED_WORKFLOW_TOOL_CONTRACTS = [
     {

package/dist/contracts/nativeToolContracts.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { nativeOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 const examples = {
     inspect_macho: {},
     inspect_signature: {},
@@ -10,9 +11,7 @@ const examples = {
     demangle_swift: { symbols: ["$s4Test3fooyyF"] },
 };
 const native = (name, description, inputSchema) => {
-    const outputSchema = nativeOutputSchemas[name];
-    if (outputSchema === undefined)
-        throw new Error(`Missing native output schema for ${name}`);
+    const outputSchema = requireOutputSchema(nativeOutputSchemas, name);
     return {
         name,
         ...toolContractMetadata(name),