Function managedWorkflowContract

Returns
    | {
        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;
    }