@nklisch/pi-enhanced 0.1.0

package/node_modules/@nklisch/pi-plugins/dist/application/native-inspection-contract.d.ts

@@ -0,0 +1,3720 @@
+import { z } from "zod";
+export declare const NativeInspectionSubjectKindSchema: z.ZodEnum<{
+    installed: "installed";
+    "marketplace-candidate": "marketplace-candidate";
+}>;
+export declare const NativeInspectionConditionSchema: z.ZodEnum<{
+    blocked: "blocked";
+    degraded: "degraded";
+    ready: "ready";
+    unavailable: "unavailable";
+}>;
+export declare const NativeInspectionFreshnessSchema: z.ZodEnum<{
+    current: "current";
+    "not-applicable": "not-applicable";
+    stale: "stale";
+    unavailable: "unavailable";
+    unknown: "unknown";
+}>;
+export declare const InspectionSnapshotIdSchema: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+export declare const InspectionDetailIdSchema: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+export declare const InspectionCursorSchema: z.core.$ZodBranded<z.ZodString, "InspectionCursor", "out">;
+export declare const SafeDisplayFieldSchema: z.ZodReadonly<z.ZodObject<{
+    text: z.ZodString;
+    escaped: z.ZodBoolean;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>>;
+export declare const NativeProvenanceViewSchema: z.ZodReadonly<z.ZodObject<{
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+    }>;
+    documentKind: z.ZodEnum<{
+        convention: "convention";
+        "foreign-state": "foreign-state";
+        hooks: "hooks";
+        manifest: "manifest";
+        marketplace: "marketplace";
+        mcp: "mcp";
+        skill: "skill";
+    }>;
+    path: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+export declare const NativeRedactedUrlSchema: z.ZodReadonly<z.ZodObject<{
+    scheme: z.ZodEnum<{
+        git: "git";
+        http: "http";
+        https: "https";
+        ssh: "ssh";
+        unknown: "unknown";
+    }>;
+    host: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    port: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    path: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    queryPresent: z.ZodBoolean;
+    fragmentPresent: z.ZodBoolean;
+}, z.core.$strict>>;
+export declare const NativeMcpEndpointSchema: z.ZodReadonly<z.ZodObject<{
+    scheme: z.ZodEnum<{
+        http: "http";
+        https: "https";
+    }>;
+    host: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    port: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    path: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    queryPresent: z.ZodBoolean;
+}, z.core.$strict>>;
+export declare const NativeSourceViewSchema: z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodEnum<{
+        git: "git";
+        "git-subdir": "git-subdir";
+        github: "github";
+        "local-git": "local-git";
+        "marketplace-path": "marketplace-path";
+        npm: "npm";
+    }>;
+    identity: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    endpoint: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        scheme: z.ZodEnum<{
+            git: "git";
+            http: "http";
+            https: "https";
+            ssh: "ssh";
+            unknown: "unknown";
+        }>;
+        host: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        port: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        queryPresent: z.ZodBoolean;
+        fragmentPresent: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    revision: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    package: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const NativeSkillComponentViewSchema: z.ZodReadonly<z.ZodObject<{
+    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+    verdict: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+        unavailable: "unavailable";
+    }>;
+    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    kind: z.ZodLiteral<"skill">;
+    name: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    root: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const NativeHookComponentViewSchema: z.ZodReadonly<z.ZodObject<{
+    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+    verdict: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+        unavailable: "unavailable";
+    }>;
+    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    kind: z.ZodLiteral<"hook">;
+    event: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    matcher: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    handler: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"shell">;
+        command: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        shell: z.ZodOptional<z.ZodEnum<{
+            bash: "bash";
+            powershell: "powershell";
+        }>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"exec">;
+        command: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>], "kind">;
+}, z.core.$strict>>;
+export declare const NativeMcpComponentViewSchema: z.ZodReadonly<z.ZodObject<{
+    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+    verdict: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+        unavailable: "unavailable";
+    }>;
+    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    kind: z.ZodLiteral<"mcp-server">;
+    nativeKey: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        stdio: "stdio";
+        "streamable-http": "streamable-http";
+    }>>;
+    command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>>;
+    url: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        scheme: z.ZodEnum<{
+            http: "http";
+            https: "https";
+        }>;
+        host: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        port: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        queryPresent: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    environmentNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>>;
+    headerNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>>;
+    authentication: z.ZodEnum<{
+        "bearer-environment": "bearer-environment";
+        none: "none";
+        "oauth-authorization-code": "oauth-authorization-code";
+        "oauth-client-credentials": "oauth-client-credentials";
+        unavailable: "unavailable";
+    }>;
+    toolPolicy: z.ZodReadonly<z.ZodObject<{
+        allowed: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        denied: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        approval: z.ZodEnum<{
+            default: "default";
+            "not-applicable": "not-applicable";
+            required: "required";
+        }>;
+    }, z.core.$strict>>;
+    startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+export declare const NativeForeignComponentViewSchema: z.ZodReadonly<z.ZodObject<{
+    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+    verdict: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+        unavailable: "unavailable";
+    }>;
+    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    kind: z.ZodLiteral<"foreign">;
+    nativeHost: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+    }>;
+    nativeKind: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const NativeComponentInventoryViewSchema: z.ZodReadonly<z.ZodObject<{
+    counts: z.ZodReadonly<z.ZodObject<{
+        skills: z.ZodNumber;
+        hooks: z.ZodNumber;
+        mcpServers: z.ZodNumber;
+        foreign: z.ZodNumber;
+    }, z.core.$strict>>;
+    skills: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+        verdict: z.ZodEnum<{
+            incompatible: "incompatible";
+            "metadata-only": "metadata-only";
+            supported: "supported";
+            unavailable: "unavailable";
+        }>;
+        requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        kind: z.ZodLiteral<"skill">;
+        name: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        root: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    hooks: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+        verdict: z.ZodEnum<{
+            incompatible: "incompatible";
+            "metadata-only": "metadata-only";
+            supported: "supported";
+            unavailable: "unavailable";
+        }>;
+        requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        kind: z.ZodLiteral<"hook">;
+        event: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        matcher: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        handler: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"shell">;
+            command: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            shell: z.ZodOptional<z.ZodEnum<{
+                bash: "bash";
+                powershell: "powershell";
+            }>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"exec">;
+            command: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>>>;
+    mcpServers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+        verdict: z.ZodEnum<{
+            incompatible: "incompatible";
+            "metadata-only": "metadata-only";
+            supported: "supported";
+            unavailable: "unavailable";
+        }>;
+        requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        kind: z.ZodLiteral<"mcp-server">;
+        nativeKey: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            stdio: "stdio";
+            "streamable-http": "streamable-http";
+        }>>;
+        command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        url: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            scheme: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+            host: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            port: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            queryPresent: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        environmentNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        headerNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+        authentication: z.ZodEnum<{
+            "bearer-environment": "bearer-environment";
+            none: "none";
+            "oauth-authorization-code": "oauth-authorization-code";
+            "oauth-client-credentials": "oauth-client-credentials";
+            unavailable: "unavailable";
+        }>;
+        toolPolicy: z.ZodReadonly<z.ZodObject<{
+            allowed: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            denied: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            approval: z.ZodEnum<{
+                default: "default";
+                "not-applicable": "not-applicable";
+                required: "required";
+            }>;
+        }, z.core.$strict>>;
+        startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    foreign: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+        verdict: z.ZodEnum<{
+            incompatible: "incompatible";
+            "metadata-only": "metadata-only";
+            supported: "supported";
+            unavailable: "unavailable";
+        }>;
+        requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        kind: z.ZodLiteral<"foreign">;
+        nativeHost: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        nativeKind: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeConfigurationOptionViewSchema: z.ZodReadonly<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    valueKind: z.ZodEnum<{
+        boolean: "boolean";
+        directory: "directory";
+        file: "file";
+        number: "number";
+        string: "string";
+        strings: "strings";
+    }>;
+    required: z.ZodBoolean;
+    sensitive: z.ZodBoolean;
+    defaultPresent: z.ZodBoolean;
+    state: z.ZodEnum<{
+        configured: "configured";
+        defaulted: "defaulted";
+        invalid: "invalid";
+        missing: "missing";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strict>>;
+export declare const NativeTrustReadinessSchema: z.ZodEnum<{
+    authorized: "authorized";
+    "invalid-evidence": "invalid-evidence";
+    "not-applicable": "not-applicable";
+    "project-untrusted": "project-untrusted";
+    required: "required";
+    revoked: "revoked";
+    unavailable: "unavailable";
+}>;
+export declare const NativeRuntimeRequirementViewSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">;
+    capability: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+    }>;
+    explanation: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeCompatibilityViewSchema: z.ZodReadonly<z.ZodObject<{
+    status: z.ZodEnum<{
+        activatable: "activatable";
+        incompatible: "incompatible";
+        unavailable: "unavailable";
+    }>;
+    reportFingerprint: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+    components: z.ZodReadonly<z.ZodObject<{
+        counts: z.ZodReadonly<z.ZodObject<{
+            skills: z.ZodNumber;
+            hooks: z.ZodNumber;
+            mcpServers: z.ZodNumber;
+            foreign: z.ZodNumber;
+        }, z.core.$strict>>;
+        skills: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+            verdict: z.ZodEnum<{
+                incompatible: "incompatible";
+                "metadata-only": "metadata-only";
+                supported: "supported";
+                unavailable: "unavailable";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            kind: z.ZodLiteral<"skill">;
+            name: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            root: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        hooks: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+            verdict: z.ZodEnum<{
+                incompatible: "incompatible";
+                "metadata-only": "metadata-only";
+                supported: "supported";
+                unavailable: "unavailable";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            kind: z.ZodLiteral<"hook">;
+            event: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            matcher: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            handler: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"shell">;
+                command: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                shell: z.ZodOptional<z.ZodEnum<{
+                    bash: "bash";
+                    powershell: "powershell";
+                }>>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"exec">;
+                command: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>], "kind">;
+        }, z.core.$strict>>>>;
+        mcpServers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+            verdict: z.ZodEnum<{
+                incompatible: "incompatible";
+                "metadata-only": "metadata-only";
+                supported: "supported";
+                unavailable: "unavailable";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            kind: z.ZodLiteral<"mcp-server">;
+            nativeKey: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                stdio: "stdio";
+                "streamable-http": "streamable-http";
+            }>>;
+            command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            url: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                scheme: z.ZodEnum<{
+                    http: "http";
+                    https: "https";
+                }>;
+                host: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                port: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                queryPresent: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            environmentNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            headerNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>>;
+            authentication: z.ZodEnum<{
+                "bearer-environment": "bearer-environment";
+                none: "none";
+                "oauth-authorization-code": "oauth-authorization-code";
+                "oauth-client-credentials": "oauth-client-credentials";
+                unavailable: "unavailable";
+            }>;
+            toolPolicy: z.ZodReadonly<z.ZodObject<{
+                allowed: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                denied: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                approval: z.ZodEnum<{
+                    default: "default";
+                    "not-applicable": "not-applicable";
+                    required: "required";
+                }>;
+            }, z.core.$strict>>;
+            startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        foreign: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+            verdict: z.ZodEnum<{
+                incompatible: "incompatible";
+                "metadata-only": "metadata-only";
+                supported: "supported";
+                unavailable: "unavailable";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            kind: z.ZodLiteral<"foreign">;
+            nativeHost: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            nativeKind: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>;
+    requirements: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">;
+        capability: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+        explanation: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeLifecycleViewSchema: z.ZodReadonly<z.ZodObject<{
+    installed: z.ZodBoolean;
+    activationIntent: z.ZodOptional<z.ZodEnum<{
+        disabled: "disabled";
+        enabled: "enabled";
+    }>>;
+    transition: z.ZodEnum<{
+        blocked: "blocked";
+        deferred: "deferred";
+        none: "none";
+        pending: "pending";
+        "recovery-required": "recovery-required";
+    }>;
+    update: z.ZodEnum<{
+        "approval-required": "approval-required";
+        "automatic-applied": "automatic-applied";
+        "automatic-pending": "automatic-pending";
+        "automatic-retryable": "automatic-retryable";
+        available: "available";
+        "capability-blocked": "capability-blocked";
+        "configuration-blocked": "configuration-blocked";
+        current: "current";
+        failed: "failed";
+        "manual-required": "manual-required";
+        "not-applicable": "not-applicable";
+        "recovery-required": "recovery-required";
+        unknown: "unknown";
+    }>;
+    policy: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        application: z.ZodEnum<{
+            automatic: "automatic";
+            manual: "manual";
+        }>;
+        winningLevel: z.ZodEnum<{
+            global: "global";
+            guard: "guard";
+            marketplace: "marketplace";
+            plugin: "plugin";
+            scope: "scope";
+        }>;
+        sourceGuard: z.ZodDefault<z.ZodEnum<{
+            "legacy-source": "legacy-source";
+            local: "local";
+            "marketplace-source-changed": "marketplace-source-changed";
+            none: "none";
+            "plugin-source-changed": "plugin-source-changed";
+        }>>;
+    }, z.core.$strict>>>;
+    notice: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        disposition: z.ZodEnum<{
+            "approval-required": "approval-required";
+            "automatic-applied": "automatic-applied";
+            "automatic-pending": "automatic-pending";
+            "automatic-retryable": "automatic-retryable";
+            "capability-blocked": "capability-blocked";
+            "configuration-blocked": "configuration-blocked";
+            "manual-required": "manual-required";
+            "recovery-required": "recovery-required";
+        }>;
+        unread: z.ZodBoolean;
+        unresolved: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    schedule: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        state: z.ZodEnum<{
+            "clock-regressed": "clock-regressed";
+            current: "current";
+            due: "due";
+            unavailable: "unavailable";
+        }>;
+        nextAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    updateSubsystem: z.ZodOptional<z.ZodEnum<{
+        "clock-regressed": "clock-regressed";
+        degraded: "degraded";
+        disabled: "disabled";
+        running: "running";
+        standby: "standby";
+        stopped: "stopped";
+    }>>;
+}, z.core.$strict>>;
+export declare const NativeActivationViewSchema: z.ZodReadonly<z.ZodObject<{
+    intent: z.ZodEnum<{
+        disabled: "disabled";
+        enabled: "enabled";
+    }>;
+    state: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        inactive: "inactive";
+        pending: "pending";
+        "recovery-required": "recovery-required";
+        unavailable: "unavailable";
+    }>;
+    selectedRevision: z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">;
+    projectionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+    participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        participant: z.ZodEnum<{
+            mcp: "mcp";
+            "skills-hooks": "skills-hooks";
+        }>;
+        status: z.ZodEnum<{
+            matching: "matching";
+            mismatched: "mismatched";
+            missing: "missing";
+            unavailable: "unavailable";
+        }>;
+        contributionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeMcpHealthViewSchema: z.ZodReadonly<z.ZodObject<{
+    localRegistration: z.ZodEnum<{
+        absent: "absent";
+        matching: "matching";
+        mismatched: "mismatched";
+        unavailable: "unavailable";
+    }>;
+    servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+        serverKey: z.core.$ZodBranded<z.ZodString, "McpRuntimeServerKey", "out">;
+        nativeKey: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        authority: z.ZodEnum<{
+            current: "current";
+            stale: "stale";
+            unavailable: "unavailable";
+        }>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            stdio: "stdio";
+            "streamable-http": "streamable-http";
+        }>>;
+        state: z.ZodEnum<{
+            connected: "connected";
+            connecting: "connecting";
+            failed: "failed";
+            idle: "idle";
+            "needs-auth": "needs-auth";
+            registered: "registered";
+        }>;
+        toolCount: z.ZodOptional<z.ZodNumber>;
+        errorCode: z.ZodOptional<z.ZodEnum<{
+            ADAPTER_FAILED: "ADAPTER_FAILED";
+            CLAIM_CONFLICT: "CLAIM_CONFLICT";
+            COLLECTION_DEFERRED: "COLLECTION_DEFERRED";
+            CONTENT_VERIFICATION_FAILED: "CONTENT_VERIFICATION_FAILED";
+            DURABILITY_UNAVAILABLE: "DURABILITY_UNAVAILABLE";
+            ENTRY_INVALID: "ENTRY_INVALID";
+            FOREIGN_STATE_ROOT_INVALID: "FOREIGN_STATE_ROOT_INVALID";
+            IDENTITY_INVALID: "IDENTITY_INVALID";
+            MANIFEST_ROOT_INVALID: "MANIFEST_ROOT_INVALID";
+            MARKETPLACE_ROOT_INVALID: "MARKETPLACE_ROOT_INVALID";
+            MCP_LAUNCH_AUTHORITY_REJECTED: "MCP_LAUNCH_AUTHORITY_REJECTED";
+            MCP_LAUNCH_CANCELLED: "MCP_LAUNCH_CANCELLED";
+            MCP_LAUNCH_CLEANUP_FAILED: "MCP_LAUNCH_CLEANUP_FAILED";
+            MCP_LAUNCH_CONFIGURATION_FAILED: "MCP_LAUNCH_CONFIGURATION_FAILED";
+            MCP_LAUNCH_ENVIRONMENT_FAILED: "MCP_LAUNCH_ENVIRONMENT_FAILED";
+            MCP_LAUNCH_TIMEOUT: "MCP_LAUNCH_TIMEOUT";
+            MCP_LAUNCH_VALUE_INVALID: "MCP_LAUNCH_VALUE_INVALID";
+            PATH_CONTAINMENT_FAILED: "PATH_CONTAINMENT_FAILED";
+            RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+            REQUIREMENT_UNAVAILABLE: "REQUIREMENT_UNAVAILABLE";
+            SCHEMA_INVALID: "SCHEMA_INVALID";
+            SOURCE_INVALID: "SOURCE_INVALID";
+            SOURCE_RESOLUTION_FAILED: "SOURCE_RESOLUTION_FAILED";
+            STAGING_ALLOCATION_INVALID: "STAGING_ALLOCATION_INVALID";
+            STORE_IDENTITY_COLLISION: "STORE_IDENTITY_COLLISION";
+            TRANSITION_JOURNAL_CORRUPT: "TRANSITION_JOURNAL_CORRUPT";
+            UNSUPPORTED_DECLARATION: "UNSUPPORTED_DECLARATION";
+        }>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeDiagnosticFactSchema: z.ZodReadonly<z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const NativeDiagnosticSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodEnum<{
+        ACTIVATION_EVIDENCE_MISMATCH: "ACTIVATION_EVIDENCE_MISMATCH";
+        ADOPTION_DOCUMENT_CHANGED: "ADOPTION_DOCUMENT_CHANGED";
+        ADOPTION_DOCUMENT_UNREADABLE: "ADOPTION_DOCUMENT_UNREADABLE";
+        CANDIDATE_MISSING: "CANDIDATE_MISSING";
+        CAPABILITY_EVIDENCE_UNAVAILABLE: "CAPABILITY_EVIDENCE_UNAVAILABLE";
+        CATALOG_CORRUPT: "CATALOG_CORRUPT";
+        CATALOG_STALE: "CATALOG_STALE";
+        CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+        COMPATIBILITY_INCOMPATIBLE: "COMPATIBILITY_INCOMPATIBLE";
+        CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+        CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+        EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+        HOST_STARTUP_BLOCKED: "HOST_STARTUP_BLOCKED";
+        MCP_REGISTRATION_MISMATCH: "MCP_REGISTRATION_MISMATCH";
+        MCP_REGISTRATION_MISSING: "MCP_REGISTRATION_MISSING";
+        MCP_REMOTE_AUTH_REQUIRED: "MCP_REMOTE_AUTH_REQUIRED";
+        MCP_REMOTE_HEALTH_FAILED: "MCP_REMOTE_HEALTH_FAILED";
+        PROJECTION_UNAVAILABLE: "PROJECTION_UNAVAILABLE";
+        PROJECT_UNTRUSTED: "PROJECT_UNTRUSTED";
+        RECORD_CORRUPT: "RECORD_CORRUPT";
+        RECOVERY_BLOCKED: "RECOVERY_BLOCKED";
+        RECOVERY_DEFERRED: "RECOVERY_DEFERRED";
+        RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+        REVISION_UNAVAILABLE: "REVISION_UNAVAILABLE";
+        RUNTIME_EVIDENCE_MISSING: "RUNTIME_EVIDENCE_MISSING";
+        RUNTIME_EVIDENCE_UNAVAILABLE: "RUNTIME_EVIDENCE_UNAVAILABLE";
+        RUNTIME_REQUIREMENT_UNAVAILABLE: "RUNTIME_REQUIREMENT_UNAVAILABLE";
+        SECRET_CUSTODY_UNAVAILABLE: "SECRET_CUSTODY_UNAVAILABLE";
+        SOURCE_CONTENT_UNSAFE: "SOURCE_CONTENT_UNSAFE";
+        SOURCE_DECLARATION_CONFLICT: "SOURCE_DECLARATION_CONFLICT";
+        SOURCE_DOCUMENT_INVALID: "SOURCE_DOCUMENT_INVALID";
+        SOURCE_INVALID: "SOURCE_INVALID";
+        SOURCE_UNAVAILABLE: "SOURCE_UNAVAILABLE";
+        STATE_CORRUPT: "STATE_CORRUPT";
+        TRANSITION_PENDING: "TRANSITION_PENDING";
+        TRUST_EVIDENCE_INVALID: "TRUST_EVIDENCE_INVALID";
+        TRUST_REQUIRED: "TRUST_REQUIRED";
+        TRUST_REVOKED: "TRUST_REVOKED";
+        UPDATE_APPROVAL_REQUIRED: "UPDATE_APPROVAL_REQUIRED";
+        UPDATE_AUTOMATIC_PENDING: "UPDATE_AUTOMATIC_PENDING";
+        UPDATE_AVAILABLE: "UPDATE_AVAILABLE";
+        UPDATE_CAPABILITY_BLOCKED: "UPDATE_CAPABILITY_BLOCKED";
+        UPDATE_CLOCK_REGRESSED: "UPDATE_CLOCK_REGRESSED";
+        UPDATE_CONFIGURATION_BLOCKED: "UPDATE_CONFIGURATION_BLOCKED";
+        UPDATE_FAILED: "UPDATE_FAILED";
+        UPDATE_MANUAL_REQUIRED: "UPDATE_MANUAL_REQUIRED";
+        UPDATE_RECOVERY_REQUIRED: "UPDATE_RECOVERY_REQUIRED";
+    }>;
+    category: z.ZodEnum<{
+        activation: "activation";
+        adoption: "adoption";
+        capability: "capability";
+        compatibility: "compatibility";
+        configuration: "configuration";
+        evidence: "evidence";
+        freshness: "freshness";
+        integrity: "integrity";
+        "live-health": "live-health";
+        recovery: "recovery";
+        trust: "trust";
+        update: "update";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    subjectId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">>;
+    componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ComponentId", "out">>;
+    summary: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    facts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    action: z.ZodEnum<{
+        "inspect-source": "inspect-source";
+        "provide-configuration": "provide-configuration";
+        "refresh-marketplace": "refresh-marketplace";
+        "reload-runtime": "reload-runtime";
+        "retry-read": "retry-read";
+        "review-trust": "review-trust";
+        "review-update": "review-update";
+        "run-recovery": "run-recovery";
+        "trust-project": "trust-project";
+    }>;
+}, z.core.$strict>>;
+export declare const NativeInspectionListRequestSchema: z.ZodReadonly<z.ZodObject<{
+    subjects: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        installed: "installed";
+        "marketplace-candidate": "marketplace-candidate";
+    }>>>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        "all-current": "all-current";
+        project: "project";
+        user: "user";
+    }>>;
+    query: z.ZodDefault<z.ZodString>;
+    conditions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        blocked: "blocked";
+        degraded: "degraded";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>>>>;
+    cursor: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionCursor", "out">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>>;
+export declare const NativeInspectionSummarySchema: z.ZodReadonly<z.ZodObject<{
+    detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+    subject: z.ZodEnum<{
+        installed: "installed";
+        "marketplace-candidate": "marketplace-candidate";
+    }>;
+    scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"user">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+    }, z.core.$strict>>], "kind">;
+    plugin: z.core.$ZodBranded<z.ZodString, "PluginKey", "out">;
+    name: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    marketplace: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    revision: z.ZodReadonly<z.ZodObject<{
+        installed: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        available: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        immutable: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+        resolution: z.ZodEnum<{
+            "declared-selector": "declared-selector";
+            exact: "exact";
+            unresolved: "unresolved";
+        }>;
+    }, z.core.$strict>>;
+    condition: z.ZodEnum<{
+        blocked: "blocked";
+        degraded: "degraded";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>;
+    freshness: z.ZodReadonly<z.ZodObject<{
+        status: z.ZodEnum<{
+            current: "current";
+            "not-applicable": "not-applicable";
+            stale: "stale";
+            unavailable: "unavailable";
+            unknown: "unknown";
+        }>;
+        basis: z.ZodEnum<{
+            marketplace: "marketplace";
+            none: "none";
+            runtime: "runtime";
+            state: "state";
+            update: "update";
+        }>;
+    }, z.core.$strict>>;
+    diagnosticCounts: z.ZodReadonly<z.ZodObject<{
+        error: z.ZodNumber;
+        warning: z.ZodNumber;
+        info: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const NativeScopeObservationSchema: z.ZodReadonly<z.ZodObject<{
+    scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"user">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+    }, z.core.$strict>>], "kind">;
+    status: z.ZodEnum<{
+        corrupt: "corrupt";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>;
+    generation: z.ZodOptional<z.ZodNumber>;
+    corruptionCodes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        text: z.ZodString;
+        escaped: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeInspectionPageSchema: z.ZodReadonly<z.ZodObject<{
+    snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+    condition: z.ZodEnum<{
+        blocked: "blocked";
+        degraded: "degraded";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>;
+    items: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+        subject: z.ZodEnum<{
+            installed: "installed";
+            "marketplace-candidate": "marketplace-candidate";
+        }>;
+        scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+        }, z.core.$strict>>], "kind">;
+        plugin: z.core.$ZodBranded<z.ZodString, "PluginKey", "out">;
+        name: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        marketplace: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        revision: z.ZodReadonly<z.ZodObject<{
+            installed: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            available: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            immutable: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            resolution: z.ZodEnum<{
+                "declared-selector": "declared-selector";
+                exact: "exact";
+                unresolved: "unresolved";
+            }>;
+        }, z.core.$strict>>;
+        condition: z.ZodEnum<{
+            blocked: "blocked";
+            degraded: "degraded";
+            ready: "ready";
+            unavailable: "unavailable";
+        }>;
+        freshness: z.ZodReadonly<z.ZodObject<{
+            status: z.ZodEnum<{
+                current: "current";
+                "not-applicable": "not-applicable";
+                stale: "stale";
+                unavailable: "unavailable";
+                unknown: "unknown";
+            }>;
+            basis: z.ZodEnum<{
+                marketplace: "marketplace";
+                none: "none";
+                runtime: "runtime";
+                state: "state";
+                update: "update";
+            }>;
+        }, z.core.$strict>>;
+        diagnosticCounts: z.ZodReadonly<z.ZodObject<{
+            error: z.ZodNumber;
+            warning: z.ZodNumber;
+            info: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    observations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+        }, z.core.$strict>>], "kind">;
+        status: z.ZodEnum<{
+            corrupt: "corrupt";
+            ready: "ready";
+            unavailable: "unavailable";
+        }>;
+        generation: z.ZodOptional<z.ZodNumber>;
+        corruptionCodes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+    nextCursor: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionCursor", "out">>;
+}, z.core.$strict>>;
+export declare const NativeInspectionDetailRequestSchema: z.ZodReadonly<z.ZodObject<{
+    snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+    detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+}, z.core.$strict>>;
+export declare const NativeInspectionDetailSchema: z.ZodReadonly<z.ZodObject<{
+    snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+    summary: z.ZodReadonly<z.ZodObject<{
+        detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+        subject: z.ZodEnum<{
+            installed: "installed";
+            "marketplace-candidate": "marketplace-candidate";
+        }>;
+        scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+        }, z.core.$strict>>], "kind">;
+        plugin: z.core.$ZodBranded<z.ZodString, "PluginKey", "out">;
+        name: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        marketplace: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        revision: z.ZodReadonly<z.ZodObject<{
+            installed: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            available: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            immutable: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            resolution: z.ZodEnum<{
+                "declared-selector": "declared-selector";
+                exact: "exact";
+                unresolved: "unresolved";
+            }>;
+        }, z.core.$strict>>;
+        condition: z.ZodEnum<{
+            blocked: "blocked";
+            degraded: "degraded";
+            ready: "ready";
+            unavailable: "unavailable";
+        }>;
+        freshness: z.ZodReadonly<z.ZodObject<{
+            status: z.ZodEnum<{
+                current: "current";
+                "not-applicable": "not-applicable";
+                stale: "stale";
+                unavailable: "unavailable";
+                unknown: "unknown";
+            }>;
+            basis: z.ZodEnum<{
+                marketplace: "marketplace";
+                none: "none";
+                runtime: "runtime";
+                state: "state";
+                update: "update";
+            }>;
+        }, z.core.$strict>>;
+        diagnosticCounts: z.ZodReadonly<z.ZodObject<{
+            error: z.ZodNumber;
+            warning: z.ZodNumber;
+            info: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    source: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodEnum<{
+            git: "git";
+            "git-subdir": "git-subdir";
+            github: "github";
+            "local-git": "local-git";
+            "marketplace-path": "marketplace-path";
+            npm: "npm";
+        }>;
+        identity: z.ZodOptional<z.ZodString>;
+        location: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        endpoint: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            scheme: z.ZodEnum<{
+                git: "git";
+                http: "http";
+                https: "https";
+                ssh: "ssh";
+                unknown: "unknown";
+            }>;
+            host: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            port: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            queryPresent: z.ZodBoolean;
+            fragmentPresent: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        revision: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        package: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+        }>;
+        documentKind: z.ZodEnum<{
+            convention: "convention";
+            "foreign-state": "foreign-state";
+            hooks: "hooks";
+            manifest: "manifest";
+            marketplace: "marketplace";
+            mcp: "mcp";
+            skill: "skill";
+        }>;
+        path: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+    compatibility: z.ZodReadonly<z.ZodObject<{
+        status: z.ZodEnum<{
+            activatable: "activatable";
+            incompatible: "incompatible";
+            unavailable: "unavailable";
+        }>;
+        reportFingerprint: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+        components: z.ZodReadonly<z.ZodObject<{
+            counts: z.ZodReadonly<z.ZodObject<{
+                skills: z.ZodNumber;
+                hooks: z.ZodNumber;
+                mcpServers: z.ZodNumber;
+                foreign: z.ZodNumber;
+            }, z.core.$strict>>;
+            skills: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                verdict: z.ZodEnum<{
+                    incompatible: "incompatible";
+                    "metadata-only": "metadata-only";
+                    supported: "supported";
+                    unavailable: "unavailable";
+                }>;
+                requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    documentKind: z.ZodEnum<{
+                        convention: "convention";
+                        "foreign-state": "foreign-state";
+                        hooks: "hooks";
+                        manifest: "manifest";
+                        marketplace: "marketplace";
+                        mcp: "mcp";
+                        skill: "skill";
+                    }>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+                kind: z.ZodLiteral<"skill">;
+                name: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                root: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>>;
+            hooks: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                verdict: z.ZodEnum<{
+                    incompatible: "incompatible";
+                    "metadata-only": "metadata-only";
+                    supported: "supported";
+                    unavailable: "unavailable";
+                }>;
+                requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    documentKind: z.ZodEnum<{
+                        convention: "convention";
+                        "foreign-state": "foreign-state";
+                        hooks: "hooks";
+                        manifest: "manifest";
+                        marketplace: "marketplace";
+                        mcp: "mcp";
+                        skill: "skill";
+                    }>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+                kind: z.ZodLiteral<"hook">;
+                event: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                matcher: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                handler: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"shell">;
+                    command: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    shell: z.ZodOptional<z.ZodEnum<{
+                        bash: "bash";
+                        powershell: "powershell";
+                    }>>;
+                    timeoutMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"exec">;
+                    command: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    timeoutMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>], "kind">;
+            }, z.core.$strict>>>>;
+            mcpServers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                verdict: z.ZodEnum<{
+                    incompatible: "incompatible";
+                    "metadata-only": "metadata-only";
+                    supported: "supported";
+                    unavailable: "unavailable";
+                }>;
+                requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    documentKind: z.ZodEnum<{
+                        convention: "convention";
+                        "foreign-state": "foreign-state";
+                        hooks: "hooks";
+                        manifest: "manifest";
+                        marketplace: "marketplace";
+                        mcp: "mcp";
+                        skill: "skill";
+                    }>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+                kind: z.ZodLiteral<"mcp-server">;
+                nativeKey: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    "streamable-http": "streamable-http";
+                }>>;
+                command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                url: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    scheme: z.ZodEnum<{
+                        http: "http";
+                        https: "https";
+                    }>;
+                    host: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    port: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    queryPresent: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                environmentNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                headerNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>>;
+                authentication: z.ZodEnum<{
+                    "bearer-environment": "bearer-environment";
+                    none: "none";
+                    "oauth-authorization-code": "oauth-authorization-code";
+                    "oauth-client-credentials": "oauth-client-credentials";
+                    unavailable: "unavailable";
+                }>;
+                toolPolicy: z.ZodReadonly<z.ZodObject<{
+                    allowed: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    denied: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    approval: z.ZodEnum<{
+                        default: "default";
+                        "not-applicable": "not-applicable";
+                        required: "required";
+                    }>;
+                }, z.core.$strict>>;
+                startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            foreign: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                verdict: z.ZodEnum<{
+                    incompatible: "incompatible";
+                    "metadata-only": "metadata-only";
+                    supported: "supported";
+                    unavailable: "unavailable";
+                }>;
+                requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    documentKind: z.ZodEnum<{
+                        convention: "convention";
+                        "foreign-state": "foreign-state";
+                        hooks: "hooks";
+                        manifest: "manifest";
+                        marketplace: "marketplace";
+                        mcp: "mcp";
+                        skill: "skill";
+                    }>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+                kind: z.ZodLiteral<"foreign">;
+                nativeHost: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                nativeKind: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>;
+        requirements: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">;
+            capability: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            status: z.ZodEnum<{
+                available: "available";
+                unavailable: "unavailable";
+            }>;
+            explanation: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>;
+    trust: z.ZodEnum<{
+        authorized: "authorized";
+        "invalid-evidence": "invalid-evidence";
+        "not-applicable": "not-applicable";
+        "project-untrusted": "project-untrusted";
+        required: "required";
+        revoked: "revoked";
+        unavailable: "unavailable";
+    }>;
+    configuration: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        valueKind: z.ZodEnum<{
+            boolean: "boolean";
+            directory: "directory";
+            file: "file";
+            number: "number";
+            string: "string";
+            strings: "strings";
+        }>;
+        required: z.ZodBoolean;
+        sensitive: z.ZodBoolean;
+        defaultPresent: z.ZodBoolean;
+        state: z.ZodEnum<{
+            configured: "configured";
+            defaulted: "defaulted";
+            invalid: "invalid";
+            missing: "missing";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strict>>>>;
+    lifecycle: z.ZodReadonly<z.ZodObject<{
+        installed: z.ZodBoolean;
+        activationIntent: z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>>;
+        transition: z.ZodEnum<{
+            blocked: "blocked";
+            deferred: "deferred";
+            none: "none";
+            pending: "pending";
+            "recovery-required": "recovery-required";
+        }>;
+        update: z.ZodEnum<{
+            "approval-required": "approval-required";
+            "automatic-applied": "automatic-applied";
+            "automatic-pending": "automatic-pending";
+            "automatic-retryable": "automatic-retryable";
+            available: "available";
+            "capability-blocked": "capability-blocked";
+            "configuration-blocked": "configuration-blocked";
+            current: "current";
+            failed: "failed";
+            "manual-required": "manual-required";
+            "not-applicable": "not-applicable";
+            "recovery-required": "recovery-required";
+            unknown: "unknown";
+        }>;
+        policy: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            application: z.ZodEnum<{
+                automatic: "automatic";
+                manual: "manual";
+            }>;
+            winningLevel: z.ZodEnum<{
+                global: "global";
+                guard: "guard";
+                marketplace: "marketplace";
+                plugin: "plugin";
+                scope: "scope";
+            }>;
+            sourceGuard: z.ZodDefault<z.ZodEnum<{
+                "legacy-source": "legacy-source";
+                local: "local";
+                "marketplace-source-changed": "marketplace-source-changed";
+                none: "none";
+                "plugin-source-changed": "plugin-source-changed";
+            }>>;
+        }, z.core.$strict>>>;
+        notice: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            disposition: z.ZodEnum<{
+                "approval-required": "approval-required";
+                "automatic-applied": "automatic-applied";
+                "automatic-pending": "automatic-pending";
+                "automatic-retryable": "automatic-retryable";
+                "capability-blocked": "capability-blocked";
+                "configuration-blocked": "configuration-blocked";
+                "manual-required": "manual-required";
+                "recovery-required": "recovery-required";
+            }>;
+            unread: z.ZodBoolean;
+            unresolved: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        schedule: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            state: z.ZodEnum<{
+                "clock-regressed": "clock-regressed";
+                current: "current";
+                due: "due";
+                unavailable: "unavailable";
+            }>;
+            nextAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        updateSubsystem: z.ZodOptional<z.ZodEnum<{
+            "clock-regressed": "clock-regressed";
+            degraded: "degraded";
+            disabled: "disabled";
+            running: "running";
+            standby: "standby";
+            stopped: "stopped";
+        }>>;
+    }, z.core.$strict>>;
+    activation: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        intent: z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>;
+        state: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            inactive: "inactive";
+            pending: "pending";
+            "recovery-required": "recovery-required";
+            unavailable: "unavailable";
+        }>;
+        selectedRevision: z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">;
+        projectionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+        participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            participant: z.ZodEnum<{
+                mcp: "mcp";
+                "skills-hooks": "skills-hooks";
+            }>;
+            status: z.ZodEnum<{
+                matching: "matching";
+                mismatched: "mismatched";
+                missing: "missing";
+                unavailable: "unavailable";
+            }>;
+            contributionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+    mcpHealth: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        localRegistration: z.ZodEnum<{
+            absent: "absent";
+            matching: "matching";
+            mismatched: "mismatched";
+            unavailable: "unavailable";
+        }>;
+        servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+            serverKey: z.core.$ZodBranded<z.ZodString, "McpRuntimeServerKey", "out">;
+            nativeKey: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            authority: z.ZodEnum<{
+                current: "current";
+                stale: "stale";
+                unavailable: "unavailable";
+            }>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                stdio: "stdio";
+                "streamable-http": "streamable-http";
+            }>>;
+            state: z.ZodEnum<{
+                connected: "connected";
+                connecting: "connecting";
+                failed: "failed";
+                idle: "idle";
+                "needs-auth": "needs-auth";
+                registered: "registered";
+            }>;
+            toolCount: z.ZodOptional<z.ZodNumber>;
+            errorCode: z.ZodOptional<z.ZodEnum<{
+                ADAPTER_FAILED: "ADAPTER_FAILED";
+                CLAIM_CONFLICT: "CLAIM_CONFLICT";
+                COLLECTION_DEFERRED: "COLLECTION_DEFERRED";
+                CONTENT_VERIFICATION_FAILED: "CONTENT_VERIFICATION_FAILED";
+                DURABILITY_UNAVAILABLE: "DURABILITY_UNAVAILABLE";
+                ENTRY_INVALID: "ENTRY_INVALID";
+                FOREIGN_STATE_ROOT_INVALID: "FOREIGN_STATE_ROOT_INVALID";
+                IDENTITY_INVALID: "IDENTITY_INVALID";
+                MANIFEST_ROOT_INVALID: "MANIFEST_ROOT_INVALID";
+                MARKETPLACE_ROOT_INVALID: "MARKETPLACE_ROOT_INVALID";
+                MCP_LAUNCH_AUTHORITY_REJECTED: "MCP_LAUNCH_AUTHORITY_REJECTED";
+                MCP_LAUNCH_CANCELLED: "MCP_LAUNCH_CANCELLED";
+                MCP_LAUNCH_CLEANUP_FAILED: "MCP_LAUNCH_CLEANUP_FAILED";
+                MCP_LAUNCH_CONFIGURATION_FAILED: "MCP_LAUNCH_CONFIGURATION_FAILED";
+                MCP_LAUNCH_ENVIRONMENT_FAILED: "MCP_LAUNCH_ENVIRONMENT_FAILED";
+                MCP_LAUNCH_TIMEOUT: "MCP_LAUNCH_TIMEOUT";
+                MCP_LAUNCH_VALUE_INVALID: "MCP_LAUNCH_VALUE_INVALID";
+                PATH_CONTAINMENT_FAILED: "PATH_CONTAINMENT_FAILED";
+                RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+                REQUIREMENT_UNAVAILABLE: "REQUIREMENT_UNAVAILABLE";
+                SCHEMA_INVALID: "SCHEMA_INVALID";
+                SOURCE_INVALID: "SOURCE_INVALID";
+                SOURCE_RESOLUTION_FAILED: "SOURCE_RESOLUTION_FAILED";
+                STAGING_ALLOCATION_INVALID: "STAGING_ALLOCATION_INVALID";
+                STORE_IDENTITY_COLLISION: "STORE_IDENTITY_COLLISION";
+                TRANSITION_JOURNAL_CORRUPT: "TRANSITION_JOURNAL_CORRUPT";
+                UNSUPPORTED_DECLARATION: "UNSUPPORTED_DECLARATION";
+            }>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+    diagnostics: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodEnum<{
+            ACTIVATION_EVIDENCE_MISMATCH: "ACTIVATION_EVIDENCE_MISMATCH";
+            ADOPTION_DOCUMENT_CHANGED: "ADOPTION_DOCUMENT_CHANGED";
+            ADOPTION_DOCUMENT_UNREADABLE: "ADOPTION_DOCUMENT_UNREADABLE";
+            CANDIDATE_MISSING: "CANDIDATE_MISSING";
+            CAPABILITY_EVIDENCE_UNAVAILABLE: "CAPABILITY_EVIDENCE_UNAVAILABLE";
+            CATALOG_CORRUPT: "CATALOG_CORRUPT";
+            CATALOG_STALE: "CATALOG_STALE";
+            CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+            COMPATIBILITY_INCOMPATIBLE: "COMPATIBILITY_INCOMPATIBLE";
+            CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+            CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+            EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+            HOST_STARTUP_BLOCKED: "HOST_STARTUP_BLOCKED";
+            MCP_REGISTRATION_MISMATCH: "MCP_REGISTRATION_MISMATCH";
+            MCP_REGISTRATION_MISSING: "MCP_REGISTRATION_MISSING";
+            MCP_REMOTE_AUTH_REQUIRED: "MCP_REMOTE_AUTH_REQUIRED";
+            MCP_REMOTE_HEALTH_FAILED: "MCP_REMOTE_HEALTH_FAILED";
+            PROJECTION_UNAVAILABLE: "PROJECTION_UNAVAILABLE";
+            PROJECT_UNTRUSTED: "PROJECT_UNTRUSTED";
+            RECORD_CORRUPT: "RECORD_CORRUPT";
+            RECOVERY_BLOCKED: "RECOVERY_BLOCKED";
+            RECOVERY_DEFERRED: "RECOVERY_DEFERRED";
+            RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+            REVISION_UNAVAILABLE: "REVISION_UNAVAILABLE";
+            RUNTIME_EVIDENCE_MISSING: "RUNTIME_EVIDENCE_MISSING";
+            RUNTIME_EVIDENCE_UNAVAILABLE: "RUNTIME_EVIDENCE_UNAVAILABLE";
+            RUNTIME_REQUIREMENT_UNAVAILABLE: "RUNTIME_REQUIREMENT_UNAVAILABLE";
+            SECRET_CUSTODY_UNAVAILABLE: "SECRET_CUSTODY_UNAVAILABLE";
+            SOURCE_CONTENT_UNSAFE: "SOURCE_CONTENT_UNSAFE";
+            SOURCE_DECLARATION_CONFLICT: "SOURCE_DECLARATION_CONFLICT";
+            SOURCE_DOCUMENT_INVALID: "SOURCE_DOCUMENT_INVALID";
+            SOURCE_INVALID: "SOURCE_INVALID";
+            SOURCE_UNAVAILABLE: "SOURCE_UNAVAILABLE";
+            STATE_CORRUPT: "STATE_CORRUPT";
+            TRANSITION_PENDING: "TRANSITION_PENDING";
+            TRUST_EVIDENCE_INVALID: "TRUST_EVIDENCE_INVALID";
+            TRUST_REQUIRED: "TRUST_REQUIRED";
+            TRUST_REVOKED: "TRUST_REVOKED";
+            UPDATE_APPROVAL_REQUIRED: "UPDATE_APPROVAL_REQUIRED";
+            UPDATE_AUTOMATIC_PENDING: "UPDATE_AUTOMATIC_PENDING";
+            UPDATE_AVAILABLE: "UPDATE_AVAILABLE";
+            UPDATE_CAPABILITY_BLOCKED: "UPDATE_CAPABILITY_BLOCKED";
+            UPDATE_CLOCK_REGRESSED: "UPDATE_CLOCK_REGRESSED";
+            UPDATE_CONFIGURATION_BLOCKED: "UPDATE_CONFIGURATION_BLOCKED";
+            UPDATE_FAILED: "UPDATE_FAILED";
+            UPDATE_MANUAL_REQUIRED: "UPDATE_MANUAL_REQUIRED";
+            UPDATE_RECOVERY_REQUIRED: "UPDATE_RECOVERY_REQUIRED";
+        }>;
+        category: z.ZodEnum<{
+            activation: "activation";
+            adoption: "adoption";
+            capability: "capability";
+            compatibility: "compatibility";
+            configuration: "configuration";
+            evidence: "evidence";
+            freshness: "freshness";
+            integrity: "integrity";
+            "live-health": "live-health";
+            recovery: "recovery";
+            trust: "trust";
+            update: "update";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        subjectId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">>;
+        componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ComponentId", "out">>;
+        summary: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        facts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        action: z.ZodEnum<{
+            "inspect-source": "inspect-source";
+            "provide-configuration": "provide-configuration";
+            "refresh-marketplace": "refresh-marketplace";
+            "reload-runtime": "reload-runtime";
+            "retry-read": "retry-read";
+            "review-trust": "review-trust";
+            "review-update": "review-update";
+            "run-recovery": "run-recovery";
+            "trust-project": "trust-project";
+        }>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export declare const NativeInspectionDetailResultSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"found">;
+    detail: z.ZodReadonly<z.ZodObject<{
+        snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+        summary: z.ZodReadonly<z.ZodObject<{
+            detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+            subject: z.ZodEnum<{
+                installed: "installed";
+                "marketplace-candidate": "marketplace-candidate";
+            }>;
+            scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"user">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodLiteral<"project">;
+                projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+            }, z.core.$strict>>], "kind">;
+            plugin: z.core.$ZodBranded<z.ZodString, "PluginKey", "out">;
+            name: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            marketplace: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            revision: z.ZodReadonly<z.ZodObject<{
+                installed: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                available: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                immutable: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+                resolution: z.ZodEnum<{
+                    "declared-selector": "declared-selector";
+                    exact: "exact";
+                    unresolved: "unresolved";
+                }>;
+            }, z.core.$strict>>;
+            condition: z.ZodEnum<{
+                blocked: "blocked";
+                degraded: "degraded";
+                ready: "ready";
+                unavailable: "unavailable";
+            }>;
+            freshness: z.ZodReadonly<z.ZodObject<{
+                status: z.ZodEnum<{
+                    current: "current";
+                    "not-applicable": "not-applicable";
+                    stale: "stale";
+                    unavailable: "unavailable";
+                    unknown: "unknown";
+                }>;
+                basis: z.ZodEnum<{
+                    marketplace: "marketplace";
+                    none: "none";
+                    runtime: "runtime";
+                    state: "state";
+                    update: "update";
+                }>;
+            }, z.core.$strict>>;
+            diagnosticCounts: z.ZodReadonly<z.ZodObject<{
+                error: z.ZodNumber;
+                warning: z.ZodNumber;
+                info: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        source: z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodEnum<{
+                git: "git";
+                "git-subdir": "git-subdir";
+                github: "github";
+                "local-git": "local-git";
+                "marketplace-path": "marketplace-path";
+                npm: "npm";
+            }>;
+            identity: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            endpoint: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                scheme: z.ZodEnum<{
+                    git: "git";
+                    http: "http";
+                    https: "https";
+                    ssh: "ssh";
+                    unknown: "unknown";
+                }>;
+                host: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                port: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                queryPresent: z.ZodBoolean;
+                fragmentPresent: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            revision: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            package: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        compatibility: z.ZodReadonly<z.ZodObject<{
+            status: z.ZodEnum<{
+                activatable: "activatable";
+                incompatible: "incompatible";
+                unavailable: "unavailable";
+            }>;
+            reportFingerprint: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            components: z.ZodReadonly<z.ZodObject<{
+                counts: z.ZodReadonly<z.ZodObject<{
+                    skills: z.ZodNumber;
+                    hooks: z.ZodNumber;
+                    mcpServers: z.ZodNumber;
+                    foreign: z.ZodNumber;
+                }, z.core.$strict>>;
+                skills: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                    verdict: z.ZodEnum<{
+                        incompatible: "incompatible";
+                        "metadata-only": "metadata-only";
+                        supported: "supported";
+                        unavailable: "unavailable";
+                    }>;
+                    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        host: z.ZodEnum<{
+                            claude: "claude";
+                            codex: "codex";
+                        }>;
+                        documentKind: z.ZodEnum<{
+                            convention: "convention";
+                            "foreign-state": "foreign-state";
+                            hooks: "hooks";
+                            manifest: "manifest";
+                            marketplace: "marketplace";
+                            mcp: "mcp";
+                            skill: "skill";
+                        }>;
+                        path: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>;
+                        line: z.ZodOptional<z.ZodNumber>;
+                        column: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>>;
+                    kind: z.ZodLiteral<"skill">;
+                    name: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    root: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>>;
+                hooks: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                    verdict: z.ZodEnum<{
+                        incompatible: "incompatible";
+                        "metadata-only": "metadata-only";
+                        supported: "supported";
+                        unavailable: "unavailable";
+                    }>;
+                    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        host: z.ZodEnum<{
+                            claude: "claude";
+                            codex: "codex";
+                        }>;
+                        documentKind: z.ZodEnum<{
+                            convention: "convention";
+                            "foreign-state": "foreign-state";
+                            hooks: "hooks";
+                            manifest: "manifest";
+                            marketplace: "marketplace";
+                            mcp: "mcp";
+                            skill: "skill";
+                        }>;
+                        path: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>;
+                        line: z.ZodOptional<z.ZodNumber>;
+                        column: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>>;
+                    kind: z.ZodLiteral<"hook">;
+                    event: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    matcher: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    handler: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodLiteral<"shell">;
+                        command: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        shell: z.ZodOptional<z.ZodEnum<{
+                            bash: "bash";
+                            powershell: "powershell";
+                        }>>;
+                        timeoutMs: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodLiteral<"exec">;
+                        command: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>>;
+                        timeoutMs: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>], "kind">;
+                }, z.core.$strict>>>>;
+                mcpServers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                    verdict: z.ZodEnum<{
+                        incompatible: "incompatible";
+                        "metadata-only": "metadata-only";
+                        supported: "supported";
+                        unavailable: "unavailable";
+                    }>;
+                    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        host: z.ZodEnum<{
+                            claude: "claude";
+                            codex: "codex";
+                        }>;
+                        documentKind: z.ZodEnum<{
+                            convention: "convention";
+                            "foreign-state": "foreign-state";
+                            hooks: "hooks";
+                            manifest: "manifest";
+                            marketplace: "marketplace";
+                            mcp: "mcp";
+                            skill: "skill";
+                        }>;
+                        path: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>;
+                        line: z.ZodOptional<z.ZodNumber>;
+                        column: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>>;
+                    kind: z.ZodLiteral<"mcp-server">;
+                    nativeKey: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    transport: z.ZodOptional<z.ZodEnum<{
+                        stdio: "stdio";
+                        "streamable-http": "streamable-http";
+                    }>>;
+                    command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    args: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    url: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        scheme: z.ZodEnum<{
+                            http: "http";
+                            https: "https";
+                        }>;
+                        host: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        port: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        path: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        queryPresent: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    environmentNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    headerNames: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>>;
+                    authentication: z.ZodEnum<{
+                        "bearer-environment": "bearer-environment";
+                        none: "none";
+                        "oauth-authorization-code": "oauth-authorization-code";
+                        "oauth-client-credentials": "oauth-client-credentials";
+                        unavailable: "unavailable";
+                    }>;
+                    toolPolicy: z.ZodReadonly<z.ZodObject<{
+                        allowed: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>>;
+                        denied: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>>;
+                        approval: z.ZodEnum<{
+                            default: "default";
+                            "not-applicable": "not-applicable";
+                            required: "required";
+                        }>;
+                    }, z.core.$strict>>;
+                    startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                    toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+                foreign: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                    verdict: z.ZodEnum<{
+                        incompatible: "incompatible";
+                        "metadata-only": "metadata-only";
+                        supported: "supported";
+                        unavailable: "unavailable";
+                    }>;
+                    requirementIds: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">>>;
+                    provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        host: z.ZodEnum<{
+                            claude: "claude";
+                            codex: "codex";
+                        }>;
+                        documentKind: z.ZodEnum<{
+                            convention: "convention";
+                            "foreign-state": "foreign-state";
+                            hooks: "hooks";
+                            manifest: "manifest";
+                            marketplace: "marketplace";
+                            mcp: "mcp";
+                            skill: "skill";
+                        }>;
+                        path: z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                        pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                            text: z.ZodString;
+                            escaped: z.ZodBoolean;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>>;
+                        line: z.ZodOptional<z.ZodNumber>;
+                        column: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>>>;
+                    kind: z.ZodLiteral<"foreign">;
+                    nativeHost: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    nativeKind: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            requirements: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "RuntimeRequirementId", "out">;
+                capability: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                status: z.ZodEnum<{
+                    available: "available";
+                    unavailable: "unavailable";
+                }>;
+                explanation: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        codex: "codex";
+                    }>;
+                    documentKind: z.ZodEnum<{
+                        convention: "convention";
+                        "foreign-state": "foreign-state";
+                        hooks: "hooks";
+                        manifest: "manifest";
+                        marketplace: "marketplace";
+                        mcp: "mcp";
+                        skill: "skill";
+                    }>;
+                    path: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                        escaped: z.ZodBoolean;
+                        truncated: z.ZodBoolean;
+                    }, z.core.$strict>>>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>;
+        trust: z.ZodEnum<{
+            authorized: "authorized";
+            "invalid-evidence": "invalid-evidence";
+            "not-applicable": "not-applicable";
+            "project-untrusted": "project-untrusted";
+            required: "required";
+            revoked: "revoked";
+            unavailable: "unavailable";
+        }>;
+        configuration: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            valueKind: z.ZodEnum<{
+                boolean: "boolean";
+                directory: "directory";
+                file: "file";
+                number: "number";
+                string: "string";
+                strings: "strings";
+            }>;
+            required: z.ZodBoolean;
+            sensitive: z.ZodBoolean;
+            defaultPresent: z.ZodBoolean;
+            state: z.ZodEnum<{
+                configured: "configured";
+                defaulted: "defaulted";
+                invalid: "invalid";
+                missing: "missing";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strict>>>>;
+        lifecycle: z.ZodReadonly<z.ZodObject<{
+            installed: z.ZodBoolean;
+            activationIntent: z.ZodOptional<z.ZodEnum<{
+                disabled: "disabled";
+                enabled: "enabled";
+            }>>;
+            transition: z.ZodEnum<{
+                blocked: "blocked";
+                deferred: "deferred";
+                none: "none";
+                pending: "pending";
+                "recovery-required": "recovery-required";
+            }>;
+            update: z.ZodEnum<{
+                "approval-required": "approval-required";
+                "automatic-applied": "automatic-applied";
+                "automatic-pending": "automatic-pending";
+                "automatic-retryable": "automatic-retryable";
+                available: "available";
+                "capability-blocked": "capability-blocked";
+                "configuration-blocked": "configuration-blocked";
+                current: "current";
+                failed: "failed";
+                "manual-required": "manual-required";
+                "not-applicable": "not-applicable";
+                "recovery-required": "recovery-required";
+                unknown: "unknown";
+            }>;
+            policy: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                application: z.ZodEnum<{
+                    automatic: "automatic";
+                    manual: "manual";
+                }>;
+                winningLevel: z.ZodEnum<{
+                    global: "global";
+                    guard: "guard";
+                    marketplace: "marketplace";
+                    plugin: "plugin";
+                    scope: "scope";
+                }>;
+                sourceGuard: z.ZodDefault<z.ZodEnum<{
+                    "legacy-source": "legacy-source";
+                    local: "local";
+                    "marketplace-source-changed": "marketplace-source-changed";
+                    none: "none";
+                    "plugin-source-changed": "plugin-source-changed";
+                }>>;
+            }, z.core.$strict>>>;
+            notice: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                disposition: z.ZodEnum<{
+                    "approval-required": "approval-required";
+                    "automatic-applied": "automatic-applied";
+                    "automatic-pending": "automatic-pending";
+                    "automatic-retryable": "automatic-retryable";
+                    "capability-blocked": "capability-blocked";
+                    "configuration-blocked": "configuration-blocked";
+                    "manual-required": "manual-required";
+                    "recovery-required": "recovery-required";
+                }>;
+                unread: z.ZodBoolean;
+                unresolved: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            schedule: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                state: z.ZodEnum<{
+                    "clock-regressed": "clock-regressed";
+                    current: "current";
+                    due: "due";
+                    unavailable: "unavailable";
+                }>;
+                nextAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            updateSubsystem: z.ZodOptional<z.ZodEnum<{
+                "clock-regressed": "clock-regressed";
+                degraded: "degraded";
+                disabled: "disabled";
+                running: "running";
+                standby: "standby";
+                stopped: "stopped";
+            }>>;
+        }, z.core.$strict>>;
+        activation: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            intent: z.ZodEnum<{
+                disabled: "disabled";
+                enabled: "enabled";
+            }>;
+            state: z.ZodEnum<{
+                active: "active";
+                blocked: "blocked";
+                inactive: "inactive";
+                pending: "pending";
+                "recovery-required": "recovery-required";
+                unavailable: "unavailable";
+            }>;
+            selectedRevision: z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">;
+            projectionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                participant: z.ZodEnum<{
+                    mcp: "mcp";
+                    "skills-hooks": "skills-hooks";
+                }>;
+                status: z.ZodEnum<{
+                    matching: "matching";
+                    mismatched: "mismatched";
+                    missing: "missing";
+                    unavailable: "unavailable";
+                }>;
+                contributionDigest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>>;
+        mcpHealth: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            localRegistration: z.ZodEnum<{
+                absent: "absent";
+                matching: "matching";
+                mismatched: "mismatched";
+                unavailable: "unavailable";
+            }>;
+            servers: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                componentId: z.core.$ZodBranded<z.ZodString, "ComponentId", "out">;
+                serverKey: z.core.$ZodBranded<z.ZodString, "McpRuntimeServerKey", "out">;
+                nativeKey: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                authority: z.ZodEnum<{
+                    current: "current";
+                    stale: "stale";
+                    unavailable: "unavailable";
+                }>;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    "streamable-http": "streamable-http";
+                }>>;
+                state: z.ZodEnum<{
+                    connected: "connected";
+                    connecting: "connecting";
+                    failed: "failed";
+                    idle: "idle";
+                    "needs-auth": "needs-auth";
+                    registered: "registered";
+                }>;
+                toolCount: z.ZodOptional<z.ZodNumber>;
+                errorCode: z.ZodOptional<z.ZodEnum<{
+                    ADAPTER_FAILED: "ADAPTER_FAILED";
+                    CLAIM_CONFLICT: "CLAIM_CONFLICT";
+                    COLLECTION_DEFERRED: "COLLECTION_DEFERRED";
+                    CONTENT_VERIFICATION_FAILED: "CONTENT_VERIFICATION_FAILED";
+                    DURABILITY_UNAVAILABLE: "DURABILITY_UNAVAILABLE";
+                    ENTRY_INVALID: "ENTRY_INVALID";
+                    FOREIGN_STATE_ROOT_INVALID: "FOREIGN_STATE_ROOT_INVALID";
+                    IDENTITY_INVALID: "IDENTITY_INVALID";
+                    MANIFEST_ROOT_INVALID: "MANIFEST_ROOT_INVALID";
+                    MARKETPLACE_ROOT_INVALID: "MARKETPLACE_ROOT_INVALID";
+                    MCP_LAUNCH_AUTHORITY_REJECTED: "MCP_LAUNCH_AUTHORITY_REJECTED";
+                    MCP_LAUNCH_CANCELLED: "MCP_LAUNCH_CANCELLED";
+                    MCP_LAUNCH_CLEANUP_FAILED: "MCP_LAUNCH_CLEANUP_FAILED";
+                    MCP_LAUNCH_CONFIGURATION_FAILED: "MCP_LAUNCH_CONFIGURATION_FAILED";
+                    MCP_LAUNCH_ENVIRONMENT_FAILED: "MCP_LAUNCH_ENVIRONMENT_FAILED";
+                    MCP_LAUNCH_TIMEOUT: "MCP_LAUNCH_TIMEOUT";
+                    MCP_LAUNCH_VALUE_INVALID: "MCP_LAUNCH_VALUE_INVALID";
+                    PATH_CONTAINMENT_FAILED: "PATH_CONTAINMENT_FAILED";
+                    RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+                    REQUIREMENT_UNAVAILABLE: "REQUIREMENT_UNAVAILABLE";
+                    SCHEMA_INVALID: "SCHEMA_INVALID";
+                    SOURCE_INVALID: "SOURCE_INVALID";
+                    SOURCE_RESOLUTION_FAILED: "SOURCE_RESOLUTION_FAILED";
+                    STAGING_ALLOCATION_INVALID: "STAGING_ALLOCATION_INVALID";
+                    STORE_IDENTITY_COLLISION: "STORE_IDENTITY_COLLISION";
+                    TRANSITION_JOURNAL_CORRUPT: "TRANSITION_JOURNAL_CORRUPT";
+                    UNSUPPORTED_DECLARATION: "UNSUPPORTED_DECLARATION";
+                }>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            code: z.ZodEnum<{
+                ACTIVATION_EVIDENCE_MISMATCH: "ACTIVATION_EVIDENCE_MISMATCH";
+                ADOPTION_DOCUMENT_CHANGED: "ADOPTION_DOCUMENT_CHANGED";
+                ADOPTION_DOCUMENT_UNREADABLE: "ADOPTION_DOCUMENT_UNREADABLE";
+                CANDIDATE_MISSING: "CANDIDATE_MISSING";
+                CAPABILITY_EVIDENCE_UNAVAILABLE: "CAPABILITY_EVIDENCE_UNAVAILABLE";
+                CATALOG_CORRUPT: "CATALOG_CORRUPT";
+                CATALOG_STALE: "CATALOG_STALE";
+                CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+                COMPATIBILITY_INCOMPATIBLE: "COMPATIBILITY_INCOMPATIBLE";
+                CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+                CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+                EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+                HOST_STARTUP_BLOCKED: "HOST_STARTUP_BLOCKED";
+                MCP_REGISTRATION_MISMATCH: "MCP_REGISTRATION_MISMATCH";
+                MCP_REGISTRATION_MISSING: "MCP_REGISTRATION_MISSING";
+                MCP_REMOTE_AUTH_REQUIRED: "MCP_REMOTE_AUTH_REQUIRED";
+                MCP_REMOTE_HEALTH_FAILED: "MCP_REMOTE_HEALTH_FAILED";
+                PROJECTION_UNAVAILABLE: "PROJECTION_UNAVAILABLE";
+                PROJECT_UNTRUSTED: "PROJECT_UNTRUSTED";
+                RECORD_CORRUPT: "RECORD_CORRUPT";
+                RECOVERY_BLOCKED: "RECOVERY_BLOCKED";
+                RECOVERY_DEFERRED: "RECOVERY_DEFERRED";
+                RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+                REVISION_UNAVAILABLE: "REVISION_UNAVAILABLE";
+                RUNTIME_EVIDENCE_MISSING: "RUNTIME_EVIDENCE_MISSING";
+                RUNTIME_EVIDENCE_UNAVAILABLE: "RUNTIME_EVIDENCE_UNAVAILABLE";
+                RUNTIME_REQUIREMENT_UNAVAILABLE: "RUNTIME_REQUIREMENT_UNAVAILABLE";
+                SECRET_CUSTODY_UNAVAILABLE: "SECRET_CUSTODY_UNAVAILABLE";
+                SOURCE_CONTENT_UNSAFE: "SOURCE_CONTENT_UNSAFE";
+                SOURCE_DECLARATION_CONFLICT: "SOURCE_DECLARATION_CONFLICT";
+                SOURCE_DOCUMENT_INVALID: "SOURCE_DOCUMENT_INVALID";
+                SOURCE_INVALID: "SOURCE_INVALID";
+                SOURCE_UNAVAILABLE: "SOURCE_UNAVAILABLE";
+                STATE_CORRUPT: "STATE_CORRUPT";
+                TRANSITION_PENDING: "TRANSITION_PENDING";
+                TRUST_EVIDENCE_INVALID: "TRUST_EVIDENCE_INVALID";
+                TRUST_REQUIRED: "TRUST_REQUIRED";
+                TRUST_REVOKED: "TRUST_REVOKED";
+                UPDATE_APPROVAL_REQUIRED: "UPDATE_APPROVAL_REQUIRED";
+                UPDATE_AUTOMATIC_PENDING: "UPDATE_AUTOMATIC_PENDING";
+                UPDATE_AVAILABLE: "UPDATE_AVAILABLE";
+                UPDATE_CAPABILITY_BLOCKED: "UPDATE_CAPABILITY_BLOCKED";
+                UPDATE_CLOCK_REGRESSED: "UPDATE_CLOCK_REGRESSED";
+                UPDATE_CONFIGURATION_BLOCKED: "UPDATE_CONFIGURATION_BLOCKED";
+                UPDATE_FAILED: "UPDATE_FAILED";
+                UPDATE_MANUAL_REQUIRED: "UPDATE_MANUAL_REQUIRED";
+                UPDATE_RECOVERY_REQUIRED: "UPDATE_RECOVERY_REQUIRED";
+            }>;
+            category: z.ZodEnum<{
+                activation: "activation";
+                adoption: "adoption";
+                capability: "capability";
+                compatibility: "compatibility";
+                configuration: "configuration";
+                evidence: "evidence";
+                freshness: "freshness";
+                integrity: "integrity";
+                "live-health": "live-health";
+                recovery: "recovery";
+                trust: "trust";
+                update: "update";
+            }>;
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+            }>;
+            subjectId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">>;
+            componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ComponentId", "out">>;
+            summary: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            facts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>>;
+            provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    codex: "codex";
+                }>;
+                documentKind: z.ZodEnum<{
+                    convention: "convention";
+                    "foreign-state": "foreign-state";
+                    hooks: "hooks";
+                    manifest: "manifest";
+                    marketplace: "marketplace";
+                    mcp: "mcp";
+                    skill: "skill";
+                }>;
+                path: z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    text: z.ZodString;
+                    escaped: z.ZodBoolean;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+            action: z.ZodEnum<{
+                "inspect-source": "inspect-source";
+                "provide-configuration": "provide-configuration";
+                "refresh-marketplace": "refresh-marketplace";
+                "reload-runtime": "reload-runtime";
+                "retry-read": "retry-read";
+                "review-trust": "review-trust";
+                "review-update": "review-update";
+                "run-recovery": "run-recovery";
+                "trust-project": "trust-project";
+            }>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"stale">;
+    action: z.ZodLiteral<"retry-read">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"invalid-id">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    summary: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+        subject: z.ZodEnum<{
+            installed: "installed";
+            "marketplace-candidate": "marketplace-candidate";
+        }>;
+        scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+        }, z.core.$strict>>], "kind">;
+        plugin: z.core.$ZodBranded<z.ZodString, "PluginKey", "out">;
+        name: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        marketplace: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        revision: z.ZodReadonly<z.ZodObject<{
+            installed: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            available: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            immutable: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ContentDigest", "out">>;
+            resolution: z.ZodEnum<{
+                "declared-selector": "declared-selector";
+                exact: "exact";
+                unresolved: "unresolved";
+            }>;
+        }, z.core.$strict>>;
+        condition: z.ZodEnum<{
+            blocked: "blocked";
+            degraded: "degraded";
+            ready: "ready";
+            unavailable: "unavailable";
+        }>;
+        freshness: z.ZodReadonly<z.ZodObject<{
+            status: z.ZodEnum<{
+                current: "current";
+                "not-applicable": "not-applicable";
+                stale: "stale";
+                unavailable: "unavailable";
+                unknown: "unknown";
+            }>;
+            basis: z.ZodEnum<{
+                marketplace: "marketplace";
+                none: "none";
+                runtime: "runtime";
+                state: "state";
+                update: "update";
+            }>;
+        }, z.core.$strict>>;
+        diagnosticCounts: z.ZodReadonly<z.ZodObject<{
+            error: z.ZodNumber;
+            warning: z.ZodNumber;
+            info: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    diagnostics: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodEnum<{
+            ACTIVATION_EVIDENCE_MISMATCH: "ACTIVATION_EVIDENCE_MISMATCH";
+            ADOPTION_DOCUMENT_CHANGED: "ADOPTION_DOCUMENT_CHANGED";
+            ADOPTION_DOCUMENT_UNREADABLE: "ADOPTION_DOCUMENT_UNREADABLE";
+            CANDIDATE_MISSING: "CANDIDATE_MISSING";
+            CAPABILITY_EVIDENCE_UNAVAILABLE: "CAPABILITY_EVIDENCE_UNAVAILABLE";
+            CATALOG_CORRUPT: "CATALOG_CORRUPT";
+            CATALOG_STALE: "CATALOG_STALE";
+            CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+            COMPATIBILITY_INCOMPATIBLE: "COMPATIBILITY_INCOMPATIBLE";
+            CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+            CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+            EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+            HOST_STARTUP_BLOCKED: "HOST_STARTUP_BLOCKED";
+            MCP_REGISTRATION_MISMATCH: "MCP_REGISTRATION_MISMATCH";
+            MCP_REGISTRATION_MISSING: "MCP_REGISTRATION_MISSING";
+            MCP_REMOTE_AUTH_REQUIRED: "MCP_REMOTE_AUTH_REQUIRED";
+            MCP_REMOTE_HEALTH_FAILED: "MCP_REMOTE_HEALTH_FAILED";
+            PROJECTION_UNAVAILABLE: "PROJECTION_UNAVAILABLE";
+            PROJECT_UNTRUSTED: "PROJECT_UNTRUSTED";
+            RECORD_CORRUPT: "RECORD_CORRUPT";
+            RECOVERY_BLOCKED: "RECOVERY_BLOCKED";
+            RECOVERY_DEFERRED: "RECOVERY_DEFERRED";
+            RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+            REVISION_UNAVAILABLE: "REVISION_UNAVAILABLE";
+            RUNTIME_EVIDENCE_MISSING: "RUNTIME_EVIDENCE_MISSING";
+            RUNTIME_EVIDENCE_UNAVAILABLE: "RUNTIME_EVIDENCE_UNAVAILABLE";
+            RUNTIME_REQUIREMENT_UNAVAILABLE: "RUNTIME_REQUIREMENT_UNAVAILABLE";
+            SECRET_CUSTODY_UNAVAILABLE: "SECRET_CUSTODY_UNAVAILABLE";
+            SOURCE_CONTENT_UNSAFE: "SOURCE_CONTENT_UNSAFE";
+            SOURCE_DECLARATION_CONFLICT: "SOURCE_DECLARATION_CONFLICT";
+            SOURCE_DOCUMENT_INVALID: "SOURCE_DOCUMENT_INVALID";
+            SOURCE_INVALID: "SOURCE_INVALID";
+            SOURCE_UNAVAILABLE: "SOURCE_UNAVAILABLE";
+            STATE_CORRUPT: "STATE_CORRUPT";
+            TRANSITION_PENDING: "TRANSITION_PENDING";
+            TRUST_EVIDENCE_INVALID: "TRUST_EVIDENCE_INVALID";
+            TRUST_REQUIRED: "TRUST_REQUIRED";
+            TRUST_REVOKED: "TRUST_REVOKED";
+            UPDATE_APPROVAL_REQUIRED: "UPDATE_APPROVAL_REQUIRED";
+            UPDATE_AUTOMATIC_PENDING: "UPDATE_AUTOMATIC_PENDING";
+            UPDATE_AVAILABLE: "UPDATE_AVAILABLE";
+            UPDATE_CAPABILITY_BLOCKED: "UPDATE_CAPABILITY_BLOCKED";
+            UPDATE_CLOCK_REGRESSED: "UPDATE_CLOCK_REGRESSED";
+            UPDATE_CONFIGURATION_BLOCKED: "UPDATE_CONFIGURATION_BLOCKED";
+            UPDATE_FAILED: "UPDATE_FAILED";
+            UPDATE_MANUAL_REQUIRED: "UPDATE_MANUAL_REQUIRED";
+            UPDATE_RECOVERY_REQUIRED: "UPDATE_RECOVERY_REQUIRED";
+        }>;
+        category: z.ZodEnum<{
+            activation: "activation";
+            adoption: "adoption";
+            capability: "capability";
+            compatibility: "compatibility";
+            configuration: "configuration";
+            evidence: "evidence";
+            freshness: "freshness";
+            integrity: "integrity";
+            "live-health": "live-health";
+            recovery: "recovery";
+            trust: "trust";
+            update: "update";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        subjectId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">>;
+        componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ComponentId", "out">>;
+        summary: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        facts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        action: z.ZodEnum<{
+            "inspect-source": "inspect-source";
+            "provide-configuration": "provide-configuration";
+            "refresh-marketplace": "refresh-marketplace";
+            "reload-runtime": "reload-runtime";
+            "retry-read": "retry-read";
+            "review-trust": "review-trust";
+            "review-update": "review-update";
+            "run-recovery": "run-recovery";
+            "trust-project": "trust-project";
+        }>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>], "kind">;
+export declare const NativeDiagnosisRequestSchema: z.ZodReadonly<z.ZodObject<{
+    target: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"host">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"detail">;
+        snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+        detailId: z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">;
+    }, z.core.$strict>>], "kind">>;
+    includeAdoption: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>>;
+export declare const NativeDiagnosticReportSchema: z.ZodReadonly<z.ZodObject<{
+    snapshotId: z.core.$ZodBranded<z.ZodString, "InspectionSnapshotId", "out">;
+    condition: z.ZodEnum<{
+        blocked: "blocked";
+        degraded: "degraded";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>;
+    observations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        scope: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            projectKey: z.core.$ZodBranded<z.ZodString, "ProjectKey", "out">;
+        }, z.core.$strict>>], "kind">;
+        status: z.ZodEnum<{
+            corrupt: "corrupt";
+            ready: "ready";
+            unavailable: "unavailable";
+        }>;
+        generation: z.ZodOptional<z.ZodNumber>;
+        corruptionCodes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+    diagnostics: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodEnum<{
+            ACTIVATION_EVIDENCE_MISMATCH: "ACTIVATION_EVIDENCE_MISMATCH";
+            ADOPTION_DOCUMENT_CHANGED: "ADOPTION_DOCUMENT_CHANGED";
+            ADOPTION_DOCUMENT_UNREADABLE: "ADOPTION_DOCUMENT_UNREADABLE";
+            CANDIDATE_MISSING: "CANDIDATE_MISSING";
+            CAPABILITY_EVIDENCE_UNAVAILABLE: "CAPABILITY_EVIDENCE_UNAVAILABLE";
+            CATALOG_CORRUPT: "CATALOG_CORRUPT";
+            CATALOG_STALE: "CATALOG_STALE";
+            CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+            COMPATIBILITY_INCOMPATIBLE: "COMPATIBILITY_INCOMPATIBLE";
+            CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+            CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+            EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+            HOST_STARTUP_BLOCKED: "HOST_STARTUP_BLOCKED";
+            MCP_REGISTRATION_MISMATCH: "MCP_REGISTRATION_MISMATCH";
+            MCP_REGISTRATION_MISSING: "MCP_REGISTRATION_MISSING";
+            MCP_REMOTE_AUTH_REQUIRED: "MCP_REMOTE_AUTH_REQUIRED";
+            MCP_REMOTE_HEALTH_FAILED: "MCP_REMOTE_HEALTH_FAILED";
+            PROJECTION_UNAVAILABLE: "PROJECTION_UNAVAILABLE";
+            PROJECT_UNTRUSTED: "PROJECT_UNTRUSTED";
+            RECORD_CORRUPT: "RECORD_CORRUPT";
+            RECOVERY_BLOCKED: "RECOVERY_BLOCKED";
+            RECOVERY_DEFERRED: "RECOVERY_DEFERRED";
+            RECOVERY_REQUIRED: "RECOVERY_REQUIRED";
+            REVISION_UNAVAILABLE: "REVISION_UNAVAILABLE";
+            RUNTIME_EVIDENCE_MISSING: "RUNTIME_EVIDENCE_MISSING";
+            RUNTIME_EVIDENCE_UNAVAILABLE: "RUNTIME_EVIDENCE_UNAVAILABLE";
+            RUNTIME_REQUIREMENT_UNAVAILABLE: "RUNTIME_REQUIREMENT_UNAVAILABLE";
+            SECRET_CUSTODY_UNAVAILABLE: "SECRET_CUSTODY_UNAVAILABLE";
+            SOURCE_CONTENT_UNSAFE: "SOURCE_CONTENT_UNSAFE";
+            SOURCE_DECLARATION_CONFLICT: "SOURCE_DECLARATION_CONFLICT";
+            SOURCE_DOCUMENT_INVALID: "SOURCE_DOCUMENT_INVALID";
+            SOURCE_INVALID: "SOURCE_INVALID";
+            SOURCE_UNAVAILABLE: "SOURCE_UNAVAILABLE";
+            STATE_CORRUPT: "STATE_CORRUPT";
+            TRANSITION_PENDING: "TRANSITION_PENDING";
+            TRUST_EVIDENCE_INVALID: "TRUST_EVIDENCE_INVALID";
+            TRUST_REQUIRED: "TRUST_REQUIRED";
+            TRUST_REVOKED: "TRUST_REVOKED";
+            UPDATE_APPROVAL_REQUIRED: "UPDATE_APPROVAL_REQUIRED";
+            UPDATE_AUTOMATIC_PENDING: "UPDATE_AUTOMATIC_PENDING";
+            UPDATE_AVAILABLE: "UPDATE_AVAILABLE";
+            UPDATE_CAPABILITY_BLOCKED: "UPDATE_CAPABILITY_BLOCKED";
+            UPDATE_CLOCK_REGRESSED: "UPDATE_CLOCK_REGRESSED";
+            UPDATE_CONFIGURATION_BLOCKED: "UPDATE_CONFIGURATION_BLOCKED";
+            UPDATE_FAILED: "UPDATE_FAILED";
+            UPDATE_MANUAL_REQUIRED: "UPDATE_MANUAL_REQUIRED";
+            UPDATE_RECOVERY_REQUIRED: "UPDATE_RECOVERY_REQUIRED";
+        }>;
+        category: z.ZodEnum<{
+            activation: "activation";
+            adoption: "adoption";
+            capability: "capability";
+            compatibility: "compatibility";
+            configuration: "configuration";
+            evidence: "evidence";
+            freshness: "freshness";
+            integrity: "integrity";
+            "live-health": "live-health";
+            recovery: "recovery";
+            trust: "trust";
+            update: "update";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        subjectId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InspectionDetailId", "out">>;
+        componentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ComponentId", "out">>;
+        summary: z.ZodReadonly<z.ZodObject<{
+            text: z.ZodString;
+            escaped: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        facts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        provenance: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            host: z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+            }>;
+            documentKind: z.ZodEnum<{
+                convention: "convention";
+                "foreign-state": "foreign-state";
+                hooks: "hooks";
+                manifest: "manifest";
+                marketplace: "marketplace";
+                mcp: "mcp";
+                skill: "skill";
+            }>;
+            path: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            pointer: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+                escaped: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            line: z.ZodOptional<z.ZodNumber>;
+            column: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+        action: z.ZodEnum<{
+            "inspect-source": "inspect-source";
+            "provide-configuration": "provide-configuration";
+            "refresh-marketplace": "refresh-marketplace";
+            "reload-runtime": "reload-runtime";
+            "retry-read": "retry-read";
+            "review-trust": "review-trust";
+            "review-update": "review-update";
+            "run-recovery": "run-recovery";
+            "trust-project": "trust-project";
+        }>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>>;
+export type NativeInspectionSubjectKind = z.infer<typeof NativeInspectionSubjectKindSchema>;
+export type NativeInspectionCondition = z.infer<typeof NativeInspectionConditionSchema>;
+export type NativeInspectionFreshness = z.infer<typeof NativeInspectionFreshnessSchema>;
+export type InspectionSnapshotId = z.infer<typeof InspectionSnapshotIdSchema>;
+export type InspectionDetailId = z.infer<typeof InspectionDetailIdSchema>;
+export type InspectionCursor = z.infer<typeof InspectionCursorSchema>;
+export type SafeDisplayField = z.infer<typeof SafeDisplayFieldSchema>;
+export type NativeProvenanceView = z.infer<typeof NativeProvenanceViewSchema>;
+export type NativeMcpEndpoint = z.infer<typeof NativeMcpEndpointSchema>;
+export type NativeSourceView = z.infer<typeof NativeSourceViewSchema>;
+export type NativeComponentInventoryView = z.infer<typeof NativeComponentInventoryViewSchema>;
+export type NativeConfigurationOptionView = z.infer<typeof NativeConfigurationOptionViewSchema>;
+export type NativeTrustReadiness = z.infer<typeof NativeTrustReadinessSchema>;
+export type NativeCompatibilityView = z.infer<typeof NativeCompatibilityViewSchema>;
+export type NativeLifecycleView = z.infer<typeof NativeLifecycleViewSchema>;
+export type NativeActivationView = z.infer<typeof NativeActivationViewSchema>;
+export type NativeMcpHealthView = z.infer<typeof NativeMcpHealthViewSchema>;
+export type NativeDiagnostic = z.infer<typeof NativeDiagnosticSchema>;
+export type NativeInspectionListRequest = z.infer<typeof NativeInspectionListRequestSchema>;
+export type NativeInspectionSummary = z.infer<typeof NativeInspectionSummarySchema>;
+export type NativeScopeObservation = z.infer<typeof NativeScopeObservationSchema>;
+export type NativeInspectionPage = z.infer<typeof NativeInspectionPageSchema>;
+export type NativeInspectionDetailRequest = z.infer<typeof NativeInspectionDetailRequestSchema>;
+export type NativeInspectionDetail = z.infer<typeof NativeInspectionDetailSchema>;
+export type NativeInspectionDetailResult = z.infer<typeof NativeInspectionDetailResultSchema>;
+export type NativeDiagnosisRequest = z.infer<typeof NativeDiagnosisRequestSchema>;
+export type NativeDiagnosticReport = z.infer<typeof NativeDiagnosticReportSchema>;
+export interface NativeInspectionService {
+    list(request: NativeInspectionListRequest, signal: AbortSignal): Promise<NativeInspectionPage>;
+    detail(request: NativeInspectionDetailRequest, signal: AbortSignal): Promise<NativeInspectionDetailResult>;
+    diagnose(request: NativeDiagnosisRequest, signal: AbortSignal): Promise<NativeDiagnosticReport>;
+}