@agentxm/extension-model 0.28.4-bootstrap.0

package/dist/src/unstable/agent-capabilities/schema.d.ts

@@ -0,0 +1,3788 @@
+/**
+ * Agent capability catalog schemas.
+ *
+ * Sourcing namespaces:
+ *
+ * - `native` is the vendor-authoritative fact layer: whether the agent exposes
+ *   the surface, which standard or convention it follows, where config lives,
+ *   and the source URLs used to verify that claim.
+ * - `axm` is AXM integration state: whether AXM has modeled support, whether a
+ *   writer exists, the writer metadata needed by AXM, and AXM-owned backlog or
+ *   unsupported reasons. These fields are not vendor facts.
+ * - `canonical` is a derived, vendor-neutral vocabulary. Hook event/tool
+ *   mappings store canonical IDs beside native names, but the catalog does not
+ *   store a per-agent canonical capability block.
+ *
+ * Status axes:
+ *
+ * - `AgentLifecycle` describes the coding agent product itself.
+ * - `VendorStatus` describes the vendor or plugin surface named by
+ *   `Availability`.
+ * - `Availability` describes whether the surface is native, plugin-backed, or
+ *   absent.
+ * - AXM support/writer state lives under `axm.status` and `axm.writer`;
+ *   `axm.writer !== null` means AXM has verified write mechanics for that
+ *   capability.
+ *
+ * `capabilities` is keyed on the placement axis: exactly the extension types
+ * `EXTENSION_TYPE_TABLE` marks `placement: "per-agent"`, because only those
+ * render into a directory the agent owns. Two sibling fields sit beside it
+ * rather than inside it:
+ *
+ * - `instructions` carries the `rule` capability. Rules are `placement:
+ *   "workspace"` — they live in shared instruction files that every configured
+ *   agent reads — so the catalog records how each agent consumes that shared
+ *   file, not an agent-owned slot. The field name is the type's
+ *   `workspaceCapability` axis value.
+ * - `permissions` models AXM grant/write mechanics for an agent's permission
+ *   system. It is not a publishable extension type at all.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { type PerAgentType } from "../extensions/common.js";
+export { DocLinkSchema, LEAF_EXTENSION_TYPES, StandardSchema, UrlSchema, type DocLink, type LeafExtensionType, type Standard, type Url, } from "../extension-types/schema.js";
+export { type PerAgentType } from "../extensions/common.js";
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentIdFromYamlSchema: Schema.NonEmptyString;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentIdFromYaml = Schema.Schema.Type<typeof AgentIdFromYamlSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const StandardsComplianceSchema: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type StandardsCompliance = Schema.Schema.Type<typeof StandardsComplianceSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ConventionSchema: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type Convention = Schema.Schema.Type<typeof ConventionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const SkillReadPathStatusSchema: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type SkillReadPathStatus = Schema.Schema.Type<typeof SkillReadPathStatusSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const SkillReadPathSchema: Schema.Struct<{
+    readonly path: Schema.NonEmptyString;
+    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type SkillReadPath = Schema.Schema.Type<typeof SkillReadPathSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ScopeSchema: Schema.Literals<readonly ["user", "project"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type Scope = Schema.Schema.Type<typeof ScopeSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const SUPPORTED_AXM_SUPPORT: "supported";
+/** @experimental This API is unstable and may change without notice. */
+export declare const AxmSupportSchema: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type AxmSupport = Schema.Schema.Type<typeof AxmSupportSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ActiveAxmSupportSchema: Schema.Literals<readonly ["supported", "planned"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type ActiveAxmSupport = Schema.Schema.Type<typeof ActiveAxmSupportSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const InactiveAxmSupportSchema: Schema.Literals<readonly ["unsupported", "unknown"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type InactiveAxmSupport = Schema.Schema.Type<typeof InactiveAxmSupportSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDistributionMechanismSchema: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDistributionMechanism = Schema.Schema.Type<typeof PluginDistributionMechanismSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDistributionSchema: Schema.Struct<{
+    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDistribution = Schema.Schema.Type<typeof PluginDistributionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDetectionPathSchema: Schema.Struct<{
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly path: Schema.NonEmptyString;
+    readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDetectionPath = Schema.Schema.Type<typeof PluginDetectionPathSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDetectionConfigKeySchema: Schema.Struct<{
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly file: Schema.NonEmptyString;
+    readonly key: Schema.NonEmptyString;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDetectionConfigKey = Schema.Schema.Type<typeof PluginDetectionConfigKeySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDetectionSchema: Schema.Struct<{
+    readonly paths: Schema.$Array<Schema.Struct<{
+        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+        readonly path: Schema.NonEmptyString;
+        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+    }>>;
+    readonly configKeys: Schema.$Array<Schema.Struct<{
+        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+        readonly file: Schema.NonEmptyString;
+        readonly key: Schema.NonEmptyString;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDetection = Schema.Schema.Type<typeof PluginDetectionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PluginDescriptorSchema: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly homepage: Schema.NonEmptyString;
+    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+    readonly distribution: Schema.Struct<{
+        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+    }>;
+    readonly detection: Schema.NullOr<Schema.Struct<{
+        readonly paths: Schema.$Array<Schema.Struct<{
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly path: Schema.NonEmptyString;
+            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+        }>>;
+        readonly configKeys: Schema.$Array<Schema.Struct<{
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly file: Schema.NonEmptyString;
+            readonly key: Schema.NonEmptyString;
+        }>>;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PluginDescriptor = Schema.Schema.Type<typeof PluginDescriptorSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const AvailabilitySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly via: Schema.Literal<"native">;
+}>, Schema.Struct<{
+    readonly via: Schema.Literal<"none">;
+}>, Schema.Struct<{
+    readonly via: Schema.Literal<"plugin">;
+    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+    readonly plugin: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly homepage: Schema.NonEmptyString;
+        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+        readonly distribution: Schema.Struct<{
+            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+        }>;
+        readonly detection: Schema.NullOr<Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+            }>>;
+            readonly configKeys: Schema.$Array<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly file: Schema.NonEmptyString;
+                readonly key: Schema.NonEmptyString;
+            }>>;
+        }>>;
+    }>;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type Availability = Schema.Schema.Type<typeof AvailabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const VendorStatusSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literal<"active">;
+}>, Schema.Struct<{
+    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+    readonly state: Schema.Literal<"maintenance">;
+}>, Schema.Struct<{
+    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+    readonly state: Schema.Literal<"deprecated">;
+}>, Schema.Struct<{
+    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+    readonly state: Schema.Literal<"removed">;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type VendorStatus = Schema.Schema.Type<typeof VendorStatusSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentInterfaceSchema: Schema.Literals<readonly ["cli", "ide-extension", "chat", "hosted-agent"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentInterface = Schema.Schema.Type<typeof AgentInterfaceSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpTransportSchema: Schema.Literals<readonly ["stdio", "http", "sse"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpTransport = Schema.Schema.Type<typeof McpTransportSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DetectionSignalSchema: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type DetectionSignal = Schema.Schema.Type<typeof DetectionSignalSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DetectionMarkerSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"dir">;
+    readonly path: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"file">;
+    readonly path: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"executable">;
+    readonly name: Schema.NonEmptyString;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type DetectionMarker = Schema.Schema.Type<typeof DetectionMarkerSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ScopeDetectionSchema: Schema.Struct<{
+    readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"dir">;
+        readonly path: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"executable">;
+        readonly name: Schema.NonEmptyString;
+    }>]>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type ScopeDetection = Schema.Schema.Type<typeof ScopeDetectionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DetectionSchema: Schema.Struct<{
+    readonly project: Schema.Struct<{
+        readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"dir">;
+            readonly path: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"file">;
+            readonly path: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"executable">;
+            readonly name: Schema.NonEmptyString;
+        }>]>>;
+    }>;
+    readonly user: Schema.Struct<{
+        readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"dir">;
+            readonly path: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"file">;
+            readonly path: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly kind: Schema.Literal<"executable">;
+            readonly name: Schema.NonEmptyString;
+        }>]>>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type Detection = Schema.Schema.Type<typeof DetectionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const LastVerifiedDateSchema: Schema.NonEmptyString;
+/** @experimental This API is unstable and may change without notice. */
+export type LastVerifiedDate = Schema.Schema.Type<typeof LastVerifiedDateSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ProvenanceSchema: Schema.Struct<{
+    sources: Schema.$Array<Schema.NonEmptyString>;
+    lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type Provenance = Schema.Schema.Type<typeof ProvenanceSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const NativeCapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<{
+    availability: Schema.Union<readonly [Schema.Struct<{
+        readonly via: Schema.Literal<"native">;
+    }>, Schema.Struct<{
+        readonly via: Schema.Literal<"plugin">;
+        readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+        readonly plugin: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly homepage: Schema.NonEmptyString;
+            readonly author: Schema.NullOr<Schema.NonEmptyString>;
+            readonly distribution: Schema.Struct<{
+                readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+            readonly detection: Schema.NullOr<Schema.Struct<{
+                readonly paths: Schema.$Array<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                }>>;
+                readonly configKeys: Schema.$Array<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly file: Schema.NonEmptyString;
+                    readonly key: Schema.NonEmptyString;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    vendorStatus: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"active">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"maintenance">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"deprecated">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"removed">;
+    }>]>;
+    notes: Schema.NullOr<Schema.NonEmptyString>;
+    docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    sources: Schema.$Array<Schema.NonEmptyString>;
+    scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+}>, Schema.Struct<{
+    availability: Schema.Struct<{
+        readonly via: Schema.Literal<"none">;
+    }>;
+    vendorStatus: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"active">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"maintenance">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"deprecated">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+        readonly state: Schema.Literal<"removed">;
+    }>]>;
+    notes: Schema.NullOr<Schema.NonEmptyString>;
+    docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    sources: Schema.$Array<Schema.NonEmptyString>;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type NativeCapabilityBase = Schema.Schema.Type<typeof NativeCapabilityBaseSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+        readonly directory: Schema.NonEmptyString;
+        readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+        }>>, never>>;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly convention: Schema.Literal<"hosted">;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type SkillsExtensionCapability = Schema.Schema.Type<typeof SkillsExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+/** @experimental This API is unstable and may change without notice. */
+export declare const SubagentsLayoutSchema: Schema.Literals<readonly ["file", "directory"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type SubagentsLayout = Schema.Schema.Type<typeof SubagentsLayoutSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const SubagentsExtensionCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly availability: Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>;
+        readonly directory: Schema.NonEmptyString;
+        readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly availability: Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type SubagentsExtensionCapability = Schema.Schema.Type<typeof SubagentsExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const RuleInstructionsKindSchema: Schema.Literals<readonly ["agents-md", "own-file", "rules-dir"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type RuleInstructionsKind = Schema.Schema.Type<typeof RuleInstructionsKindSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const RuleInstructionsImportSyntaxSchema: Schema.Literals<readonly ["at-path"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type RuleInstructionsImportSyntax = Schema.Schema.Type<typeof RuleInstructionsImportSyntaxSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const RulesExtensionCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"agents-md">;
+        readonly files: Schema.Tuple<readonly [Schema.Literal<"AGENTS.md">]>;
+        readonly nestedDiscovery: Schema.Boolean;
+        readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+        readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"own-file">;
+        readonly files: Schema.Tuple<readonly [Schema.NonEmptyString]>;
+        readonly nestedDiscovery: Schema.Boolean;
+        readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+        readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"rules-dir">;
+        readonly files: Schema.$Array<Schema.NonEmptyString>;
+        readonly nestedDiscovery: Schema.Boolean;
+        readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+        readonly directory: Schema.NonEmptyString;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Never>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type RulesExtensionCapability = Schema.Schema.Type<typeof RulesExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ConfigFileFormatSchema: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type ConfigFileFormat = Schema.Schema.Type<typeof ConfigFileFormatSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpServersKeySchema: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpServersKey = Schema.Schema.Type<typeof McpServersKeySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpTargetAttributionSchema: Schema.Literals<readonly ["shared", "agent"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpTargetAttribution = Schema.Schema.Type<typeof McpTargetAttributionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpConfigTargetSchema: Schema.Struct<{
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly path: Schema.NonEmptyString;
+    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+    readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpConfigTarget = Schema.Schema.Type<typeof McpConfigTargetSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpTypeFieldValueMapSchema: Schema.Struct<{
+    readonly "streamable-http": Schema.NonEmptyString;
+    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpTypeFieldValueMap = Schema.Schema.Type<typeof McpTypeFieldValueMapSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpTypeFieldRepresentationSchema: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+        readonly "streamable-http": Schema.NonEmptyString;
+        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+    }>]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpTypeFieldRepresentation = Schema.Schema.Type<typeof McpTypeFieldRepresentationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpTypeFieldSchema: Schema.Struct<{
+    readonly required: Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+            readonly "streamable-http": Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+        }>]>;
+    }>>;
+    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+            readonly "streamable-http": Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+        }>]>;
+    }>>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpTypeField = Schema.Schema.Type<typeof McpTypeFieldSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpActivationFieldRepresentationSchema: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly enabled: Schema.Boolean;
+    readonly disabled: Schema.Boolean;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpActivationFieldRepresentation = Schema.Schema.Type<typeof McpActivationFieldRepresentationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpActivationFieldSchema: Schema.Struct<{
+    readonly required: Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly enabled: Schema.Boolean;
+        readonly disabled: Schema.Boolean;
+    }>>;
+    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly enabled: Schema.Boolean;
+        readonly disabled: Schema.Boolean;
+    }>>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpActivationField = Schema.Schema.Type<typeof McpActivationFieldSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpStdioDialectSchema: Schema.Struct<{
+    readonly typeField: Schema.Struct<{
+        readonly required: Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                readonly "streamable-http": Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
+        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                readonly "streamable-http": Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+            }>]>;
+        }>>>;
+    }>;
+    readonly command: Schema.Literals<readonly ["split", "array"]>;
+    readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpStdioDialect = Schema.Schema.Type<typeof McpStdioDialectSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpUrlKeyMapSchema: Schema.Struct<{
+    readonly "streamable-http": Schema.NonEmptyString;
+    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpUrlKeyMap = Schema.Schema.Type<typeof McpUrlKeyMapSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpRemoteDialectSchema: Schema.Struct<{
+    readonly typeField: Schema.Struct<{
+        readonly required: Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                readonly "streamable-http": Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+            }>]>;
+        }>>;
+        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                readonly "streamable-http": Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+            }>]>;
+        }>>>;
+    }>;
+    readonly urlKey: Schema.Struct<{
+        readonly "streamable-http": Schema.NonEmptyString;
+        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+    readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+    readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpRemoteDialect = Schema.Schema.Type<typeof McpRemoteDialectSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpConfigSchema: Schema.Struct<{
+    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+    readonly activationField: Schema.Struct<{
+        readonly required: Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly enabled: Schema.Boolean;
+            readonly disabled: Schema.Boolean;
+        }>>;
+        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly enabled: Schema.Boolean;
+            readonly disabled: Schema.Boolean;
+        }>>>;
+    }>;
+    readonly targets: Schema.$Array<Schema.Struct<{
+        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+        readonly path: Schema.NonEmptyString;
+        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+    }>>;
+    readonly stdio: Schema.NullOr<Schema.Struct<{
+        readonly typeField: Schema.Struct<{
+            readonly required: Schema.NullOr<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                    readonly "streamable-http": Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
+            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                    readonly "streamable-http": Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                }>]>;
+            }>>>;
+        }>;
+        readonly command: Schema.Literals<readonly ["split", "array"]>;
+        readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+    }>>;
+    readonly remote: Schema.NullOr<Schema.Struct<{
+        readonly typeField: Schema.Struct<{
+            readonly required: Schema.NullOr<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                    readonly "streamable-http": Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                }>]>;
+            }>>;
+            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                    readonly "streamable-http": Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                }>]>;
+            }>>>;
+        }>;
+        readonly urlKey: Schema.Struct<{
+            readonly "streamable-http": Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+        }>;
+        readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+        readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpConfig = Schema.Schema.Type<typeof McpConfigSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpEnvExpansionSchema: Schema.Struct<{
+    readonly variables: Schema.Literals<readonly ["none", "braced"]>;
+    readonly defaults: Schema.Boolean;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpEnvExpansion = Schema.Schema.Type<typeof McpEnvExpansionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly native: Schema.Struct<{
+        readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+        readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
+            readonly variables: Schema.Literals<readonly ["none", "braced"]>;
+            readonly defaults: Schema.Boolean;
+        }>>;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly config: Schema.Struct<{
+                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                readonly activationField: Schema.Struct<{
+                    readonly required: Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>;
+                    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>>;
+                }>;
+                readonly targets: Schema.$Array<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>>;
+                    }>;
+                    readonly command: Schema.Literals<readonly ["split", "array"]>;
+                    readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                }>>;
+                readonly remote: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>>;
+                    }>;
+                    readonly urlKey: Schema.Struct<{
+                        readonly "streamable-http": Schema.NonEmptyString;
+                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>;
+                    readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                }>>;
+            }>;
+        }>>;
+    }>;
+}>, Schema.Struct<{
+    readonly native: Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly config: Schema.Struct<{
+                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                readonly activationField: Schema.Struct<{
+                    readonly required: Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>;
+                    readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly enabled: Schema.Boolean;
+                        readonly disabled: Schema.Boolean;
+                    }>>>;
+                }>;
+                readonly targets: Schema.$Array<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>>;
+                    }>;
+                    readonly command: Schema.Literals<readonly ["split", "array"]>;
+                    readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                }>>;
+                readonly remote: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>]>;
+                        }>>>;
+                    }>;
+                    readonly urlKey: Schema.Struct<{
+                        readonly "streamable-http": Schema.NonEmptyString;
+                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>;
+                    readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                }>>;
+            }>;
+        }>>;
+    }>;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpExtensionCapability = Schema.Schema.Type<typeof McpExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionMechanismSchema: Schema.Literals<readonly ["config-file", "cli-flag", "ui-only"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionMechanism = Schema.Schema.Type<typeof PermissionMechanismSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionGrammarStyleSchema: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionGrammarStyle = Schema.Schema.Type<typeof PermissionGrammarStyleSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ConfigFileLocationSchema: Schema.Struct<{
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly path: Schema.NonEmptyString;
+    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+    readonly gitignored: Schema.Boolean;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type ConfigFileLocation = Schema.Schema.Type<typeof ConfigFileLocationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CANONICAL_HOOK_EVENT_IDS: readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookEventIdSchema: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookEventId = Schema.Schema.Type<typeof CanonicalHookEventIdSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookEventTierSchema: Schema.Literals<readonly ["core", "extended"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookEventTier = Schema.Schema.Type<typeof HookEventTierSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookEventSchema: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+    readonly tier: Schema.Literals<readonly ["core", "extended"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookEvent = Schema.Schema.Type<typeof CanonicalHookEventSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CANONICAL_HOOK_EVENTS: readonly [{
+    readonly id: "session.start";
+    readonly tier: "core";
+}, {
+    readonly id: "prompt.submit";
+    readonly tier: "core";
+}, {
+    readonly id: "turn.end";
+    readonly tier: "core";
+}, {
+    readonly id: "tool.pre";
+    readonly tier: "core";
+}, {
+    readonly id: "tool.post";
+    readonly tier: "core";
+}, {
+    readonly id: "subagent.stop";
+    readonly tier: "extended";
+}, {
+    readonly id: "compaction.pre";
+    readonly tier: "extended";
+}];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CANONICAL_HOOK_TOOL_IDS: readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"];
+/** @experimental This API is unstable and may change without notice. */
+export declare const CanonicalHookToolIdSchema: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type CanonicalHookToolId = Schema.Schema.Type<typeof CanonicalHookToolIdSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookToolMappingSchema: Schema.Struct<{
+    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly lastVerified: Schema.NonEmptyString;
+    readonly nativeName: Schema.NonEmptyString;
+    readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookToolMapping = Schema.Schema.Type<typeof HookToolMappingSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMechanismFamilySchema: Schema.Literals<readonly ["command-stdin", "raw"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMechanismFamily = Schema.Schema.Type<typeof HookMechanismFamilySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherKindSchema: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcherKind = Schema.Schema.Type<typeof HookMatcherKindSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+    readonly example: Schema.NullOr<Schema.NonEmptyString>;
+    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcher = Schema.Schema.Type<typeof HookMatcherSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookBlockOutcomeSchema: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookBlockOutcome = Schema.Schema.Type<typeof HookBlockOutcomeSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookModifyOperationSchema: Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookModifyOperation = Schema.Schema.Type<typeof HookModifyOperationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookDecisionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"observe">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"modify">;
+    readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookDecisionCapability = Schema.Schema.Type<typeof HookDecisionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookEventMappingSchema: Schema.Struct<{
+    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly lastVerified: Schema.NonEmptyString;
+    readonly nativeName: Schema.NonEmptyString;
+    readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+    readonly matcher: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+        readonly example: Schema.NullOr<Schema.NonEmptyString>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+    }>;
+    readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"observe">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"block">;
+        readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"modify">;
+        readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+    }>]>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookEventMapping = Schema.Schema.Type<typeof HookEventMappingSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksSerializerSchema: Schema.Literals<readonly ["command-stdin"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HooksSerializer = Schema.Schema.Type<typeof HooksSerializerSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookMatcherSerializationSchema: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookMatcherSerialization = Schema.Schema.Type<typeof HookMatcherSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookTimeoutSerializationSchema: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookTimeoutSerialization = Schema.Schema.Type<typeof HookTimeoutSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HookCommandNameSerializationSchema: Schema.Literals<readonly ["omit", "manifest"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HookCommandNameSerialization = Schema.Schema.Type<typeof HookCommandNameSerializationSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksWriterSchema: Schema.Struct<{
+    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+    readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+        readonly path: Schema.NonEmptyString;
+        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+        readonly gitignored: Schema.Boolean;
+    }>>;
+    readonly settingsKey: Schema.NonEmptyString;
+    readonly eventMap: Schema.Literal<"native.events">;
+    readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+    readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+    readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+    readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HooksWriter = Schema.Schema.Type<typeof HooksWriterSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
+        readonly configFiles: Schema.$Array<Schema.Struct<{
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly path: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly gitignored: Schema.Boolean;
+        }>>;
+        readonly events: Schema.NonEmptyArray<Schema.Struct<{
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly nativeName: Schema.NonEmptyString;
+            readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+            readonly matcher: Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+            readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"observe">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"block">;
+                readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"modify">;
+                readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+            }>]>>;
+        }>>;
+        readonly tools: Schema.$Array<Schema.Struct<{
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly nativeName: Schema.NonEmptyString;
+            readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+        }>>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        readonly modeling: Schema.Literal<"native-unmodeled">;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+            readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
+            }>>;
+            readonly settingsKey: Schema.NonEmptyString;
+            readonly eventMap: Schema.Literal<"native.events">;
+            readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+            readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+            readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+            readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
+        }>>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HooksExtensionCapability = Schema.Schema.Type<typeof HooksExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionGrammarSchema: Schema.Struct<{
+    readonly style: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
+    readonly example: Schema.NonEmptyString;
+    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionGrammar = Schema.Schema.Type<typeof PermissionGrammarSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionPrerequisiteSchema: Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionPrerequisite = Schema.Schema.Type<typeof PermissionPrerequisiteSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionCliFlagSchema: Schema.Struct<{
+    readonly flag: Schema.NonEmptyString;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionCliFlag = Schema.Schema.Type<typeof PermissionCliFlagSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionGrantSchema: Schema.Struct<{
+    readonly target: Schema.NonEmptyString;
+    readonly patch: Schema.NullOr<Schema.Unknown>;
+    readonly template: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionGrant = Schema.Schema.Type<typeof PermissionGrantSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Union<readonly [Schema.Struct<{
+        readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["config-file", "cli-flag", "ui-only"]>>;
+        readonly configFiles: Schema.$Array<Schema.Struct<{
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly path: Schema.NonEmptyString;
+            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+            readonly gitignored: Schema.Boolean;
+        }>>;
+        readonly grammar: Schema.NullOr<Schema.Struct<{
+            readonly style: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
+            readonly example: Schema.NonEmptyString;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        }>>;
+        readonly prerequisites: Schema.$Array<Schema.Struct<{
+            readonly key: Schema.NonEmptyString;
+            readonly value: Schema.NonEmptyString;
+            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        }>>;
+        readonly cliFlags: Schema.$Array<Schema.Struct<{
+            readonly flag: Schema.NonEmptyString;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        }>>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literal<"native">;
+        }>, Schema.Struct<{
+            readonly via: Schema.Literal<"plugin">;
+            readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+            readonly plugin: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly homepage: Schema.NonEmptyString;
+                readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                readonly distribution: Schema.Struct<{
+                    readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                    readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly detection: Schema.NullOr<Schema.Struct<{
+                    readonly paths: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                    }>>;
+                    readonly configKeys: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly file: Schema.NonEmptyString;
+                        readonly key: Schema.NonEmptyString;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>, Schema.Struct<{
+        availability: Schema.Struct<{
+            readonly via: Schema.Literal<"none">;
+        }>;
+        vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        notes: Schema.NullOr<Schema.NonEmptyString>;
+        docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
+    }>]>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+        readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
+                readonly target: Schema.NonEmptyString;
+                readonly patch: Schema.NullOr<Schema.Unknown>;
+                readonly template: Schema.NullOr<Schema.NonEmptyString>;
+            }>>;
+        }>>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PermissionsExtensionCapability = Schema.Schema.Type<typeof PermissionsExtensionCapabilitySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentCapabilitiesSchema: Schema.Struct<{
+    skill: Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+            readonly directory: Schema.NonEmptyString;
+            readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
+                readonly path: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+            }>>, never>>;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly convention: Schema.Literal<"hosted">;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
+    }>;
+    "mcp-server": Schema.Union<readonly [Schema.Struct<{
+        readonly native: Schema.Struct<{
+            readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+            readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
+                readonly variables: Schema.Literals<readonly ["none", "braced"]>;
+                readonly defaults: Schema.Boolean;
+            }>>;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly config: Schema.Struct<{
+                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                    readonly activationField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>>;
+                    }>;
+                    readonly targets: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>>;
+                        }>;
+                        readonly command: Schema.Literals<readonly ["split", "array"]>;
+                        readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                    }>>;
+                    readonly remote: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>>;
+                        }>;
+                        readonly urlKey: Schema.Struct<{
+                            readonly "streamable-http": Schema.NonEmptyString;
+                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                        }>;
+                        readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    }>>;
+                }>;
+            }>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly native: Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly config: Schema.Struct<{
+                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                    readonly activationField: Schema.Struct<{
+                        readonly required: Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>;
+                        readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                            readonly name: Schema.NonEmptyString;
+                            readonly enabled: Schema.Boolean;
+                            readonly disabled: Schema.Boolean;
+                        }>>>;
+                    }>;
+                    readonly targets: Schema.$Array<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                        readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>>;
+                        }>;
+                        readonly command: Schema.Literals<readonly ["split", "array"]>;
+                        readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                    }>>;
+                    readonly remote: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                    readonly "streamable-http": Schema.NonEmptyString;
+                                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                }>]>;
+                            }>>>;
+                        }>;
+                        readonly urlKey: Schema.Struct<{
+                            readonly "streamable-http": Schema.NonEmptyString;
+                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                        }>;
+                        readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                        readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                    }>>;
+                }>;
+            }>>;
+        }>;
+    }>]>;
+    subagent: Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly availability: Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>;
+            readonly directory: Schema.NonEmptyString;
+            readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly availability: Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
+    }>;
+    hook: Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
+            readonly configFiles: Schema.$Array<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
+            }>>;
+            readonly events: Schema.NonEmptyArray<Schema.Struct<{
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly nativeName: Schema.NonEmptyString;
+                readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+                readonly matcher: Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                    readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+                readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"observe">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"block">;
+                    readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"modify">;
+                    readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+                }>]>>;
+            }>>;
+            readonly tools: Schema.$Array<Schema.Struct<{
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly nativeName: Schema.NonEmptyString;
+                readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+            }>>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly modeling: Schema.Literal<"native-unmodeled">;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly gitignored: Schema.Boolean;
+                }>>;
+                readonly settingsKey: Schema.NonEmptyString;
+                readonly eventMap: Schema.Literal<"native.events">;
+                readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+                readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+                readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
+            }>>;
+        }>;
+    }>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentCapabilities = Schema.Schema.Type<typeof AgentCapabilitiesSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentExtensionCapability = AgentCapabilities[PerAgentType] | RulesExtensionCapability;
+/** @experimental This API is unstable and may change without notice. */
+export type NativeCapability = AgentExtensionCapability["native"];
+/** @experimental This API is unstable and may change without notice. */
+export type AxmCapabilityState = AgentExtensionCapability["axm"];
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentLifecycleStateSchema: Schema.Literals<readonly ["active", "deprecated", "retired"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentLifecycleState = Schema.Schema.Type<typeof AgentLifecycleStateSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentLifecycleSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literal<"active">;
+}>, Schema.Struct<{
+    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly supersededBy: Schema.NullOr<Schema.NonEmptyString>;
+    readonly state: Schema.Literal<"deprecated">;
+}>, Schema.Struct<{
+    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly supersededBy: Schema.NullOr<Schema.NonEmptyString>;
+    readonly state: Schema.Literal<"retired">;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentLifecycle = Schema.Schema.Type<typeof AgentLifecycleSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CapabilityTargetingEntrySchema: Schema.Struct<{
+    readonly grades: Schema.$Array<Schema.NonEmptyString>;
+    readonly nouns: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+    readonly affordances: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CapabilityTargetingSchema: Schema.Struct<{
+    readonly extends: Schema.NullOr<Schema.NonEmptyString>;
+    readonly capabilities: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly grades: Schema.$Array<Schema.NonEmptyString>;
+        readonly nouns: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+        readonly affordances: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HostedInstallDeliverySchema: Schema.Literals<readonly ["upload", "directory"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HostedInstallDelivery = Schema.Schema.Type<typeof HostedInstallDeliverySchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HostedInstallArtifactSchema: Schema.Literals<readonly ["directory", "zip", "skill-file-or-zip"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type HostedInstallArtifact = Schema.Schema.Type<typeof HostedInstallArtifactSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const HostedInstallTargetSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"hosted">;
+    readonly delivery: Schema.NonEmptyArray<Schema.Literals<readonly ["upload", "directory"]>>;
+    readonly artifact: Schema.Literals<readonly ["directory", "zip", "skill-file-or-zip"]>;
+    readonly instructions: Schema.NonEmptyString;
+    readonly docs: Schema.NonEmptyString;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type HostedInstallTarget = Schema.Schema.Type<typeof HostedInstallTargetSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const AgentSchema: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly vendor: Schema.NonEmptyString;
+    readonly homepage: Schema.NonEmptyString;
+    readonly interfaces: Schema.NonEmptyArray<Schema.Literals<readonly ["cli", "ide-extension", "chat", "hosted-agent"]>>;
+    readonly family: Schema.NullOr<Schema.NonEmptyString>;
+    readonly rootDir: Schema.NullOr<Schema.NonEmptyString>;
+    readonly installTarget: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Literal<"hosted">;
+        readonly delivery: Schema.NonEmptyArray<Schema.Literals<readonly ["upload", "directory"]>>;
+        readonly artifact: Schema.Literals<readonly ["directory", "zip", "skill-file-or-zip"]>;
+        readonly instructions: Schema.NonEmptyString;
+        readonly docs: Schema.NonEmptyString;
+    }>>;
+    readonly lifecycle: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"active">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededBy: Schema.NullOr<Schema.NonEmptyString>;
+        readonly state: Schema.Literal<"deprecated">;
+    }>, Schema.Struct<{
+        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly supersededBy: Schema.NullOr<Schema.NonEmptyString>;
+        readonly state: Schema.Literal<"retired">;
+    }>]>;
+    readonly detection: Schema.Struct<{
+        readonly project: Schema.Struct<{
+            readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"dir">;
+                readonly path: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"file">;
+                readonly path: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"executable">;
+                readonly name: Schema.NonEmptyString;
+            }>]>>;
+        }>;
+        readonly user: Schema.Struct<{
+            readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"dir">;
+                readonly path: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"file">;
+                readonly path: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly kind: Schema.Literal<"executable">;
+                readonly name: Schema.NonEmptyString;
+            }>]>>;
+        }>;
+    }>;
+    readonly docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    readonly capabilities: Schema.Struct<{
+        skill: Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
+                readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+                readonly directory: Schema.NonEmptyString;
+                readonly additionalReadPaths: Schema.optionalKey<Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.NonEmptyString;
+                    readonly status: Schema.Literals<readonly ["canonical", "compat", "deprecated"]>;
+                }>>, never>>;
+                readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                readonly convention: Schema.Literal<"hosted">;
+                readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"none">;
+                }>;
+                vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                notes: Schema.NullOr<Schema.NonEmptyString>;
+                docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                sources: Schema.$Array<Schema.NonEmptyString>;
+            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
+        }>;
+        "mcp-server": Schema.Union<readonly [Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
+                readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
+                    readonly variables: Schema.Literals<readonly ["none", "braced"]>;
+                    readonly defaults: Schema.Boolean;
+                }>>;
+                readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+                readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly config: Schema.Struct<{
+                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                        readonly activationField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly enabled: Schema.Boolean;
+                                readonly disabled: Schema.Boolean;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly enabled: Schema.Boolean;
+                                readonly disabled: Schema.Boolean;
+                            }>>>;
+                        }>;
+                        readonly targets: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                            readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: Schema.Struct<{
+                                readonly required: Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>;
+                                readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>>;
+                            }>;
+                            readonly command: Schema.Literals<readonly ["split", "array"]>;
+                            readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                        }>>;
+                        readonly remote: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: Schema.Struct<{
+                                readonly required: Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>;
+                                readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>>;
+                            }>;
+                            readonly urlKey: Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>;
+                            readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                            readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                        }>>;
+                    }>;
+                }>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly native: Schema.Struct<{
+                availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"none">;
+                }>;
+                vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                notes: Schema.NullOr<Schema.NonEmptyString>;
+                docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                sources: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly config: Schema.Struct<{
+                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                        readonly activationField: Schema.Struct<{
+                            readonly required: Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly enabled: Schema.Boolean;
+                                readonly disabled: Schema.Boolean;
+                            }>>;
+                            readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                readonly name: Schema.NonEmptyString;
+                                readonly enabled: Schema.Boolean;
+                                readonly disabled: Schema.Boolean;
+                            }>>>;
+                        }>;
+                        readonly targets: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                            readonly attribution: Schema.Literals<readonly ["shared", "agent"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: Schema.Struct<{
+                                readonly required: Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>;
+                                readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>>;
+                            }>;
+                            readonly command: Schema.Literals<readonly ["split", "array"]>;
+                            readonly envKey: Schema.NullOr<Schema.NonEmptyString>;
+                        }>>;
+                        readonly remote: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: Schema.Struct<{
+                                readonly required: Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>;
+                                readonly accepted: Schema.NonEmptyArray<Schema.NullOr<Schema.Struct<{
+                                    readonly name: Schema.NonEmptyString;
+                                    readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
+                                        readonly "streamable-http": Schema.NonEmptyString;
+                                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                                    }>]>;
+                                }>>>;
+                            }>;
+                            readonly urlKey: Schema.Struct<{
+                                readonly "streamable-http": Schema.NonEmptyString;
+                                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
+                            }>;
+                            readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly bearerTokenEnvKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                            readonly envHeadersKey: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+                        }>>;
+                    }>;
+                }>>;
+            }>;
+        }>]>;
+        subagent: Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
+                readonly availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>;
+                readonly directory: Schema.NonEmptyString;
+                readonly layout: Schema.Literals<readonly ["file", "directory"]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                readonly availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"none">;
+                }>;
+                vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                notes: Schema.NullOr<Schema.NonEmptyString>;
+                docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                sources: Schema.$Array<Schema.NonEmptyString>;
+            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Never>;
+            }>;
+        }>;
+        hook: Schema.Struct<{
+            readonly native: Schema.Union<readonly [Schema.Struct<{
+                readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["command-stdin", "raw"]>>;
+                readonly configFiles: Schema.$Array<Schema.Struct<{
+                    readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                    readonly path: Schema.NonEmptyString;
+                    readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                    readonly gitignored: Schema.Boolean;
+                }>>;
+                readonly events: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly lastVerified: Schema.NonEmptyString;
+                    readonly nativeName: Schema.NonEmptyString;
+                    readonly canonical: Schema.Literals<readonly ["session.start", "prompt.submit", "turn.end", "tool.pre", "tool.post", "subagent.stop", "compaction.pre"]>;
+                    readonly matcher: Schema.Struct<{
+                        readonly kind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                        readonly example: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly decision: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"observe">;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"block">;
+                        readonly outcomes: Schema.NonEmptyArray<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"modify">;
+                        readonly operations: Schema.NonEmptyArray<Schema.Literals<readonly ["modify-input", "inject-context", "modify-output", "synthesize", "redact"]>>;
+                    }>]>>;
+                }>>;
+                readonly tools: Schema.$Array<Schema.Struct<{
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly lastVerified: Schema.NonEmptyString;
+                    readonly nativeName: Schema.NonEmptyString;
+                    readonly canonical: Schema.Literals<readonly ["file.read", "file.write", "file.edit", "shell.exec", "web.fetch", "mcp.call"]>;
+                }>>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                readonly modeling: Schema.Literal<"native-unmodeled">;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literal<"native">;
+                }>, Schema.Struct<{
+                    readonly via: Schema.Literal<"plugin">;
+                    readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                    readonly plugin: Schema.Struct<{
+                        readonly name: Schema.NonEmptyString;
+                        readonly homepage: Schema.NonEmptyString;
+                        readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly distribution: Schema.Struct<{
+                            readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                            readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                            readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                        }>;
+                        readonly detection: Schema.NullOr<Schema.Struct<{
+                            readonly paths: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly path: Schema.NonEmptyString;
+                                readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                            }>>;
+                            readonly configKeys: Schema.$Array<Schema.Struct<{
+                                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                                readonly file: Schema.NonEmptyString;
+                                readonly key: Schema.NonEmptyString;
+                            }>>;
+                        }>>;
+                    }>;
+                }>]>;
+                readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+            }>, Schema.Struct<{
+                availability: Schema.Struct<{
+                    readonly via: Schema.Literal<"none">;
+                }>;
+                vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                notes: Schema.NullOr<Schema.NonEmptyString>;
+                docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                sources: Schema.$Array<Schema.NonEmptyString>;
+            }>]>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+                readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly serializer: Schema.Literals<readonly ["command-stdin"]>;
+                    readonly configFiles: Schema.NonEmptyArray<Schema.Struct<{
+                        readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                        readonly path: Schema.NonEmptyString;
+                        readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                        readonly gitignored: Schema.Boolean;
+                    }>>;
+                    readonly settingsKey: Schema.NonEmptyString;
+                    readonly eventMap: Schema.Literal<"native.events">;
+                    readonly matcherKind: Schema.Literals<readonly ["regex", "literal-list", "glob", "tool-category", "exact-substring", "none-imperative"]>;
+                    readonly matcherSerialization: Schema.Literals<readonly ["bare", "slash-delimited", "glob"]>;
+                    readonly timeoutSerialization: Schema.Literals<readonly ["seconds", "milliseconds"]>;
+                    readonly commandNameSerialization: Schema.Literals<readonly ["omit", "manifest"]>;
+                }>>;
+            }>;
+        }>;
+    }>;
+    readonly instructions: Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"agents-md">;
+            readonly files: Schema.Tuple<readonly [Schema.Literal<"AGENTS.md">]>;
+            readonly nestedDiscovery: Schema.Boolean;
+            readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+            readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"own-file">;
+            readonly files: Schema.Tuple<readonly [Schema.NonEmptyString]>;
+            readonly nestedDiscovery: Schema.Boolean;
+            readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+            readonly directory: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"rules-dir">;
+            readonly files: Schema.$Array<Schema.NonEmptyString>;
+            readonly nestedDiscovery: Schema.Boolean;
+            readonly importSyntax: Schema.NullOr<Schema.Literals<readonly ["at-path"]>>;
+            readonly directory: Schema.NonEmptyString;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly convention: Schema.Literals<readonly ["universal", "vendor", "hosted"]>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Never>;
+        }>;
+    }>;
+    readonly permissions: Schema.Struct<{
+        readonly native: Schema.Union<readonly [Schema.Struct<{
+            readonly mechanism: Schema.NonEmptyArray<Schema.Literals<readonly ["config-file", "cli-flag", "ui-only"]>>;
+            readonly configFiles: Schema.$Array<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly path: Schema.NonEmptyString;
+                readonly format: Schema.Literals<readonly ["json", "jsonc", "toml", "yaml", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
+            }>>;
+            readonly grammar: Schema.NullOr<Schema.Struct<{
+                readonly style: Schema.Literals<readonly ["tool-call", "prefix", "regex", "glob", "starlark-rule"]>;
+                readonly example: Schema.NonEmptyString;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            }>>;
+            readonly prerequisites: Schema.$Array<Schema.Struct<{
+                readonly key: Schema.NonEmptyString;
+                readonly value: Schema.NonEmptyString;
+                readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            }>>;
+            readonly cliFlags: Schema.$Array<Schema.Struct<{
+                readonly flag: Schema.NonEmptyString;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            }>>;
+            readonly availability: Schema.Union<readonly [Schema.Struct<{
+                readonly via: Schema.Literal<"native">;
+            }>, Schema.Struct<{
+                readonly via: Schema.Literal<"plugin">;
+                readonly provider: Schema.Literals<readonly ["first-party", "third-party"]>;
+                readonly plugin: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly homepage: Schema.NonEmptyString;
+                    readonly author: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly distribution: Schema.Struct<{
+                        readonly mechanism: Schema.Literals<readonly ["agent-native", "npm", "git", "manual"]>;
+                        readonly installHint: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly packageRef: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                    readonly detection: Schema.NullOr<Schema.Struct<{
+                        readonly paths: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly path: Schema.NonEmptyString;
+                            readonly kind: Schema.Literals<readonly ["dir", "file"]>;
+                        }>>;
+                        readonly configKeys: Schema.$Array<Schema.Struct<{
+                            readonly scope: Schema.Literals<readonly ["user", "project"]>;
+                            readonly file: Schema.NonEmptyString;
+                            readonly key: Schema.NonEmptyString;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            readonly vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+            readonly docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        }>, Schema.Struct<{
+            availability: Schema.Struct<{
+                readonly via: Schema.Literal<"none">;
+            }>;
+            vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"active">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"maintenance">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"deprecated">;
+            }>, Schema.Struct<{
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                readonly state: Schema.Literal<"removed">;
+            }>]>;
+            notes: Schema.NullOr<Schema.NonEmptyString>;
+            docs: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.NonEmptyString;
+                readonly url: Schema.NonEmptyString;
+            }>>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
+        }>]>;
+        readonly axm: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+            readonly lastVerified: Schema.NullOr<Schema.NonEmptyString>;
+            readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly grants: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly target: Schema.NonEmptyString;
+                    readonly patch: Schema.NullOr<Schema.Unknown>;
+                    readonly template: Schema.NullOr<Schema.NonEmptyString>;
+                }>>;
+            }>>;
+        }>;
+    }>;
+    readonly targeting: Schema.optionalKey<Schema.Struct<{
+        readonly extends: Schema.NullOr<Schema.NonEmptyString>;
+        readonly capabilities: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly grades: Schema.$Array<Schema.NonEmptyString>;
+            readonly nouns: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+            readonly affordances: Schema.$Record<Schema.String, Schema.NonEmptyString>;
+        }>>;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type Agent = Schema.Schema.Type<typeof AgentSchema>;
+//# sourceMappingURL=schema.d.ts.map