npm - @agentxm/client-core - Versions diffs - 0.15.1 → 0.16.0 - Mend

@agentxm/client-core 0.15.1 → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (234) hide show

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

@@ -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. */
@@ -175,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;
@@ -185,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;
@@ -197,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;
@@ -214,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;
@@ -224,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;
@@ -237,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;
@@ -247,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;
@@ -265,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;
@@ -275,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;
@@ -302,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;
@@ -319,9 +921,57 @@ 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 notes: Schema.NullOr<Schema.NonEmptyString>;
-    readonly docs: Schema.$Array<Schema.Struct<{
+    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;
         readonly url: Schema.NonEmptyString;
     }>>;
@@ -336,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;
@@ -346,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;
@@ -361,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;
@@ -371,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;
@@ -541,7 +1383,55 @@ export declare const McpExtensionCapabilitySchema: Schema.Union<readonly [Schema
     }>>;
     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;
@@ -551,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;
@@ -591,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;
@@ -601,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;
@@ -672,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;
@@ -682,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;
@@ -698,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;
@@ -708,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;
@@ -718,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;
@@ -728,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;
@@ -779,7 +2101,55 @@ export declare const AgentCapabilitiesSchema: Schema.Struct<{
         }>>;
         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;
@@ -789,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;
@@ -800,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;
@@ -810,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;
@@ -822,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;
@@ -832,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;
@@ -848,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;
@@ -865,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;
@@ -882,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;
@@ -892,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;
@@ -908,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;
@@ -918,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;
@@ -932,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;
@@ -940,6 +2858,19 @@ 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 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<{
@@ -1027,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;
@@ -1037,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;
@@ -1047,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;
@@ -1057,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;
@@ -1108,7 +3231,55 @@ export declare const AgentSchema: Schema.Struct<{
             }>>;
             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;
@@ -1118,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;
@@ -1129,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;
@@ -1139,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;
@@ -1151,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;
@@ -1161,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;
@@ -1177,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;
@@ -1194,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;
@@ -1211,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;
@@ -1221,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;
@@ -1237,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;
@@ -1247,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;
@@ -1284,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;
@@ -1294,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;