@agentxm/client-core 0.15.0 → 0.16.0

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. */
@@ -45,10 +167,128 @@ export declare const McpTransportSchema: Schema.Literals<readonly ["stdio", "htt
 /** @experimental This API is unstable and may change without notice. */
 export type McpTransport = Schema.Schema.Type<typeof McpTransportSchema>;
 /** @experimental This API is unstable and may change without notice. */
-export declare const DetectionSchema: Schema.Struct<{
+export declare const DetectionSignalSchema: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type DetectionSignal = Schema.Schema.Type<typeof DetectionSignalSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DetectionMarkerSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"dir">;
+    readonly path: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"file">;
+    readonly path: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+    readonly kind: Schema.Literal<"executable">;
+    readonly name: Schema.NonEmptyString;
+}>]>;
+/** @experimental This API is unstable and may change without notice. */
+export type DetectionMarker = Schema.Schema.Type<typeof DetectionMarkerSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ScopeDetectionSchema: Schema.Struct<{
+    readonly markers: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"dir">;
+        readonly path: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly signal: Schema.Literals<readonly ["definitive", "supporting", "ambiguous"]>;
+        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+        readonly kind: Schema.Literal<"executable">;
+        readonly name: Schema.NonEmptyString;
+    }>]>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type ScopeDetection = Schema.Schema.Type<typeof ScopeDetectionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DetectionSchema: Schema.decodeTo<Schema.toType<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.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. */
@@ -57,7 +297,55 @@ export declare const LastVerifiedDateSchema: Schema.NonEmptyString;
 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"]>;
+    availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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">;
+    }>]>;
+    axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     notes: Schema.NullOr<Schema.NonEmptyString>;
     docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -67,7 +355,55 @@ export declare const CapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<
     lastVerified: Schema.NonEmptyString;
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -79,7 +415,55 @@ export declare const CapabilityBaseSchema: Schema.Union<readonly [Schema.Struct<
 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.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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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">;
+    }>]>;
+    axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     notes: Schema.NullOr<Schema.NonEmptyString>;
     docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -96,7 +480,55 @@ export declare const SkillsExtensionCapabilitySchema: Schema.Union<readonly [Sch
     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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -106,7 +538,55 @@ export declare const SkillsExtensionCapabilitySchema: Schema.Union<readonly [Sch
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -119,7 +599,55 @@ export type SkillsExtensionCapability = Schema.Schema.Type<typeof SkillsExtensio
 /** @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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -129,7 +657,55 @@ export declare const CommandsExtensionCapabilitySchema: Schema.Union<readonly [S
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -147,7 +723,55 @@ export type SubagentsLayout = Schema.Schema.Type<typeof SubagentsLayoutSchema>;
 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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -157,7 +781,55 @@ export declare const SubagentsExtensionCapabilitySchema: Schema.Union<readonly [
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -184,7 +856,55 @@ export declare const RulesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -201,7 +921,55 @@ export declare const RulesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -218,7 +986,55 @@ export declare const RulesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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 availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -228,7 +1044,55 @@ export declare const RulesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -243,7 +1107,55 @@ export declare const FilesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     readonly directory: Schema.NonEmptyString;
     readonly files: Schema.$Array<Schema.NonEmptyString>;
     readonly naming: Schema.NullOr<Schema.NonEmptyString>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+    readonly availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -253,7 +1165,55 @@ export declare const FilesExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -282,7 +1242,7 @@ export type McpConfigTarget = Schema.Schema.Type<typeof McpConfigTargetSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpTypeFieldValueMapSchema: Schema.Struct<{
     readonly "streamable-http": Schema.NonEmptyString;
-    readonly sse: Schema.NonEmptyString;
+    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type McpTypeFieldValueMap = Schema.Schema.Type<typeof McpTypeFieldValueMapSchema>;
@@ -291,7 +1251,7 @@ export declare const McpTypeFieldSchema: Schema.Struct<{
     readonly name: Schema.NonEmptyString;
     readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
         readonly "streamable-http": Schema.NonEmptyString;
-        readonly sse: Schema.NonEmptyString;
+        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
     }>]>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
@@ -302,7 +1262,7 @@ export declare const McpStdioDialectSchema: Schema.Struct<{
         readonly name: Schema.NonEmptyString;
         readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
             readonly "streamable-http": Schema.NonEmptyString;
-            readonly sse: Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
         }>]>;
     }>>;
     readonly command: Schema.Literals<readonly ["split", "array"]>;
@@ -313,7 +1273,7 @@ export type McpStdioDialect = Schema.Schema.Type<typeof McpStdioDialectSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export declare const McpUrlKeyMapSchema: Schema.Struct<{
     readonly "streamable-http": Schema.NonEmptyString;
-    readonly sse: Schema.NonEmptyString;
+    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
 }>;
 /** @experimental This API is unstable and may change without notice. */
 export type McpUrlKeyMap = Schema.Schema.Type<typeof McpUrlKeyMapSchema>;
@@ -323,12 +1283,12 @@ export declare const McpRemoteDialectSchema: Schema.Struct<{
         readonly name: Schema.NonEmptyString;
         readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
             readonly "streamable-http": Schema.NonEmptyString;
-            readonly sse: Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
         }>]>;
     }>>;
     readonly urlKey: Schema.Struct<{
         readonly "streamable-http": Schema.NonEmptyString;
-        readonly sse: Schema.NonEmptyString;
+        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
     }>;
     readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
 }>;
@@ -348,7 +1308,7 @@ export declare const McpConfigSchema: Schema.Struct<{
             readonly name: Schema.NonEmptyString;
             readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                 readonly "streamable-http": Schema.NonEmptyString;
-                readonly sse: Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
             }>]>;
         }>>;
         readonly command: Schema.Literals<readonly ["split", "array"]>;
@@ -359,12 +1319,12 @@ export declare const McpConfigSchema: Schema.Struct<{
             readonly name: Schema.NonEmptyString;
             readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                 readonly "streamable-http": Schema.NonEmptyString;
-                readonly sse: Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
             }>]>;
         }>>;
         readonly urlKey: Schema.Struct<{
             readonly "streamable-http": Schema.NonEmptyString;
-            readonly sse: Schema.NonEmptyString;
+            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
         }>;
         readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
     }>>;
@@ -373,11 +1333,16 @@ export declare const McpConfigSchema: Schema.Struct<{
 /** @experimental This API is unstable and may change without notice. */
 export type McpConfig = Schema.Schema.Type<typeof McpConfigSchema>;
 /** @experimental This API is unstable and may change without notice. */
+export declare const McpEnvExpansionSchema: Schema.Struct<{
+    readonly variables: Schema.Literals<readonly ["none", "braced"]>;
+    readonly defaults: Schema.Boolean;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type McpEnvExpansion = Schema.Schema.Type<typeof McpEnvExpansionSchema>;
+/** @experimental This API is unstable and may change without notice. */
 export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema.Struct<{
-    readonly standardsCompliance: Schema.Literal<"full">;
-    readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
     readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-    readonly config: Schema.Struct<{
+    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<{
@@ -390,7 +1355,7 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
                 readonly name: Schema.NonEmptyString;
                 readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                     readonly "streamable-http": Schema.NonEmptyString;
-                    readonly sse: Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                 }>]>;
             }>>;
             readonly command: Schema.Literals<readonly ["split", "array"]>;
@@ -401,31 +1366,72 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
                 readonly name: Schema.NonEmptyString;
                 readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                     readonly "streamable-http": Schema.NonEmptyString;
-                    readonly sse: Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                 }>]>;
             }>>;
             readonly urlKey: Schema.Struct<{
                 readonly "streamable-http": Schema.NonEmptyString;
-                readonly sse: Schema.NonEmptyString;
+                readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
             }>;
             readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
         }>>;
         readonly transform: 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 standardsCompliance: Schema.Literals<readonly ["parity", "partial"]>;
+    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 transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+    readonly availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -435,7 +1441,55 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -475,7 +1529,55 @@ export declare const HooksExtensionCapabilitySchema: Schema.Union<readonly [Sche
         readonly gitignored: Schema.Boolean;
     }>>;
     readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+    readonly availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -485,7 +1587,55 @@ export declare const HooksExtensionCapabilitySchema: Schema.Union<readonly [Sche
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -556,7 +1706,55 @@ export declare const PermissionsExtensionCapabilitySchema: Schema.Union<readonly
         readonly patch: Schema.NullOr<Schema.Unknown>;
         readonly template: Schema.NullOr<Schema.NonEmptyString>;
     }>>;
-    readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+    readonly availability: 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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -566,7 +1764,55 @@ export declare const PermissionsExtensionCapabilitySchema: Schema.Union<readonly
     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<"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;
+                }>>;
+            }>>;
+        }>;
+    }>]>;
+    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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
     readonly notes: Schema.NullOr<Schema.NonEmptyString>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
@@ -582,7 +1828,55 @@ export declare const AgentCapabilitiesSchema: 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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -592,7 +1886,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -602,7 +1944,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
     }>]>;
     command: Schema.Union<readonly [Schema.Struct<{
         readonly directory: Schema.NonEmptyString;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -612,7 +2002,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -621,10 +2059,8 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         readonly sources: Schema.$Array<Schema.NonEmptyString>;
     }>]>;
     "mcp-server": Schema.Union<readonly [Schema.Struct<{
-        readonly standardsCompliance: Schema.Literal<"full">;
-        readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
         readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-        readonly config: Schema.Struct<{
+        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<{
@@ -637,7 +2073,7 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
                     readonly name: Schema.NonEmptyString;
                     readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                         readonly "streamable-http": Schema.NonEmptyString;
-                        readonly sse: Schema.NonEmptyString;
+                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                     }>]>;
                 }>>;
                 readonly command: Schema.Literals<readonly ["split", "array"]>;
@@ -648,31 +2084,72 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
                     readonly name: Schema.NonEmptyString;
                     readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                         readonly "streamable-http": Schema.NonEmptyString;
-                        readonly sse: Schema.NonEmptyString;
+                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                     }>]>;
                 }>>;
                 readonly urlKey: Schema.Struct<{
                     readonly "streamable-http": Schema.NonEmptyString;
-                    readonly sse: Schema.NonEmptyString;
+                    readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                 }>;
                 readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
             }>>;
             readonly transform: 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 standardsCompliance: Schema.Literals<readonly ["parity", "partial"]>;
+        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 transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -682,7 +2159,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -693,7 +2218,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
     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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -703,7 +2276,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -715,7 +2336,55 @@ export declare const AgentCapabilitiesSchema: 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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -725,7 +2394,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -741,7 +2458,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -758,7 +2523,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -775,7 +2588,55 @@ export declare const AgentCapabilitiesSchema: 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 availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -785,7 +2646,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -801,7 +2710,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
             readonly gitignored: Schema.Boolean;
         }>>;
         readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -811,7 +2768,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -825,6 +2830,26 @@ export type AgentCapabilities = Schema.Schema.Type<typeof AgentCapabilitiesSchem
 /** @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 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;
@@ -833,10 +2858,97 @@ 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.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.decodeTo<Schema.toType<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.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>;
     readonly docs: Schema.$Array<Schema.Struct<{
         readonly label: Schema.NonEmptyString;
         readonly url: Schema.NonEmptyString;
@@ -846,7 +2958,55 @@ export declare const AgentSchema: 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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -856,7 +3016,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -866,7 +3074,55 @@ export declare const AgentSchema: Schema.Struct<{
         }>]>;
         command: Schema.Union<readonly [Schema.Struct<{
             readonly directory: Schema.NonEmptyString;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -876,7 +3132,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -885,10 +3189,8 @@ export declare const AgentSchema: Schema.Struct<{
             readonly sources: Schema.$Array<Schema.NonEmptyString>;
         }>]>;
         "mcp-server": Schema.Union<readonly [Schema.Struct<{
-            readonly standardsCompliance: Schema.Literal<"full">;
-            readonly convention: Schema.Literals<readonly ["universal", "vendor"]>;
             readonly transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-            readonly config: Schema.Struct<{
+            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<{
@@ -901,7 +3203,7 @@ export declare const AgentSchema: Schema.Struct<{
                         readonly name: Schema.NonEmptyString;
                         readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                             readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.NonEmptyString;
+                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                         }>]>;
                     }>>;
                     readonly command: Schema.Literals<readonly ["split", "array"]>;
@@ -912,31 +3214,72 @@ export declare const AgentSchema: Schema.Struct<{
                         readonly name: Schema.NonEmptyString;
                         readonly value: Schema.Union<readonly [Schema.NonEmptyString, Schema.Struct<{
                             readonly "streamable-http": Schema.NonEmptyString;
-                            readonly sse: Schema.NonEmptyString;
+                            readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                         }>]>;
                     }>>;
                     readonly urlKey: Schema.Struct<{
                         readonly "streamable-http": Schema.NonEmptyString;
-                        readonly sse: Schema.NonEmptyString;
+                        readonly sse: Schema.optionalKey<Schema.NonEmptyString>;
                     }>;
                     readonly headersKey: Schema.NullOr<Schema.NonEmptyString>;
                 }>>;
                 readonly transform: 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 standardsCompliance: Schema.Literals<readonly ["parity", "partial"]>;
+            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 transports: Schema.NonEmptyArray<Schema.Literals<readonly ["stdio", "http", "sse"]>>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -946,7 +3289,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -957,7 +3348,55 @@ export declare const AgentSchema: Schema.Struct<{
         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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -967,7 +3406,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -979,7 +3466,55 @@ export declare const AgentSchema: 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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -989,7 +3524,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1005,7 +3588,55 @@ export declare const AgentSchema: Schema.Struct<{
             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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1022,7 +3653,55 @@ export declare const AgentSchema: Schema.Struct<{
             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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1039,7 +3718,55 @@ export declare const AgentSchema: 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 availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1049,7 +3776,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1065,7 +3840,55 @@ export declare const AgentSchema: Schema.Struct<{
                 readonly gitignored: Schema.Boolean;
             }>>;
             readonly serializer: Schema.Literals<readonly ["claude-code-settings"]>;
-            readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+            readonly availability: 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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1075,7 +3898,55 @@ export declare const AgentSchema: Schema.Struct<{
             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<"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;
+                        }>>;
+                    }>>;
+                }>;
+            }>]>;
+            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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
             readonly notes: Schema.NullOr<Schema.NonEmptyString>;
             readonly docs: Schema.$Array<Schema.Struct<{
                 readonly label: Schema.NonEmptyString;
@@ -1112,7 +3983,55 @@ export declare const AgentSchema: Schema.Struct<{
             readonly patch: Schema.NullOr<Schema.Unknown>;
             readonly template: Schema.NullOr<Schema.NonEmptyString>;
         }>>;
-        readonly lifecycle: Schema.Literals<readonly ["supported", "planned"]>;
+        readonly availability: 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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["supported", "planned"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;
@@ -1122,7 +4041,55 @@ export declare const AgentSchema: Schema.Struct<{
         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<"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;
+                    }>>;
+                }>>;
+            }>;
+        }>]>;
+        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 axmSupport: Schema.Literals<readonly ["unsupported", "unknown"]>;
         readonly notes: Schema.NullOr<Schema.NonEmptyString>;
         readonly docs: Schema.$Array<Schema.Struct<{
             readonly label: Schema.NonEmptyString;