@agentxm/client-core 0.15.1 → 0.16.1

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

@@ -19,23 +19,145 @@ export declare const ConventionSchema: Schema.Literals<readonly ["universal", "v
 /** @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 SUPPORTED_LIFECYCLE: "supported";
+export declare const ScopeSchema: Schema.Literals<readonly ["user", "project"]>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const CapabilityLifecycleSchema: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+export type Scope = Schema.Schema.Type<typeof ScopeSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export type CapabilityLifecycle = Schema.Schema.Type<typeof CapabilityLifecycleSchema>;
+export declare const SUPPORTED_AXM_SUPPORT: "supported";
 /** @experimental This API is unstable and may change without notice. */
-export declare const ActiveLifecycleSchema: Schema.Literals<readonly ["supported", "planned"]>;
+export declare const AxmSupportSchema: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
 /** @experimental This API is unstable and may change without notice. */
-export type ActiveLifecycle = Schema.Schema.Type<typeof ActiveLifecycleSchema>;
+export type AxmSupport = Schema.Schema.Type<typeof AxmSupportSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const InactiveLifecycleSchema: Schema.Literals<readonly ["unsupported", "unknown"]>;
+export declare const ActiveAxmSupportSchema: Schema.Literals<readonly ["supported", "planned"]>;
 /** @experimental This API is unstable and may change without notice. */
-export type InactiveLifecycle = Schema.Schema.Type<typeof InactiveLifecycleSchema>;
+export type ActiveAxmSupport = Schema.Schema.Type<typeof ActiveAxmSupportSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const ScopeSchema: Schema.Literals<readonly ["user", "project"]>;
+export declare const InactiveAxmSupportSchema: Schema.Literals<readonly ["unsupported", "unknown"]>;
 /** @experimental This API is unstable and may change without notice. */
-export type Scope = Schema.Schema.Type<typeof ScopeSchema>;
+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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
 /** @experimental This API is unstable and may change without notice. */
@@ -89,7 +211,7 @@ export declare const ScopeDetectionSchema: Schema.Struct<{
 /** @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.decodeTo<Schema.toType<Schema.Struct<{
+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"]>;
@@ -126,47 +248,7 @@ export declare const DetectionSchema: Schema.decodeTo<Schema.toType<Schema.Struc
             readonly name: Schema.NonEmptyString;
         }>]>>;
     }>;
-}>>, Schema.Union<readonly [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;
-        }>]>>;
-    }>;
-}>, Schema.Struct<{
-    readonly projectDirs: Schema.$Array<Schema.NonEmptyString>;
-    readonly userDirs: Schema.$Array<Schema.NonEmptyString>;
-}>]>, never, never>;
+}>;
 /** @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. */
@@ -174,87 +256,285 @@ 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 CapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<{
-    lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+export declare const CanonicalCapabilityBaseSchema: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.NonEmptyArray<Schema.NonEmptyString>;
-    lastVerified: Schema.NonEmptyString;
+    sources: Schema.$Array<Schema.NonEmptyString>;
     scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
 }>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
-/** @experimental This API is unstable and may change without notice. */
-export type CapabilityBase = Schema.Schema.Type<typeof CapabilityBaseSchema>;
-/** @experimental This API is unstable and may change without notice. */
-export declare const ScopedCapabilityBaseSchema: Schema.Struct<{
-    lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+    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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.NonEmptyArray<Schema.NonEmptyString>;
-    lastVerified: Schema.NonEmptyString;
-    scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>;
+    sources: Schema.$Array<Schema.NonEmptyString>;
+}>]>;
 /** @experimental This API is unstable and may change without notice. */
-export type ScopedCapabilityBase = Schema.Schema.Type<typeof ScopedCapabilityBaseSchema>;
+export type CanonicalCapabilityBase = Schema.Schema.Type<typeof CanonicalCapabilityBaseSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const SkillsExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.NonEmptyString;
-    readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-    readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
+export declare const SkillsExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly directory: Schema.NonEmptyString;
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+        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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.Null;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.Null;
+    }>]>;
+}>;
 /** @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. */
-export declare const CommandsExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.NonEmptyString;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
+export declare const CommandsExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly directory: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.Null;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.Null;
+    }>]>;
+}>;
 /** @experimental This API is unstable and may change without notice. */
 export type CommandsExtensionCapability = Schema.Schema.Type<typeof CommandsExtensionCapabilitySchema>;
 /** @experimental This API is unstable and may change without notice. */
@@ -262,27 +542,128 @@ export declare const SubagentsLayoutSchema: Schema.Literals<readonly ["file", "d
 /** @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.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.NonEmptyString;
-    readonly layout: Schema.Literals<readonly ["file", "directory"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
+export declare const SubagentsExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.Null;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.Null;
+    }>]>;
+}>;
 /** @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. */
@@ -294,91 +675,327 @@ export declare const RuleInstructionsImportSyntaxSchema: Schema.Literals<readonl
 /** @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.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"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: 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"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: 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"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
+export declare const RulesExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: 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"]>;
+        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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+        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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+        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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.Null;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.Null;
+    }>]>;
+}>;
 /** @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 FilesExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.NonEmptyString;
-    readonly files: Schema.$Array<Schema.NonEmptyString>;
-    readonly naming: Schema.NullOr<Schema.NonEmptyString>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
+export declare const FilesExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        readonly directory: Schema.NonEmptyString;
+        readonly files: Schema.$Array<Schema.NonEmptyString>;
+        readonly naming: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.Null;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.Null;
+    }>]>;
+}>;
 /** @experimental This API is unstable and may change without notice. */
 export type FilesExtensionCapability = Schema.Schema.Type<typeof FilesExtensionCapabilitySchema>;
 /** @experimental This API is unstable and may change without notice. */
@@ -499,65 +1116,258 @@ export declare const McpEnvExpansionSchema: Schema.Struct<{
 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 transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-    readonly config: Schema.optionalKey<Schema.Struct<{
-        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-        readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
-        }>>;
-        readonly stdio: Schema.NullOr<Schema.Struct<{
-            readonly typeField: 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 canonical: 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 remote: Schema.NullOr<Schema.Struct<{
-            readonly typeField: Schema.NullOr<Schema.Struct<{
+        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+        readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+        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 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 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 headersKey: Schema.NullOr<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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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 transform: Schema.NullOr<Schema.NonEmptyString>;
-    }>>;
-    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"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+    }>;
+    readonly axm: Schema.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly config: Schema.Struct<{
+                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+        }>>;
+    }>]>;
 }>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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 canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly config: Schema.Struct<{
+                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                }>>;
+                readonly stdio: Schema.NullOr<Schema.Struct<{
+                    readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+            }>;
+        }>>;
+    }>]>;
 }>]>;
 /** @experimental This API is unstable and may change without notice. */
 export type McpExtensionCapability = Schema.Schema.Type<typeof McpExtensionCapabilitySchema>;
@@ -583,38 +1393,115 @@ export declare const HooksSerializerSchema: Schema.Literals<readonly ["claude-co
 /** @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 HooksExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    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", "starlark", "vscode-settings"]>;
-        readonly gitignored: Schema.Boolean;
-    }>>;
-    readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
-/** @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;
+export declare const HooksExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: Schema.Union<readonly [Schema.Struct<{
+        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", "starlark", "vscode-settings"]>;
+            readonly gitignored: Schema.Boolean;
+        }>>;
+        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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly lastVerified: Schema.NonEmptyString;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        readonly writer: Schema.NullOr<Schema.Struct<{
+            readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+        }>>;
+    }>]>;
+}>;
+/** @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. */
@@ -644,294 +1531,1154 @@ export declare const PermissionGrantSchema: Schema.Struct<{
 /** @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.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", "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 grants: Schema.$Record<Schema.String, Schema.Struct<{
-        readonly target: Schema.NonEmptyString;
-        readonly patch: Schema.NullOr<Schema.Unknown>;
-        readonly template: Schema.NullOr<Schema.NonEmptyString>;
-    }>>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-    readonly lastVerified: Schema.NonEmptyString;
-    readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-}>, Schema.Struct<{
-    readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-    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>;
-}>]>;
-/** @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.Union<readonly [Schema.Struct<{
-        readonly directory: Schema.NonEmptyString;
-        readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-        readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
+export declare const PermissionsExtensionCapabilitySchema: Schema.Struct<{
+    readonly canonical: 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", "starlark", "vscode-settings"]>;
+            readonly gitignored: Schema.Boolean;
         }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
+        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 sources: Schema.$Array<Schema.NonEmptyString>;
-    }>]>;
-    command: Schema.Union<readonly [Schema.Struct<{
-        readonly directory: Schema.NonEmptyString;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: 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 sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
+        readonly cliFlags: Schema.$Array<Schema.Struct<{
+            readonly flag: Schema.NonEmptyString;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
         }>>;
-        readonly sources: Schema.$Array<Schema.NonEmptyString>;
-    }>]>;
-    "mcp-server": Schema.Union<readonly [Schema.Struct<{
-        readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-        readonly config: Schema.optionalKey<Schema.Struct<{
-            readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-            readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
-            }>>;
-            readonly stdio: Schema.NullOr<Schema.Struct<{
-                readonly typeField: 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.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 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 headersKey: Schema.NullOr<Schema.NonEmptyString>;
-            }>>;
-            readonly transform: Schema.NullOr<Schema.NonEmptyString>;
-        }>>;
-        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"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        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>;
-    }>]>;
-    subagent: Schema.Union<readonly [Schema.Struct<{
-        readonly directory: Schema.NonEmptyString;
-        readonly layout: Schema.Literals<readonly ["file", "directory"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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>;
-    }>]>;
-    files: Schema.Union<readonly [Schema.Struct<{
-        readonly directory: Schema.NonEmptyString;
-        readonly files: Schema.$Array<Schema.NonEmptyString>;
-        readonly naming: Schema.NullOr<Schema.NonEmptyString>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
         readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
     }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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;
         }>>;
-        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
-    rule: 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"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: 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"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: 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"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly axm: Schema.Union<readonly [Schema.Struct<{
+        readonly support: Schema.Literals<readonly ["supported", "planned"]>;
         readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        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>;
-    }>]>;
-    hook: Schema.Union<readonly [Schema.Struct<{
-        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", "starlark", "vscode-settings"]>;
-            readonly gitignored: Schema.Boolean;
-        }>>;
-        readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: 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 sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
     }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
+        readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+        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 sources: Schema.$Array<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 canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly directory: Schema.NonEmptyString;
+            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+            readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.Null;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.Null;
+        }>]>;
+    }>;
+    command: Schema.Struct<{
+        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly directory: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.Null;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.Null;
+        }>]>;
+    }>;
+    "mcp-server": Schema.Union<readonly [Schema.Struct<{
+        readonly canonical: 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"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly config: Schema.Struct<{
+                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                    readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+            }>>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly config: Schema.Struct<{
+                    readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                    readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                    }>>;
+                    readonly stdio: Schema.NullOr<Schema.Struct<{
+                        readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                }>;
+            }>>;
+        }>]>;
+    }>]>;
+    subagent: Schema.Struct<{
+        readonly canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.Null;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.Null;
+        }>]>;
+    }>;
+    files: Schema.Struct<{
+        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            readonly directory: Schema.NonEmptyString;
+            readonly files: Schema.$Array<Schema.NonEmptyString>;
+            readonly naming: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.Null;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.Null;
+        }>]>;
+    }>;
+    rule: Schema.Struct<{
+        readonly canonical: 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"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.Null;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.Null;
+        }>]>;
+    }>;
+    hook: Schema.Struct<{
+        readonly canonical: Schema.Union<readonly [Schema.Struct<{
+            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", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
+            }>>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly lastVerified: Schema.NonEmptyString;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            readonly writer: Schema.NullOr<Schema.Struct<{
+                readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+            }>>;
+        }>]>;
+    }>;
+}>;
+/** @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[LeafExtensionType];
 /** @experimental This API is unstable and may change without notice. */
+export type CanonicalCapability = AgentExtensionCapability["canonical"];
+/** @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 AgentSchema: Schema.Struct<{
     readonly id: Schema.NonEmptyString;
     readonly name: Schema.NonEmptyString;
@@ -940,7 +2687,20 @@ export declare const AgentSchema: Schema.Struct<{
     readonly interfaces: Schema.NonEmptyArray<Schema.Literals<readonly ["cli", "ide-extension"]>>;
     readonly family: Schema.NullOr<Schema.NonEmptyString>;
     readonly rootDir: Schema.NullOr<Schema.NonEmptyString>;
-    readonly detection: Schema.decodeTo<Schema.toType<Schema.Struct<{
+    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"]>;
@@ -977,331 +2737,1127 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly name: Schema.NonEmptyString;
             }>]>>;
         }>;
-    }>>, Schema.Union<readonly [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;
+    }>;
+    readonly docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    readonly capabilities: Schema.Struct<{
+        skill: Schema.Struct<{
+            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+                readonly directory: Schema.NonEmptyString;
+                readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
+                readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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 signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
-                readonly note: Schema.NullOr<Schema.NonEmptyString>;
-                readonly kind: Schema.Literal<"file">;
-                readonly path: Schema.NonEmptyString;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.Null;
             }>, 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 support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.Null;
+            }>]>;
         }>;
-        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;
+        command: Schema.Struct<{
+            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+                readonly directory: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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 signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
-                readonly note: Schema.NullOr<Schema.NonEmptyString>;
-                readonly kind: Schema.Literal<"file">;
-                readonly path: Schema.NonEmptyString;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.Null;
             }>, 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 support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.Null;
+            }>]>;
         }>;
-    }>, Schema.Struct<{
-        readonly projectDirs: Schema.$Array<Schema.NonEmptyString>;
-        readonly userDirs: Schema.$Array<Schema.NonEmptyString>;
-    }>]>, never, never>;
-    readonly docs: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.NonEmptyString;
-        readonly url: Schema.NonEmptyString;
-    }>>;
-    readonly capabilities: Schema.Struct<{
-        skill: Schema.Union<readonly [Schema.Struct<{
-            readonly directory: Schema.NonEmptyString;
-            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-            readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-        }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            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>;
-        }>]>;
-        command: Schema.Union<readonly [Schema.Struct<{
-            readonly directory: Schema.NonEmptyString;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
+        "mcp-server": Schema.Union<readonly [Schema.Struct<{
+            readonly canonical: 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"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                }>>;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly config: Schema.Struct<{
+                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                        readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                }>>;
+            }>]>;
         }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            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 canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: 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 nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                }>>;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly config: Schema.Struct<{
+                        readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
+                        readonly nativeEnabled: 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", "starlark", "vscode-settings"]>;
+                        }>>;
+                        readonly stdio: Schema.NullOr<Schema.Struct<{
+                            readonly typeField: 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.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 transform: Schema.NullOr<Schema.NonEmptyString>;
+                    }>;
+                }>>;
+            }>]>;
         }>]>;
-        "mcp-server": Schema.Union<readonly [Schema.Struct<{
-            readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-            readonly config: Schema.optionalKey<Schema.Struct<{
-                readonly serversKey: Schema.Literals<readonly ["mcpServers", "servers", "mcp", "mcp_servers", "context_servers"]>;
-                readonly nativeEnabled: Schema.Boolean;
-                readonly targets: Schema.$Array<Schema.Struct<{
+        subagent: Schema.Struct<{
+            readonly canonical: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.Null;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.Null;
+            }>]>;
+        }>;
+        files: Schema.Struct<{
+            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+                readonly directory: Schema.NonEmptyString;
+                readonly files: Schema.$Array<Schema.NonEmptyString>;
+                readonly naming: 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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.Null;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.Null;
+            }>]>;
+        }>;
+        rule: Schema.Struct<{
+            readonly canonical: 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"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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"]>;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.Null;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.Null;
+            }>]>;
+        }>;
+        hook: Schema.Struct<{
+            readonly canonical: Schema.Union<readonly [Schema.Struct<{
+                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", "starlark", "vscode-settings"]>;
+                    readonly gitignored: Schema.Boolean;
                 }>>;
-                readonly stdio: Schema.NullOr<Schema.Struct<{
-                    readonly typeField: 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.NullOr<Schema.Struct<{
+                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 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 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 headersKey: Schema.NullOr<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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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 transform: Schema.NullOr<Schema.NonEmptyString>;
-            }>>;
-            readonly mcpEnvExpansion: Schema.optionalKey<Schema.Struct<{
-                readonly variables: Schema.Literals<readonly ["none", "braced"]>;
-                readonly defaults: Schema.Boolean;
+                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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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.Union<readonly [Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["supported", "planned"]>;
+                readonly lastVerified: Schema.NonEmptyString;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+                }>>;
+            }>, Schema.Struct<{
+                readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+                readonly writer: Schema.NullOr<Schema.Struct<{
+                    readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
+                }>>;
+            }>]>;
+        }>;
+    }>;
+    readonly permissions: Schema.Struct<{
+        readonly canonical: 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", "starlark", "vscode-settings"]>;
+                readonly gitignored: Schema.Boolean;
             }>>;
-            readonly standardsCompliance: Schema.Literals<readonly ["full", "parity", "partial", "none"]>;
-            readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
+            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 sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-        }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: 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 sources: Schema.$Array<Schema.NonEmptyString>;
-        }>]>;
-        subagent: Schema.Union<readonly [Schema.Struct<{
-            readonly directory: Schema.NonEmptyString;
-            readonly layout: Schema.Literals<readonly ["file", "directory"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
+            readonly cliFlags: Schema.$Array<Schema.Struct<{
+                readonly flag: Schema.NonEmptyString;
+                readonly note: Schema.NullOr<Schema.NonEmptyString>;
             }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-        }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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>;
-        }>]>;
-        files: Schema.Union<readonly [Schema.Struct<{
-            readonly directory: Schema.NonEmptyString;
-            readonly files: Schema.$Array<Schema.NonEmptyString>;
-            readonly naming: Schema.NullOr<Schema.NonEmptyString>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
             readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
         }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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", "command", "mcp-server", "subagent", "files", "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;
             }>>;
-            readonly sources: Schema.$Array<Schema.NonEmptyString>;
+            sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
-        rule: 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"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: 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"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: 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"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
-            }>>;
-            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly axm: Schema.Union<readonly [Schema.Struct<{
+            readonly support: Schema.Literals<readonly ["supported", "planned"]>;
             readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-        }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            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>;
-        }>]>;
-        hook: Schema.Union<readonly [Schema.Struct<{
-            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", "starlark", "vscode-settings"]>;
-                readonly gitignored: Schema.Boolean;
-            }>>;
-            readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: 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 sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-            readonly lastVerified: Schema.NonEmptyString;
-            readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
         }>, Schema.Struct<{
-            readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-            readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-            readonly docs: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.NonEmptyString;
-                readonly url: Schema.NonEmptyString;
+            readonly support: Schema.Literals<readonly ["unsupported", "unknown"]>;
+            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 sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
     }>;
-    readonly permissions: 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", "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 grants: Schema.$Record<Schema.String, Schema.Struct<{
-            readonly target: Schema.NonEmptyString;
-            readonly patch: Schema.NullOr<Schema.Unknown>;
-            readonly template: Schema.NullOr<Schema.NonEmptyString>;
-        }>>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
-        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
-        readonly docs: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.NonEmptyString;
-            readonly url: Schema.NonEmptyString;
-        }>>;
-        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
-        readonly lastVerified: Schema.NonEmptyString;
-        readonly scopes: Schema.NonEmptyArray<Schema.Literals<readonly ["user", "project"]>>;
-    }>, Schema.Struct<{
-        readonly lifecycle: Schema.Literals<readonly ["unsupported", "unknown"]>;
-        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>;
-    }>]>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type Agent = Schema.Schema.Type<typeof AgentSchema>;