npm - @agentxm/extension-model - Versions diffs - 0.37.3 → 0.38.0 - Mend

@agentxm/extension-model 0.37.3 → 0.38.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 (161) hide show

package/dist/src/unstable/agent-capabilities/reference.d.ts ADDED Viewed

@@ -0,0 +1,822 @@
+import * as Schema from "effect/Schema";
+import { type Agent, type AgentExtensionCapability } from "./schema.js";
+export declare const AgentInstallabilitySchema: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+}>;
+export type AgentInstallability = Schema.Schema.Type<typeof AgentInstallabilitySchema>;
+/** Public evidence projection; native paths and AXM writer mechanics stay private to the catalog. */
+export declare const AgentCatalogCapabilitySchema: Schema.Struct<{
+    readonly native: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+        readonly availability: Schema.Union<readonly [Schema.Struct<{
+            readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+        }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"active">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"maintenance">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"deprecated">;
+        }>, Schema.Struct<{
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NullOr<Schema.NonEmptyString>;
+            readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+            readonly state: Schema.Literal<"removed">;
+        }>]>;
+        readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly sources: Schema.$Array<Schema.NonEmptyString>;
+        readonly review: Schema.NullOr<Schema.Struct<{
+            readonly reviewedAt: Schema.NonEmptyString;
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+            readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+        }>>;
+        readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+        readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+    }>;
+    readonly axm: Schema.Struct<{
+        readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+        readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+        readonly verification: Schema.NullOr<Schema.Struct<{
+            readonly verifiedAt: Schema.NonEmptyString;
+            readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+            readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+        }>>;
+    }>;
+    readonly installability: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+    }>;
+}>;
+export type AgentCatalogCapability = Schema.Schema.Type<typeof AgentCatalogCapabilitySchema>;
+export declare const AgentCatalogEntrySchema: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly vendor: Schema.NonEmptyString;
+    readonly homepage: Schema.NonEmptyString;
+    readonly interfaces: Schema.NonEmptyArray<Schema.Literals<readonly ["cli", "ide-extension", "desktop", "embedded", "workspace-agent", "chat", "hosted-agent"]>>;
+    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 docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    readonly profile: Schema.NullOr<Schema.Struct<{
+        readonly identity: Schema.Struct<{
+            readonly product: Schema.NonEmptyString;
+            readonly surface: Schema.NonEmptyString;
+            readonly edition: Schema.NullOr<Schema.NonEmptyString>;
+            readonly ownership: Schema.NullOr<Schema.Struct<{
+                readonly company: Schema.NonEmptyString;
+                readonly parentCompany: Schema.NullOr<Schema.NonEmptyString>;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>>;
+            readonly modelProviders: Schema.NullOr<Schema.$Array<Schema.NonEmptyString>>;
+        }>;
+        readonly review: Schema.Struct<{
+            readonly reviewedAt: Schema.NonEmptyString;
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+            readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+        }>;
+        readonly lifecycleQualifications: Schema.$Array<Schema.Struct<{
+            readonly scope: Schema.Literals<readonly ["vendor", "product", "surface", "edition"]>;
+            readonly subject: Schema.NonEmptyString;
+            readonly state: Schema.Literals<readonly ["active", "maintenance", "deprecated", "retired"]>;
+            readonly since: Schema.NullOr<Schema.NonEmptyString>;
+            readonly note: Schema.NonEmptyString;
+            readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        }>>;
+    }>>;
+    readonly capabilities: Schema.Struct<{
+        readonly skill: Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly review: Schema.NullOr<Schema.Struct<{
+                    readonly reviewedAt: Schema.NonEmptyString;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                }>>;
+                readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly verification: Schema.NullOr<Schema.Struct<{
+                    readonly verifiedAt: Schema.NonEmptyString;
+                    readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                    readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>>;
+            }>;
+            readonly installability: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+        }>;
+        readonly "mcp-server": Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly review: Schema.NullOr<Schema.Struct<{
+                    readonly reviewedAt: Schema.NonEmptyString;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                }>>;
+                readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly verification: Schema.NullOr<Schema.Struct<{
+                    readonly verifiedAt: Schema.NonEmptyString;
+                    readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                    readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>>;
+            }>;
+            readonly installability: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+        }>;
+        readonly subagent: Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly review: Schema.NullOr<Schema.Struct<{
+                    readonly reviewedAt: Schema.NonEmptyString;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                }>>;
+                readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly verification: Schema.NullOr<Schema.Struct<{
+                    readonly verifiedAt: Schema.NonEmptyString;
+                    readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                    readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>>;
+            }>;
+            readonly installability: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+        }>;
+        readonly rule: Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly review: Schema.NullOr<Schema.Struct<{
+                    readonly reviewedAt: Schema.NonEmptyString;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                }>>;
+                readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly verification: Schema.NullOr<Schema.Struct<{
+                    readonly verifiedAt: Schema.NonEmptyString;
+                    readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                    readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>>;
+            }>;
+            readonly installability: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+        }>;
+        readonly hook: Schema.Struct<{
+            readonly native: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                readonly availability: Schema.Union<readonly [Schema.Struct<{
+                    readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                    readonly state: Schema.Literal<"active">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"maintenance">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"deprecated">;
+                }>, Schema.Struct<{
+                    readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                    readonly state: Schema.Literal<"removed">;
+                }>]>;
+                readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                readonly docs: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.NonEmptyString;
+                    readonly url: Schema.NonEmptyString;
+                }>>;
+                readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                readonly review: Schema.NullOr<Schema.Struct<{
+                    readonly reviewedAt: Schema.NonEmptyString;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                }>>;
+                readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+            }>;
+            readonly axm: Schema.Struct<{
+                readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                readonly verification: Schema.NullOr<Schema.Struct<{
+                    readonly verifiedAt: Schema.NonEmptyString;
+                    readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                    readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>>;
+            }>;
+            readonly installability: Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+            }>;
+        }>;
+    }>;
+}>;
+export type AgentCatalogEntry = Schema.Schema.Type<typeof AgentCatalogEntrySchema>;
+/** Versioned release asset consumed independently of CLI implementation details. */
+export declare const AgentCatalogReferenceSchema: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly vendor: Schema.NonEmptyString;
+        readonly homepage: Schema.NonEmptyString;
+        readonly interfaces: Schema.NonEmptyArray<Schema.Literals<readonly ["cli", "ide-extension", "desktop", "embedded", "workspace-agent", "chat", "hosted-agent"]>>;
+        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 docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly profile: Schema.NullOr<Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly product: Schema.NonEmptyString;
+                readonly surface: Schema.NonEmptyString;
+                readonly edition: Schema.NullOr<Schema.NonEmptyString>;
+                readonly ownership: Schema.NullOr<Schema.Struct<{
+                    readonly company: Schema.NonEmptyString;
+                    readonly parentCompany: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                }>>;
+                readonly modelProviders: Schema.NullOr<Schema.$Array<Schema.NonEmptyString>>;
+            }>;
+            readonly review: Schema.Struct<{
+                readonly reviewedAt: Schema.NonEmptyString;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+            }>;
+            readonly lifecycleQualifications: Schema.$Array<Schema.Struct<{
+                readonly scope: Schema.Literals<readonly ["vendor", "product", "surface", "edition"]>;
+                readonly subject: Schema.NonEmptyString;
+                readonly state: Schema.Literals<readonly ["active", "maintenance", "deprecated", "retired"]>;
+                readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                readonly note: Schema.NonEmptyString;
+                readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            }>>;
+        }>>;
+        readonly capabilities: Schema.Struct<{
+            readonly skill: Schema.Struct<{
+                readonly native: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                    readonly availability: Schema.Union<readonly [Schema.Struct<{
+                        readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                    }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"active">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"maintenance">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"deprecated">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"removed">;
+                    }>]>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly docs: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.NonEmptyString;
+                        readonly url: Schema.NonEmptyString;
+                    }>>;
+                    readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                    readonly review: Schema.NullOr<Schema.Struct<{
+                        readonly reviewedAt: Schema.NonEmptyString;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                        readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>>;
+                    readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                    readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+                }>;
+                readonly axm: Schema.Struct<{
+                    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly verification: Schema.NullOr<Schema.Struct<{
+                        readonly verifiedAt: Schema.NonEmptyString;
+                        readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                        readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    }>>;
+                }>;
+                readonly installability: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>;
+            }>;
+            readonly "mcp-server": Schema.Struct<{
+                readonly native: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                    readonly availability: Schema.Union<readonly [Schema.Struct<{
+                        readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                    }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"active">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"maintenance">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"deprecated">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"removed">;
+                    }>]>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly docs: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.NonEmptyString;
+                        readonly url: Schema.NonEmptyString;
+                    }>>;
+                    readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                    readonly review: Schema.NullOr<Schema.Struct<{
+                        readonly reviewedAt: Schema.NonEmptyString;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                        readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>>;
+                    readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                    readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+                }>;
+                readonly axm: Schema.Struct<{
+                    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly verification: Schema.NullOr<Schema.Struct<{
+                        readonly verifiedAt: Schema.NonEmptyString;
+                        readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                        readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    }>>;
+                }>;
+                readonly installability: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>;
+            }>;
+            readonly subagent: Schema.Struct<{
+                readonly native: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                    readonly availability: Schema.Union<readonly [Schema.Struct<{
+                        readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                    }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"active">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"maintenance">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"deprecated">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"removed">;
+                    }>]>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly docs: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.NonEmptyString;
+                        readonly url: Schema.NonEmptyString;
+                    }>>;
+                    readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                    readonly review: Schema.NullOr<Schema.Struct<{
+                        readonly reviewedAt: Schema.NonEmptyString;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                        readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>>;
+                    readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                    readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+                }>;
+                readonly axm: Schema.Struct<{
+                    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly verification: Schema.NullOr<Schema.Struct<{
+                        readonly verifiedAt: Schema.NonEmptyString;
+                        readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                        readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    }>>;
+                }>;
+                readonly installability: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>;
+            }>;
+            readonly rule: Schema.Struct<{
+                readonly native: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                    readonly availability: Schema.Union<readonly [Schema.Struct<{
+                        readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                    }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"active">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"maintenance">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"deprecated">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"removed">;
+                    }>]>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly docs: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.NonEmptyString;
+                        readonly url: Schema.NonEmptyString;
+                    }>>;
+                    readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                    readonly review: Schema.NullOr<Schema.Struct<{
+                        readonly reviewedAt: Schema.NonEmptyString;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                        readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>>;
+                    readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                    readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+                }>;
+                readonly axm: Schema.Struct<{
+                    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly verification: Schema.NullOr<Schema.Struct<{
+                        readonly verifiedAt: Schema.NonEmptyString;
+                        readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                        readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    }>>;
+                }>;
+                readonly installability: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>;
+            }>;
+            readonly hook: Schema.Struct<{
+                readonly native: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["native", "native-deprecated", "plugin", "plugin-deprecated", "none", "unknown"]>;
+                    readonly availability: Schema.Union<readonly [Schema.Struct<{
+                        readonly via: Schema.Literals<readonly ["native", "none", "unknown"]>;
+                    }>, 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 vendorStatus: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"active">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"maintenance">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"deprecated">;
+                    }>, Schema.Struct<{
+                        readonly since: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly note: Schema.NullOr<Schema.NonEmptyString>;
+                        readonly supersededByType: Schema.NullOr<Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>>;
+                        readonly state: Schema.Literal<"removed">;
+                    }>]>;
+                    readonly notes: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly docs: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.NonEmptyString;
+                        readonly url: Schema.NonEmptyString;
+                    }>>;
+                    readonly sources: Schema.$Array<Schema.NonEmptyString>;
+                    readonly review: Schema.NullOr<Schema.Struct<{
+                        readonly reviewedAt: Schema.NonEmptyString;
+                        readonly sources: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                        readonly claimScope: Schema.optionalKey<Schema.NonEmptyString>;
+                    }>>;
+                    readonly scopes: Schema.$Array<Schema.Literals<readonly ["user", "project"]>>;
+                    readonly mechanisms: Schema.$Array<Schema.Literals<readonly ["command-stdin", "http", "prompt", "agent", "mcp", "raw"]>>;
+                }>;
+                readonly axm: Schema.Struct<{
+                    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>, Schema.Literal<"writer">]>;
+                    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly verification: Schema.NullOr<Schema.Struct<{
+                        readonly verifiedAt: Schema.NonEmptyString;
+                        readonly boundary: Schema.Literals<readonly ["configuration", "vendor-runtime"]>;
+                        readonly evidence: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                    }>>;
+                }>;
+                readonly installability: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["supported", "manual", "conditional", "unsupported", "unknown"]>;
+                    readonly conditions: Schema.$Array<Schema.NonEmptyString>;
+                    readonly limitations: Schema.$Array<Schema.NonEmptyString>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>;
+export type AgentCatalogReference = Schema.Schema.Type<typeof AgentCatalogReferenceSchema>;
+export declare const capabilityInstallability: (agent: Agent, capability: AgentExtensionCapability) => AgentInstallability;
+export declare const makeAgentCatalogCapability: (agent: Agent, capability: AgentExtensionCapability) => AgentCatalogCapability;
+export declare const makeAgentCatalogEntry: (agent: Agent) => AgentCatalogEntry;
+export declare const makeAgentCatalogReference: (agents: ReadonlyArray<Agent>) => AgentCatalogReference;
+//# sourceMappingURL=reference.d.ts.map