Variable TOOL_CONTRACTSConst

TOOL_CONTRACTS: readonly [
    ToolContract<"address_name">,
    ToolContract<"comment">,
    ToolContract<"current_address">,
    ToolContract<"current_procedure">,
    ToolContract<"current_document">,
    ToolContract<"goto_address">,
    ToolContract<"inline_comment">,
    ToolContract<"list_bookmarks">,
    ToolContract<"list_documents">,
    ToolContract<"list_names">,
    ToolContract<"list_procedures">,
    ToolContract<"list_segments">,
    ToolContract<"list_strings">,
    ToolContract<"next_address">,
    ToolContract<"prev_address">,
    ToolContract<"procedure_address">,
    ToolContract<"procedure_assembly">,
    ToolContract<"procedure_callees">,
    ToolContract<"procedure_callers">,
    ToolContract<"procedure_info">,
    ToolContract<"procedure_references">,
    ToolContract<"procedure_pseudo_code">,
    ToolContract<"resolve_containing_procedure">,
    ToolContract<"search_procedures">,
    ToolContract<"search_strings">,
    ToolContract<"set_address_name">,
    ToolContract<"set_addresses_names">,
    ToolContract<"set_bookmark">,
    ToolContract<"set_comment">,
    ToolContract<"set_current_document">,
    ToolContract<"set_inline_comment">,
    ToolContract<"unset_bookmark">,
    ToolContract<"xrefs">,
    ToolContract<"swift_classes">,
    ToolContract<"get_objc_classes">,
    ToolContract<"get_objc_protocols">,
    ToolContract<"batch_decompile">,
    ToolContract<"get_call_graph">,
    ToolContract<"analyze_swift_types">,
    ToolContract<"find_xrefs_to_name">,
    ToolContract<"binary_overview">,
    ToolContract<"analyze_function">,
    ToolContract<"trace_feature">,
    ToolContract<"inspect_macho">,
    ToolContract<"inspect_signature">,
    ToolContract<"inspect_plist">,
    ToolContract<"list_architectures">,
    ToolContract<"demangle_swift">,
    ToolContract<"inventory_artifact">,
    ToolContract<"extract_artifact">,
    {
        annotations: DerivedToolAnnotations;
        description: "Classify the active PE/CLI artifact and inventory exact assembly/module identity, target framework evidence, references, resources, and custom attributes without loading or executing target code. Returns bounded pages and explicit partial or malformed coverage.";
        effects: ToolEffects;
        examples: readonly [
            { input: {}; title: "Example inspect managed artifact request" },
        ];
        inputSchema: ZodObject<
            {
                attribute_limit: ZodDefault<ZodNumber>;
                attribute_offset: ZodDefault<ZodNumber>;
                max_file_bytes: ZodDefault<ZodNumber>;
                max_heap_item_bytes: ZodDefault<ZodNumber>;
                max_metadata_bytes: ZodDefault<ZodNumber>;
                max_table_rows: ZodDefault<ZodNumber>;
                reference_limit: ZodDefault<ZodNumber>;
                reference_offset: ZodDefault<ZodNumber>;
                resource_limit: ZodDefault<ZodNumber>;
                resource_offset: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "managed-provider";
        name: "inspect_managed_artifact";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Inspect bounded PE/CLI metadata members, signatures, raw CIL hashes, limited member-result-v1 decoded-instruction-tuple hashes, separately reported exception regions, call edges, and field-access anchors without loading or executing target code. Metadata tokens are reported as build-local coordinates bound to the artifact SHA-256 and MVID; the v1 tuple hash does not resolve them or fully commit control flow.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: { edge_limit: 100; method_limit: 25 };
                title: "Example inspect managed members request";
            },
        ];
        inputSchema: ZodObject<
            {
                edge_limit: ZodDefault<ZodNumber>;
                edge_offset: ZodDefault<ZodNumber>;
                field_limit: ZodDefault<ZodNumber>;
                field_offset: ZodDefault<ZodNumber>;
                instruction_anchor_limit: ZodDefault<ZodNumber>;
                max_file_bytes: ZodDefault<ZodNumber>;
                max_heap_item_bytes: ZodDefault<ZodNumber>;
                max_metadata_bytes: ZodDefault<ZodNumber>;
                max_method_body_bytes: ZodDefault<ZodNumber>;
                max_method_instructions: ZodDefault<ZodNumber>;
                max_table_rows: ZodDefault<ZodNumber>;
                member_ref_limit: ZodDefault<ZodNumber>;
                member_ref_offset: ZodDefault<ZodNumber>;
                method_limit: ZodDefault<ZodNumber>;
                method_offset: ZodDefault<ZodNumber>;
                type_limit: ZodDefault<ZodNumber>;
                type_offset: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "managed-provider";
        name: "inspect_managed_members";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Inspect PE/CLI ModuleRef, ImplMap/PInvoke declarations, CLI native-header indicators, and non-IL method implementation flags without loading or executing target code. Results are managed declarations and degraded native-boundary observations, not verified native exports or addresses.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: { implementation_limit: 50; import_limit: 50 };
                title: "Example inspect managed/native boundary request";
            },
        ];
        inputSchema: ZodObject<
            {
                implementation_limit: ZodDefault<ZodNumber>;
                implementation_offset: ZodDefault<ZodNumber>;
                import_limit: ZodDefault<ZodNumber>;
                import_offset: ZodDefault<ZodNumber>;
                max_file_bytes: ZodDefault<ZodNumber>;
                max_heap_item_bytes: ZodDefault<ZodNumber>;
                max_metadata_bytes: ZodDefault<ZodNumber>;
                max_table_rows: ZodDefault<ZodNumber>;
                module_ref_limit: ZodDefault<ZodNumber>;
                module_ref_offset: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "managed-provider";
        name: "inspect_managed_native_boundaries";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Compare two authenticated inspect_managed_members Evidence records using unique-only decoded-CIL-v1/signature and structural method-shape tiers. Names are reported as observations but are not used as a matching basis; metadata tokens remain build-local coordinates bound to each artifact SHA-256 and MVID, and the v1 tuple digest does not itself remap them.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    left_evidence_id: string;
                    limits: {
                        max_candidates: number;
                        max_field_matches: number;
                        max_method_matches: number;
                    };
                    right_evidence_id: string;
                };
                title: "Compare two managed member observations";
            },
        ];
        inputSchema: ZodObject<
            {
                left_evidence_id: ZodString;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_candidates: ZodDefault<ZodNumber>;
                            max_field_matches: ZodDefault<ZodNumber>;
                            max_method_matches: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                right_evidence_id: ZodString;
                unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
            },
            $strict,
        >;
        kind: "application";
        name: "compare_managed_members";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Verify managed P/Invoke/native-boundary declarations against authenticated native export or function Evidence without executing managed code or translating managed metadata tokens into native addresses. The workflow preserves declaration-only, verified, inferred, contradicted, and unresolved states.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    limits: {
                        max_candidates_per_import: number;
                        max_native_observations: number;
                    };
                    managed_boundaries_evidence_id: string;
                    native_observation_evidence_ids: string[];
                };
                title: "Verify a managed P/Invoke declaration against native Evidence";
            },
        ];
        inputSchema: ZodObject<
            {
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_candidates_per_import: ZodDefault<ZodNumber>;
                            max_native_observations: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                managed_boundaries_evidence_id: ZodString;
                native_observation_evidence_ids: ZodArray<ZodString>;
                unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
            },
            $strict,
        >;
        kind: "application";
        name: "verify_managed_native_boundaries";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Import decompiler-produced managed reconstruction against authenticated inspect_managed_members Evidence. The workflow locks each method to artifact SHA-256, MVID, metadata token, signature hash, and the limited member-result-v1 decoded-IL tuple hash, records the decompiler identity and options, and marks C# or pseudocode as analyst inference rather than canonical byte observation.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    decompiler: {
                        executable_sha256: null;
                        family: string;
                        name: string;
                        options: string[];
                        version: string;
                    };
                    methods: {
                        normalized_il_sha256: string;
                        reconstruction: {
                            end_line: number;
                            kind: string;
                            language: string;
                            source_path: string;
                            start_line: number;
                            text: string;
                        };
                        signature_sha256: string;
                        token: string;
                    }[];
                    notes: string[];
                    static_members_evidence_id: string;
                };
                title: "Import a decompiler reconstruction for one managed method";
            },
        ];
        inputSchema: ZodObject<
            {
                decompiler: ZodObject<
                    {
                        executable_sha256: ZodNullable<ZodString>;
                        family: ZodEnum<
                            {
                                dnlib: "dnlib";
                                dnspy: "dnspy";
                                ilspy: "ilspy";
                                "mono-cecil": "mono-cecil";
                                other: "other";
                            },
                        >;
                        name: ZodString;
                        options: ZodDefault<ZodArray<ZodString>>;
                        version: ZodNullable<ZodString>;
                    },
                    $strict,
                >;
                methods: ZodArray<
                    ZodObject<
                        {
                            normalized_il_sha256: ZodNullable<ZodString>;
                            reconstruction: ZodObject<
                                {
                                    end_line: ZodOptional<ZodNullable<(...)>>;
                                    kind: ZodEnum<
                                        {
                                            "decompiled-csharp": ...;
                                            "decompiled-il": ...;
                                            "semantic-pseudocode": ...;
                                        },
                                    >;
                                    language: ZodEnum<{ csharp: ...; il: ...; pseudocode: ... }>;
                                    source_path: ZodOptional<ZodNullable<(...)>>;
                                    start_line: ZodOptional<ZodNullable<(...)>>;
                                    text: ZodString;
                                    text_sha256: ZodOptional<ZodString>;
                                },
                                $strict,
                            >;
                            signature_sha256: ZodString;
                            token: ZodString;
                        },
                        $strict,
                    >,
                >;
                notes: ZodDefault<ZodArray<ZodString>>;
                static_members_evidence_id: ZodString;
                unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
            },
            $strict,
        >;
        kind: "application";
        name: "import_managed_reconstruction";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Prepare a separately authorized managed runtime-correlation admission plan from authenticated inspect_managed_members Evidence. The operation is default-disabled, requires the managed_runtime permission ceiling and grant, locks the exact artifact SHA-256, MVID, method signature, and limited member-result-v1 decoded-IL tuple hash, distinguishes attach/load/debugger/reflection/instrumentation effects, and records that no target code was executed.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    bounds: {
                        allow_network: boolean;
                        allow_ui: boolean;
                        max_output_bytes: number;
                        max_threads: number;
                        timeout_ms: number;
                    };
                    host: { architecture: string; clr_family: string; os: string };
                    method: {
                        normalized_il_sha256: string;
                        signature_sha256: string;
                        token: string;
                    };
                    requested_effect: string;
                    static_members_evidence_id: string;
                };
                title: "Plan an exact-build managed runtime correlation";
            },
        ];
        inputSchema: ZodObject<
            {
                bounds: ZodDefault<
                    ZodObject<
                        {
                            allow_network: ZodDefault<ZodLiteral<false>>;
                            allow_ui: ZodDefault<ZodLiteral<false>>;
                            max_output_bytes: ZodDefault<ZodNumber>;
                            max_threads: ZodDefault<ZodNumber>;
                            timeout_ms: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                host: ZodObject<
                    {
                        architecture: ZodEnum<
                            { arm: "arm"; arm64: "arm64"; x86: "x86"; x86_64: "x86_64" },
                        >;
                        clr_family: ZodEnum<
                            {
                                dotnet: "dotnet";
                                "dotnet-framework": "dotnet-framework";
                                mono: "mono";
                                unknown: "unknown";
                            },
                        >;
                        os: ZodEnum<{ linux: "linux"; macos: "macos"; windows: "windows" }>;
                    },
                    $strict,
                >;
                method: ZodObject<
                    {
                        normalized_il_sha256: ZodNullable<ZodString>;
                        signature_sha256: ZodString;
                        token: ZodString;
                    },
                    $strict,
                >;
                requested_effect: ZodEnum<
                    {
                        attach: "attach";
                        debugger: "debugger";
                        instrumentation: "instrumentation";
                        load: "load";
                        reflection: "reflection";
                    },
                >;
                static_members_evidence_id: ZodString;
                unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
            },
            $strict,
        >;
        kind: "application";
        name: "plan_managed_runtime_correlation";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Project authenticated managed artifact, member, and native-boundary Evidence into the provider-neutral application graph without executing managed code, loading assemblies, or translating managed metadata tokens to native addresses. The graph preserves managed static observations as managed-specific nodes linked to source Evidence.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    limits: {
                        max_fields: number;
                        max_methods: number;
                        max_native_implementations: number;
                        max_pinvoke_imports: number;
                        max_types: number;
                    };
                    managed_members_evidence_id: string;
                };
                title: "Project static managed observations into an application graph";
            },
        ];
        inputSchema: ZodObject<
            {
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_fields: ZodDefault<ZodNumber>;
                            max_methods: ZodDefault<ZodNumber>;
                            max_native_implementations: ZodDefault<ZodNumber>;
                            max_pinvoke_imports: ZodDefault<ZodNumber>;
                            max_types: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                managed_artifact_evidence_id: ZodOptional<ZodString>;
                managed_members_evidence_id: ZodOptional<ZodString>;
                managed_native_boundaries_evidence_id: ZodOptional<ZodString>;
            },
            $strict,
        >;
        kind: "application";
        name: "project_managed_application_graph";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Project authenticated, bounded IPA inventory Evidence into deterministic Apple application components, runtime-family observations, and explicit cross-language bridge hypotheses. Reports exact artifact paths and hashes without executing code or parsing provisioning-profile signing material.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    inventory_evidence_ids: [`ev_${string}`];
                    limits: { max_components: 1000 };
                };
                title: "Project an IPA inventory into Apple application components";
            },
        ];
        inputSchema: ZodObject<
            {
                inventory_evidence_ids: ZodArray<ZodString>;
                limits: ZodDefault<
                    ZodObject<{ max_components: ZodDefault<ZodNumber> }, $strict>,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "project_apple_application_graph";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Project authenticated, bounded APK inventory Evidence into deterministic Android components, runtime-family observations, and explicit managed-to-native bridge hypotheses. Reports exact artifact paths and hashes without executing code or decoding Android binary formats.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    inventory_evidence_ids: [`ev_${string}`];
                    limits: { max_components: 1000 };
                };
                title: "Project an APK inventory into Android application components";
            },
        ];
        inputSchema: ZodObject<
            {
                inventory_evidence_ids: ZodArray<ZodString>;
                limits: ZodDefault<
                    ZodObject<{ max_components: ZodDefault<ZodNumber> }, $strict>,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "project_android_application_graph";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Identify runtime families from authenticated artifact inventory Evidence and report whether semantic tooling is available, missing, or requires provider selection. This classifies exact formats and paths without executing or decoding target bytecode.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    inventory_evidence_ids: [`ev_${string}`];
                    limits: { max_observations: 1000 };
                };
                title: "Identify runtimes in an artifact inventory";
            },
        ];
        inputSchema: ZodObject<
            {
                inventory_evidence_ids: ZodArray<ZodString>;
                limits: ZodDefault<
                    ZodObject<{ max_observations: ZodDefault<ZodNumber> }, $strict>,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "identify_runtime";
        outputSchema: ZodObject<$ZodLooseShape, $strip>;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "List bounded page targets from an approved user-owned loopback Chrome DevTools Protocol endpoint. Only targets whose current URL matches an approved exact origin are returned; URL credentials, query values, and fragments are redacted.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    limit: 100;
                    offset: 0;
                };
                title: "List approved browser page targets";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                limit: ZodDefault<ZodNumber>;
                offset: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "list_browser_targets";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Passively inspect one approved page target through CDP without evaluating JavaScript, navigating, clicking, closing, or mutating the page. Returns bounded DOM structure, accessibility, scripts, resources, attach-window network and console metadata, workers, and redacted storage inventory as Evidence v2.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    console_text_approved: false;
                    include_accessibility_text: false;
                    include_console_text: false;
                    include_json_body_shapes: false;
                    include_script_sources: false;
                    include_storage_keys: false;
                    include_websocket_shapes: false;
                    json_body_schema_approved: false;
                    limits: {
                        max_ax_nodes: 2000;
                        max_ax_text_field_bytes: 1024;
                        max_console_events: 200;
                        max_console_text_field_bytes: 1024;
                        max_dom_nodes: 2000;
                        max_frames: 200;
                        max_json_body_bytes: 1048576;
                        max_json_shape_depth: 20;
                        max_json_shape_nodes: 5000;
                        max_network_events: 1000;
                        max_resources: 2000;
                        max_script_source_bytes: 1048576;
                        max_scripts: 200;
                        max_storage_keys: 1000;
                        max_total_ax_text_bytes: 65536;
                        max_total_console_text_bytes: 65536;
                        max_total_json_body_bytes: 4194304;
                        max_total_script_source_bytes: 4194304;
                        max_total_websocket_shape_bytes: 1048576;
                        max_websocket_events: 500;
                        max_websocket_shape_bytes: 65536;
                        max_workers: 500;
                    };
                    observation_ms: 500;
                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS";
                    websocket_shape_approved: false;
                };
                title: "Inspect one approved browser page";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                console_text_approved: ZodDefault<ZodBoolean>;
                include_accessibility_text: ZodDefault<ZodBoolean>;
                include_console_text: ZodDefault<ZodBoolean>;
                include_json_body_shapes: ZodDefault<ZodBoolean>;
                include_script_sources: ZodDefault<ZodBoolean>;
                include_storage_keys: ZodDefault<ZodBoolean>;
                include_websocket_shapes: ZodDefault<ZodBoolean>;
                json_body_schema_approved: ZodDefault<ZodBoolean>;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_ax_nodes: ZodDefault<ZodNumber>;
                            max_ax_text_field_bytes: ZodDefault<ZodNumber>;
                            max_console_events: ZodDefault<ZodNumber>;
                            max_console_text_field_bytes: ZodDefault<ZodNumber>;
                            max_dom_nodes: ZodDefault<ZodNumber>;
                            max_frames: ZodDefault<ZodNumber>;
                            max_json_body_bytes: ZodDefault<ZodNumber>;
                            max_json_shape_depth: ZodDefault<ZodNumber>;
                            max_json_shape_nodes: ZodDefault<ZodNumber>;
                            max_network_events: ZodDefault<ZodNumber>;
                            max_resources: ZodDefault<ZodNumber>;
                            max_script_source_bytes: ZodDefault<ZodNumber>;
                            max_scripts: ZodDefault<ZodNumber>;
                            max_storage_keys: ZodDefault<ZodNumber>;
                            max_total_ax_text_bytes: ZodDefault<ZodNumber>;
                            max_total_console_text_bytes: ZodDefault<ZodNumber>;
                            max_total_json_body_bytes: ZodDefault<ZodNumber>;
                            max_total_script_source_bytes: ZodDefault<ZodNumber>;
                            max_total_websocket_shape_bytes: ZodDefault<ZodNumber>;
                            max_websocket_events: ZodDefault<ZodNumber>;
                            max_websocket_shape_bytes: ZodDefault<ZodNumber>;
                            max_workers: ZodDefault<ZodNumber>;
                        },
                        $strip,
                    >,
                >;
                observation_ms: ZodDefault<ZodNumber>;
                target_id: ZodString;
                websocket_shape_approved: ZodDefault<ZodBoolean>;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "inspect_web_page";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Capture explicitly approved JavaScript source from one approved CDP page and statically derive a bounded chunk graph, route and endpoint candidates, vendor fingerprints, page-declared WebMCP metadata, and optional separately approved source-map evidence. JavaScript is parsed but never executed.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    analysis_limits: {
                        max_ast_nodes: 250000;
                        max_findings: 1000;
                        max_original_sources: 2000;
                        max_source_map_bytes: 4194304;
                        max_source_map_mappings: 10000;
                        max_source_maps: 100;
                        max_total_source_map_bytes: 16777216;
                    };
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    fetch_source_maps: false;
                    include_accessibility_text: false;
                    include_script_sources: true;
                    include_storage_keys: false;
                    observation_ms: 500;
                    source_capture_approved: true;
                    source_map_fetch_approved: false;
                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS";
                };
                title: "Analyze an approved page bundle";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                analysis_limits: ZodDefault<
                    ZodObject<
                        {
                            max_ast_nodes: ZodDefault<ZodNumber>;
                            max_findings: ZodDefault<ZodNumber>;
                            max_original_sources: ZodDefault<ZodNumber>;
                            max_source_map_bytes: ZodDefault<ZodNumber>;
                            max_source_map_mappings: ZodDefault<ZodNumber>;
                            max_source_maps: ZodDefault<ZodNumber>;
                            max_total_source_map_bytes: ZodDefault<ZodNumber>;
                        },
                        $strip,
                    >,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                console_text_approved: ZodDefault<ZodBoolean>;
                fetch_source_maps: ZodDefault<ZodBoolean>;
                include_accessibility_text: ZodDefault<ZodBoolean>;
                include_console_text: ZodDefault<ZodBoolean>;
                include_json_body_shapes: ZodDefault<ZodBoolean>;
                include_script_sources: ZodDefault<ZodLiteral<true>>;
                include_storage_keys: ZodDefault<ZodBoolean>;
                include_websocket_shapes: ZodDefault<ZodBoolean>;
                json_body_schema_approved: ZodDefault<ZodBoolean>;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_ax_nodes: ZodDefault<ZodNumber>;
                            max_ax_text_field_bytes: ZodDefault<ZodNumber>;
                            max_console_events: ZodDefault<ZodNumber>;
                            max_console_text_field_bytes: ZodDefault<ZodNumber>;
                            max_dom_nodes: ZodDefault<ZodNumber>;
                            max_frames: ZodDefault<ZodNumber>;
                            max_json_body_bytes: ZodDefault<ZodNumber>;
                            max_json_shape_depth: ZodDefault<ZodNumber>;
                            max_json_shape_nodes: ZodDefault<ZodNumber>;
                            max_network_events: ZodDefault<ZodNumber>;
                            max_resources: ZodDefault<ZodNumber>;
                            max_script_source_bytes: ZodDefault<ZodNumber>;
                            max_scripts: ZodDefault<ZodNumber>;
                            max_storage_keys: ZodDefault<ZodNumber>;
                            max_total_ax_text_bytes: ZodDefault<ZodNumber>;
                            max_total_console_text_bytes: ZodDefault<ZodNumber>;
                            max_total_json_body_bytes: ZodDefault<ZodNumber>;
                            max_total_script_source_bytes: ZodDefault<ZodNumber>;
                            max_total_websocket_shape_bytes: ZodDefault<ZodNumber>;
                            max_websocket_events: ZodDefault<ZodNumber>;
                            max_websocket_shape_bytes: ZodDefault<ZodNumber>;
                            max_workers: ZodDefault<ZodNumber>;
                        },
                        $strip,
                    >,
                >;
                observation_ms: ZodDefault<ZodNumber>;
                source_capture_approved: ZodLiteral<true>;
                source_map_fetch_approved: ZodDefault<ZodBoolean>;
                target_id: ZodString;
                websocket_shape_approved: ZodDefault<ZodBoolean>;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "analyze_web_bundle";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Arm a bounded CDP observation window while the user operates the page. Allows approved same-origin reload and SPA navigation, records ordered navigation, redirect, lifecycle, and failure metadata, and stops before retaining an out-of-policy destination.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    max_timeline_events: 2000;
                    observation_ms: 10000;
                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS";
                };
                title: "Observe one external user action";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                max_timeline_events: ZodDefault<ZodNumber>;
                observation_ms: ZodDefault<ZodNumber>;
                target_id: ZodString;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "observe_web_session";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Passively inventory page-registered WebMCP tools using the experimental CDP WebMCP domain. Metadata is bounded and page-declared-untrusted; REA never registers or invokes discovered tools.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    max_schema_bytes: 262144;
                    max_schema_depth: 20;
                    max_schema_nodes: 5000;
                    max_tools: 500;
                    observation_ms: 100;
                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS";
                };
                title: "Discover current WebMCP declarations";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                max_schema_bytes: ZodDefault<ZodNumber>;
                max_schema_depth: ZodDefault<ZodNumber>;
                max_schema_nodes: ZodDefault<ZodNumber>;
                max_tools: ZodDefault<ZodNumber>;
                observation_ms: ZodDefault<ZodNumber>;
                target_id: ZodString;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "discover_webmcp_tools";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Compare two normalized web captures across DOM, scripts, resources, network, safe metadata, and optional WebMCP inventories. Stable observed changes are distinguished from unknown absence caused by incomplete capture coverage.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    after: {
                        inspection: {
                            accessibility: {
                                nodes: never[];
                                text_capture: {
                                    excluded_fields: number;
                                    retained_bytes: number;
                                    status: string;
                                    truncated_fields: number;
                                };
                                total_nodes: number;
                            };
                            browser: {
                                js_version: string;
                                product: string;
                                protocol_version: string;
                                revision: string;
                                user_agent: string;
                            };
                            capture_window: {
                                ended_at: string;
                                observation_ms: number;
                                started_at: string;
                            };
                            completeness: {
                                attach_limited_sections: never[];
                                conditions: string[];
                                dropped_events: {
                                    console_events: number;
                                    network_requests: number;
                                    scripts: number;
                                    timeline_events: number;
                                    total: number;
                                    webmcp_tools: number;
                                    websocket_connections: number;
                                    websocket_frames: number;
                                };
                                excluded: never[];
                                policy_filtered_sections: never[];
                                status: string;
                                truncated_sections: never[];
                                unavailable_sections: never[];
                            };
                            console: {
                                coverage_started_at: string;
                                events: never[];
                                prior_activity_available: boolean;
                            };
                            dom: { nodes: never[]; total_nodes: number };
                            frames: never[];
                            limitations: never[];
                            metadata: {
                                agent_hints: never[];
                                dom_urls: never[];
                                excluded_dom_urls: number;
                                headers_allowlisted: boolean;
                                responses: never[];
                            };
                            network: {
                                coverage_started_at: string;
                                prior_activity_available: boolean;
                                requests: never[];
                                websocket_events: never[];
                            };
                            resources: never[];
                            schema_version: number;
                            scripts: { items: never[]; total: number };
                            storage: {
                                cache_names: never[];
                                indexed_db_names: never[];
                                local_storage_keys: never[];
                                origin: string;
                                quota_bytes: null;
                                session_storage_keys: never[];
                                usage_bytes: null;
                                values_redacted: boolean;
                            };
                            target: {
                                attached: boolean;
                                origin: string;
                                target_id: string;
                                title: string;
                                type: string;
                                url: string;
                            };
                            workers: never[];
                        };
                    };
                    before: {
                        inspection: {
                            accessibility: {
                                nodes: never[];
                                text_capture: {
                                    excluded_fields: number;
                                    retained_bytes: number;
                                    status: string;
                                    truncated_fields: number;
                                };
                                total_nodes: number;
                            };
                            browser: {
                                js_version: string;
                                product: string;
                                protocol_version: string;
                                revision: string;
                                user_agent: string;
                            };
                            capture_window: {
                                ended_at: string;
                                observation_ms: number;
                                started_at: string;
                            };
                            completeness: {
                                attach_limited_sections: never[];
                                conditions: string[];
                                dropped_events: {
                                    console_events: number;
                                    network_requests: number;
                                    scripts: number;
                                    timeline_events: number;
                                    total: number;
                                    webmcp_tools: number;
                                    websocket_connections: number;
                                    websocket_frames: number;
                                };
                                excluded: never[];
                                policy_filtered_sections: never[];
                                status: string;
                                truncated_sections: never[];
                                unavailable_sections: never[];
                            };
                            console: {
                                coverage_started_at: string;
                                events: never[];
                                prior_activity_available: boolean;
                            };
                            dom: { nodes: never[]; total_nodes: number };
                            frames: never[];
                            limitations: never[];
                            metadata: {
                                agent_hints: never[];
                                dom_urls: never[];
                                excluded_dom_urls: number;
                                headers_allowlisted: boolean;
                                responses: never[];
                            };
                            network: {
                                coverage_started_at: string;
                                prior_activity_available: boolean;
                                requests: never[];
                                websocket_events: never[];
                            };
                            resources: never[];
                            schema_version: number;
                            scripts: { items: never[]; total: number };
                            storage: {
                                cache_names: never[];
                                indexed_db_names: never[];
                                local_storage_keys: never[];
                                origin: string;
                                quota_bytes: null;
                                session_storage_keys: never[];
                                usage_bytes: null;
                                values_redacted: boolean;
                            };
                            target: {
                                attached: boolean;
                                origin: string;
                                target_id: string;
                                title: string;
                                type: string;
                                url: string;
                            };
                            workers: never[];
                        };
                    };
                    max_changes: 2000;
                };
                title: "Compare two normalized captures";
            },
        ];
        inputSchema: ZodObject<
            {
                after: ZodObject<
                    {
                        inspection: ZodObject<
                            {
                                accessibility: ZodObject<
                                    {
                                        nodes: ZodArray<(...)>;
                                        text_capture: ZodObject<(...), (...)>;
                                        total_nodes: ZodNumber;
                                    },
                                    $strip,
                                >;
                                browser: ZodObject<
                                    {
                                        js_version: ZodString;
                                        product: ZodString;
                                        protocol_version: ZodString;
                                        revision: ZodString;
                                        user_agent: ZodString;
                                    },
                                    $strip,
                                >;
                                capture_window: ZodObject<
                                    {
                                        ended_at: ZodISODateTime;
                                        observation_ms: ZodNumber;
                                        started_at: ZodISODateTime;
                                    },
                                    $strip,
                                >;
                                completeness: ZodObject<
                                    {
                                        attach_limited_sections: ZodArray<(...)>;
                                        conditions: ZodArray<(...)>;
                                        dropped_events: ZodObject<(...), (...)>;
                                        excluded: ZodArray<(...)>;
                                        policy_filtered_sections: ZodArray<(...)>;
                                        status: ZodEnum<(...)>;
                                        truncated_sections: ZodArray<(...)>;
                                        unavailable_sections: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                console: ZodObject<
                                    {
                                        coverage_started_at: ZodISODateTime;
                                        events: ZodArray<(...)>;
                                        prior_activity_available: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                dom: ZodObject<
                                    { nodes: ZodArray<(...)>; total_nodes: ZodNumber },
                                    $strip,
                                >;
                                frames: ZodArray<
                                    ZodObject<
                                        { frame_id: ...; origin: ...; parent_frame_id: ...; url: ... },
                                        $strip,
                                    >,
                                >;
                                limitations: ZodArray<ZodString>;
                                metadata: ZodObject<
                                    {
                                        agent_hints: ZodArray<(...)>;
                                        dom_urls: ZodArray<(...)>;
                                        excluded_dom_urls: ZodNumber;
                                        headers_allowlisted: ZodLiteral<(...)>;
                                        responses: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                network: ZodObject<
                                    {
                                        coverage_started_at: ZodISODateTime;
                                        prior_activity_available: ZodLiteral<(...)>;
                                        requests: ZodArray<(...)>;
                                        websocket_events: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                resources: ZodArray<
                                    ZodObject<
                                        {
                                            content_size: ...;
                                            mime_type: ...;
                                            origin: ...;
                                            resource_key: ...;
                                            type: ...;
                                            url: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                                schema_version: ZodLiteral<2>;
                                scripts: ZodObject<
                                    { items: ZodArray<(...)>; total: ZodNumber },
                                    $strip,
                                >;
                                storage: ZodObject<
                                    {
                                        cache_names: ZodArray<(...)>;
                                        indexed_db_names: ZodArray<(...)>;
                                        local_storage_keys: ZodArray<(...)>;
                                        origin: ZodString;
                                        quota_bytes: ZodNullable<(...)>;
                                        session_storage_keys: ZodArray<(...)>;
                                        usage_bytes: ZodNullable<(...)>;
                                        values_redacted: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                target: ZodObject<
                                    {
                                        attached: ZodBoolean;
                                        origin: ZodString;
                                        target_id: ZodString;
                                        title: ZodString;
                                        type: ZodString;
                                        url: ZodString;
                                    },
                                    $strip,
                                >;
                                workers: ZodArray<
                                    ZodObject<
                                        {
                                            attached: ...;
                                            opener_target_id: ...;
                                            origin: ...;
                                            parent_frame_id: ...;
                                            target_id: ...;
                                            type: ...;
                                            url: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strip,
                        >;
                        webmcp: ZodDefault<
                            ZodNullable<
                                ZodObject<
                                    {
                                        browser: ZodObject<(...), (...)>;
                                        completeness: ZodObject<(...), (...)>;
                                        limitations: ZodArray<(...)>;
                                        schema_version: ZodLiteral<(...)>;
                                        status: ZodEnum<(...)>;
                                        target: ZodObject<(...), (...)>;
                                        tools: ZodObject<(...), (...)>;
                                    },
                                    $strip,
                                >,
                            >,
                        >;
                    },
                    $strip,
                >;
                before: ZodObject<
                    {
                        inspection: ZodObject<
                            {
                                accessibility: ZodObject<
                                    {
                                        nodes: ZodArray<(...)>;
                                        text_capture: ZodObject<(...), (...)>;
                                        total_nodes: ZodNumber;
                                    },
                                    $strip,
                                >;
                                browser: ZodObject<
                                    {
                                        js_version: ZodString;
                                        product: ZodString;
                                        protocol_version: ZodString;
                                        revision: ZodString;
                                        user_agent: ZodString;
                                    },
                                    $strip,
                                >;
                                capture_window: ZodObject<
                                    {
                                        ended_at: ZodISODateTime;
                                        observation_ms: ZodNumber;
                                        started_at: ZodISODateTime;
                                    },
                                    $strip,
                                >;
                                completeness: ZodObject<
                                    {
                                        attach_limited_sections: ZodArray<(...)>;
                                        conditions: ZodArray<(...)>;
                                        dropped_events: ZodObject<(...), (...)>;
                                        excluded: ZodArray<(...)>;
                                        policy_filtered_sections: ZodArray<(...)>;
                                        status: ZodEnum<(...)>;
                                        truncated_sections: ZodArray<(...)>;
                                        unavailable_sections: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                console: ZodObject<
                                    {
                                        coverage_started_at: ZodISODateTime;
                                        events: ZodArray<(...)>;
                                        prior_activity_available: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                dom: ZodObject<
                                    { nodes: ZodArray<(...)>; total_nodes: ZodNumber },
                                    $strip,
                                >;
                                frames: ZodArray<
                                    ZodObject<
                                        { frame_id: ...; origin: ...; parent_frame_id: ...; url: ... },
                                        $strip,
                                    >,
                                >;
                                limitations: ZodArray<ZodString>;
                                metadata: ZodObject<
                                    {
                                        agent_hints: ZodArray<(...)>;
                                        dom_urls: ZodArray<(...)>;
                                        excluded_dom_urls: ZodNumber;
                                        headers_allowlisted: ZodLiteral<(...)>;
                                        responses: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                network: ZodObject<
                                    {
                                        coverage_started_at: ZodISODateTime;
                                        prior_activity_available: ZodLiteral<(...)>;
                                        requests: ZodArray<(...)>;
                                        websocket_events: ZodArray<(...)>;
                                    },
                                    $strip,
                                >;
                                resources: ZodArray<
                                    ZodObject<
                                        {
                                            content_size: ...;
                                            mime_type: ...;
                                            origin: ...;
                                            resource_key: ...;
                                            type: ...;
                                            url: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                                schema_version: ZodLiteral<2>;
                                scripts: ZodObject<
                                    { items: ZodArray<(...)>; total: ZodNumber },
                                    $strip,
                                >;
                                storage: ZodObject<
                                    {
                                        cache_names: ZodArray<(...)>;
                                        indexed_db_names: ZodArray<(...)>;
                                        local_storage_keys: ZodArray<(...)>;
                                        origin: ZodString;
                                        quota_bytes: ZodNullable<(...)>;
                                        session_storage_keys: ZodArray<(...)>;
                                        usage_bytes: ZodNullable<(...)>;
                                        values_redacted: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                target: ZodObject<
                                    {
                                        attached: ZodBoolean;
                                        origin: ZodString;
                                        target_id: ZodString;
                                        title: ZodString;
                                        type: ZodString;
                                        url: ZodString;
                                    },
                                    $strip,
                                >;
                                workers: ZodArray<
                                    ZodObject<
                                        {
                                            attached: ...;
                                            opener_target_id: ...;
                                            origin: ...;
                                            parent_frame_id: ...;
                                            target_id: ...;
                                            type: ...;
                                            url: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strip,
                        >;
                        webmcp: ZodDefault<
                            ZodNullable<
                                ZodObject<
                                    {
                                        browser: ZodObject<(...), (...)>;
                                        completeness: ZodObject<(...), (...)>;
                                        limitations: ZodArray<(...)>;
                                        schema_version: ZodLiteral<(...)>;
                                        status: ZodEnum<(...)>;
                                        target: ZodObject<(...), (...)>;
                                        tools: ZodObject<(...), (...)>;
                                    },
                                    $strip,
                                >,
                            >,
                        >;
                    },
                    $strip,
                >;
                max_changes: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "compare_web_captures";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Capture the current visible viewport of one approved page as a bounded, content-addressed PNG artifact. Screenshot capture requires separate explicit approval and never scrolls, navigates, or evaluates page JavaScript.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_origins: ["https://app.example.test"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9222";
                    maximum_image_bytes: 4194304;
                    screenshot_approved: true;
                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS";
                };
                title: "Capture an approved viewport";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_origins: ZodPipe<
                    ZodArray<ZodPipe<ZodString, ZodTransform<string, string>>>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                maximum_image_bytes: ZodDefault<ZodNumber>;
                screenshot_approved: ZodLiteral<true>;
                target_id: ZodString;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "capture_web_screenshot";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Compare two self-verifying PNG screenshot artifacts with bounded local pixel metrics. Returns exact changed-pixel ratios and channel deltas without OCR or external services.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    after: {
                        bytes: number;
                        data_base64: string;
                        media_type: string;
                        sha256: string;
                        uri: string;
                    };
                    before: {
                        bytes: number;
                        data_base64: string;
                        media_type: string;
                        sha256: string;
                        uri: string;
                    };
                    channel_threshold: 0;
                    maximum_pixels: 16000000;
                };
                title: "Compare two screenshot artifacts";
            },
        ];
        inputSchema: ZodObject<
            {
                after: ZodObject<
                    {
                        bytes: ZodNumber;
                        data_base64: ZodString;
                        media_type: ZodLiteral<"image/png">;
                        sha256: ZodString;
                        uri: ZodString;
                    },
                    $strip,
                >;
                before: ZodObject<
                    {
                        bytes: ZodNumber;
                        data_base64: ZodString;
                        media_type: ZodLiteral<"image/png">;
                        sha256: ZodString;
                        uri: ZodString;
                    },
                    $strip,
                >;
                channel_threshold: ZodDefault<ZodNumber>;
                maximum_pixels: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "browser-provider";
        name: "compare_web_screenshots";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "List Electron file:// page targets from an approved user-owned loopback CDP endpoint. Every path is canonicalized and must remain contained by an approved filesystem root, including after symlink resolution.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_file_roots: ["/Applications/Example.app/Contents/Resources"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9223";
                    limit: 100;
                    offset: 0;
                };
                title: "List approved Electron file pages";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_file_roots: ZodPipe<
                    ZodArray<ZodString>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                limit: ZodDefault<ZodNumber>;
                offset: ZodDefault<ZodNumber>;
            },
            $strip,
        >;
        kind: "electron-provider";
        name: "list_electron_targets";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Passively inspect one approved Electron file page through CDP. Returns root-confined frames, DOM structure, resource paths, and scripts without evaluating renderer JavaScript or invoking Electron APIs; script contents require separate approval.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    allowed_file_roots: ["/Applications/Example.app/Contents/Resources"];
                    approved: true;
                    cdp_endpoint: "http://127.0.0.1:9223";
                    include_script_sources: false;
                    limits: {
                        max_dom_nodes: 2000;
                        max_frames: 200;
                        max_resources: 2000;
                        max_script_source_bytes: 1048576;
                        max_scripts: 500;
                        max_total_script_source_bytes: 4194304;
                        max_workers: 500;
                    };
                    observation_ms: 100;
                    source_capture_approved: false;
                    target_id: "TARGET_ID_FROM_LIST_ELECTRON_TARGETS";
                };
                title: "Inspect an approved Electron page";
            },
        ];
        inputSchema: ZodObject<
            {
                allowed_file_roots: ZodPipe<
                    ZodArray<ZodString>,
                    ZodTransform<string[], string[]>,
                >;
                approved: ZodLiteral<true>;
                cdp_endpoint: ZodPipe<ZodString, ZodTransform<string, string>>;
                include_script_sources: ZodDefault<ZodBoolean>;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_dom_nodes: ZodDefault<ZodNumber>;
                            max_frames: ZodDefault<ZodNumber>;
                            max_resources: ZodDefault<ZodNumber>;
                            max_script_source_bytes: ZodDefault<ZodNumber>;
                            max_scripts: ZodDefault<ZodNumber>;
                            max_total_script_source_bytes: ZodDefault<ZodNumber>;
                            max_workers: ZodDefault<ZodNumber>;
                        },
                        $strip,
                    >,
                >;
                observation_ms: ZodDefault<ZodNumber>;
                source_capture_approved: ZodDefault<ZodBoolean>;
                target_id: ZodString;
            },
            $strip,
        >;
        kind: "electron-provider";
        name: "inspect_electron_page";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Statically reconstruct one approved local ASAR or extracted JavaScript application as Evidence v2 and JavaScript Application Graph v1. Maps BrowserWindow preferences, preload and contextBridge APIs, literal and dynamic IPC, handler locations, sender-validation observations, utility processes, and requested native addon bindings without executing JavaScript; source-map contents require separate approval.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    approved: true;
                    format: "auto";
                    input_path: "/Applications/Example.app/Contents/Resources/app.asar";
                    source_map_read_approved: false;
                };
                title: "Analyze one approved local Electron application";
            },
        ];
        inputSchema: ZodObject<
            {
                approved: ZodLiteral<true>;
                format: ZodDefault<
                    ZodEnum<{ asar: "asar"; auto: "auto"; directory: "directory" }>,
                >;
                input_path: ZodString;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_artifact_entry_bytes: ZodDefault<ZodNumber>;
                            max_ast_nodes: ZodDefault<ZodNumber>;
                            max_compression_ratio: ZodDefault<ZodNumber>;
                            max_depth: ZodDefault<ZodNumber>;
                            max_entries: ZodDefault<ZodNumber>;
                            max_findings: ZodDefault<ZodNumber>;
                            max_modules: ZodDefault<ZodNumber>;
                            max_parse_milliseconds: ZodDefault<ZodNumber>;
                            max_path_bytes: ZodDefault<ZodNumber>;
                            max_source_map_sources: ZodDefault<ZodNumber>;
                            max_text_file_bytes: ZodDefault<ZodNumber>;
                            max_text_files: ZodDefault<ZodNumber>;
                            max_total_artifact_bytes: ZodDefault<ZodNumber>;
                            max_total_text_bytes: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                source_map_read_approved: ZodDefault<ZodBoolean>;
            },
            $strict,
        >;
        kind: "electron-provider";
        name: "analyze_javascript_application";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        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.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    runtime_observations: (
                        | {
                            analysis_profile: {
                                digest: string;
                                parameters: Record<string, JSONType>;
                                provider: { id: string; name: string; version: string };
                                provider_profile_schema_version: number;
                                schema_version: 1;
                            };
                            authority: | "shipped-artifact"
                            | "controlled-replay"
                            | "historical-reference"
                            | "external-service"
                            | "analyst-inference";
                            confidence: "observed"
                            | "derived"
                            | "inferred";
                            environment:
                                | {
                                    architecture: string;
                                    id: string;
                                    isolation: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    platform: string;
                                }
                                | null;
                            evidence_id: string;
                            evidence_links: string[];
                            limitations: string[];
                            locations: (
                                | { address: ...; kind: ... }
                                | { end: ...; kind: ...; start: ... }
                                | { kind: ...; path: ... }
                                | { kind: ...; offset: ... }
                                | { end: ...; kind: ...; start: ... }
                            )[];
                            normalized_result: JSONType;
                            operation: string;
                            parameters: Record<string, JSONType>;
                            predicate_type: string;
                            provider: { id: string; name: string; version: string | null };
                            raw_result: JSONType;
                            schema_version: 2;
                            subject:
                                | {
                                    architecture: (...)
                                    | (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    digest: { sha256: ... };
                                    format:
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...);
                                    local_path: string;
                                    name: string;
                                }
                                | null;
                        }
                        | {
                            authority: | "shipped-artifact"
                            | "controlled-replay"
                            | "historical-reference"
                            | "external-service"
                            | "analyst-inference";
                            confidence: "observed"
                            | "derived"
                            | "inferred";
                            environment:
                                | {
                                    architecture: string;
                                    id: string;
                                    isolation: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    platform: string;
                                }
                                | null;
                            evidence_id: string;
                            evidence_links: string[];
                            limitations: string[];
                            locations: (
                                | { address: ...; kind: ... }
                                | { end: ...; kind: ...; start: ... }
                                | { kind: ...; path: ... }
                                | { kind: ...; offset: ... }
                                | { end: ...; kind: ...; start: ... }
                            )[];
                            normalized_result: JSONType;
                            operation: string;
                            parameters: Record<string, JSONType>;
                            predicate_type: string;
                            provider: { id: string; name: string; version: string | null };
                            raw_result: JSONType;
                            schema_version: 2;
                            subject:
                                | {
                                    architecture: (...)
                                    | (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    digest: { sha256: ... };
                                    format:
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...)
                                        | (...);
                                    local_path: string;
                                    name: string;
                                }
                                | null;
                        }
                    )[];
                    static_layers: {
                        analysis: | {
                            analysis_profile: {
                                digest: string;
                                parameters: Record<(...), (...)>;
                                provider: { id: ...; name: ...; version: ... };
                                provider_profile_schema_version: number;
                                schema_version: 1;
                            };
                            authority: | "shipped-artifact"
                            | "controlled-replay"
                            | "historical-reference"
                            | "external-service"
                            | "analyst-inference";
                            confidence: "observed"
                            | "derived"
                            | "inferred";
                            environment:
                                | { architecture: ...; id: ...; isolation: ...; platform: ... }
                                | null;
                            evidence_id: string;
                            evidence_links: string[];
                            limitations: string[];
                            locations: ((...) | (...) | (...) | (...) | (...))[];
                            normalized_result: JSONType;
                            operation: string;
                            parameters: Record<string, JSONType>;
                            predicate_type: string;
                            provider: { id: string; name: string; version: (...) | (...) };
                            raw_result: JSONType;
                            schema_version: 2;
                            subject:
                                | {
                                    architecture: ...;
                                    digest: ...;
                                    format: ...;
                                    local_path: ...;
                                    name: ...;
                                }
                                | null;
                        }
                        | {
                            authority: | "shipped-artifact"
                            | "controlled-replay"
                            | "historical-reference"
                            | "external-service"
                            | "analyst-inference";
                            confidence: "observed"
                            | "derived"
                            | "inferred";
                            environment:
                                | { architecture: ...; id: ...; isolation: ...; platform: ... }
                                | null;
                            evidence_id: string;
                            evidence_links: string[];
                            limitations: string[];
                            locations: ((...) | (...) | (...) | (...) | (...))[];
                            normalized_result: JSONType;
                            operation: string;
                            parameters: Record<string, JSONType>;
                            predicate_type: string;
                            provider: { id: string; name: string; version: (...) | (...) };
                            raw_result: JSONType;
                            schema_version: 2;
                            subject:
                                | {
                                    architecture: ...;
                                    digest: ...;
                                    format: ...;
                                    local_path: ...;
                                    name: ...;
                                }
                                | null;
                        };
                        role: string;
                    }[];
                };
                title: "Reconcile one passive Electron capture";
            },
        ];
        inputSchema: ZodObject<
            {
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_reconciliation_items: ZodDefault<ZodNumber>;
                            max_runtime_entities: ZodDefault<ZodNumber>;
                            max_static_load_states: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                runtime_observations: ZodArray<
                    ZodObject<
                        {
                            analysis_profile: ZodOptional<
                                ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >,
                            >;
                            authority: ZodEnum<
                                {
                                    "analyst-inference": "analyst-inference";
                                    "controlled-replay": "controlled-replay";
                                    "external-service": "external-service";
                                    "historical-reference": "historical-reference";
                                    "shipped-artifact": "shipped-artifact";
                                },
                            >;
                            confidence: ZodEnum<
                                {
                                    derived: "derived";
                                    inferred: "inferred";
                                    observed: "observed";
                                },
                            >;
                            environment: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodString;
                                        id: ZodString;
                                        isolation: ZodEnum<(...)>;
                                        platform: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                            evidence_id: ZodString;
                            evidence_links: ZodArray<ZodString>;
                            limitations: ZodArray<ZodString>;
                            locations: ZodArray<
                                ZodDiscriminatedUnion<
                                    [
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                    ],
                                    "kind",
                                >,
                            >;
                            normalized_result: ZodJSONSchema;
                            operation: ZodString;
                            parameters: ZodRecord<ZodString, ZodJSONSchema>;
                            predicate_type: ZodString;
                            provider: ZodObject<
                                {
                                    id: ZodString;
                                    name: ZodString;
                                    version: ZodNullable<ZodString>;
                                },
                                $strip,
                            >;
                            raw_result: ZodNullable<ZodJSONSchema>;
                            schema_version: ZodLiteral<2>;
                            subject: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodNullable<(...)>;
                                        digest: ZodObject<(...), (...)>;
                                        format: ZodEnum<(...)>;
                                        local_path: ZodString;
                                        name: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                        },
                        $strict,
                    >,
                >;
                static_layers: ZodArray<
                    ZodObject<
                        {
                            analysis: ZodObject<
                                {
                                    analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                    authority: ZodEnum<
                                        {
                                            "analyst-inference": ...;
                                            "controlled-replay": ...;
                                            "external-service": ...;
                                            "historical-reference": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                    environment: ZodNullable<ZodObject<(...), (...)>>;
                                    evidence_id: ZodString;
                                    evidence_links: ZodArray<ZodString>;
                                    limitations: ZodArray<ZodString>;
                                    locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                    normalized_result: ZodJSONSchema;
                                    operation: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    predicate_type: ZodString;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    raw_result: ZodNullable<ZodJSONSchema>;
                                    schema_version: ZodLiteral<2>;
                                    subject: ZodNullable<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >;
                            role: ZodEnum<
                                { application: "application"; assets: "assets"; cache: "cache" },
                            >;
                            runtime_mappings: ZodDefault<
                                ZodArray<ZodDiscriminatedUnion<[(...), (...)], "kind">>,
                            >;
                        },
                        $strict,
                    >,
                >;
            },
            $strict,
        >;
        kind: "electron-provider";
        name: "reconcile_javascript_runtime";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Trace a typed literal seed through an authenticated JavaScript Application Graph with explicit direction, depth, node, edge, and path bounds. Original static, native, passive-runtime, inferred, and unknown authorities remain distinct; native addon handoffs never open a provider or execute the application.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    application: | {
                        analysis_profile: {
                            digest: string;
                            parameters: Record<string, JSONType>;
                            provider: { id: string; name: string; version: string };
                            provider_profile_schema_version: number;
                            schema_version: 1;
                        };
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    }
                    | {
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    };
                    direction: "both";
                    seed: {
                        case_sensitive: boolean;
                        kind: "module";
                        match: "exact";
                        value: string;
                    };
                };
                title: "Trace one module seed through a retained application graph";
            },
        ];
        inputSchema: ZodObject<
            {
                application: ZodObject<
                    {
                        analysis_profile: ZodOptional<
                            ZodObject<
                                {
                                    digest: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    provider_profile_schema_version: ZodNumber;
                                    schema_version: ZodLiteral<1>;
                                },
                                $strip,
                            >,
                        >;
                        authority: ZodEnum<
                            {
                                "analyst-inference": "analyst-inference";
                                "controlled-replay": "controlled-replay";
                                "external-service": "external-service";
                                "historical-reference": "historical-reference";
                                "shipped-artifact": "shipped-artifact";
                            },
                        >;
                        confidence: ZodEnum<
                            { derived: "derived"; inferred: "inferred"; observed: "observed" },
                        >;
                        environment: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodString;
                                    id: ZodString;
                                    isolation: ZodEnum<
                                        {
                                            container: ...;
                                            none: ...;
                                            process: ...;
                                            "virtual-machine": ...;
                                        },
                                    >;
                                    platform: ZodString;
                                },
                                $strip,
                            >,
                        >;
                        evidence_id: ZodString;
                        evidence_links: ZodArray<ZodString>;
                        limitations: ZodArray<ZodString>;
                        locations: ZodArray<
                            ZodDiscriminatedUnion<
                                [
                                    ZodObject<{ address: ...; kind: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                    ZodObject<{ kind: ...; path: ... }, $strip>,
                                    ZodObject<{ kind: ...; offset: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                ],
                                "kind",
                            >,
                        >;
                        normalized_result: ZodJSONSchema;
                        operation: ZodString;
                        parameters: ZodRecord<ZodString, ZodJSONSchema>;
                        predicate_type: ZodString;
                        provider: ZodObject<
                            {
                                id: ZodString;
                                name: ZodString;
                                version: ZodNullable<ZodString>;
                            },
                            $strip,
                        >;
                        raw_result: ZodNullable<ZodJSONSchema>;
                        schema_version: ZodLiteral<2>;
                        subject: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodNullable<ZodEnum<(...)>>;
                                    digest: ZodObject<{ sha256: ... }, $strip>;
                                    format: ZodEnum<
                                        {
                                            "analysis-database": ...;
                                            "android-manifest": ...;
                                            "android-resources": ...;
                                            apk: ...;
                                            asar: ...;
                                            dex: ...;
                                            directory: ...;
                                            dmg: ...;
                                            elf: ...;
                                            entitlements: ...;
                                            file: ...;
                                            hopper: ...;
                                            ipa: ...;
                                            javascript: ...;
                                            "javascript-bundle": ...;
                                            "jvm-class": ...;
                                            "mach-o": ...;
                                            "mach-o-universal": ...;
                                            pe: ...;
                                            pkg: ...;
                                            plist: ...;
                                            "source-map": ...;
                                            unknown: ...;
                                            webassembly: ...;
                                            zip: ...;
                                        },
                                    >;
                                    local_path: ZodString;
                                    name: ZodString;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strict,
                >;
                direction: ZodDefault<
                    ZodEnum<
                        { both: "both"; incoming: "incoming"; outgoing: "outgoing" },
                    >,
                >;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_depth: ZodDefault<ZodNumber>;
                            max_edges: ZodDefault<ZodNumber>;
                            max_nodes: ZodDefault<ZodNumber>;
                            max_paths: ZodDefault<ZodNumber>;
                            max_seed_matches: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                native_observations: ZodDefault<
                    ZodArray<
                        ZodObject<
                            {
                                analysis_profile: ZodOptional<
                                    ZodObject<
                                        {
                                            digest: ...;
                                            parameters: ...;
                                            provider: ...;
                                            provider_profile_schema_version: ...;
                                            schema_version: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    >,
                >;
                seed: ZodObject<
                    {
                        case_sensitive: ZodDefault<ZodBoolean>;
                        kind: ZodEnum<
                            {
                                api: "api";
                                channel: "channel";
                                module: "module";
                                "native-export": "native-export";
                                "node-id": "node-id";
                                route: "route";
                                string: "string";
                            },
                        >;
                        match: ZodDefault<
                            ZodNullable<ZodEnum<{ contains: "contains"; exact: "exact" }>>,
                        >;
                        value: ZodString;
                    },
                    $strict,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "trace_application_feature";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Compare two authenticated JavaScript Application Graph versions using unique-only exact digest, module source digest, source-map identity, structural fingerprint, and non-module semantic-key tiers. Reports added, removed, changed, ambiguous, and unknown entities plus a bounded changed_from graph without fuzzy or module-ordinal pairing.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    left: | {
                        analysis_profile: {
                            digest: string;
                            parameters: Record<string, JSONType>;
                            provider: { id: string; name: string; version: string };
                            provider_profile_schema_version: number;
                            schema_version: 1;
                        };
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    }
                    | {
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    };
                    right: | {
                        analysis_profile: {
                            digest: string;
                            parameters: Record<string, JSONType>;
                            provider: { id: string; name: string; version: string };
                            provider_profile_schema_version: number;
                            schema_version: 1;
                        };
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    }
                    | {
                        authority: | "shipped-artifact"
                        | "controlled-replay"
                        | "historical-reference"
                        | "external-service"
                        | "analyst-inference";
                        confidence: "observed"
                        | "derived"
                        | "inferred";
                        environment:
                            | {
                                architecture: string;
                                id: string;
                                isolation: "process"
                                | "none"
                                | "container"
                                | "virtual-machine";
                                platform: string;
                            }
                            | null;
                        evidence_id: string;
                        evidence_links: string[];
                        limitations: string[];
                        locations: (
                            | { address: string; kind: "address" }
                            | { end: string; kind: "address-range"; start: string }
                            | { kind: "artifact-path"; path: string }
                            | { kind: "file-offset"; offset: number }
                            | { end: number; kind: "file-offset-range"; start: number }
                        )[];
                        normalized_result: JSONType;
                        operation: string;
                        parameters: Record<string, JSONType>;
                        predicate_type: string;
                        provider: { id: string; name: string; version: string | null };
                        raw_result: JSONType;
                        schema_version: 2;
                        subject:
                            | {
                                architecture: "x86"
                                | "x86_64"
                                | "arm"
                                | "arm64"
                                | null;
                                digest: { sha256: string };
                                format:
                                    | "unknown"
                                    | "file"
                                    | "directory"
                                    | "javascript"
                                    | "source-map"
                                    | "plist"
                                    | "entitlements"
                                    | "dmg"
                                    | "zip"
                                    | "pkg"
                                    | "asar"
                                    | "javascript-bundle"
                                    | "mach-o-universal"
                                    | "mach-o"
                                    | "elf"
                                    | "pe"
                                    | "hopper"
                                    | "analysis-database"
                                    | "ipa"
                                    | "apk"
                                    | "dex"
                                    | "jvm-class"
                                    | "webassembly"
                                    | "android-manifest"
                                    | "android-resources";
                                local_path: string;
                                name: string;
                            }
                            | null;
                    };
                };
                title: "Compare authenticated static and reconciled application graphs";
            },
        ];
        inputSchema: ZodObject<
            {
                left: ZodObject<
                    {
                        analysis_profile: ZodOptional<
                            ZodObject<
                                {
                                    digest: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    provider_profile_schema_version: ZodNumber;
                                    schema_version: ZodLiteral<1>;
                                },
                                $strip,
                            >,
                        >;
                        authority: ZodEnum<
                            {
                                "analyst-inference": "analyst-inference";
                                "controlled-replay": "controlled-replay";
                                "external-service": "external-service";
                                "historical-reference": "historical-reference";
                                "shipped-artifact": "shipped-artifact";
                            },
                        >;
                        confidence: ZodEnum<
                            { derived: "derived"; inferred: "inferred"; observed: "observed" },
                        >;
                        environment: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodString;
                                    id: ZodString;
                                    isolation: ZodEnum<
                                        {
                                            container: ...;
                                            none: ...;
                                            process: ...;
                                            "virtual-machine": ...;
                                        },
                                    >;
                                    platform: ZodString;
                                },
                                $strip,
                            >,
                        >;
                        evidence_id: ZodString;
                        evidence_links: ZodArray<ZodString>;
                        limitations: ZodArray<ZodString>;
                        locations: ZodArray<
                            ZodDiscriminatedUnion<
                                [
                                    ZodObject<{ address: ...; kind: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                    ZodObject<{ kind: ...; path: ... }, $strip>,
                                    ZodObject<{ kind: ...; offset: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                ],
                                "kind",
                            >,
                        >;
                        normalized_result: ZodJSONSchema;
                        operation: ZodString;
                        parameters: ZodRecord<ZodString, ZodJSONSchema>;
                        predicate_type: ZodString;
                        provider: ZodObject<
                            {
                                id: ZodString;
                                name: ZodString;
                                version: ZodNullable<ZodString>;
                            },
                            $strip,
                        >;
                        raw_result: ZodNullable<ZodJSONSchema>;
                        schema_version: ZodLiteral<2>;
                        subject: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodNullable<ZodEnum<(...)>>;
                                    digest: ZodObject<{ sha256: ... }, $strip>;
                                    format: ZodEnum<
                                        {
                                            "analysis-database": ...;
                                            "android-manifest": ...;
                                            "android-resources": ...;
                                            apk: ...;
                                            asar: ...;
                                            dex: ...;
                                            directory: ...;
                                            dmg: ...;
                                            elf: ...;
                                            entitlements: ...;
                                            file: ...;
                                            hopper: ...;
                                            ipa: ...;
                                            javascript: ...;
                                            "javascript-bundle": ...;
                                            "jvm-class": ...;
                                            "mach-o": ...;
                                            "mach-o-universal": ...;
                                            pe: ...;
                                            pkg: ...;
                                            plist: ...;
                                            "source-map": ...;
                                            unknown: ...;
                                            webassembly: ...;
                                            zip: ...;
                                        },
                                    >;
                                    local_path: ZodString;
                                    name: ZodString;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strict,
                >;
                left_native_observations: ZodDefault<
                    ZodArray<
                        ZodObject<
                            {
                                analysis_profile: ZodOptional<
                                    ZodObject<
                                        {
                                            digest: ...;
                                            parameters: ...;
                                            provider: ...;
                                            provider_profile_schema_version: ...;
                                            schema_version: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    >,
                >;
                limits: ZodDefault<
                    ZodObject<
                        {
                            max_candidate_nodes: ZodDefault<ZodNumber>;
                            max_comparison_items: ZodDefault<ZodNumber>;
                            max_graph_edges: ZodDefault<ZodNumber>;
                            max_graph_nodes: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                right: ZodObject<
                    {
                        analysis_profile: ZodOptional<
                            ZodObject<
                                {
                                    digest: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    provider_profile_schema_version: ZodNumber;
                                    schema_version: ZodLiteral<1>;
                                },
                                $strip,
                            >,
                        >;
                        authority: ZodEnum<
                            {
                                "analyst-inference": "analyst-inference";
                                "controlled-replay": "controlled-replay";
                                "external-service": "external-service";
                                "historical-reference": "historical-reference";
                                "shipped-artifact": "shipped-artifact";
                            },
                        >;
                        confidence: ZodEnum<
                            { derived: "derived"; inferred: "inferred"; observed: "observed" },
                        >;
                        environment: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodString;
                                    id: ZodString;
                                    isolation: ZodEnum<
                                        {
                                            container: ...;
                                            none: ...;
                                            process: ...;
                                            "virtual-machine": ...;
                                        },
                                    >;
                                    platform: ZodString;
                                },
                                $strip,
                            >,
                        >;
                        evidence_id: ZodString;
                        evidence_links: ZodArray<ZodString>;
                        limitations: ZodArray<ZodString>;
                        locations: ZodArray<
                            ZodDiscriminatedUnion<
                                [
                                    ZodObject<{ address: ...; kind: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                    ZodObject<{ kind: ...; path: ... }, $strip>,
                                    ZodObject<{ kind: ...; offset: ... }, $strip>,
                                    ZodObject<{ end: ...; kind: ...; start: ... }, $strip>,
                                ],
                                "kind",
                            >,
                        >;
                        normalized_result: ZodJSONSchema;
                        operation: ZodString;
                        parameters: ZodRecord<ZodString, ZodJSONSchema>;
                        predicate_type: ZodString;
                        provider: ZodObject<
                            {
                                id: ZodString;
                                name: ZodString;
                                version: ZodNullable<ZodString>;
                            },
                            $strip,
                        >;
                        raw_result: ZodNullable<ZodJSONSchema>;
                        schema_version: ZodLiteral<2>;
                        subject: ZodNullable<
                            ZodObject<
                                {
                                    architecture: ZodNullable<ZodEnum<(...)>>;
                                    digest: ZodObject<{ sha256: ... }, $strip>;
                                    format: ZodEnum<
                                        {
                                            "analysis-database": ...;
                                            "android-manifest": ...;
                                            "android-resources": ...;
                                            apk: ...;
                                            asar: ...;
                                            dex: ...;
                                            directory: ...;
                                            dmg: ...;
                                            elf: ...;
                                            entitlements: ...;
                                            file: ...;
                                            hopper: ...;
                                            ipa: ...;
                                            javascript: ...;
                                            "javascript-bundle": ...;
                                            "jvm-class": ...;
                                            "mach-o": ...;
                                            "mach-o-universal": ...;
                                            pe: ...;
                                            pkg: ...;
                                            plist: ...;
                                            "source-map": ...;
                                            unknown: ...;
                                            webassembly: ...;
                                            zip: ...;
                                        },
                                    >;
                                    local_path: ZodString;
                                    name: ZodString;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strict,
                >;
                right_native_observations: ZodDefault<
                    ZodArray<
                        ZodObject<
                            {
                                analysis_profile: ZodOptional<
                                    ZodObject<
                                        {
                                            digest: ...;
                                            parameters: ...;
                                            provider: ...;
                                            provider_profile_schema_version: ...;
                                            schema_version: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    >,
                >;
                unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
            },
            $strict,
        >;
        kind: "application";
        name: "compare_application_versions";
        outputSchema: ZodObject<
            {
                evidence_id: ZodString;
                evidence_uri: ZodString;
                result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Plan or execute a content-bound extracted-module JavaScript replay inside the Linux Bubblewrap, seccomp, and cgroup boundary. Execution requires approved: true and the exact plan digest. Supports deterministic boundary cases and optional left/right differential comparison; observations have controlled-replay authority and do not claim real application runtime behavior.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    approved: false;
                    cases: [{ arguments: [""]; case_id: "empty" }];
                    determinism: {
                        clock_iso: "2000-01-01T00:00:00.000Z";
                        locale: "en-US";
                        platform: "linux";
                        random_seed: 0;
                        timezone: "UTC";
                    };
                    left: {
                        entry_alias: "parser";
                        entry_export: "default";
                        modules: [
                            {
                                alias: "parser";
                                dependencies: {};
                                format: "esm";
                                path: "/approved/parser.mjs";
                                role: "module";
                            },
                        ];
                    };
                    limits: {
                        cpu_quota_percent: 50;
                        input_bytes: 262144;
                        memory_bytes: 134217728;
                        module_bytes: 4194304;
                        output_bytes: 524288;
                        protocol_bytes: 16777216;
                        result_depth: 16;
                        result_nodes: 10000;
                        stderr_bytes: 32768;
                        tasks: 8;
                        tmpfs_bytes: 16777216;
                        wall_time_ms: 3000;
                    };
                    mode: "plan";
                };
                title: "Plan one extracted ESM parser replay";
            },
        ];
        inputSchema: ZodObject<
            {
                approved: ZodDefault<ZodBoolean>;
                cases: ZodDefault<
                    ZodArray<
                        ZodObject<
                            { arguments: ZodArray<ZodJSONSchema>; case_id: ZodString },
                            $strict,
                        >,
                    >,
                >;
                determinism: ZodDefault<
                    ZodObject<
                        {
                            clock_iso: ZodDefault<ZodISODateTime>;
                            locale: ZodDefault<ZodLiteral<"en-US">>;
                            platform: ZodDefault<ZodLiteral<"linux">>;
                            random_seed: ZodDefault<ZodNumber>;
                            timezone: ZodDefault<ZodLiteral<"UTC">>;
                        },
                        $strict,
                    >,
                >;
                generator: ZodOptional<
                    ZodObject<
                        {
                            count: ZodNumber;
                            preset: ZodEnum<
                                {
                                    "clipboard-boundaries": "clipboard-boundaries";
                                    "parser-boundaries": "parser-boundaries";
                                    "sanitizer-boundaries": "sanitizer-boundaries";
                                },
                            >;
                            seed: ZodNumber;
                        },
                        $strict,
                    >,
                >;
                left: ZodObject<
                    {
                        entry_alias: ZodString;
                        entry_export: ZodDefault<ZodString>;
                        modules: ZodArray<
                            ZodObject<
                                {
                                    alias: ZodString;
                                    dependencies: ZodDefault<ZodRecord<(...), (...)>>;
                                    format: ZodEnum<{ "commonjs-factory": ...; esm: ... }>;
                                    path: ZodString;
                                    role: ZodDefault<ZodEnum<(...)>>;
                                },
                                $strict,
                            >,
                        >;
                    },
                    $strict,
                >;
                limits: ZodDefault<
                    ZodObject<
                        {
                            cpu_quota_percent: ZodDefault<ZodNumber>;
                            input_bytes: ZodDefault<ZodNumber>;
                            memory_bytes: ZodDefault<ZodNumber>;
                            module_bytes: ZodDefault<ZodNumber>;
                            output_bytes: ZodDefault<ZodNumber>;
                            protocol_bytes: ZodDefault<ZodNumber>;
                            result_depth: ZodDefault<ZodNumber>;
                            result_nodes: ZodDefault<ZodNumber>;
                            stderr_bytes: ZodDefault<ZodNumber>;
                            tasks: ZodDefault<ZodNumber>;
                            tmpfs_bytes: ZodDefault<ZodNumber>;
                            wall_time_ms: ZodDefault<ZodNumber>;
                        },
                        $strict,
                    >,
                >;
                mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                plan_digest: ZodOptional<ZodString>;
                reproducer_export: ZodOptional<
                    ZodObject<
                        {
                            approved: ZodBoolean;
                            include_sources: ZodDefault<ZodBoolean>;
                            path: ZodString;
                        },
                        $strict,
                    >,
                >;
                right: ZodOptional<
                    ZodObject<
                        {
                            entry_alias: ZodString;
                            entry_export: ZodDefault<ZodString>;
                            modules: ZodArray<
                                ZodObject<
                                    {
                                        alias: ZodString;
                                        dependencies: ZodDefault<(...)>;
                                        format: ZodEnum<(...)>;
                                        path: ZodString;
                                        role: ZodDefault<(...)>;
                                    },
                                    $strict,
                                >,
                            >;
                        },
                        $strict,
                    >,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "run_controlled_replay";
        outputSchema: ZodObject<
            {
                evidence: ZodNullable<
                    ZodObject<
                        {
                            analysis_profile: ZodOptional<
                                ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >,
                            >;
                            authority: ZodEnum<
                                {
                                    "analyst-inference": "analyst-inference";
                                    "controlled-replay": "controlled-replay";
                                    "external-service": "external-service";
                                    "historical-reference": "historical-reference";
                                    "shipped-artifact": "shipped-artifact";
                                },
                            >;
                            confidence: ZodEnum<
                                {
                                    derived: "derived";
                                    inferred: "inferred";
                                    observed: "observed";
                                },
                            >;
                            environment: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodString;
                                        id: ZodString;
                                        isolation: ZodEnum<(...)>;
                                        platform: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                            evidence_id: ZodString;
                            evidence_links: ZodArray<ZodString>;
                            limitations: ZodArray<ZodString>;
                            locations: ZodArray<
                                ZodDiscriminatedUnion<
                                    [
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                    ],
                                    "kind",
                                >,
                            >;
                            normalized_result: ZodObject<
                                {
                                    cleanup: ZodObject<
                                        { residual_resources: ...; state: ... },
                                        $strict,
                                    >;
                                    comparison: ZodOptional<ZodArray<(...)>>;
                                    limitations: ZodArray<ZodString>;
                                    outcomes: ZodArray<ZodObject<(...), (...)>>;
                                    plan_digest: ZodString;
                                    reproducer: ZodNullable<ZodDiscriminatedUnion<(...), (...)>>;
                                    schema_version: ZodLiteral<1>;
                                    stderr: ZodString;
                                    termination: ZodEnum<
                                        {
                                            cancelled: ...;
                                            completed: ...;
                                            crash: ...;
                                            oom: ...;
                                            protocol_error: ...;
                                            timeout: ...;
                                        },
                                    >;
                                },
                                $strict,
                            >;
                            operation: ZodString;
                            parameters: ZodRecord<ZodString, ZodJSONSchema>;
                            predicate_type: ZodString;
                            provider: ZodObject<
                                {
                                    id: ZodString;
                                    name: ZodString;
                                    version: ZodNullable<ZodString>;
                                },
                                $strip,
                            >;
                            raw_result: ZodNullable<ZodJSONSchema>;
                            schema_version: ZodLiteral<2>;
                            subject: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodNullable<(...)>;
                                        digest: ZodObject<(...), (...)>;
                                        format: ZodEnum<(...)>;
                                        local_path: ZodString;
                                        name: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                        },
                        $strict,
                    >,
                >;
                phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                plan: ZodNullable<
                    ZodObject<
                        {
                            cases: ZodArray<
                                ZodObject<
                                    {
                                        arguments: ZodArray<(...)>;
                                        case_id: ZodString;
                                        sha256: ZodString;
                                    },
                                    $strict,
                                >,
                            >;
                            determinism: ZodObject<
                                {
                                    clock_iso: ZodDefault<ZodISODateTime>;
                                    locale: ZodDefault<ZodLiteral<(...)>>;
                                    platform: ZodDefault<ZodLiteral<(...)>>;
                                    random_seed: ZodDefault<ZodNumber>;
                                    timezone: ZodDefault<ZodLiteral<(...)>>;
                                },
                                $strict,
                            >;
                            effects: ZodArray<ZodString>;
                            filesystem: ZodObject<
                                {
                                    host_writes: ZodLiteral<false>;
                                    private_tmpfs_bytes: ZodNumber;
                                },
                                $strict,
                            >;
                            left: ZodObject<
                                {
                                    entry_alias: ZodString;
                                    entry_export: ZodString;
                                    modules: ZodArray<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >;
                            limits: ZodObject<
                                {
                                    cpu_quota_percent: ZodDefault<ZodNumber>;
                                    input_bytes: ZodDefault<ZodNumber>;
                                    memory_bytes: ZodDefault<ZodNumber>;
                                    module_bytes: ZodDefault<ZodNumber>;
                                    output_bytes: ZodDefault<ZodNumber>;
                                    protocol_bytes: ZodDefault<ZodNumber>;
                                    result_depth: ZodDefault<ZodNumber>;
                                    result_nodes: ZodDefault<ZodNumber>;
                                    stderr_bytes: ZodDefault<ZodNumber>;
                                    tasks: ZodDefault<ZodNumber>;
                                    tmpfs_bytes: ZodDefault<ZodNumber>;
                                    wall_time_ms: ZodDefault<ZodNumber>;
                                },
                                $strict,
                            >;
                            network: ZodLiteral<"none">;
                            plan_digest: ZodString;
                            policy_sha256: ZodString;
                            policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                            reproducer_export: ZodNullable<
                                ZodObject<
                                    {
                                        authority: ZodLiteral<(...)>;
                                        include_sources: ZodBoolean;
                                        path: ZodString;
                                    },
                                    $strict,
                                >,
                            >;
                            right: ZodOptional<
                                ZodObject<
                                    {
                                        entry_alias: ZodString;
                                        entry_export: ZodString;
                                        modules: ZodArray<(...)>;
                                    },
                                    $strict,
                                >,
                            >;
                            runtime: ZodObject<
                                {
                                    executable: ZodObject<
                                        { path: ...; sha256: ...; version: ... },
                                        $strict,
                                    >;
                                    read_only_files: ZodArray<ZodObject<(...), (...)>>;
                                    worker: ZodObject<
                                        { path: ...; sha256: ...; version: ... },
                                        $strict,
                                    >;
                                },
                                $strict,
                            >;
                            sandbox: ZodObject<
                                {
                                    bubblewrap: ZodObject<
                                        { path: ...; sha256: ...; version: ... },
                                        $strict,
                                    >;
                                    seccomp_sha256: ZodString;
                                    shell: ZodObject<{ path: ...; sha256: ...; version: ... }, $strict>;
                                    systemctl: ZodObject<
                                        { path: ...; sha256: ...; version: ... },
                                        $strict,
                                    >;
                                    systemd_run: ZodObject<
                                        { path: ...; sha256: ...; version: ... },
                                        $strict,
                                    >;
                                },
                                $strict,
                            >;
                            schema_version: ZodLiteral<1>;
                        },
                        $strict,
                    >,
                >;
                source_evidence: ZodArray<
                    ZodObject<
                        {
                            analysis_profile: ZodOptional<
                                ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >,
                            >;
                            authority: ZodEnum<
                                {
                                    "analyst-inference": "analyst-inference";
                                    "controlled-replay": "controlled-replay";
                                    "external-service": "external-service";
                                    "historical-reference": "historical-reference";
                                    "shipped-artifact": "shipped-artifact";
                                },
                            >;
                            confidence: ZodEnum<
                                {
                                    derived: "derived";
                                    inferred: "inferred";
                                    observed: "observed";
                                },
                            >;
                            environment: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodString;
                                        id: ZodString;
                                        isolation: ZodEnum<(...)>;
                                        platform: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                            evidence_id: ZodString;
                            evidence_links: ZodArray<ZodString>;
                            limitations: ZodArray<ZodString>;
                            locations: ZodArray<
                                ZodDiscriminatedUnion<
                                    [
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                        ZodObject<(...), (...)>,
                                    ],
                                    "kind",
                                >,
                            >;
                            normalized_result: ZodObject<
                                {
                                    cleanup: ZodObject<
                                        { residual_resources: ...; state: ... },
                                        $strict,
                                    >;
                                    comparison: ZodOptional<ZodArray<(...)>>;
                                    limitations: ZodArray<ZodString>;
                                    outcomes: ZodArray<ZodObject<(...), (...)>>;
                                    plan_digest: ZodString;
                                    reproducer: ZodNullable<ZodDiscriminatedUnion<(...), (...)>>;
                                    schema_version: ZodLiteral<1>;
                                    stderr: ZodString;
                                    termination: ZodEnum<
                                        {
                                            cancelled: ...;
                                            completed: ...;
                                            crash: ...;
                                            oom: ...;
                                            protocol_error: ...;
                                            timeout: ...;
                                        },
                                    >;
                                },
                                $strict,
                            >;
                            operation: ZodString;
                            parameters: ZodRecord<ZodString, ZodJSONSchema>;
                            predicate_type: ZodString;
                            provider: ZodObject<
                                {
                                    id: ZodString;
                                    name: ZodString;
                                    version: ZodNullable<ZodString>;
                                },
                                $strip,
                            >;
                            raw_result: ZodNullable<ZodJSONSchema>;
                            schema_version: ZodLiteral<2>;
                            subject: ZodNullable<
                                ZodObject<
                                    {
                                        architecture: ZodNullable<(...)>;
                                        digest: ZodObject<(...), (...)>;
                                        format: ZodEnum<(...)>;
                                        local_path: ZodString;
                                        name: ZodString;
                                    },
                                    $strip,
                                >,
                            >;
                        },
                        $strict,
                    >,
                >;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Prepare a hash-bound Node/JavaScript characterization plan and deterministic reversible export transformation without executing target code. The exact source, selected byte range, runtime closure, sandbox profile, cases, and limits are committed for separate execution approval.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: Record<string, JSONType>;
                title: "Prepare one exact bundled callable characterization";
            },
        ];
        inputSchema: ZodObject<
            {
                expected_effect: ZodEnum<
                    { "observation-only": "observation-only"; pure: "pure" },
                >;
                instrumentation: ZodObject<
                    {
                        artifact_path: ZodString;
                        artifact_sha256: ZodString;
                        selection: ZodObject<
                            {
                                byte_end: ZodNumber;
                                byte_start: ZodNumber;
                                export_name: ZodString;
                                selected_sha256: ZodString;
                            },
                            $strict,
                        >;
                    },
                    $strict,
                >;
                preparation_approved: ZodLiteral<true>;
                replay: ZodObject<
                    {
                        approved: ZodDefault<ZodBoolean>;
                        cases: ZodDefault<
                            ZodArray<
                                ZodObject<
                                    { arguments: ZodArray<(...)>; case_id: ZodString },
                                    $strict,
                                >,
                            >,
                        >;
                        determinism: ZodDefault<
                            ZodObject<
                                {
                                    clock_iso: ZodDefault<ZodISODateTime>;
                                    locale: ZodDefault<ZodLiteral<(...)>>;
                                    platform: ZodDefault<ZodLiteral<(...)>>;
                                    random_seed: ZodDefault<ZodNumber>;
                                    timezone: ZodDefault<ZodLiteral<(...)>>;
                                },
                                $strict,
                            >,
                        >;
                        generator: ZodOptional<
                            ZodObject<
                                {
                                    count: ZodNumber;
                                    preset: ZodEnum<
                                        {
                                            "clipboard-boundaries": ...;
                                            "parser-boundaries": ...;
                                            "sanitizer-boundaries": ...;
                                        },
                                    >;
                                    seed: ZodNumber;
                                },
                                $strict,
                            >,
                        >;
                        left: ZodObject<
                            {
                                entry_alias: ZodString;
                                entry_export: ZodDefault<ZodString>;
                                modules: ZodArray<
                                    ZodObject<
                                        {
                                            alias: ...;
                                            dependencies: ...;
                                            format: ...;
                                            path: ...;
                                            role: ...;
                                        },
                                        $strict,
                                    >,
                                >;
                            },
                            $strict,
                        >;
                        limits: ZodDefault<
                            ZodObject<
                                {
                                    cpu_quota_percent: ZodDefault<ZodNumber>;
                                    input_bytes: ZodDefault<ZodNumber>;
                                    memory_bytes: ZodDefault<ZodNumber>;
                                    module_bytes: ZodDefault<ZodNumber>;
                                    output_bytes: ZodDefault<ZodNumber>;
                                    protocol_bytes: ZodDefault<ZodNumber>;
                                    result_depth: ZodDefault<ZodNumber>;
                                    result_nodes: ZodDefault<ZodNumber>;
                                    stderr_bytes: ZodDefault<ZodNumber>;
                                    tasks: ZodDefault<ZodNumber>;
                                    tmpfs_bytes: ZodDefault<ZodNumber>;
                                    wall_time_ms: ZodDefault<ZodNumber>;
                                },
                                $strict,
                            >,
                        >;
                        mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                        plan_digest: ZodOptional<ZodString>;
                        reproducer_export: ZodOptional<
                            ZodObject<
                                {
                                    approved: ZodBoolean;
                                    include_sources: ZodDefault<ZodBoolean>;
                                    path: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        right: ZodOptional<
                            ZodObject<
                                {
                                    entry_alias: ZodString;
                                    entry_export: ZodDefault<ZodString>;
                                    modules: ZodArray<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >,
                        >;
                    },
                    $strict,
                >;
                selected_alias: ZodString;
            },
            $strict,
        >;
        kind: "application";
        name: "prepare_node_characterization";
        outputSchema: ZodObject<
            {
                phase: ZodLiteral<"preparation">;
                plan: ZodObject<
                    {
                        allowed_boundaries: ZodArray<ZodString>;
                        artifact: ZodObject<
                            { byte_length: ZodNumber; path: ZodString; sha256: ZodString },
                            $strict,
                        >;
                        authority: ZodObject<
                            {
                                execution_approved: ZodLiteral<false>;
                                network: ZodEnum<{ loopback: "loopback"; none: "none" }>;
                                preparation_approved: ZodLiteral<true>;
                                provider_owned_process_only: ZodLiteral<true>;
                            },
                            $strict,
                        >;
                        callable: ZodObject<
                            {
                                callable_id: ZodString;
                                export_name: ZodString;
                                module_id: ZodString;
                                selector_sha256: ZodString;
                                semantic_evidence_id: ZodNullable<ZodString>;
                            },
                            $strict,
                        >;
                        determinism: ZodObject<
                            {
                                clock: ZodEnum<{ fixed: "fixed"; real: "real" }>;
                                identifiers: ZodEnum<
                                    { deterministic: "deterministic"; runtime: "runtime" },
                                >;
                                randomness: ZodEnum<{ seeded: "seeded"; system: "system" }>;
                                seed: ZodNumber;
                            },
                            $strict,
                        >;
                        expected_effect: ZodEnum<
                            {
                                "bounded-effects": "bounded-effects";
                                "observation-only": "observation-only";
                                pure: "pure";
                            },
                        >;
                        isolated_home: ZodString;
                        limits: ZodObject<
                            {
                                idle_timeout_ms: ZodNumber;
                                max_bytes: ZodNumber;
                                max_calls: ZodNumber;
                                max_files: ZodNumber;
                                max_handles: ZodNumber;
                                max_processes: ZodNumber;
                                timeout_ms: ZodNumber;
                            },
                            $strict,
                        >;
                        plan_sha256: ZodString;
                        preparation_sha256: ZodString;
                        runtime: ZodObject<
                            {
                                executable_path: ZodString;
                                executable_sha256: ZodString;
                                family: ZodString;
                                profile_sha256: ZodString;
                                provider_id: ZodString;
                                version: ZodString;
                            },
                            $strict,
                        >;
                        schema_version: ZodLiteral<1>;
                        working_directory: ZodString;
                    },
                    $strict,
                >;
                replay: ZodObject<
                    {
                        evidence: ZodNullable<
                            ZodObject<
                                {
                                    analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                    authority: ZodEnum<
                                        {
                                            "analyst-inference": ...;
                                            "controlled-replay": ...;
                                            "external-service": ...;
                                            "historical-reference": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                    environment: ZodNullable<ZodObject<(...), (...)>>;
                                    evidence_id: ZodString;
                                    evidence_links: ZodArray<ZodString>;
                                    limitations: ZodArray<ZodString>;
                                    locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                    normalized_result: ZodObject<
                                        {
                                            cleanup: ...;
                                            comparison: ...;
                                            limitations: ...;
                                            outcomes: ...;
                                            plan_digest: ...;
                                            reproducer: ...;
                                            schema_version: ...;
                                            stderr: ...;
                                            termination: ...;
                                        },
                                        $strict,
                                    >;
                                    operation: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    predicate_type: ZodString;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    raw_result: ZodNullable<ZodJSONSchema>;
                                    schema_version: ZodLiteral<2>;
                                    subject: ZodNullable<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >,
                        >;
                        phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                        plan: ZodNullable<
                            ZodObject<
                                {
                                    cases: ZodArray<ZodObject<(...), (...)>>;
                                    determinism: ZodObject<
                                        {
                                            clock_iso: ...;
                                            locale: ...;
                                            platform: ...;
                                            random_seed: ...;
                                            timezone: ...;
                                        },
                                        $strict,
                                    >;
                                    effects: ZodArray<ZodString>;
                                    filesystem: ZodObject<
                                        { host_writes: ...; private_tmpfs_bytes: ... },
                                        $strict,
                                    >;
                                    left: ZodObject<
                                        { entry_alias: ...; entry_export: ...; modules: ... },
                                        $strict,
                                    >;
                                    limits: ZodObject<
                                        {
                                            cpu_quota_percent: ...;
                                            input_bytes: ...;
                                            memory_bytes: ...;
                                            module_bytes: ...;
                                            output_bytes: ...;
                                            protocol_bytes: ...;
                                            result_depth: ...;
                                            result_nodes: ...;
                                            stderr_bytes: ...;
                                            tasks: ...;
                                            tmpfs_bytes: ...;
                                            wall_time_ms: ...;
                                        },
                                        $strict,
                                    >;
                                    network: ZodLiteral<"none">;
                                    plan_digest: ZodString;
                                    policy_sha256: ZodString;
                                    policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                                    reproducer_export: ZodNullable<ZodObject<(...), (...)>>;
                                    right: ZodOptional<ZodObject<(...), (...)>>;
                                    runtime: ZodObject<
                                        { executable: ...; read_only_files: ...; worker: ... },
                                        $strict,
                                    >;
                                    sandbox: ZodObject<
                                        {
                                            bubblewrap: ...;
                                            seccomp_sha256: ...;
                                            shell: ...;
                                            systemctl: ...;
                                            systemd_run: ...;
                                        },
                                        $strict,
                                    >;
                                    schema_version: ZodLiteral<1>;
                                },
                                $strict,
                            >,
                        >;
                        source_evidence: ZodArray<
                            ZodObject<
                                {
                                    analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                    authority: ZodEnum<
                                        {
                                            "analyst-inference": ...;
                                            "controlled-replay": ...;
                                            "external-service": ...;
                                            "historical-reference": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                    environment: ZodNullable<ZodObject<(...), (...)>>;
                                    evidence_id: ZodString;
                                    evidence_links: ZodArray<ZodString>;
                                    limitations: ZodArray<ZodString>;
                                    locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                    normalized_result: ZodObject<
                                        {
                                            cleanup: ...;
                                            comparison: ...;
                                            limitations: ...;
                                            outcomes: ...;
                                            plan_digest: ...;
                                            reproducer: ...;
                                            schema_version: ...;
                                            stderr: ...;
                                            termination: ...;
                                        },
                                        $strict,
                                    >;
                                    operation: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    predicate_type: ZodString;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    raw_result: ZodNullable<ZodJSONSchema>;
                                    schema_version: ZodLiteral<2>;
                                    subject: ZodNullable<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >,
                        >;
                    },
                    $strict,
                >;
                schema_version: ZodLiteral<1>;
                transformation: ZodObject<
                    {
                        artifact_path: ZodString;
                        inserted_ranges: ZodArray<
                            ZodObject<
                                {
                                    byte_end: ZodNumber;
                                    byte_start: ZodNumber;
                                    inserted_sha256: ZodString;
                                    purpose: ZodEnum<
                                        {
                                            "export-binding": ...;
                                            "factory-prefix": ...;
                                            "factory-suffix": ...;
                                        },
                                    >;
                                },
                                $strict,
                            >,
                        >;
                        instrumented_byte_length: ZodNumber;
                        instrumented_sha256: ZodString;
                        kind: ZodLiteral<"commonjs-factory-export-v1">;
                        original_byte_length: ZodNumber;
                        original_sha256: ZodString;
                        output_format: ZodLiteral<"commonjs-factory">;
                        schema_version: ZodLiteral<1>;
                        selected_range: ZodObject<
                            {
                                byte_end: ZodNumber;
                                byte_start: ZodNumber;
                                selected_sha256: ZodString;
                            },
                            $strict,
                        >;
                        source_map: ZodLiteral<null>;
                    },
                    $strict,
                >;
                transformation_evidence: ZodUnion<
                    readonly [
                        ZodObject<
                            {
                                analysis_profile: ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                        ZodObject<
                            {
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    ],
                >;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Recompute and execute one separately approved exact Node characterization plan in the owned controlled-replay boundary. Returns transformation, replay, cleanup, and provider-neutral characterization Evidence v2; stale plans fail before execution.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    approved_plan_sha256: string;
                    execution_approved: true;
                    preparation: Record<string, JSONType>;
                };
                title: "Execute one approved exact characterization plan";
            },
        ];
        inputSchema: ZodObject<
            {
                approved_plan_sha256: ZodString;
                execution_approved: ZodLiteral<true>;
                preparation: ZodObject<
                    {
                        expected_effect: ZodEnum<
                            { "observation-only": "observation-only"; pure: "pure" },
                        >;
                        instrumentation: ZodObject<
                            {
                                artifact_path: ZodString;
                                artifact_sha256: ZodString;
                                selection: ZodObject<
                                    {
                                        byte_end: ZodNumber;
                                        byte_start: ZodNumber;
                                        export_name: ZodString;
                                        selected_sha256: ZodString;
                                    },
                                    $strict,
                                >;
                            },
                            $strict,
                        >;
                        preparation_approved: ZodLiteral<true>;
                        replay: ZodObject<
                            {
                                approved: ZodDefault<ZodBoolean>;
                                cases: ZodDefault<ZodArray<ZodObject<(...), (...)>>>;
                                determinism: ZodDefault<
                                    ZodObject<
                                        {
                                            clock_iso: ...;
                                            locale: ...;
                                            platform: ...;
                                            random_seed: ...;
                                            timezone: ...;
                                        },
                                        $strict,
                                    >,
                                >;
                                generator: ZodOptional<
                                    ZodObject<{ count: ...; preset: ...; seed: ... }, $strict>,
                                >;
                                left: ZodObject<
                                    {
                                        entry_alias: ZodString;
                                        entry_export: ZodDefault<(...)>;
                                        modules: ZodArray<(...)>;
                                    },
                                    $strict,
                                >;
                                limits: ZodDefault<
                                    ZodObject<
                                        {
                                            cpu_quota_percent: ...;
                                            input_bytes: ...;
                                            memory_bytes: ...;
                                            module_bytes: ...;
                                            output_bytes: ...;
                                            protocol_bytes: ...;
                                            result_depth: ...;
                                            result_nodes: ...;
                                            stderr_bytes: ...;
                                            tasks: ...;
                                            tmpfs_bytes: ...;
                                            wall_time_ms: ...;
                                        },
                                        $strict,
                                    >,
                                >;
                                mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                                plan_digest: ZodOptional<ZodString>;
                                reproducer_export: ZodOptional<
                                    ZodObject<
                                        { approved: ...; include_sources: ...; path: ... },
                                        $strict,
                                    >,
                                >;
                                right: ZodOptional<
                                    ZodObject<
                                        { entry_alias: ...; entry_export: ...; modules: ... },
                                        $strict,
                                    >,
                                >;
                            },
                            $strict,
                        >;
                        selected_alias: ZodString;
                    },
                    $strict,
                >;
            },
            $strict,
        >;
        kind: "application";
        name: "execute_node_characterization";
        outputSchema: ZodObject<
            {
                evidence: ZodUnion<
                    readonly [
                        ZodObject<
                            {
                                analysis_profile: ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                        ZodObject<
                            {
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    ],
                >;
                phase: ZodLiteral<"execution">;
                plan: ZodObject<
                    {
                        allowed_boundaries: ZodArray<ZodString>;
                        artifact: ZodObject<
                            { byte_length: ZodNumber; path: ZodString; sha256: ZodString },
                            $strict,
                        >;
                        authority: ZodObject<
                            {
                                execution_approved: ZodLiteral<false>;
                                network: ZodEnum<{ loopback: "loopback"; none: "none" }>;
                                preparation_approved: ZodLiteral<true>;
                                provider_owned_process_only: ZodLiteral<true>;
                            },
                            $strict,
                        >;
                        callable: ZodObject<
                            {
                                callable_id: ZodString;
                                export_name: ZodString;
                                module_id: ZodString;
                                selector_sha256: ZodString;
                                semantic_evidence_id: ZodNullable<ZodString>;
                            },
                            $strict,
                        >;
                        determinism: ZodObject<
                            {
                                clock: ZodEnum<{ fixed: "fixed"; real: "real" }>;
                                identifiers: ZodEnum<
                                    { deterministic: "deterministic"; runtime: "runtime" },
                                >;
                                randomness: ZodEnum<{ seeded: "seeded"; system: "system" }>;
                                seed: ZodNumber;
                            },
                            $strict,
                        >;
                        expected_effect: ZodEnum<
                            {
                                "bounded-effects": "bounded-effects";
                                "observation-only": "observation-only";
                                pure: "pure";
                            },
                        >;
                        isolated_home: ZodString;
                        limits: ZodObject<
                            {
                                idle_timeout_ms: ZodNumber;
                                max_bytes: ZodNumber;
                                max_calls: ZodNumber;
                                max_files: ZodNumber;
                                max_handles: ZodNumber;
                                max_processes: ZodNumber;
                                timeout_ms: ZodNumber;
                            },
                            $strict,
                        >;
                        plan_sha256: ZodString;
                        preparation_sha256: ZodString;
                        runtime: ZodObject<
                            {
                                executable_path: ZodString;
                                executable_sha256: ZodString;
                                family: ZodString;
                                profile_sha256: ZodString;
                                provider_id: ZodString;
                                version: ZodString;
                            },
                            $strict,
                        >;
                        schema_version: ZodLiteral<1>;
                        working_directory: ZodString;
                    },
                    $strict,
                >;
                replay: ZodObject<
                    {
                        evidence: ZodNullable<
                            ZodObject<
                                {
                                    analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                    authority: ZodEnum<
                                        {
                                            "analyst-inference": ...;
                                            "controlled-replay": ...;
                                            "external-service": ...;
                                            "historical-reference": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                    environment: ZodNullable<ZodObject<(...), (...)>>;
                                    evidence_id: ZodString;
                                    evidence_links: ZodArray<ZodString>;
                                    limitations: ZodArray<ZodString>;
                                    locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                    normalized_result: ZodObject<
                                        {
                                            cleanup: ...;
                                            comparison: ...;
                                            limitations: ...;
                                            outcomes: ...;
                                            plan_digest: ...;
                                            reproducer: ...;
                                            schema_version: ...;
                                            stderr: ...;
                                            termination: ...;
                                        },
                                        $strict,
                                    >;
                                    operation: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    predicate_type: ZodString;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    raw_result: ZodNullable<ZodJSONSchema>;
                                    schema_version: ZodLiteral<2>;
                                    subject: ZodNullable<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >,
                        >;
                        phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                        plan: ZodNullable<
                            ZodObject<
                                {
                                    cases: ZodArray<ZodObject<(...), (...)>>;
                                    determinism: ZodObject<
                                        {
                                            clock_iso: ...;
                                            locale: ...;
                                            platform: ...;
                                            random_seed: ...;
                                            timezone: ...;
                                        },
                                        $strict,
                                    >;
                                    effects: ZodArray<ZodString>;
                                    filesystem: ZodObject<
                                        { host_writes: ...; private_tmpfs_bytes: ... },
                                        $strict,
                                    >;
                                    left: ZodObject<
                                        { entry_alias: ...; entry_export: ...; modules: ... },
                                        $strict,
                                    >;
                                    limits: ZodObject<
                                        {
                                            cpu_quota_percent: ...;
                                            input_bytes: ...;
                                            memory_bytes: ...;
                                            module_bytes: ...;
                                            output_bytes: ...;
                                            protocol_bytes: ...;
                                            result_depth: ...;
                                            result_nodes: ...;
                                            stderr_bytes: ...;
                                            tasks: ...;
                                            tmpfs_bytes: ...;
                                            wall_time_ms: ...;
                                        },
                                        $strict,
                                    >;
                                    network: ZodLiteral<"none">;
                                    plan_digest: ZodString;
                                    policy_sha256: ZodString;
                                    policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                                    reproducer_export: ZodNullable<ZodObject<(...), (...)>>;
                                    right: ZodOptional<ZodObject<(...), (...)>>;
                                    runtime: ZodObject<
                                        { executable: ...; read_only_files: ...; worker: ... },
                                        $strict,
                                    >;
                                    sandbox: ZodObject<
                                        {
                                            bubblewrap: ...;
                                            seccomp_sha256: ...;
                                            shell: ...;
                                            systemctl: ...;
                                            systemd_run: ...;
                                        },
                                        $strict,
                                    >;
                                    schema_version: ZodLiteral<1>;
                                },
                                $strict,
                            >,
                        >;
                        source_evidence: ZodArray<
                            ZodObject<
                                {
                                    analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                    authority: ZodEnum<
                                        {
                                            "analyst-inference": ...;
                                            "controlled-replay": ...;
                                            "external-service": ...;
                                            "historical-reference": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                    environment: ZodNullable<ZodObject<(...), (...)>>;
                                    evidence_id: ZodString;
                                    evidence_links: ZodArray<ZodString>;
                                    limitations: ZodArray<ZodString>;
                                    locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                    normalized_result: ZodObject<
                                        {
                                            cleanup: ...;
                                            comparison: ...;
                                            limitations: ...;
                                            outcomes: ...;
                                            plan_digest: ...;
                                            reproducer: ...;
                                            schema_version: ...;
                                            stderr: ...;
                                            termination: ...;
                                        },
                                        $strict,
                                    >;
                                    operation: ZodString;
                                    parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                    predicate_type: ZodString;
                                    provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                    raw_result: ZodNullable<ZodJSONSchema>;
                                    schema_version: ZodLiteral<2>;
                                    subject: ZodNullable<ZodObject<(...), (...)>>;
                                },
                                $strict,
                            >,
                        >;
                    },
                    $strict,
                >;
                schema_version: ZodLiteral<1>;
                transformation: ZodObject<
                    {
                        artifact_path: ZodString;
                        inserted_ranges: ZodArray<
                            ZodObject<
                                {
                                    byte_end: ZodNumber;
                                    byte_start: ZodNumber;
                                    inserted_sha256: ZodString;
                                    purpose: ZodEnum<
                                        {
                                            "export-binding": ...;
                                            "factory-prefix": ...;
                                            "factory-suffix": ...;
                                        },
                                    >;
                                },
                                $strict,
                            >,
                        >;
                        instrumented_byte_length: ZodNumber;
                        instrumented_sha256: ZodString;
                        kind: ZodLiteral<"commonjs-factory-export-v1">;
                        original_byte_length: ZodNumber;
                        original_sha256: ZodString;
                        output_format: ZodLiteral<"commonjs-factory">;
                        schema_version: ZodLiteral<1>;
                        selected_range: ZodObject<
                            {
                                byte_end: ZodNumber;
                                byte_start: ZodNumber;
                                selected_sha256: ZodString;
                            },
                            $strict,
                        >;
                        source_map: ZodLiteral<null>;
                    },
                    $strict,
                >;
                transformation_evidence: ZodUnion<
                    readonly [
                        ZodObject<
                            {
                                analysis_profile: ZodObject<
                                    {
                                        digest: ZodString;
                                        parameters: ZodRecord<(...), (...)>;
                                        provider: ZodObject<(...), (...)>;
                                        provider_profile_schema_version: ZodNumber;
                                        schema_version: ZodLiteral<(...)>;
                                    },
                                    $strip,
                                >;
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                        ZodObject<
                            {
                                authority: ZodEnum<
                                    {
                                        "analyst-inference": "analyst-inference";
                                        "controlled-replay": "controlled-replay";
                                        "external-service": "external-service";
                                        "historical-reference": "historical-reference";
                                        "shipped-artifact": "shipped-artifact";
                                    },
                                >;
                                confidence: ZodEnum<
                                    {
                                        derived: "derived";
                                        inferred: "inferred";
                                        observed: "observed";
                                    },
                                >;
                                environment: ZodNullable<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                evidence_id: ZodString;
                                evidence_links: ZodArray<ZodString>;
                                limitations: ZodArray<ZodString>;
                                locations: ZodArray<
                                    ZodDiscriminatedUnion<
                                        [(...), (...), (...), (...), (...)],
                                        "kind",
                                    >,
                                >;
                                normalized_result: ZodJSONSchema;
                                operation: ZodString;
                                parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                predicate_type: ZodString;
                                provider: ZodObject<
                                    { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                    $strip,
                                >;
                                raw_result: ZodNullable<ZodJSONSchema>;
                                schema_version: ZodLiteral<2>;
                                subject: ZodNullable<
                                    ZodObject<
                                        {
                                            architecture: ...;
                                            digest: ...;
                                            format: ...;
                                            local_path: ...;
                                            name: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strict,
                        >,
                    ],
                >;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Atomically commit one canonical evidence-backed reconstruction coverage workspace revision under an approved root. CAS revisions reject lost updates; every Evidence and residual-unknown reference must resolve in the embedded canonical bundle.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    approved: true;
                    expected_revision: null;
                    workspace: Record<string, JSONType>;
                    workspace_path: "/approved/coverage.json";
                };
                title: "Commit the first canonical coverage revision";
            },
        ];
        inputSchema: ZodObject<
            {
                approved: ZodLiteral<true>;
                expected_revision: ZodNullable<ZodNumber>;
                workspace: ZodObject<
                    {
                        artifacts: ZodArray<
                            ZodObject<
                                {
                                    artifact_id: ZodString;
                                    artifact_sha256: ZodString;
                                    environment_sha256: ZodString;
                                    evidence_ids: ZodArray<ZodString>;
                                    version: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        boundaries: ZodArray<
                            ZodObject<
                                {
                                    allowed_dispositions: ZodArray<ZodEnum<(...)>>;
                                    allowed_unknown_ids: ZodArray<ZodString>;
                                    boundary_id: ZodString;
                                    required_claim_ids: ZodArray<ZodString>;
                                    required_package_proof_kinds: ZodArray<ZodEnum<(...)>>;
                                    required_surface_ids: ZodArray<ZodString>;
                                    title: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        claims: ZodArray<
                            ZodObject<
                                {
                                    claim_id: ZodString;
                                    kind: ZodString;
                                    required_authority: ZodEnum<
                                        {
                                            "controlled-replay": ...;
                                            external: ...;
                                            "live-observation": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    required_dimensions: ZodArray<ZodString>;
                                    surface_ids: ZodArray<ZodString>;
                                    title: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        contradictions: ZodArray<
                            ZodObject<
                                {
                                    claim_ids: ZodArray<ZodString>;
                                    contradiction_id: ZodString;
                                    evidence_ids: ZodArray<ZodString>;
                                    status: ZodEnum<{ active: ...; resolved: ... }>;
                                    surface_ids: ZodArray<ZodString>;
                                },
                                $strict,
                            >,
                        >;
                        evidence_bundle: ZodObject<
                            {
                                artifacts: ZodArray<
                                    ZodObject<
                                        { architecture: ...; digest: ...; format: ... },
                                        $strip,
                                    >,
                                >;
                                bundle_version: ZodLiteral<2>;
                                captures: ZodArray<
                                    ZodObject<{ evidence_id: ...; predicate_type: ... }, $strip>,
                                >;
                                environments: ZodArray<
                                    ZodObject<
                                        { architecture: ...; id: ...; isolation: ...; platform: ... },
                                        $strip,
                                    >,
                                >;
                                providers: ZodArray<
                                    ZodObject<{ id: ...; name: ...; version: ... }, $strip>,
                                >;
                                records: ZodArray<ZodUnion<readonly [(...), (...)]>>;
                                scenarios: ZodArray<
                                    ZodObject<
                                        { authority: ...; evidence_id: ...; operation: ... },
                                        $strip,
                                    >,
                                >;
                                unknowns: ZodArray<
                                    ZodObject<
                                        {
                                            contradicting_evidence_ids: ...;
                                            domain: ...;
                                            mutation_evidence_ids: ...;
                                            previous_revision_digest: ...;
                                            question: ...;
                                            recommended_probes: ...;
                                            registry_version: ...;
                                            relationships: ...;
                                            required_authority: ...;
                                            required_confidence: ...;
                                            required_environment: ...;
                                            resolution: ...;
                                            revision: ...;
                                            revision_digest: ...;
                                            scope_digest: ...;
                                            severity: ...;
                                            status: ...;
                                            supporting_evidence_ids: ...;
                                            unknown_id: ...;
                                        },
                                        $strip,
                                    >,
                                >;
                            },
                            $strip,
                        >;
                        name: ZodString;
                        owners: ZodArray<
                            ZodObject<
                                {
                                    ownership: ZodDiscriminatedUnion<[(...), (...)], "disposition">;
                                    surface_id: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        package_proofs: ZodArray<
                            ZodObject<
                                {
                                    artifact_sha256s: ZodArray<ZodString>;
                                    evidence_ids: ZodArray<ZodString>;
                                    kind: ZodEnum<
                                        {
                                            "authority-independence": ...;
                                            build: ...;
                                            "clean-install": ...;
                                            "package-contents": ...;
                                            "runtime-routing": ...;
                                        },
                                    >;
                                    proof_id: ZodString;
                                    status: ZodEnum<
                                        {
                                            fail: ...;
                                            pass: ...;
                                            skipped: ...;
                                            unknown: ...;
                                            unsupported: ...;
                                        },
                                    >;
                                },
                                $strict,
                            >,
                        >;
                        previous_revision_sha256: ZodNullable<ZodString>;
                        residual_unknown_ids: ZodArray<ZodString>;
                        revision: ZodNumber;
                        revision_sha256: ZodString;
                        schema_version: ZodLiteral<1>;
                        surfaces: ZodArray<
                            ZodObject<
                                {
                                    artifact_id: ZodString;
                                    authority: ZodEnum<
                                        {
                                            derived: ...;
                                            external: ...;
                                            historical: ...;
                                            inferred: ...;
                                            observed: ...;
                                        },
                                    >;
                                    dependency_surface_ids: ZodArray<ZodString>;
                                    evidence_ids: ZodArray<ZodString>;
                                    family: ZodString;
                                    location: ZodString;
                                    occurrence_id: ZodNullable<ZodString>;
                                    surface_id: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        verifier_contracts: ZodArray<
                            ZodObject<
                                {
                                    authority: ZodEnum<
                                        {
                                            "controlled-replay": ...;
                                            external: ...;
                                            "live-observation": ...;
                                            "shipped-artifact": ...;
                                        },
                                    >;
                                    claim_ids: ZodArray<ZodString>;
                                    contract_sha256: ZodString;
                                    dimensions: ZodArray<ZodString>;
                                    max_age_ms: ZodNumber;
                                    minimum_repeats: ZodNumber;
                                    normalization_removes_dimensions: ZodLiteral<false>;
                                    normalization_sha256: ZodString;
                                    verifier_id: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        verifier_results: ZodArray<
                            ZodObject<
                                {
                                    artifact_sha256s: ZodArray<ZodString>;
                                    contract_sha256: ZodString;
                                    covered_claim_ids: ZodArray<ZodString>;
                                    covered_dimensions: ZodArray<ZodString>;
                                    evidence_ids: ZodArray<ZodString>;
                                    normalization_sha256: ZodString;
                                    observed_at: ZodString;
                                    owner_sha256s: ZodArray<ZodString>;
                                    repeats: ZodNumber;
                                    status: ZodEnum<
                                        {
                                            fail: ...;
                                            pass: ...;
                                            skipped: ...;
                                            truncated: ...;
                                            unknown: ...;
                                            unsupported: ...;
                                        },
                                    >;
                                    verifier_id: ZodString;
                                },
                                $strict,
                            >,
                        >;
                        workspace_id: ZodString;
                    },
                    $strict,
                >;
                workspace_path: ZodString;
            },
            $strict,
        >;
        kind: "application";
        name: "commit_reconstruction_coverage";
        outputSchema: ZodObject<
            {
                bytes: ZodNumber;
                evidence_records: ZodNumber;
                revision: ZodNumber;
                revision_sha256: ZodString;
                workspace_id: ZodString;
                workspace_path: ZodString;
            },
            $strict,
        >;
        title: string;
    },
    {
        annotations: DerivedToolAnnotations;
        description: "Evaluate one named reconstruction boundary from a canonical coverage workspace. Missing ownership or inventory is partial; stale, weak, truncated, skipped, or unresolved proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.";
        effects: ToolEffects;
        examples: readonly [
            {
                input: {
                    boundary_id: "replacement.cli";
                    workspace_path: "/approved/coverage.json";
                };
                title: "Evaluate one replacement boundary";
            },
        ];
        inputSchema: ZodObject<
            { boundary_id: ZodString; workspace_path: ZodString },
            $strict,
        >;
        kind: "application";
        name: "query_reconstruction_coverage";
        outputSchema: ZodObject<
            {
                boundary_id: ZodString;
                evidence_ids: ZodArray<ZodString>;
                reasons: ZodArray<
                    ZodObject<
                        {
                            code: ZodEnum<
                                {
                                    "active-contradiction": "active-contradiction";
                                    "active-unknown": "active-unknown";
                                    "authority-routing-detected": "authority-routing-detected";
                                    "authority-routing-unknown": "authority-routing-unknown";
                                    "claim-missing": "claim-missing";
                                    "dependency-surface-missing": "dependency-surface-missing";
                                    "disposition-not-allowed": "disposition-not-allowed";
                                    "owner-distribution-unknown": "owner-distribution-unknown";
                                    "owner-duplicate": "owner-duplicate";
                                    "owner-missing": "owner-missing";
                                    "owner-path-missing": "owner-path-missing";
                                    "owner-path-unknown": "owner-path-unknown";
                                    "owner-undistributed": "owner-undistributed";
                                    "package-proof-failed": "package-proof-failed";
                                    "package-proof-missing": "package-proof-missing";
                                    "package-proof-unknown": "package-proof-unknown";
                                    "surface-missing": "surface-missing";
                                    "verifier-duplicate": "verifier-duplicate";
                                    "verifier-failed": "verifier-failed";
                                    "verifier-missing": "verifier-missing";
                                    "verifier-result-incompatible": "verifier-result-incompatible";
                                    "verifier-result-missing": "verifier-result-missing";
                                    "verifier-result-stale": "verifier-result-stale";
                                    "verifier-unknown": "verifier-unknown";
                                },
                            >;
                            detail: ZodString;
                            subject_id: ZodString;
                        },
                        $strict,
                    >,
                >;
                recommended_probes: ZodArray<
                    ZodObject<
                        {
                            operation: ZodString;
                            rationale: ZodString;
                            subject_id: ZodString;
                        },
                        $strict,
                    >,
                >;
                status: ZodEnum<
                    {
                        failed: "failed";
                        partial: "partial";
                        ready: "ready";
                        unknown: "unknown";
                    },
                >;
                summary: ZodObject<
                    {
                        reasons: ZodNumber;
                        required_claims: ZodNumber;
                        required_surfaces: ZodNumber;
                    },
                    $strict,
                >;
                workspace_revision_sha256: ZodString;
            },
            $strict,
        >;
        title: string;
    },
    ToolContract<"open_binary">,
    ToolContract<"close_binary">,
    ToolContract<"binary_session">,
    ToolContract<"export_evidence_bundle">,
    ToolContract<"import_evidence_bundle">,
    ToolContract<"capture_process_scenario">,
    ToolContract<"compare_process_captures">,
    ToolContract<"compare_artifacts">,
    ToolContract<"compare_functions">,
    ToolContract<"compare_bundles">,
    ToolContract<"find_changed_behavior">,
    ToolContract<"build_call_path">,
    ToolContract<"correlate_static_and_runtime">,
    ToolContract<"verify_reconstruction">,
    ToolContract<"list_unknowns">,
    ToolContract<"record_unknown">,
    ToolContract<"update_unknown">,
    ToolContract<"verify_unknown_resolution">,
] = ...