@nklisch/pi-enhanced 0.1.0

package/node_modules/@nklisch/pi-plugins/dist/domain/compatibility-policy.d.ts

@@ -0,0 +1,1341 @@
+import { z } from "zod";
+import { type ErrorCode } from "./error-contract.js";
+/**
+ * Runtime facts are deliberately separate from component verdicts.  This
+ * registry is the only vocabulary a capability adapter may report.
+ */
+export declare const RuntimeCapabilityRegistry: {
+    readonly skillToolRestrictions: {
+        readonly id: "pi.skill.allowed-tools";
+        readonly description: "Pi preserves skill tool restrictions";
+        readonly rank: 10;
+    };
+    readonly commandHooks: {
+        readonly id: "pi.hooks.command";
+        readonly description: "Pi command-hook adapter is available";
+        readonly rank: 20;
+    };
+    readonly bash: {
+        readonly id: "platform.shell.bash";
+        readonly description: "Bash is available";
+        readonly rank: 30;
+    };
+    readonly powershell: {
+        readonly id: "platform.shell.powershell";
+        readonly description: "PowerShell is available on Windows";
+        readonly rank: 40;
+    };
+    readonly subagentInterception: {
+        readonly id: "pi.subagents.lifecycle-interception";
+        readonly description: "Subagent pre-start and pre-stop interception is available";
+        readonly rank: 50;
+    };
+    readonly mcpRuntime: {
+        readonly id: "pi.mcp.runtime";
+        readonly description: "Plugin-scoped MCP runtime is available";
+        readonly rank: 60;
+    };
+    readonly mcpTransportStdio: {
+        readonly id: "pi.mcp.transport.stdio";
+        readonly description: "MCP standard-I/O transport is available";
+        readonly rank: 65;
+    };
+    readonly mcpTransportStreamableHttp: {
+        readonly id: "pi.mcp.transport.streamable-http";
+        readonly description: "MCP Streamable HTTP transport is available";
+        readonly rank: 66;
+    };
+    readonly mcpOAuthAuthorizationCode: {
+        readonly id: "pi.mcp.oauth.authorization-code";
+        readonly description: "MCP authorization-code OAuth is available";
+        readonly rank: 70;
+    };
+    readonly mcpOAuthClientCredentials: {
+        readonly id: "pi.mcp.oauth.client-credentials";
+        readonly description: "MCP client-credentials OAuth is available";
+        readonly rank: 80;
+    };
+    readonly mcpToolApproval: {
+        readonly id: "pi.mcp.tool-approval";
+        readonly description: "MCP tool approval policy is available";
+        readonly rank: 90;
+    };
+    readonly mcpSampling: {
+        readonly id: "pi.mcp.sampling";
+        readonly description: "MCP sampling is available";
+        readonly rank: 100;
+    };
+    readonly mcpElicitationForm: {
+        readonly id: "pi.mcp.elicitation.form";
+        readonly description: "Interactive form elicitation is available";
+        readonly rank: 110;
+    };
+    readonly mcpElicitationUrl: {
+        readonly id: "pi.mcp.elicitation.url";
+        readonly description: "Interactive URL elicitation is available";
+        readonly rank: 120;
+    };
+    readonly mcpResources: {
+        readonly id: "pi.mcp.resources";
+        readonly description: "MCP resource access is available";
+        readonly rank: 125;
+    };
+};
+export declare const RuntimeCapabilityIdSchema: z.ZodEnum<{
+    "pi.hooks.command": "pi.hooks.command";
+    "pi.mcp.elicitation.form": "pi.mcp.elicitation.form";
+    "pi.mcp.elicitation.url": "pi.mcp.elicitation.url";
+    "pi.mcp.oauth.authorization-code": "pi.mcp.oauth.authorization-code";
+    "pi.mcp.oauth.client-credentials": "pi.mcp.oauth.client-credentials";
+    "pi.mcp.resources": "pi.mcp.resources";
+    "pi.mcp.runtime": "pi.mcp.runtime";
+    "pi.mcp.sampling": "pi.mcp.sampling";
+    "pi.mcp.tool-approval": "pi.mcp.tool-approval";
+    "pi.mcp.transport.stdio": "pi.mcp.transport.stdio";
+    "pi.mcp.transport.streamable-http": "pi.mcp.transport.streamable-http";
+    "pi.skill.allowed-tools": "pi.skill.allowed-tools";
+    "pi.subagents.lifecycle-interception": "pi.subagents.lifecycle-interception";
+    "platform.shell.bash": "platform.shell.bash";
+    "platform.shell.powershell": "platform.shell.powershell";
+}>;
+export type RuntimeCapabilityId = z.infer<typeof RuntimeCapabilityIdSchema>;
+export declare const RuntimeCapabilityAvailabilitySchema: z.ZodReadonly<z.ZodObject<{
+    status: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+    }>;
+    explanation: z.ZodString;
+}, z.core.$strict>>;
+export type RuntimeCapabilityAvailability = z.infer<typeof RuntimeCapabilityAvailabilitySchema>;
+/** A complete immutable fact snapshot supplied by the application boundary. */
+export declare const RuntimeCapabilitySnapshotSchema: z.ZodReadonly<z.ZodObject<{
+    capabilities: z.ZodRecord<z.ZodEnum<{
+        "pi.hooks.command": "pi.hooks.command";
+        "pi.mcp.elicitation.form": "pi.mcp.elicitation.form";
+        "pi.mcp.elicitation.url": "pi.mcp.elicitation.url";
+        "pi.mcp.oauth.authorization-code": "pi.mcp.oauth.authorization-code";
+        "pi.mcp.oauth.client-credentials": "pi.mcp.oauth.client-credentials";
+        "pi.mcp.resources": "pi.mcp.resources";
+        "pi.mcp.runtime": "pi.mcp.runtime";
+        "pi.mcp.sampling": "pi.mcp.sampling";
+        "pi.mcp.tool-approval": "pi.mcp.tool-approval";
+        "pi.mcp.transport.stdio": "pi.mcp.transport.stdio";
+        "pi.mcp.transport.streamable-http": "pi.mcp.transport.streamable-http";
+        "pi.skill.allowed-tools": "pi.skill.allowed-tools";
+        "pi.subagents.lifecycle-interception": "pi.subagents.lifecycle-interception";
+        "platform.shell.bash": "platform.shell.bash";
+        "platform.shell.powershell": "platform.shell.powershell";
+    }>, z.ZodReadonly<z.ZodObject<{
+        status: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+        explanation: z.ZodString;
+    }, z.core.$strict>>>;
+    capturedBy: z.ZodString;
+}, z.core.$strict>>;
+export type RuntimeCapabilitySnapshot = z.infer<typeof RuntimeCapabilitySnapshotSchema>;
+export type CompatibilityPolicySurface = "skill" | "hook" | "mcp-server" | "foreign" | "configuration" | "marketplace" | "report";
+export type CompatibilityPolicyDisposition = "supported" | "metadata-only" | "incompatible";
+export type CompatibilityPolicyRule = Readonly<{
+    id: string;
+    surface: CompatibilityPolicySurface;
+    disposition: CompatibilityPolicyDisposition;
+    requirementCapabilityIds: readonly RuntimeCapabilityId[];
+    diagnosticCode?: ErrorCode | undefined;
+    message: string;
+    rank: number;
+}>;
+/**
+ * All compatibility knowledge is data in this registry.  Evaluator dispatch,
+ * capability references, diagnostic messages, and contract tables consume the
+ * sections below instead of keeping switch-local semantic lists.
+ */
+export declare const CompatibilityPolicyRegistry: {
+    readonly skills: {
+        readonly core: {
+            readonly id: "skill.core";
+            readonly surface: "skill";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Agent Skill name and description are supported";
+            readonly rank: 10;
+        };
+        readonly presentation: {
+            readonly id: "skill.presentation";
+            readonly surface: "skill";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Skill presentation metadata is retained as metadata only";
+            readonly rank: 20;
+        };
+        readonly disableModelInvocation: {
+            readonly id: "skill.disable-model-invocation";
+            readonly surface: "skill";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Skill invocation visibility is representable by Pi";
+            readonly rank: 30;
+        };
+        readonly codexPresentation: {
+            readonly id: "skill.codex-presentation";
+            readonly surface: "skill";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Codex skill presentation metadata is retained as metadata only";
+            readonly rank: 40;
+        };
+        readonly codexInvocationPolicy: {
+            readonly id: "skill.codex-invocation-policy";
+            readonly surface: "skill";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "The Codex implicit-invocation policy is representable by Pi";
+            readonly rank: 50;
+        };
+        readonly allowedTools: {
+            readonly id: "skill.allowed-tools";
+            readonly surface: "skill";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.skill.allowed-tools"];
+            readonly message: "Pi preserves the skill allowed-tools restriction";
+            readonly rank: 60;
+        };
+        readonly scopedHooks: {
+            readonly id: "skill.scoped-hooks";
+            readonly surface: "skill";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Skill-scoped hooks have no faithful Pi activation boundary; the skill activates without them";
+            readonly rank: 70;
+        };
+        readonly unknownFrontmatter: {
+            readonly id: "skill.unknown-frontmatter";
+            readonly surface: "skill";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Unknown skill frontmatter is retained as metadata only";
+            readonly rank: 80;
+        };
+        readonly presentationKeys: readonly ["description", "license", "compatibility", "metadata"];
+        readonly invocationPolicyKeys: readonly ["allow_implicit_invocation", "allowImplicitInvocation", "implicit_invocation", "implicitInvocation", "default_mode", "defaultMode", "policy"];
+        readonly invocationPolicyValues: readonly ["always", "never", "manual", "implicit", "explicit"];
+        readonly metadataPrefixes: readonly ["agent-skills", "codex.agents"];
+    };
+    readonly hookHandlers: {
+        readonly command: {
+            readonly id: "hook.command";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.hooks.command"];
+            readonly message: "Command hook execution is available through Pi";
+            readonly rank: 10;
+        };
+        readonly statusMessage: {
+            readonly id: "hook.status-message";
+            readonly surface: "hook";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Hook status text affects presentation only";
+            readonly rank: 20;
+        };
+        readonly shellBash: {
+            readonly id: "hook.shell.bash";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["platform.shell.bash"];
+            readonly message: "The hook requires the Bash shell";
+            readonly rank: 30;
+        };
+        readonly shellPowershell: {
+            readonly id: "hook.shell.powershell";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["platform.shell.powershell"];
+            readonly message: "The hook requires the PowerShell shell";
+            readonly rank: 40;
+        };
+        readonly ifRule: {
+            readonly id: "hook.if-rule";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "The hook condition uses Pi's representable condition grammar";
+            readonly rank: 50;
+        };
+        readonly async: {
+            readonly id: "hook.async";
+            readonly surface: "hook";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Asynchronous hook ordering cannot be preserved by Pi; the hook is retained but not activated";
+            readonly rank: 60;
+        };
+        readonly unsupportedHandler: {
+            readonly id: "hook.handler.unsupported";
+            readonly surface: "hook";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "The hook handler type is not a supported command handler; the hook is retained but not activated";
+            readonly rank: 70;
+        };
+        readonly unknownEvent: {
+            readonly id: "hook.event.default-deny";
+            readonly surface: "hook";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Unknown hook events are retained but not activated";
+            readonly rank: 80;
+        };
+        readonly incompatibleEvent: {
+            readonly id: "hook.event.incompatible";
+            readonly surface: "hook";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "The hook event has no faithful Pi lifecycle boundary; the hook is retained but not activated";
+            readonly rank: 90;
+        };
+        readonly supportedEvent: {
+            readonly id: "hook.event.supported";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "The hook event maps to a Pi lifecycle boundary";
+            readonly rank: 100;
+        };
+        readonly subagentEvent: {
+            readonly id: "hook.event.subagent";
+            readonly surface: "hook";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.subagents.lifecycle-interception"];
+            readonly message: "The subagent hook requires lifecycle interception";
+            readonly rank: 110;
+        };
+    };
+    readonly hookEvents: {
+        readonly supported: [import("./hook-runtime-contract.js").OrdinaryHookEvent, ...import("./hook-runtime-contract.js").OrdinaryHookEvent[]];
+        readonly subagent: [import("./hook-runtime-contract.js").SubagentHookEvent, ...import("./hook-runtime-contract.js").SubagentHookEvent[]];
+        readonly incompatible: [import("./hook-runtime-contract.js").IncompatibleHookEvent, ...import("./hook-runtime-contract.js").IncompatibleHookEvent[]];
+        readonly rules: {
+            readonly command: {
+                readonly id: "hook.command";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly ["pi.hooks.command"];
+                readonly message: "Command hook execution is available through Pi";
+                readonly rank: 10;
+            };
+            readonly statusMessage: {
+                readonly id: "hook.status-message";
+                readonly surface: "hook";
+                readonly disposition: "metadata-only";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "Hook status text affects presentation only";
+                readonly rank: 20;
+            };
+            readonly shellBash: {
+                readonly id: "hook.shell.bash";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly ["platform.shell.bash"];
+                readonly message: "The hook requires the Bash shell";
+                readonly rank: 30;
+            };
+            readonly shellPowershell: {
+                readonly id: "hook.shell.powershell";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly ["platform.shell.powershell"];
+                readonly message: "The hook requires the PowerShell shell";
+                readonly rank: 40;
+            };
+            readonly ifRule: {
+                readonly id: "hook.if-rule";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "The hook condition uses Pi's representable condition grammar";
+                readonly rank: 50;
+            };
+            readonly async: {
+                readonly id: "hook.async";
+                readonly surface: "hook";
+                readonly disposition: "metadata-only";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "Asynchronous hook ordering cannot be preserved by Pi; the hook is retained but not activated";
+                readonly rank: 60;
+            };
+            readonly unsupportedHandler: {
+                readonly id: "hook.handler.unsupported";
+                readonly surface: "hook";
+                readonly disposition: "metadata-only";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "The hook handler type is not a supported command handler; the hook is retained but not activated";
+                readonly rank: 70;
+            };
+            readonly unknownEvent: {
+                readonly id: "hook.event.default-deny";
+                readonly surface: "hook";
+                readonly disposition: "metadata-only";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "Unknown hook events are retained but not activated";
+                readonly rank: 80;
+            };
+            readonly incompatibleEvent: {
+                readonly id: "hook.event.incompatible";
+                readonly surface: "hook";
+                readonly disposition: "metadata-only";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "The hook event has no faithful Pi lifecycle boundary; the hook is retained but not activated";
+                readonly rank: 90;
+            };
+            readonly supportedEvent: {
+                readonly id: "hook.event.supported";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly [];
+                readonly message: "The hook event maps to a Pi lifecycle boundary";
+                readonly rank: 100;
+            };
+            readonly subagentEvent: {
+                readonly id: "hook.event.subagent";
+                readonly surface: "hook";
+                readonly disposition: "supported";
+                readonly requirementCapabilityIds: readonly ["pi.subagents.lifecycle-interception"];
+                readonly message: "The subagent hook requires lifecycle interception";
+                readonly rank: 110;
+            };
+        };
+        readonly metadata: {
+            readonly prefixes: readonly ["handler", "group", "claude.hook", "codex.hook"];
+            readonly statusMessage: readonly ["statusMessage", "status_message", "statusText"];
+            readonly shell: readonly ["shell"];
+            readonly async: readonly ["async", "asyncRewake"];
+            readonly ifRule: readonly ["if", "conditions"];
+        };
+        readonly conditionFields: readonly ["tool_name", "tool_input", "tool_response", "hook_event_name"];
+        readonly conditionOperators: readonly ["contains" | "equals" | "in" | "matches" | "regex", ...("contains" | "equals" | "in" | "matches" | "regex")[]];
+        readonly conditionOperatorDefinitions: Readonly<{
+            readonly equals: "primitive";
+            readonly contains: "string";
+            readonly matches: "string";
+            readonly regex: "string";
+            readonly in: "primitive-array";
+        }>;
+        readonly conditionPredicateKeys: readonly ["field", "operator", "value"];
+        readonly conditionWrapperKeys: readonly ["if"];
+        readonly definitions: Readonly<{
+            readonly SessionStart: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["session_start", "session_compact"];
+                readonly matcher: "session-source";
+                readonly rank: 10;
+                readonly conditionFields: readonly [];
+            };
+            readonly SessionEnd: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["session_shutdown"];
+                readonly matcher: "none";
+                readonly rank: 20;
+                readonly conditionFields: readonly [];
+            };
+            readonly UserPromptSubmit: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["input"];
+                readonly matcher: "none";
+                readonly rank: 30;
+                readonly conditionFields: readonly [];
+            };
+            readonly PreToolUse: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["tool_call"];
+                readonly matcher: "tool";
+                readonly rank: 40;
+                readonly conditionFields: readonly ["tool_name", "tool_input", "hook_event_name"];
+            };
+            readonly PostToolUse: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["tool_result"];
+                readonly matcher: "tool";
+                readonly rank: 50;
+                readonly conditionFields: readonly ["tool_name", "tool_input", "tool_response", "hook_event_name"];
+            };
+            readonly PostToolUseFailure: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["tool_result"];
+                readonly matcher: "tool";
+                readonly rank: 60;
+                readonly conditionFields: readonly ["tool_name", "tool_input", "tool_response", "hook_event_name"];
+            };
+            readonly PreCompact: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["session_before_compact"];
+                readonly matcher: "compact-trigger";
+                readonly rank: 70;
+                readonly conditionFields: readonly [];
+            };
+            readonly PostCompact: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["session_compact"];
+                readonly matcher: "compact-trigger";
+                readonly rank: 80;
+                readonly conditionFields: readonly [];
+            };
+            readonly Stop: {
+                readonly owner: "ordinary";
+                readonly piBoundaries: readonly ["agent_settled"];
+                readonly matcher: "none";
+                readonly rank: 90;
+                readonly conditionFields: readonly [];
+            };
+            readonly SubagentStart: {
+                readonly owner: "subagent";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "subagent";
+                readonly rank: 100;
+                readonly conditionFields: readonly [];
+            };
+            readonly SubagentStop: {
+                readonly owner: "subagent";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "subagent";
+                readonly rank: 110;
+                readonly conditionFields: readonly [];
+            };
+            readonly PermissionRequest: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 120;
+                readonly conditionFields: readonly [];
+            };
+            readonly PermissionDenied: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 121;
+                readonly conditionFields: readonly [];
+            };
+            readonly Setup: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 122;
+                readonly conditionFields: readonly [];
+            };
+            readonly UserPromptExpansion: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 123;
+                readonly conditionFields: readonly [];
+            };
+            readonly PostToolBatch: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 124;
+                readonly conditionFields: readonly [];
+            };
+            readonly Notification: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 125;
+                readonly conditionFields: readonly [];
+            };
+            readonly MessageDisplay: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 126;
+                readonly conditionFields: readonly [];
+            };
+            readonly TaskCreated: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 127;
+                readonly conditionFields: readonly [];
+            };
+            readonly TaskCompleted: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 128;
+                readonly conditionFields: readonly [];
+            };
+            readonly StopFailure: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 129;
+                readonly conditionFields: readonly [];
+            };
+            readonly TeammateIdle: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 130;
+                readonly conditionFields: readonly [];
+            };
+            readonly InstructionsLoaded: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 131;
+                readonly conditionFields: readonly [];
+            };
+            readonly ConfigChange: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 132;
+                readonly conditionFields: readonly [];
+            };
+            readonly CwdChanged: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 133;
+                readonly conditionFields: readonly [];
+            };
+            readonly FileChanged: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 134;
+                readonly conditionFields: readonly [];
+            };
+            readonly WorktreeCreate: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 135;
+                readonly conditionFields: readonly [];
+            };
+            readonly WorktreeRemove: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 136;
+                readonly conditionFields: readonly [];
+            };
+            readonly Elicitation: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 137;
+                readonly conditionFields: readonly [];
+            };
+            readonly ElicitationResult: {
+                readonly owner: "incompatible";
+                readonly piBoundaries: readonly [];
+                readonly matcher: "none";
+                readonly rank: 138;
+                readonly conditionFields: readonly [];
+            };
+        }>;
+    };
+    readonly mcp: {
+        readonly transportStdio: {
+            readonly id: "mcp.transport.stdio";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.runtime", "pi.mcp.transport.stdio"];
+            readonly message: "MCP standard-I/O transport is supported";
+            readonly rank: 10;
+        };
+        readonly transportStreamableHttp: {
+            readonly id: "mcp.transport.streamable-http";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.runtime", "pi.mcp.transport.streamable-http"];
+            readonly message: "MCP Streamable HTTP transport is supported";
+            readonly rank: 20;
+        };
+        readonly transportSecurity: {
+            readonly id: "mcp.transport.security";
+            readonly surface: "mcp-server";
+            readonly disposition: "incompatible";
+            readonly requirementCapabilityIds: readonly [];
+            readonly diagnosticCode: "UNSUPPORTED_DECLARATION";
+            readonly message: "MCP credentials require HTTPS; plaintext HTTP is limited to exact unauthenticated loopback consent";
+            readonly rank: 25;
+        };
+        readonly transportSse: {
+            readonly id: "mcp.transport.sse";
+            readonly surface: "mcp-server";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Legacy MCP SSE transport has no faithful runtime capability; the server is retained but not activated";
+            readonly rank: 30;
+        };
+        readonly transportWebsocket: {
+            readonly id: "mcp.transport.websocket";
+            readonly surface: "mcp-server";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "MCP WebSocket transport is not supported; the server is retained but not activated";
+            readonly rank: 40;
+        };
+        readonly oauthAuthorizationCode: {
+            readonly id: "mcp.oauth.authorization-code";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.runtime", "pi.mcp.oauth.authorization-code"];
+            readonly message: "MCP authorization-code OAuth is supported by the selected runtime";
+            readonly rank: 50;
+        };
+        readonly oauthClientCredentials: {
+            readonly id: "mcp.oauth.client-credentials";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.runtime", "pi.mcp.oauth.client-credentials"];
+            readonly message: "MCP client-credentials OAuth is supported by the selected runtime";
+            readonly rank: 60;
+        };
+        readonly featuresCore: {
+            readonly id: "mcp.features.core";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.runtime"];
+            readonly message: "MCP core configuration features are supported";
+            readonly rank: 70;
+        };
+        readonly featureResources: {
+            readonly id: "mcp.feature.resources";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.resources"];
+            readonly message: "MCP resource access is supported by the selected runtime";
+            readonly rank: 75;
+        };
+        readonly featureToolApproval: {
+            readonly id: "mcp.feature.tool-approval";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.tool-approval"];
+            readonly message: "MCP tool approval policy is supported by the selected runtime";
+            readonly rank: 80;
+        };
+        readonly featureSampling: {
+            readonly id: "mcp.feature.sampling";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.sampling"];
+            readonly message: "MCP sampling is supported by the selected runtime";
+            readonly rank: 90;
+        };
+        readonly featureElicitationForm: {
+            readonly id: "mcp.feature.elicitation-form";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.elicitation.form"];
+            readonly message: "MCP form elicitation is supported by the selected runtime";
+            readonly rank: 100;
+        };
+        readonly featureElicitationUrl: {
+            readonly id: "mcp.feature.elicitation-url";
+            readonly surface: "mcp-server";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly ["pi.mcp.elicitation.url"];
+            readonly message: "MCP URL elicitation is supported by the selected runtime";
+            readonly rank: 110;
+        };
+        readonly headersHelper: {
+            readonly id: "mcp.headers-helper";
+            readonly surface: "mcp-server";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Dynamic MCP header helpers have no faithful runtime capability; the server is retained but not activated";
+            readonly rank: 120;
+        };
+        readonly channels: {
+            readonly id: "mcp.channels";
+            readonly surface: "mcp-server";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Claude MCP channels are not a supported Pi runtime surface; the declaration is retained as metadata only";
+            readonly rank: 130;
+        };
+        readonly defaultDeny: {
+            readonly id: "mcp.default-deny";
+            readonly surface: "mcp-server";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Unknown MCP transport, authentication, feature, or key is retained but not activated";
+            readonly rank: 140;
+        };
+        readonly keys: {
+            readonly transport: "transport";
+            readonly transportValues: readonly ["stdio", "streamable-http", "sse", "websocket"];
+            readonly typeValues: readonly ["stdio", "streamable-http", "http", "sse", "websocket"];
+            readonly transportAliases: {
+                readonly http: "streamable-http";
+            };
+            readonly fieldGroups: {
+                readonly transport: {
+                    readonly target: "transport";
+                    readonly aliases: readonly ["transport", "type"];
+                    readonly unit: "transport";
+                    readonly collision: "canonical-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly command: {
+                    readonly target: "launch.command";
+                    readonly aliases: readonly ["command"];
+                    readonly unit: "non-empty-string";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio"];
+                };
+                readonly arguments: {
+                    readonly target: "launch.arguments";
+                    readonly aliases: readonly ["args"];
+                    readonly unit: "string-array";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio"];
+                };
+                readonly environment: {
+                    readonly target: "launch.environment";
+                    readonly aliases: readonly ["env"];
+                    readonly unit: "string-record";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio"];
+                };
+                readonly workingDirectory: {
+                    readonly target: "launch.workingDirectory";
+                    readonly aliases: readonly ["cwd", "workingDirectory"];
+                    readonly unit: "string";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio"];
+                };
+                readonly url: {
+                    readonly target: "launch.url";
+                    readonly aliases: readonly ["url"];
+                    readonly unit: "transport-url";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["streamable-http", "sse", "websocket"];
+                };
+                readonly headers: {
+                    readonly target: "launch.headers";
+                    readonly aliases: readonly ["headers", "features.headers"];
+                    readonly unit: "headers";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["streamable-http", "sse", "websocket"];
+                };
+                readonly authentication: {
+                    readonly target: "options.auth";
+                    readonly aliases: readonly ["auth", "oauth", "authentication", "bearerTokenEnv", "features.oauth"];
+                    readonly externalBearerAlias: "bearerTokenEnv";
+                    readonly unit: "authentication-mode";
+                    readonly collision: "coherent-single-mode";
+                    readonly transports: readonly ["streamable-http", "sse", "websocket"];
+                };
+                readonly startupTimeout: {
+                    readonly target: "options.startupTimeoutMs";
+                    readonly aliases: readonly ["startupTimeout", "timeoutMs"];
+                    readonly unit: "milliseconds";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly toolTimeout: {
+                    readonly target: "options.toolTimeoutMs";
+                    readonly aliases: readonly ["toolTimeout", "timeout"];
+                    readonly unit: "milliseconds";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly tools: {
+                    readonly target: "options.tools";
+                    readonly aliases: readonly ["tools"];
+                    readonly unit: "direct-tools-or-map";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly allowedTools: {
+                    readonly target: "options.allowedTools";
+                    readonly aliases: readonly ["allowTools", "allowedTools", "tools.allow"];
+                    readonly unit: "exact-string-set";
+                    readonly collision: "set-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly deniedTools: {
+                    readonly target: "options.deniedTools";
+                    readonly aliases: readonly ["denyTools", "disabledTools", "tools.deny"];
+                    readonly unit: "exact-string-set";
+                    readonly collision: "set-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly instructions: {
+                    readonly target: "options.instructions";
+                    readonly aliases: readonly ["instructions"];
+                    readonly unit: "string";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly resources: {
+                    readonly target: "options.resources";
+                    readonly aliases: readonly ["resources"];
+                    readonly unit: "resources";
+                    readonly collision: "exact-equality";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly toolApproval: {
+                    readonly target: "options.toolApproval";
+                    readonly aliases: readonly ["toolApproval", "tool_approval", "features.toolApproval", "features.tool_approval"];
+                    readonly unit: "boolean-flags";
+                    readonly collision: "reject-duplicates";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly sampling: {
+                    readonly target: "options.sampling";
+                    readonly aliases: readonly ["sampling", "features.sampling"];
+                    readonly unit: "boolean-flags";
+                    readonly collision: "reject-duplicates";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly elicitation: {
+                    readonly target: "options.elicitation";
+                    readonly aliases: readonly ["elicitation", "features.elicitation"];
+                    readonly unit: "elicitation-flags";
+                    readonly collision: "reject-duplicates";
+                    readonly transports: readonly ["stdio", "streamable-http", "sse", "websocket"];
+                };
+                readonly headersHelper: {
+                    readonly target: "unsupported.headersHelper";
+                    readonly aliases: readonly ["headersHelper"];
+                    readonly unit: "unsupported";
+                    readonly collision: "reject-duplicates";
+                    readonly transports: readonly ["streamable-http", "sse", "websocket"];
+                };
+                readonly channels: {
+                    readonly target: "unsupported.channels";
+                    readonly aliases: readonly ["channels"];
+                    readonly unit: "unsupported";
+                    readonly collision: "reject-duplicates";
+                    readonly transports: readonly ["streamable-http", "sse", "websocket"];
+                };
+            };
+            readonly type: "type";
+            readonly command: "command";
+            readonly args: "args";
+            readonly env: "env";
+            readonly cwd: "cwd";
+            readonly workingDirectory: "workingDirectory";
+            readonly url: "url";
+            readonly headers: "headers";
+            readonly bearerTokenEnv: "bearerTokenEnv";
+            readonly auth: "auth";
+            readonly oauth: "oauth";
+            readonly authentication: "authentication";
+            readonly timeout: "timeout";
+            readonly startupTimeout: "startupTimeout";
+            readonly toolTimeout: "toolTimeout";
+            readonly timeoutMs: "timeoutMs";
+            readonly allowTools: "allowTools";
+            readonly allowedTools: "allowedTools";
+            readonly denyTools: "denyTools";
+            readonly disabledTools: "disabledTools";
+            readonly tools: "tools";
+            readonly instructions: "instructions";
+            readonly resources: "resources";
+            readonly toolApproval: "toolApproval";
+            readonly tool_approval: "tool_approval";
+            readonly sampling: "sampling";
+            readonly elicitation: "elicitation";
+            readonly features: "features";
+            readonly featureValues: readonly ["tool-approval", "sampling", "elicitation-form", "elicitation-url"];
+            readonly featurePayloadDefinitions: {
+                readonly toolApproval: {
+                    readonly fieldGroup: "toolApproval";
+                    readonly shape: "boolean-flags";
+                    readonly ruleId: "mcp.feature.tool-approval";
+                };
+                readonly sampling: {
+                    readonly fieldGroup: "sampling";
+                    readonly shape: "boolean-flags";
+                    readonly ruleId: "mcp.feature.sampling";
+                };
+                readonly elicitation: {
+                    readonly fieldGroup: "elicitation";
+                    readonly shape: "elicitation-flags";
+                    readonly ruleId: "mcp.feature.elicitation-form";
+                };
+            };
+            readonly oauthGrantTypes: ("authorization-code" | "authorizationCode" | "authorization_code" | "client-credentials" | "clientCredentials" | "client_credentials")[];
+            readonly oauthFlowDefinitions: {
+                readonly authorizationCode: {
+                    readonly aliases: readonly ["authorization-code", "authorization_code", "authorizationCode"];
+                    readonly ruleId: "mcp.oauth.authorization-code";
+                };
+                readonly clientCredentials: {
+                    readonly aliases: readonly ["client-credentials", "client_credentials", "clientCredentials"];
+                    readonly ruleId: "mcp.oauth.client-credentials";
+                };
+            };
+            readonly authSelectorDefinitions: {
+                readonly modeKeys: readonly ["type", "mode"];
+                readonly modes: {
+                    readonly none: {
+                        readonly aliases: readonly ["none"];
+                    };
+                    readonly bearer: {
+                        readonly aliases: readonly ["bearer", "bearer-env"];
+                    };
+                    readonly oauth: {
+                        readonly aliases: readonly ["oauth"];
+                    };
+                };
+                readonly oauthFlowKeys: readonly ["grantType", "grant_type", "flow"];
+                readonly oauthBooleanFlowKeys: readonly ["authorizationCode", "authorization_code", "clientCredentials", "client_credentials"];
+                readonly bearerEnvironmentKeys: readonly ["env"];
+                readonly oauthParameterKeys: readonly ["clientId", "client_id", "redirectUri", "redirect_uri"];
+            };
+            readonly authKeys: readonly ["type", "mode", "env", "clientId", "client_id", "redirectUri", "redirect_uri", "grantType", "grant_type", "flow", "authorizationCode", "authorization_code", "clientCredentials", "client_credentials"];
+            readonly booleanFeatureKeys: readonly ["enabled", "required"];
+            readonly elicitationFeatureKeys: readonly ["form", "url"];
+            readonly headerEnvironmentKeys: readonly ["env"];
+            readonly headersHelper: "headersHelper";
+            readonly channels: "channels";
+        };
+    };
+    readonly foreign: {
+        readonly defaultDeny: {
+            readonly id: "foreign.default-deny";
+            readonly surface: "foreign";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Foreign runtime components are retained as metadata only and are never executed";
+            readonly rank: 10;
+        };
+        readonly piExtension: {
+            readonly id: "foreign.pi-extension";
+            readonly surface: "foreign";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "This plugin ships a Pi extension (tools/commands). This host doesn't run plugin extensions, so those won't register — install the plugin pi-natively to use them";
+            readonly rank: 10;
+        };
+    };
+    readonly configuration: {
+        readonly descriptor: {
+            readonly id: "configuration.descriptor";
+            readonly surface: "configuration";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Configuration descriptors are advisory input for downstream lifecycle services";
+            readonly rank: 10;
+        };
+        readonly requiredInput: {
+            readonly id: "configuration.required-input";
+            readonly surface: "configuration";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Configuration input is required downstream before activation";
+            readonly rank: 20;
+        };
+        readonly sensitive: {
+            readonly id: "configuration.sensitive";
+            readonly surface: "configuration";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Sensitive configuration must be supplied through the secret boundary";
+            readonly rank: 30;
+        };
+    };
+    readonly marketplace: {
+        readonly availabilityAvailable: {
+            readonly id: "marketplace.availability.available";
+            readonly surface: "marketplace";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Marketplace availability is advisory context; lifecycle policy decides installability";
+            readonly rank: 10;
+        };
+        readonly availabilityInstalledByDefault: {
+            readonly id: "marketplace.availability.installed-by-default";
+            readonly surface: "marketplace";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Marketplace installed-by-default policy is advisory context";
+            readonly rank: 20;
+        };
+        readonly availabilityNotAvailable: {
+            readonly id: "marketplace.availability.not-available";
+            readonly surface: "marketplace";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Marketplace not-available policy is advisory context; it does not alter compatibility";
+            readonly rank: 30;
+        };
+        readonly policy: {
+            readonly id: "marketplace.policy";
+            readonly surface: "marketplace";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Marketplace authentication and installation policy is lifecycle context";
+            readonly rank: 40;
+        };
+    };
+    readonly report: {
+        readonly verdictRegistry: {
+            readonly id: "verdict.registry";
+            readonly surface: "report";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Compatibility reports use exactly the supported verdict vocabulary";
+            readonly rank: 10;
+        };
+        readonly requirementSeparateStatus: {
+            readonly id: "requirement.separate-status";
+            readonly surface: "report";
+            readonly disposition: "supported";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Runtime requirement availability is separate from component verdicts";
+            readonly rank: 20;
+        };
+        readonly metadataOnly: {
+            readonly id: "verdict.metadata-only";
+            readonly surface: "report";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Presentation-only metadata does not block activation";
+            readonly rank: 30;
+        };
+        readonly incompatible: {
+            readonly id: "verdict.incompatible";
+            readonly surface: "report";
+            readonly disposition: "incompatible";
+            readonly requirementCapabilityIds: readonly [];
+            readonly diagnosticCode: "UNSUPPORTED_DECLARATION";
+            readonly message: "An incompatible component blocks complete-plugin activation";
+            readonly rank: 40;
+        };
+        readonly knownPresentation: {
+            readonly id: "metadata.known-presentation";
+            readonly surface: "report";
+            readonly disposition: "metadata-only";
+            readonly requirementCapabilityIds: readonly [];
+            readonly message: "Known plugin presentation metadata is retained without runtime meaning";
+            readonly rank: 50;
+        };
+    };
+    readonly metadata: {
+        readonly knownPluginPresentationKeys: readonly ["owner", "description", "category", "tags", "interface", "visibility"];
+    };
+};
+export type CompatibilityPolicyRegistryType = typeof CompatibilityPolicyRegistry;
+export declare const CompatibilityPolicyRuleRegistry: Readonly<Record<string, CompatibilityPolicyRule>>;
+export declare const CompatibilityPolicyRuleSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    surface: z.ZodEnum<{
+        configuration: "configuration";
+        foreign: "foreign";
+        hook: "hook";
+        marketplace: "marketplace";
+        "mcp-server": "mcp-server";
+        report: "report";
+        skill: "skill";
+    }>;
+    disposition: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+    }>;
+    requirementCapabilityIds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "pi.hooks.command": "pi.hooks.command";
+        "pi.mcp.elicitation.form": "pi.mcp.elicitation.form";
+        "pi.mcp.elicitation.url": "pi.mcp.elicitation.url";
+        "pi.mcp.oauth.authorization-code": "pi.mcp.oauth.authorization-code";
+        "pi.mcp.oauth.client-credentials": "pi.mcp.oauth.client-credentials";
+        "pi.mcp.resources": "pi.mcp.resources";
+        "pi.mcp.runtime": "pi.mcp.runtime";
+        "pi.mcp.sampling": "pi.mcp.sampling";
+        "pi.mcp.tool-approval": "pi.mcp.tool-approval";
+        "pi.mcp.transport.stdio": "pi.mcp.transport.stdio";
+        "pi.mcp.transport.streamable-http": "pi.mcp.transport.streamable-http";
+        "pi.skill.allowed-tools": "pi.skill.allowed-tools";
+        "pi.subagents.lifecycle-interception": "pi.subagents.lifecycle-interception";
+        "platform.shell.bash": "platform.shell.bash";
+        "platform.shell.powershell": "platform.shell.powershell";
+    }>>>;
+    diagnosticCode: 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";
+    }>>;
+    message: z.ZodString;
+    rank: z.ZodNumber;
+}, z.core.$strict>>;
+export declare const CompatibilityPolicyRulesSchema: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    surface: z.ZodEnum<{
+        configuration: "configuration";
+        foreign: "foreign";
+        hook: "hook";
+        marketplace: "marketplace";
+        "mcp-server": "mcp-server";
+        report: "report";
+        skill: "skill";
+    }>;
+    disposition: z.ZodEnum<{
+        incompatible: "incompatible";
+        "metadata-only": "metadata-only";
+        supported: "supported";
+    }>;
+    requirementCapabilityIds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "pi.hooks.command": "pi.hooks.command";
+        "pi.mcp.elicitation.form": "pi.mcp.elicitation.form";
+        "pi.mcp.elicitation.url": "pi.mcp.elicitation.url";
+        "pi.mcp.oauth.authorization-code": "pi.mcp.oauth.authorization-code";
+        "pi.mcp.oauth.client-credentials": "pi.mcp.oauth.client-credentials";
+        "pi.mcp.resources": "pi.mcp.resources";
+        "pi.mcp.runtime": "pi.mcp.runtime";
+        "pi.mcp.sampling": "pi.mcp.sampling";
+        "pi.mcp.tool-approval": "pi.mcp.tool-approval";
+        "pi.mcp.transport.stdio": "pi.mcp.transport.stdio";
+        "pi.mcp.transport.streamable-http": "pi.mcp.transport.streamable-http";
+        "pi.skill.allowed-tools": "pi.skill.allowed-tools";
+        "pi.subagents.lifecycle-interception": "pi.subagents.lifecycle-interception";
+        "platform.shell.bash": "platform.shell.bash";
+        "platform.shell.powershell": "platform.shell.powershell";
+    }>>>;
+    diagnosticCode: 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";
+    }>>;
+    message: z.ZodString;
+    rank: z.ZodNumber;
+}, z.core.$strict>>>>;
+export declare const RuntimeCapabilityRegistrySchema: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodObject<{
+    id: z.ZodEnum<{
+        "pi.hooks.command": "pi.hooks.command";
+        "pi.mcp.elicitation.form": "pi.mcp.elicitation.form";
+        "pi.mcp.elicitation.url": "pi.mcp.elicitation.url";
+        "pi.mcp.oauth.authorization-code": "pi.mcp.oauth.authorization-code";
+        "pi.mcp.oauth.client-credentials": "pi.mcp.oauth.client-credentials";
+        "pi.mcp.resources": "pi.mcp.resources";
+        "pi.mcp.runtime": "pi.mcp.runtime";
+        "pi.mcp.sampling": "pi.mcp.sampling";
+        "pi.mcp.tool-approval": "pi.mcp.tool-approval";
+        "pi.mcp.transport.stdio": "pi.mcp.transport.stdio";
+        "pi.mcp.transport.streamable-http": "pi.mcp.transport.streamable-http";
+        "pi.skill.allowed-tools": "pi.skill.allowed-tools";
+        "pi.subagents.lifecycle-interception": "pi.subagents.lifecycle-interception";
+        "platform.shell.bash": "platform.shell.bash";
+        "platform.shell.powershell": "platform.shell.powershell";
+    }>;
+    description: z.ZodString;
+    rank: z.ZodNumber;
+}, z.core.$strict>>>>;
+export type HookEvent = (typeof CompatibilityPolicyRegistry.hookEvents.supported)[number] | (typeof CompatibilityPolicyRegistry.hookEvents.subagent)[number] | (typeof CompatibilityPolicyRegistry.hookEvents.incompatible)[number];
+export declare const HookEventSchema: z.ZodEnum<{
+    ConfigChange: "ConfigChange";
+    CwdChanged: "CwdChanged";
+    Elicitation: "Elicitation";
+    ElicitationResult: "ElicitationResult";
+    FileChanged: "FileChanged";
+    InstructionsLoaded: "InstructionsLoaded";
+    MessageDisplay: "MessageDisplay";
+    Notification: "Notification";
+    PermissionDenied: "PermissionDenied";
+    PermissionRequest: "PermissionRequest";
+    PostCompact: "PostCompact";
+    PostToolBatch: "PostToolBatch";
+    PostToolUse: "PostToolUse";
+    PostToolUseFailure: "PostToolUseFailure";
+    PreCompact: "PreCompact";
+    PreToolUse: "PreToolUse";
+    SessionEnd: "SessionEnd";
+    SessionStart: "SessionStart";
+    Setup: "Setup";
+    Stop: "Stop";
+    StopFailure: "StopFailure";
+    SubagentStart: "SubagentStart";
+    SubagentStop: "SubagentStop";
+    TaskCompleted: "TaskCompleted";
+    TaskCreated: "TaskCreated";
+    TeammateIdle: "TeammateIdle";
+    UserPromptExpansion: "UserPromptExpansion";
+    UserPromptSubmit: "UserPromptSubmit";
+    WorktreeCreate: "WorktreeCreate";
+    WorktreeRemove: "WorktreeRemove";
+}>;
+export declare const MCPTransportSchema: z.ZodEnum<{
+    sse: "sse";
+    stdio: "stdio";
+    "streamable-http": "streamable-http";
+    websocket: "websocket";
+}>;
+export type MCPTransport = z.infer<typeof MCPTransportSchema>;
+export declare const MCPFeatureSchema: z.ZodEnum<{
+    "elicitation-form": "elicitation-form";
+    "elicitation-url": "elicitation-url";
+    sampling: "sampling";
+    "tool-approval": "tool-approval";
+}>;
+export type MCPFeature = z.infer<typeof MCPFeatureSchema>;
+export declare const RuntimeCapabilityStatusRegistry: {
+    readonly available: {
+        readonly tag: "available";
+        readonly blocksActivation: false;
+    };
+    readonly unavailable: {
+        readonly tag: "unavailable";
+        readonly blocksActivation: true;
+    };
+};
+export declare const RuntimeCapabilityStatusSchema: z.ZodEnum<{
+    available: "available";
+    unavailable: "unavailable";
+}>;