rea-agents 6.1.0 → 6.3.0

package/dist/contracts/toolOutputSchemaGroups.js

@@ -9,8 +9,8 @@ import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/nat
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { residualUnknownSchema } from "../domain/residualUnknown.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
-import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/process/processCapture.js";
-import { analysisBookmarkSchema, functionInstructionWindowSchema, referenceEdgeSchema, unresolvedCallSchema, analysisStringSchema, } from "../domain/hopperValues.js";
+import { processCaptureComparisonSchema } from "../domain/process/processComparison.js";
+import { analysisBookmarkSchema, functionInstructionWindowSchema, referenceEdgeSchema, unresolvedCallSchema, analysisStringSchema, procedureIdentitySchema, } from "../domain/hopperValues.js";
 import { nativeApiInspectionResultSchema } from "../domain/native/nativeApiBoundary.js";
 import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/native/nativeInspection.js";
 import { artifactExtractionResultSchema } from "../domain/artifactGraph.js";
@@ -21,20 +21,21 @@ import { keyedArchiveResultSchema } from "../domain/apple/keyedArchive.js";
 import { appleAssetCatalogResultSchema } from "../domain/apple/appleAssetCatalog.js";
 import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { managedMemberComparisonResultSchema } from "../domain/managed/managedMemberComparison.js";
-import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerification.js";
+import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerificationSchemas.js";
 import { managedReconstructionImportResultSchema } from "../domain/managed/managedReconstruction.js";
 import { managedApplicationGraphResultSchema } from "../domain/managed/managedApplicationGraph.js";
 import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
-import { functionComparisonResultSchema } from "../domain/functionComparison.js";
+import { functionComparisonResultSchema } from "../domain/functionComparisonSchemas.js";
 import { bundleComparisonResultSchema } from "../domain/bundleComparison.js";
 import { changedBehaviorResultSchema } from "../domain/changedBehavior.js";
-import { callPathResultSchema } from "../domain/callPath.js";
+import { callPathResultSchema } from "../domain/callPathSchemas.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
-import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
+import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerificationSchemas.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
 import { nativeDispatchMetadataResultSchema } from "../domain/native/objcSwiftMetadata.js";
 import { nativeInvestigationTraceSchema } from "../domain/native/nativeInvestigationGraph.js";
-import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureIdentity, procedureInfoOutput, evidenceResultOf as resultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
+import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureInfoOutput, evidenceResultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
+import { processCaptureSchema } from "../domain/process/processCapture.js";
 const contextFacetSchema = z.discriminatedUnion("state", [
     z.object({ state: z.literal("available"), value: jsonValueSchema }),
     z.object({
@@ -56,40 +57,40 @@ const bookmarkFacetSchema = z.discriminatedUnion("state", [
 ]);
 /** Exact structured-content schemas shared by direct analysis providers. */
 export const officialOutputSchemas = {
-    annotate_native_function: resultOf(nativeFunctionAnnotationsSchema),
-    inspect_native_load_image: resultOf(nativeLoadImageSchema),
-    inspect_native_data_type: resultOf(nativeDataTypeSchema),
-    inspect_native_instruction: resultOf(nativeInstructionSchema),
-    resolve_native_call_targets: resultOf(nativeCallTargetsSchema),
-    address_name: resultOf(nullableText),
-    comment: resultOf(nullableText),
-    current_address: resultOf(z.string()),
-    current_procedure: resultOf(z.string()),
-    current_document: resultOf(z.string()),
-    goto_address: resultOf(z.string()),
-    inline_comment: resultOf(nullableText),
-    list_bookmarks: resultOf(z.array(analysisBookmarkSchema)),
-    list_documents: resultOf(z.array(z.string())),
-    list_names: resultOf(z.array(addressedValue)),
-    list_procedures: resultOf(z.array(addressedValue)),
+    annotate_native_function: evidenceResultOf(nativeFunctionAnnotationsSchema),
+    inspect_native_load_image: evidenceResultOf(nativeLoadImageSchema),
+    inspect_native_data_type: evidenceResultOf(nativeDataTypeSchema),
+    inspect_native_instruction: evidenceResultOf(nativeInstructionSchema),
+    resolve_native_call_targets: evidenceResultOf(nativeCallTargetsSchema),
+    address_name: evidenceResultOf(nullableText),
+    comment: evidenceResultOf(nullableText),
+    current_address: evidenceResultOf(z.string()),
+    current_procedure: evidenceResultOf(z.string()),
+    current_document: evidenceResultOf(z.string()),
+    goto_address: evidenceResultOf(z.string()),
+    inline_comment: evidenceResultOf(nullableText),
+    list_bookmarks: evidenceResultOf(z.array(analysisBookmarkSchema)),
+    list_documents: evidenceResultOf(z.array(z.string())),
+    list_names: evidenceResultOf(z.array(addressedValue)),
+    list_procedures: evidenceResultOf(z.array(addressedValue)),
     list_segments: segmentOutput,
-    list_strings: resultOf(z.array(analysisStringSchema)),
-    next_address: resultOf(z.string()),
-    prev_address: resultOf(z.string()),
-    procedure_address: resultOf(z.string()),
-    procedure_assembly: resultOf(z.string()),
-    procedure_callees: resultOf(addressList),
-    procedure_callers: resultOf(addressList),
+    list_strings: evidenceResultOf(z.array(analysisStringSchema)),
+    next_address: evidenceResultOf(z.string()),
+    prev_address: evidenceResultOf(z.string()),
+    procedure_address: evidenceResultOf(z.string()),
+    procedure_assembly: evidenceResultOf(z.string()),
+    procedure_callees: evidenceResultOf(addressList),
+    procedure_callers: evidenceResultOf(addressList),
     procedure_info: procedureInfoOutput,
-    read_function_instructions: resultOf(functionInstructionWindowSchema),
-    read_bytes: resultOf(z.object({
+    read_function_instructions: evidenceResultOf(functionInstructionWindowSchema),
+    read_bytes: evidenceResultOf(z.object({
         address: z.string(),
         requested_bytes: z.number().int().min(1),
         returned_bytes: z.number().int().min(0),
         bytes_hex: z.string().regex(/^(?:[a-f0-9]{2})*$/u),
         complete: z.boolean(),
     })),
-    address_to_file_offset: resultOf(z.object({
+    address_to_file_offset: evidenceResultOf(z.object({
         address: z.string(),
         file_offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
         provider_file_offset: z
@@ -111,26 +112,26 @@ export const officialOutputSchemas = {
             .exactOptional()
             .describe("Observed original executable path used to verify the file mapping."),
     })),
-    procedure_references: resultOf(z.object({
-        procedure: procedureIdentity,
+    procedure_references: evidenceResultOf(z.object({
+        procedure: procedureIdentitySchema,
         direction: z.enum(["incoming", "outgoing"]),
-        reference_kinds_available: z.boolean().optional(),
-        unresolved_calls: z.array(unresolvedCallSchema).default([]),
+        reference_kinds_available: z.boolean(),
+        unresolved_calls: z.array(unresolvedCallSchema),
         references: z.array(referenceEdgeSchema),
     })),
-    procedure_pseudo_code: resultOf(nullableText),
-    resolve_containing_procedure: resultOf(containingProcedureResolution),
-    search_procedures: resultOf(z.array(z.object({ address: z.string(), value: z.string() }))),
-    search_strings: resultOf(z.array(analysisStringSchema)),
-    set_address_name: resultOf(z.boolean()),
-    set_addresses_names: resultOf(z.record(z.string(), z.boolean())),
-    set_bookmark: resultOf(z.boolean()),
-    set_comment: resultOf(z.boolean()),
-    set_inline_comment: resultOf(z.boolean()),
-    unset_bookmark: resultOf(z.boolean()),
-    xrefs: resultOf(addressList),
+    procedure_pseudo_code: evidenceResultOf(nullableText),
+    resolve_containing_procedure: evidenceResultOf(containingProcedureResolution),
+    search_procedures: evidenceResultOf(z.array(z.object({ address: z.string(), value: z.string() }))),
+    search_strings: evidenceResultOf(z.array(analysisStringSchema)),
+    set_address_name: evidenceResultOf(z.boolean()),
+    set_addresses_names: evidenceResultOf(z.record(z.string(), z.boolean())),
+    set_bookmark: evidenceResultOf(z.boolean()),
+    set_comment: evidenceResultOf(z.boolean()),
+    set_inline_comment: evidenceResultOf(z.boolean()),
+    unset_bookmark: evidenceResultOf(z.boolean()),
+    xrefs: evidenceResultOf(addressList),
 };
-const literalTraceOutput = resultOf(z.object({
+const literalTraceOutput = evidenceResultOf(z.object({
     query: z.string(),
     search_mode: z.literal("literal"),
     matches: z.array(z.object({
@@ -146,7 +147,7 @@ const literalTraceOutput = resultOf(z.object({
     truncated: z.boolean(),
     residual_unknowns: z.array(z.string()),
 }));
-const callPathTraceOutput = resultOf(z.object({
+const callPathTraceOutput = evidenceResultOf(z.object({
     start: z.string(),
     goal: z.string().nullable(),
     direction: z.enum(["forward", "backward"]),
@@ -172,22 +173,44 @@ const callPathTraceOutput = resultOf(z.object({
     residual_unknowns: z.array(z.string()),
     limitations: z.array(z.string()),
 }));
+/** Identity facts attached to one requested batch selector. */
+const batchProcedureIdentity = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("resolved"),
+        address: z.string().min(1).describe("Observed canonical procedure entry."),
+        name: z
+            .string()
+            .nullable()
+            .describe("Provider's entry label, or null when unavailable."),
+        name_error: analysisErrorProjectionSchema.optional(),
+    }),
+    z.object({
+        status: z.literal("unknown"),
+        error: analysisErrorProjectionSchema,
+    }),
+]);
 /** Exact structured-content schemas for composed analysis workflows. */
 export const enhancedOutputSchemas = {
-    inspect_native_dispatch_metadata: resultOf(nativeDispatchMetadataResultSchema),
-    trace_native_values: resultOf(nativeValueTraceSchema),
-    trace_native_ui_action: resultOf(nativeInvestigationTraceSchema),
+    inspect_native_dispatch_metadata: evidenceResultOf(nativeDispatchMetadataResultSchema),
+    trace_native_values: evidenceResultOf(nativeValueTraceSchema),
+    trace_native_ui_action: evidenceResultOf(nativeInvestigationTraceSchema),
     get_objc_classes: symbolDiscoveryOutput("classes"),
     get_objc_protocols: symbolDiscoveryOutput("protocols"),
-    batch_decompile: resultOf(z.object({
+    batch_decompile: evidenceResultOf(z.object({
         items: z.array(z.discriminatedUnion("status", [
             z.object({
-                address: z.string(),
+                address: z
+                    .string()
+                    .describe("Original caller-selected symbol or address."),
+                procedure: batchProcedureIdentity,
                 status: z.literal("ok"),
                 pseudocode: z.string().min(1),
             }),
             z.object({
-                address: z.string(),
+                address: z
+                    .string()
+                    .describe("Original caller-selected symbol or address."),
+                procedure: batchProcedureIdentity,
                 status: z.literal("error"),
                 error: analysisErrorProjectionSchema,
             }),
@@ -196,15 +219,23 @@ export const enhancedOutputSchemas = {
         succeeded: z.number().int().min(0),
         failed: z.number().int().min(0),
     })),
-    get_call_graph: resultOf(z.record(z.string(), z.array(graphNode))),
-    analyze_swift_types: resultOf(z.object({
+    get_call_graph: evidenceResultOf(z.record(z.string(), z.array(graphNode))),
+    analyze_swift_types: evidenceResultOf(z.object({
         total: z.number().int().min(0),
         categories: z.record(z.string(), z.object({
             count: z.number().int().min(0),
-            items: z.array(addressedEntry),
+            items: z.array(addressedEntry.extend({
+                mangled_names: z.array(z.string()),
+            })),
+        })),
+        unclassified: z.array(addressedEntry.extend({
+            mangled_names: z.array(z.string()),
+            reason: z.enum(["category_not_decoded", "conflicting_categories"]),
         })),
+        limitations: z.array(z.string()),
+        symbol_inventory_error: analysisErrorProjectionSchema.exactOptional(),
     })),
-    find_xrefs_to_name: resultOf(z.discriminatedUnion("status", [
+    find_xrefs_to_name: evidenceResultOf(z.discriminatedUnion("status", [
         z.object({
             status: z.literal("resolved"),
             name: z.string(),
@@ -217,7 +248,7 @@ export const enhancedOutputSchemas = {
             reason: z.literal("name_not_found"),
         }),
     ])),
-    binary_overview: resultOf(z.object({
+    binary_overview: evidenceResultOf(z.object({
         document: z.string(),
         segments: z.array(z.object({
             name: z.string(),
@@ -230,42 +261,42 @@ export const enhancedOutputSchemas = {
         string_count: z.number().int().min(0),
     })),
     analyze_function: functionDossierOutput,
-    inspect_native_api: resultOf(nativeApiInspectionResultSchema),
+    inspect_native_api: evidenceResultOf(nativeApiInspectionResultSchema),
     trace_feature: literalTraceOutput,
     trace_call_path: callPathTraceOutput,
 };
 /** Exact Evidence schemas for provider-neutral native inspection. */
 export const nativeOutputSchemas = {
-    observe_native_ui: resultOf(nativeUiResultSchema),
-    capture_native_ui_scenario: resultOf(nativeUiResultSchema),
-    observe_native_calls: resultOf(nativeCallObservationResultSchema),
-    inspect_macho: resultOf(inspectMachoSchema),
-    inspect_signature: resultOf(inspectSignatureSchema),
-    inspect_plist: resultOf(inspectPlistSchema),
-    list_architectures: resultOf(listArchitecturesSchema),
-    demangle_swift: resultOf(demangleSwiftSchema),
+    observe_native_ui: evidenceResultOf(nativeUiResultSchema),
+    capture_native_ui_scenario: evidenceResultOf(nativeUiResultSchema),
+    observe_native_calls: evidenceResultOf(nativeCallObservationResultSchema),
+    inspect_macho: evidenceResultOf(inspectMachoSchema),
+    inspect_signature: evidenceResultOf(inspectSignatureSchema),
+    inspect_plist: evidenceResultOf(inspectPlistSchema),
+    list_architectures: evidenceResultOf(listArchitecturesSchema),
+    demangle_swift: evidenceResultOf(demangleSwiftSchema),
 };
 /** Exact Evidence schemas for provider-neutral artifact graph operations. */
 export const artifactOutputSchemas = {
-    inspect_artifact: resultOf(artifactInspectionResultSchema),
-    extract_artifact: resultOf(artifactExtractionResultSchema),
-    decode_interface_builder: resultOf(interfaceBuilderAnalysisSchema),
-    inspect_keyed_archive: resultOf(keyedArchiveResultSchema),
-    inspect_asset_catalog: resultOf(appleAssetCatalogResultSchema),
-    trace_dylib_resolution: resultOf(dylibResolutionResultSchema),
+    inspect_artifact: evidenceResultOf(artifactInspectionResultSchema),
+    extract_artifact: evidenceResultOf(artifactExtractionResultSchema),
+    decode_interface_builder: evidenceResultOf(interfaceBuilderAnalysisSchema),
+    inspect_keyed_archive: evidenceResultOf(keyedArchiveResultSchema),
+    inspect_asset_catalog: evidenceResultOf(appleAssetCatalogResultSchema),
+    trace_dylib_resolution: evidenceResultOf(dylibResolutionResultSchema),
 };
 /** Exact Evidence schema for execution-free managed static analysis. */
 export const managedOutputSchemas = {
-    inspect_managed_artifact: resultOf(managedArtifactInspectionSchema),
-    inspect_managed_members: resultOf(managedMemberInspectionSchema),
-    inspect_managed_native_boundaries: resultOf(managedNativeBoundaryInspectionSchema),
+    inspect_managed_artifact: evidenceResultOf(managedArtifactInspectionSchema),
+    inspect_managed_members: evidenceResultOf(managedMemberInspectionSchema),
+    inspect_managed_native_boundaries: evidenceResultOf(managedNativeBoundaryInspectionSchema),
 };
 /** Exact Evidence schema for provider-neutral managed workflows. */
 export const managedWorkflowOutputSchemas = {
-    compare_managed_members: resultOf(managedMemberComparisonResultSchema),
-    verify_managed_native_boundaries: resultOf(managedNativeVerificationResultSchema),
-    import_managed_reconstruction: resultOf(managedReconstructionImportResultSchema),
-    project_managed_application_graph: resultOf(managedApplicationGraphResultSchema),
+    compare_managed_members: evidenceResultOf(managedMemberComparisonResultSchema),
+    verify_managed_native_boundaries: evidenceResultOf(managedNativeVerificationResultSchema),
+    import_managed_reconstruction: evidenceResultOf(managedReconstructionImportResultSchema),
+    project_managed_application_graph: evidenceResultOf(managedApplicationGraphResultSchema),
 };
 /** Exact structured-content schemas for target lifecycle operations. */
 export const sessionOutputSchemas = {
@@ -273,7 +304,6 @@ export const sessionOutputSchemas = {
         path: z.string(),
         format: targetFormatSchema,
         kind: targetKindSchema,
-        loaderArgs: z.array(z.string()),
         sha256: z.string().regex(/^[a-f0-9]{64}$/u),
         architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
     })),
@@ -282,7 +312,21 @@ export const sessionOutputSchemas = {
         z.object({
             path: z.string(),
             bytes: z.number().int().min(0),
-            entries: z.number().int().min(0),
+            primitive_entries: z
+                .number()
+                .int()
+                .min(0)
+                .describe("Retained eligible primitive query bindings."),
+            workflow_entries: z
+                .number()
+                .int()
+                .min(0)
+                .describe("Retained eligible composed workflow bindings."),
+            evidence_records: z
+                .number()
+                .int()
+                .min(0)
+                .describe("All retained Evidence records, including observations without replay bindings."),
         }),
     ])),
     binary_session: lifecycleResultOf(z.union([
@@ -326,15 +370,15 @@ export const sessionOutputSchemas = {
         unknowns_added: z.number().int().min(0),
         total: z.number().int().min(0),
     })),
-    capture_process_scenario: resultOf(processCaptureSchema),
-    compare_process_captures: resultOf(processCaptureComparisonSchema),
-    compare_artifacts: resultOf(artifactComparisonResultSchema),
-    compare_functions: resultOf(functionComparisonResultSchema),
-    compare_bundles: resultOf(bundleComparisonResultSchema),
-    find_changed_behavior: resultOf(changedBehaviorResultSchema),
-    build_call_path: resultOf(callPathResultSchema),
-    correlate_static_and_runtime: resultOf(staticRuntimeCorrelationResultSchema),
-    verify_reconstruction: resultOf(reconstructionVerificationResultSchema),
+    capture_process_scenario: evidenceResultOf(processCaptureSchema),
+    compare_process_captures: evidenceResultOf(processCaptureComparisonSchema),
+    compare_artifacts: evidenceResultOf(artifactComparisonResultSchema),
+    compare_functions: evidenceResultOf(functionComparisonResultSchema),
+    compare_bundles: evidenceResultOf(bundleComparisonResultSchema),
+    find_changed_behavior: evidenceResultOf(changedBehaviorResultSchema),
+    build_call_path: evidenceResultOf(callPathResultSchema),
+    correlate_static_and_runtime: evidenceResultOf(staticRuntimeCorrelationResultSchema),
+    verify_reconstruction: evidenceResultOf(reconstructionVerificationResultSchema),
     list_unknowns: lifecycleResultOf(z.object({
         items: z.array(residualUnknownSchema),
         total: z.number().int().min(0),

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -1,21 +1,15 @@
 import { z } from "zod";
 import { procedureClassificationSchema, procedureIdentitySchema, localVariableSchema, functionDossierSchema, functionBodySchema, } from "../domain/hopperValues.js";
 import { analysisProfileSchema } from "../domain/analysisProfile.js";
-import { evidenceEnvelopeSchema } from "../domain/evidence.js";
+import { evidenceSchema, validateAnalysisProfileProvider, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { PROVIDER_REJECTION_CODES, } from "./providerSelection.js";
 import { PROVIDER_FAILURE_STAGES, PROVIDER_OPERATION_STATES, PROVIDER_RETRY_ACTIONS, } from "../domain/providerOperationHealth.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
-/** Inline result with its complete Evidence record. */
-export const inlineEvidenceRecordSchema = evidenceEnvelopeSchema;
-/** Wrap a result and its Evidence while preserving the result schema type. */
-export const evidenceResultOf = (schema) => z.strictObject({
-    result: schema,
-    evidence_id: prefixedDigestSchema("ev"),
-    evidence: inlineEvidenceRecordSchema,
-});
-const resultOf = evidenceResultOf;
+/** Specialize the single normalized result inside a complete Evidence record. */
+export const evidenceResultOf = (schema) => z
+    .strictObject({ ...evidenceSchema.shape, normalized_result: schema })
+    .superRefine(validateAnalysisProfileProvider);
 /** Wrap a lifecycle result while preserving its exact schema type. */
 export const lifecycleResultOf = (schema) => z.object({ result: schema });
 /** Resolve a required named output schema or reject contract drift. */
@@ -271,8 +265,6 @@ export const toolAvailability = z.discriminatedUnion("available", [
 ]);
 export const sessionProvider = z
     .object({
-    provider: providerIdentity,
-    providers: z.array(providerIdentity),
     capabilities: z.array(providerCapability),
     analysis_run: analysisRun,
     analysis_activity: analysisActivity,
@@ -343,13 +335,11 @@ export const addressedEntry = z.object({
     address: z.string(),
     name: z.string(),
 });
-export const procedureIdentity = procedureIdentitySchema;
-const localVariable = localVariableSchema;
 export const containingProcedureResolution = z.discriminatedUnion("found", [
     z.object({
         query_address: z.string(),
         found: z.literal(true),
-        procedure: procedureIdentity,
+        procedure: procedureIdentitySchema,
     }),
     z.object({
         query_address: z.string(),
@@ -407,21 +397,18 @@ const memoryRegionOutput = z.object({
     initialized: z.boolean().optional(),
     overlay: z.boolean().optional(),
 });
-export const segmentOutput = resultOf(z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })));
-export const procedureInfoOutput = resultOf(z.object({
+export const segmentOutput = evidenceResultOf(z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })));
+export const procedureInfoOutput = evidenceResultOf(z.object({
     name: z.string(),
     entrypoint: z.string(),
     basicblock_count: z.number().int().min(0),
     length: z.number().min(0),
     signature: nullableText,
-    locals: z.array(localVariable),
-    classification: procedureClassificationSchema.nullable().default(null),
-    body: functionBodySchema.default({
-        available: false,
-        reason: "The provider did not report complete function body ranges.",
-    }),
+    locals: z.array(localVariableSchema),
+    classification: procedureClassificationSchema.nullable(),
+    body: functionBodySchema,
 }));
-export const symbolDiscoveryOutput = (property) => resultOf(z.object({
+export const symbolDiscoveryOutput = (property) => evidenceResultOf(z.object({
     count: z.number().int().min(0),
     [property]: z.array(addressedEntry),
 }));
@@ -437,4 +424,4 @@ export const graphNode = z.discriminatedUnion("status", [
         error: analysisErrorProjectionSchema,
     }),
 ]);
-export const functionDossierOutput = resultOf(functionDossierSchema);
+export const functionDossierOutput = evidenceResultOf(functionDossierSchema);

package/dist/contracts/toolSchemaMetadata.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { presentInputJsonSchema } from "./inputSchemaPresentation.js";
 const PROPERTY_DESCRIPTIONS = {
     addresses: "Ordered provider-normalized procedure addresses to analyze.",
     after: "The later or right-hand observation to compare.",
@@ -38,12 +39,21 @@ const PROPERTY_DESCRIPTIONS = {
     unknown_id: "Exact residual-unknown identifier.",
 };
 /** Attach caller guidance to a canonical schema for the SDK wire projection. */
-export const toolInputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.inputSchema, "input", (project) => (options) => flattenRootUnion({
-    ...describeProperties(project(options)),
-    examples: contract.examples.map(({ input }) => input),
+export const toolInputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.inputSchema, "input", (project) => (options) => {
+    const shared = project({
+        ...options,
+        libraryOptions: { reused: "ref", ...options.libraryOptions },
+    });
+    return {
+        ...presentInputJsonSchema(shared, fallbackPropertyDescription),
+        examples: contract.examples.map(({ input }) => input),
+    };
+});
+/** Share repeated output definitions without changing canonical validation. */
+export const toolOutputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.outputSchema, "output", (project) => (options) => project({
+    ...options,
+    libraryOptions: { reused: "ref", ...options.libraryOptions },
 }));
-/** Advertise a canonical output schema without reconverting it per listing. */
-export const toolOutputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.outputSchema, "output");
 const withAdvertisedJsonSchema = (canonical, io, advertise = (project) => project) => {
     // Zod's input projection drops root metadata when a descendant transforms.
     // Preserve the parser and let the SDK own conversion of everything else.
@@ -79,70 +89,10 @@ const memoizeByTarget = (project) => {
         return projected;
     };
 };
-/** Keep MCP tool roots object-shaped for clients that reject root unions. */
-const flattenRootUnion = (value) => {
-    if (!Array.isArray(value.anyOf))
-        return value;
-    const branches = value.anyOf.filter(isObject);
-    if (branches.length === 0 || branches.length !== value.anyOf.length)
-        return value;
-    const properties = {};
-    for (const branch of branches) {
-        if (!isObject(branch.properties))
-            return value;
-        for (const [name, schema] of Object.entries(branch.properties)) {
-            const previous = properties[name];
-            if (previous === undefined)
-                properties[name] = schema;
-            else if (JSON.stringify(previous) !== JSON.stringify(schema))
-                properties[name] = {
-                    anyOf: [previous, schema],
-                    description: fallbackPropertyDescription(name),
-                };
-        }
-    }
-    // The canonical Zod parser still enforces branch validation at invocation.
-    const { anyOf: _anyOf, required: _required, ...root } = value;
-    const requiredByBranch = branches.map((branch) => Array.isArray(branch.required)
-        ? branch.required.filter((item) => typeof item === "string")
-        : []);
-    const required = requiredByBranch.reduce((common, current) => common.filter((name) => current.includes(name)));
-    const minProperties = Math.max(typeof root.minProperties === "number" ? root.minProperties : 0, Math.min(...requiredByBranch.map((names) => names.length)));
-    return {
-        ...root,
-        type: "object",
-        properties,
-        ...(minProperties > 0 ? { minProperties } : {}),
-        ...(required.length > 0 ? { required } : {}),
-        ...(branches.every((branch) => branch.additionalProperties === false)
-            ? { additionalProperties: false }
-            : {}),
-    };
-};
-const describeProperties = (value) => Object.fromEntries(Object.entries(value).map(([key, child]) => {
-    if (key !== "properties" || !isObject(child))
-        return [key, describeValue(child)];
-    return [
-        key,
-        Object.fromEntries(Object.entries(child).map(([property, propertySchema]) => [
-            property,
-            isObject(propertySchema) &&
-                typeof propertySchema.description !== "string"
-                ? {
-                    ...describeProperties(propertySchema),
-                    description: fallbackPropertyDescription(property),
-                }
-                : describeValue(propertySchema),
-        ])),
-    ];
-}));
-const describeValue = (value) => {
-    if (Array.isArray(value))
-        return value.map(describeValue);
-    return isObject(value) ? describeProperties(value) : value;
-};
 const fallbackPropertyDescription = (property) => {
-    const explicit = PROPERTY_DESCRIPTIONS[property];
+    const explicit = Object.hasOwn(PROPERTY_DESCRIPTIONS, property)
+        ? PROPERTY_DESCRIPTIONS[property]
+        : undefined;
     if (explicit !== undefined)
         return explicit;
     const words = property.replaceAll("_", " ");
@@ -170,4 +120,3 @@ const fallbackPropertyDescription = (property) => {
         return `Whether ${words}.`;
     return `Value for ${words}.`;
 };
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/contracts/webNetworkCaptureToolContracts.js

@@ -1,6 +1,6 @@
 import { inspectWebNetworkCaptureInputSchema, webNetworkCaptureSchema, } from "../domain/webNetworkCapture.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 /** Historical inspection is distinct from live browser capture and runtime authority. */
 export const WEB_NETWORK_CAPTURE_TOOL_CONTRACTS = [
     {

package/dist/contracts/webRuntimeToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 import { observeWebExecutionInputSchema, webExecutionSchema, } from "../domain/webExecution.js";
 import { inspectWebEventListenersInputSchema, webEventListenersSchema, } from "../domain/webEventListeners.js";
 /** Native website runtime primitives distinguish instrumentation from listener inspection. */

package/dist/contracts/webScriptToolContracts.js

@@ -1,7 +1,7 @@
 import { exportWebScriptsInputSchema, webScriptExportResultSchema, } from "../domain/webScriptExport.js";
 import { webModuleTraceInputSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 import { webSourceLocationInputSchema, webSourceLocationResultSchema, } from "../domain/webSourceLocation.js";
 /** Local captured-script publication contracts shared by CLI and MCP. */
 export const WEB_SCRIPT_TOOL_CONTRACTS = [

package/dist/doctorRuntime.js

@@ -4,17 +4,19 @@ import { inspectSystemGhidraProvider } from "./ghidra/GhidraDoctor.js";
 import { inspectIdaRegistration } from "./ida/IdaDoctor.js";
 import { selectLinuxPrivateDisplayStrategy } from "./hopper/LinuxPrivateDisplayProbe.js";
 /** Compose provider diagnostics at the outer CLI adapter boundary. */
-export const createSystemDoctorHost = () => systemDoctorHost({
+export const createSystemDoctorHost = (environment = process.env) => systemDoctorHost({
+    environment,
     providerInspections: async () => [
-        await inspectSystemGhidraProvider(),
-        inspectIdaRegistration(process.env.REA_IDA_MCP_CONFIG),
+        await inspectSystemGhidraProvider(environment),
+        inspectIdaRegistration(environment.REA_IDA_MCP_CONFIG),
     ],
-    linuxDemoRuntimeCheck: inspectLinuxPrivateDisplay,
+    linuxDemoRuntimeCheck: () => inspectLinuxPrivateDisplay(environment),
 });
 const HOPPER_DEMO_HELPER_PATH = fileURLToPath(new URL("../scripts/hopper-demo-x11.py", import.meta.url));
-const inspectLinuxPrivateDisplay = async () => {
+const inspectLinuxPrivateDisplay = async (environment) => {
     const selection = await selectLinuxPrivateDisplayStrategy({
         helperPath: HOPPER_DEMO_HELPER_PATH,
+        environment,
     });
     const value = selection.diagnostic;
     const detail = [

package/dist/domain/analysisErrorBase.js

@@ -50,4 +50,9 @@ export class AnalysisError extends Error {
     executionFailure = undefined;
     partialObservation;
     cleanupReport = undefined;
+    /** Retain a completed observation when a later step fails. */
+    retainPartialObservation(observation) {
+        this.partialObservation ??= observation;
+        return this;
+    }
 }

package/dist/domain/analysisErrorCore.js

@@ -5,11 +5,14 @@ export class AnalysisUnsupportedTargetError extends AnalysisError {
     path;
     reason;
     _tag = "AnalysisUnsupportedTargetError";
+    /** Refusal-specific recovery, when the producer knows an available workflow. */
+    remediationAction;
     constructor(operation, path, reason, options) {
         super(`Unsupported target for ${operation} at ${path}: ${reason}`, options);
         this.operation = operation;
         this.path = path;
         this.reason = reason;
+        this.remediationAction = options?.remediationAction;
     }
 }
 /** An analysis or transport resource failure, distinct from malformed input or unsupported coverage. */