@agentxm/extension-model 0.28.4-bootstrap.0

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

@@ -0,0 +1,25 @@
+import type { Agent, AgentExtensionCapability } from "./schema.js";
+/** @experimental This API is unstable and may change without notice. */
+export declare const CAPABILITY_VERIFICATION_BUDGET_DAYS: {
+    readonly skill: 90;
+};
+/** @experimental This API is unstable and may change without notice. */
+export type AgentCapabilitySlot = keyof Agent["capabilities"] | "rule" | "permissions";
+/** @experimental This API is unstable and may change without notice. */
+export interface CapabilityVerificationAge {
+    readonly agentId: string;
+    readonly capability: AgentCapabilitySlot;
+    readonly status: AgentExtensionCapability["axm"]["status"];
+    readonly lastVerified: string | null;
+    readonly ageDays: number | null;
+    readonly budgetDays: number | null;
+    readonly overdue: boolean;
+}
+/**
+ * Reports verification age for every catalog capability independently. Pass an
+ * ISO date explicitly so CI and maintenance tooling produce reproducible output.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const capabilityVerificationAgeReport: (agents: ReadonlyArray<Agent>, asOf: string) => ReadonlyArray<CapabilityVerificationAge>;
+//# sourceMappingURL=verification.d.ts.map

package/dist/src/unstable/agent-capabilities/verification.js

@@ -0,0 +1,40 @@
+/** @experimental This API is unstable and may change without notice. */
+export const CAPABILITY_VERIFICATION_BUDGET_DAYS = {
+    skill: 90,
+};
+const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1_000;
+const capabilitySlots = (agent) => [
+    ["skill", agent.capabilities.skill],
+    ["mcp-server", agent.capabilities["mcp-server"]],
+    ["subagent", agent.capabilities.subagent],
+    ["hook", agent.capabilities.hook],
+    ["rule", agent.instructions],
+    ["permissions", agent.permissions],
+];
+const ageInDays = (lastVerified, asOf) => {
+    const verifiedAt = Date.parse(`${lastVerified}T00:00:00.000Z`);
+    const reportAt = Date.parse(`${asOf}T00:00:00.000Z`);
+    return Math.floor((reportAt - verifiedAt) / DAY_IN_MILLISECONDS);
+};
+/**
+ * Reports verification age for every catalog capability independently. Pass an
+ * ISO date explicitly so CI and maintenance tooling produce reproducible output.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const capabilityVerificationAgeReport = (agents, asOf) => agents.flatMap((agent) => capabilitySlots(agent).map(([capabilityName, capability]) => {
+    const budgetDays = capabilityName === "skill" ? CAPABILITY_VERIFICATION_BUDGET_DAYS.skill : null;
+    const ageDays = capability.axm.lastVerified === null ? null : ageInDays(capability.axm.lastVerified, asOf);
+    return {
+        agentId: agent.id,
+        capability: capabilityName,
+        status: capability.axm.status,
+        lastVerified: capability.axm.lastVerified,
+        ageDays,
+        budgetDays,
+        overdue: capability.axm.status === "supported" &&
+            budgetDays !== null &&
+            (ageDays === null || ageDays > budgetDays),
+    };
+}));
+//# sourceMappingURL=verification.js.map

package/dist/src/unstable/agents/registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent registry containing all known AI coding agents.
+ *
+ * Derives descriptors from the capability catalog. O(1) lookup by agent ID.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { type AgentId, type AgentRegistry } from "./types.js";
+/**
+ * Complete registry of all known AI coding agents.
+ *
+ * Keys are agent IDs, values are full descriptor objects.
+ * Paths are pre-expanded at module initialization.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const AGENTS: AgentRegistry;
+/**
+ * Get all registered agent IDs.
+ *
+ * @returns Array of all agent identifiers
+ *
+ * @example
+ * ```typescript
+ * const ids = getAgentIds();
+ * // ["adal", "amp", "antigravity", "augment", "claude-code", ...]
+ * ```
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const getAgentIds: () => ReadonlyArray<AgentId>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/unstable/agents/registry.js

@@ -0,0 +1,50 @@
+/**
+ * Agent registry containing all known AI coding agents.
+ *
+ * Derives descriptors from the capability catalog. O(1) lookup by agent ID.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Record from "effect/Record";
+import { CONFIGURABLE_AGENTS_BY_ID } from "../agent-capabilities/catalog.js";
+import { deriveAgentDescriptor } from "../agent-capabilities/derive.js";
+import { UNIVERSAL_SKILLS_DIR } from "../extensions/universal-skills-dir.js";
+import { AGENT_IDS } from "./types.js";
+const UNIVERSAL_AGENT_DESCRIPTOR = {
+    id: "universal",
+    name: "Universal",
+    rootDir: undefined,
+    skills: {
+        dir: UNIVERSAL_SKILLS_DIR,
+        additionalReadPaths: [],
+    },
+    detection: { project: { markers: [] }, user: { markers: [] } },
+};
+/**
+ * Complete registry of all known AI coding agents.
+ *
+ * Keys are agent IDs, values are full descriptor objects.
+ * Paths are pre-expanded at module initialization.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const AGENTS = {
+    ...Record.map(CONFIGURABLE_AGENTS_BY_ID, deriveAgentDescriptor),
+    universal: UNIVERSAL_AGENT_DESCRIPTOR,
+};
+/**
+ * Get all registered agent IDs.
+ *
+ * @returns Array of all agent identifiers
+ *
+ * @example
+ * ```typescript
+ * const ids = getAgentIds();
+ * // ["adal", "amp", "antigravity", "augment", "claude-code", ...]
+ * ```
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const getAgentIds = () => AGENT_IDS;
+//# sourceMappingURL=registry.js.map

package/dist/src/unstable/agents/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Type definitions for AI coding agent configuration.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { Record } from "effect";
+import { CONFIGURABLE_AGENT_IDS, type ConfigurableAgentId } from "../agent-capabilities/catalog.js";
+import type { DetectionMarker, Scope, ScopeDetection, SkillReadPath } from "../agent-capabilities/schema.js";
+/**
+ * Skills-specific configuration for an agent.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AgentSkillsDescriptor {
+    /** Skills directory, relative to cwd (e.g., ".claude/skills") */
+    readonly dir: string;
+    /** Additional native directories read for discovery. AXM never writes to these paths. */
+    readonly additionalReadPaths: ReadonlyArray<SkillReadPath>;
+}
+/**
+ * Subagents-specific configuration for an agent.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AgentSubagentsDescriptor {
+    /** Subagents directory, relative to cwd (e.g., ".claude/agents") */
+    readonly dir: string;
+    /**
+     * Scopes the agent itself supports for subagents. See
+     * The scopes the agent itself supports for subagents.
+     */
+    readonly scopes: ReadonlyArray<Scope>;
+    /**
+     * When true, the path is a single file (e.g., ".roomodes") rather than a
+     * directory containing subagent files.
+     */
+    readonly isFile?: boolean;
+}
+/**
+ * Workspace instruction-file convention for one coding agent.
+ *
+ * `rulesDir` on the file-based variants is a *secondary* native rules directory
+ * the agent also reads alongside its instruction file (e.g. Cursor reads both
+ * `AGENTS.md` and `.cursor/rules`). AXM does not write it — the field exists so
+ * status output can say so rather than silently reporting the agent as fully
+ * synced.
+ *
+ * @experimental
+ */
+export type AgentInstructionsDescriptor = {
+    readonly kind: "agents-md";
+    readonly rulesDir?: string;
+} | {
+    readonly kind: "own-file";
+    readonly file: string;
+    readonly importSyntax?: "at-path";
+    readonly rulesDir?: string;
+} | {
+    readonly kind: "rules-dir";
+    readonly dir: string;
+    readonly format: "frontmatter";
+};
+/** @experimental This API is unstable and may change without notice. */
+export type AgentDetectionMarker = DetectionMarker;
+/** @experimental This API is unstable and may change without notice. */
+export type AgentScopeDetectionDescriptor = ScopeDetection;
+/** @experimental This API is unstable and may change without notice. */
+export interface AgentDetectionDescriptor {
+    /** Project-scope markers resolved relative to the project root. */
+    readonly project: AgentScopeDetectionDescriptor;
+    /** User-scope markers resolved relative to home/config roots; executables use PATH. */
+    readonly user: AgentScopeDetectionDescriptor;
+}
+/** @experimental This API is unstable and may change without notice. */
+export { CONFIGURABLE_AGENT_IDS, type ConfigurableAgentId };
+/** @experimental This API is unstable and may change without notice. */
+export declare const AGENT_IDS: readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow", "universal"];
+/** @experimental This API is unstable and may change without notice. */
+export type AgentId = (typeof AGENT_IDS)[number];
+/** @experimental This API is unstable and may change without notice. */
+export declare const isConfigurableAgentId: (id: AgentId) => id is ConfigurableAgentId;
+/**
+ * Configuration for an AI coding agent.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AgentDescriptor {
+    /** Unique identifier (e.g., "claude-code") */
+    readonly id: AgentId;
+    /** Human-readable display name (e.g., "Claude Code") */
+    readonly name: string;
+    /**
+     * Per-agent native configuration root, relative to the workspace root
+     * (e.g., `.claude` for Claude Code, `.cursor` for Cursor). The
+     * workspace read-model scanners look for this agent's `settings.json`,
+     * `mcp.json`, and other native config files inside this directory.
+     *
+     * Three states (with `exactOptionalPropertyTypes: true`):
+     *
+     * - `string` — use this directory as the explicit native config root.
+     * - omitted (key not present) — fall back to the first segment of
+     *   `skills.dir` when a verified Skill surface exists, otherwise `.<id>`.
+     * - `undefined` — explicit opt-out. Scanners SHALL NOT attempt to
+     *   discover native config for this agent. Use this when an agent's
+     *   first `skills.dir` segment collides with another agent's (e.g.,
+     *   several agents share a parent like `.agents`) and there is no
+     *   authoritative answer about the real native config root.
+     */
+    readonly rootDir?: string | undefined;
+    /** Skills installation configuration, omitted when AXM has no verified writable surface. */
+    readonly skills?: AgentSkillsDescriptor;
+    /** Subagents installation configuration (optional — not all agents support subagents) */
+    readonly subagents?: AgentSubagentsDescriptor;
+    /** Workspace instruction-file convention for this coding agent. */
+    readonly instructions?: AgentInstructionsDescriptor;
+    /** Structured per-scope markers used by agent detection. */
+    readonly detection: AgentDetectionDescriptor;
+}
+/**
+ * Registry of all known agents, keyed by agent ID for O(1) lookup.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type AgentRegistry = Record.ReadonlyRecord<AgentId, AgentDescriptor>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/unstable/agents/types.js

@@ -0,0 +1,17 @@
+/**
+ * Type definitions for AI coding agent configuration.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { CONFIGURABLE_AGENT_IDS } from "../agent-capabilities/catalog.js";
+// -----------------------------------------------------------------------------
+// Agent Identifiers
+// -----------------------------------------------------------------------------
+/** @experimental This API is unstable and may change without notice. */
+export { CONFIGURABLE_AGENT_IDS };
+/** @experimental This API is unstable and may change without notice. */
+export const AGENT_IDS = [...CONFIGURABLE_AGENT_IDS, "universal"];
+/** @experimental This API is unstable and may change without notice. */
+export const isConfigurableAgentId = (id) => id !== "universal";
+//# sourceMappingURL=types.js.map

package/dist/src/unstable/date-time.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+/**
+ * Canonical timestamp schema: ISO 8601 UTC string on the wire, `DateTime.Utc`
+ * in memory.
+ *
+ * Decoding accepts any string `DateTime.make` understands and normalizes it to
+ * UTC; malformed strings fail decoding. Encoding always produces an ISO 8601
+ * UTC string (e.g. 2024-01-15T12:00:00.000Z), so wire formats are unchanged
+ * from the previous hand-written ISO-string handling.
+ *
+ * The encoded string side carries the `format: "date-time"` annotation so
+ * OpenAPI and JSON Schema emissions preserve the timestamp format.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const DateTimeUtcSchema: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+//# sourceMappingURL=date-time.d.ts.map

package/dist/src/unstable/date-time.js

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+/**
+ * Canonical timestamp schema: ISO 8601 UTC string on the wire, `DateTime.Utc`
+ * in memory.
+ *
+ * Decoding accepts any string `DateTime.make` understands and normalizes it to
+ * UTC; malformed strings fail decoding. Encoding always produces an ISO 8601
+ * UTC string (e.g. 2024-01-15T12:00:00.000Z), so wire formats are unchanged
+ * from the previous hand-written ISO-string handling.
+ *
+ * The encoded string side carries the `format: "date-time"` annotation so
+ * OpenAPI and JSON Schema emissions preserve the timestamp format.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const DateTimeUtcSchema = Schema.String.annotate({
+    identifier: "IsoDateTimeString",
+    title: "ISO Date-Time String",
+    description: "A date and time string (e.g. 2024-01-15T12:00:00.000Z).",
+    format: "date-time",
+})
+    .pipe(Schema.decodeTo(Schema.DateTimeUtc, SchemaTransformation.dateTimeUtcFromString))
+    .annotate({
+    identifier: "IsoDateTimeString",
+    title: "ISO Date-Time String",
+    description: "A date and time string (e.g. 2024-01-15T12:00:00.000Z).",
+    message: "Expected an ISO 8601 date-time string (e.g., 2024-01-15T12:00:00.000Z)",
+});
+//# sourceMappingURL=date-time.js.map

package/dist/src/unstable/discovery-walk.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared recursive discovery walk policy for extension scanners.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const DISCOVERY_SKIPPED_DIRECTORIES: ReadonlySet<string>;
+export declare const DISCOVERY_MAX_DEPTH = 5;
+//# sourceMappingURL=discovery-walk.d.ts.map

package/dist/src/unstable/discovery-walk.js

@@ -0,0 +1,15 @@
+/**
+ * Shared recursive discovery walk policy for extension scanners.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const DISCOVERY_SKIPPED_DIRECTORIES = new Set([
+    "node_modules",
+    ".git",
+    ".axm",
+    "dist",
+    "build",
+    "__pycache__",
+]);
+export const DISCOVERY_MAX_DEPTH = 5;
+//# sourceMappingURL=discovery-walk.js.map

package/dist/src/unstable/extension-types/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { CATALOG_EXTENSION_TYPES, type CatalogExtensionType, CatalogExtensionTypeSchema, type DocLink, DocLinkSchema, type ExtensionTypeCatalog, ExtensionTypeCatalogSchema, type ExtensionTypeDefinition, ExtensionTypeDefinitionSchema, LEAF_EXTENSION_TYPES, type LeafExtensionType, LeafExtensionTypeSchema, type Standard, StandardSchema, type Url, UrlSchema, isCatalogExtensionType, } from "./schema.js";
+export { STANDARDS } from "./standards.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/extension-types/index.js

@@ -0,0 +1,8 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { CATALOG_EXTENSION_TYPES, CatalogExtensionTypeSchema, DocLinkSchema, ExtensionTypeCatalogSchema, ExtensionTypeDefinitionSchema, LEAF_EXTENSION_TYPES, LeafExtensionTypeSchema, StandardSchema, UrlSchema, isCatalogExtensionType, } from "./schema.js";
+export { STANDARDS } from "./standards.js";
+//# sourceMappingURL=index.js.map

package/dist/src/unstable/extension-types/schema.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Agent-agnostic extension type catalog schemas.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import type { ExtensionType } from "../extensions/common.js";
+export type { PerAgentType, WorkspaceCapabilityKey, WorkspaceCapabilityType, } from "../extensions/common.js";
+/** @experimental This API is unstable and may change without notice. */
+export declare const LEAF_EXTENSION_TYPES: readonly ["skill", "mcp-server", "subagent", "rule", "hook"];
+/** @experimental This API is unstable and may change without notice. */
+export type LeafExtensionType = (typeof LEAF_EXTENSION_TYPES)[number];
+declare const _leafCoversInstallableTypes: true;
+export type _LeafExtensionTypeCoverage = typeof _leafCoversInstallableTypes;
+/** @experimental This API is unstable and may change without notice. */
+export declare const LeafExtensionTypeSchema: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook"]>;
+/** Registry/package extension types, including workspace-only knowledge bundles. */
+export declare const CATALOG_EXTENSION_TYPES: readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"];
+/** @experimental This API is unstable and may change without notice. */
+export type CatalogExtensionType = (typeof CATALOG_EXTENSION_TYPES)[number];
+declare const _catalogCoversNonPackTypes: true;
+export type _CatalogExtensionTypeCoverage = typeof _catalogCoversNonPackTypes;
+/** @experimental This API is unstable and may change without notice. */
+export declare const isCatalogExtensionType: (type: ExtensionType) => type is CatalogExtensionType;
+/** @experimental This API is unstable and may change without notice. */
+export declare const CatalogExtensionTypeSchema: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const UrlSchema: Schema.NonEmptyString;
+/** @experimental This API is unstable and may change without notice. */
+export type Url = Schema.Schema.Type<typeof UrlSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const StandardSchema: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly url: Schema.NonEmptyString;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type Standard = Schema.Schema.Type<typeof StandardSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const DocLinkSchema: Schema.Struct<{
+    readonly label: Schema.NonEmptyString;
+    readonly url: Schema.NonEmptyString;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type DocLink = Schema.Schema.Type<typeof DocLinkSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const ExtensionTypeDefinitionSchema: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+    readonly summary: Schema.NonEmptyString;
+    readonly description: Schema.NonEmptyString;
+    readonly standard: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+    readonly docs: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.NonEmptyString;
+        readonly url: Schema.NonEmptyString;
+    }>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type ExtensionTypeDefinition = Schema.Schema.Type<typeof ExtensionTypeDefinitionSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export type ExtensionTypeCatalog = {
+    readonly [Type in CatalogExtensionType]: ExtensionTypeDefinition;
+};
+/** @experimental This API is unstable and may change without notice. */
+export declare const ExtensionTypeCatalogSchema: Schema.Struct<{
+    readonly skill: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+    readonly "mcp-server": Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+    readonly subagent: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+    readonly rule: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+    readonly hook: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+    readonly knowledge: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
+        readonly summary: Schema.NonEmptyString;
+        readonly description: Schema.NonEmptyString;
+        readonly standard: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+        readonly docs: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.NonEmptyString;
+            readonly url: Schema.NonEmptyString;
+        }>>;
+    }>;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/unstable/extension-types/schema.js

@@ -0,0 +1,102 @@
+/**
+ * Agent-agnostic extension type catalog schemas.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+const isUrl = (value) => {
+    try {
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** @experimental This API is unstable and may change without notice. */
+export const LEAF_EXTENSION_TYPES = [
+    "skill",
+    "mcp-server",
+    "subagent",
+    "rule",
+    "hook",
+];
+const _leafCoversInstallableTypes = true;
+/** @experimental This API is unstable and may change without notice. */
+export const LeafExtensionTypeSchema = Schema.Literals(LEAF_EXTENSION_TYPES).annotate({
+    identifier: "LeafExtensionType",
+    title: "Leaf Extension Type",
+    description: "Installable extension type excluding packs.",
+});
+/** Registry/package extension types, including workspace-only knowledge bundles. */
+export const CATALOG_EXTENSION_TYPES = [
+    ...LEAF_EXTENSION_TYPES,
+    "knowledge",
+];
+const _catalogCoversNonPackTypes = true;
+const catalogExtensionTypeSet = new Set(CATALOG_EXTENSION_TYPES);
+/** @experimental This API is unstable and may change without notice. */
+export const isCatalogExtensionType = (type) => catalogExtensionTypeSet.has(type);
+/** @experimental This API is unstable and may change without notice. */
+export const CatalogExtensionTypeSchema = Schema.Literals(CATALOG_EXTENSION_TYPES).annotate({
+    identifier: "CatalogExtensionType",
+    title: "Catalog Extension Type",
+    description: "Non-pack extension types represented by the AgentXM registry.",
+});
+/** @experimental This API is unstable and may change without notice. */
+export const UrlSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => (isUrl(value) ? undefined : `Expected URL, got ${value}`)))).annotate({
+    identifier: "Url",
+    title: "URL",
+    description: "Absolute URL string.",
+    examples: ["https://example.com/docs"],
+});
+/** @experimental This API is unstable and may change without notice. */
+export const StandardSchema = Schema.Struct({
+    id: Schema.NonEmptyString,
+    name: Schema.NonEmptyString,
+    url: UrlSchema,
+}).annotate({
+    identifier: "Standard",
+    title: "Standard",
+    description: "Open standard that is authoritative for an extension type's capability.",
+});
+/** @experimental This API is unstable and may change without notice. */
+export const DocLinkSchema = Schema.Struct({
+    label: Schema.NonEmptyString,
+    url: UrlSchema,
+}).annotate({
+    identifier: "DocLink",
+    title: "Documentation Link",
+    description: "Documentation reference for an agent or capability.",
+});
+/** @experimental This API is unstable and may change without notice. */
+export const ExtensionTypeDefinitionSchema = Schema.Struct({
+    id: CatalogExtensionTypeSchema,
+    summary: Schema.NonEmptyString,
+    description: Schema.NonEmptyString,
+    standard: Schema.NullOr(StandardSchema),
+    docs: Schema.Array(DocLinkSchema).check(Schema.makeFilter((docs) => docs.length > 0 ? true : "Every catalog entry needs at least one doc link")),
+})
+    .annotate({
+    identifier: "ExtensionTypeDefinition",
+    title: "Extension Type Definition",
+    description: "Agent-agnostic catalog entry describing one leaf extension type's capability.",
+})
+    .check(Schema.makeFilter((definition) => definition.standard === null ||
+    definition.docs.every((doc) => doc.url !== definition.standard?.url)
+    ? true
+    : "Doc links must be distinct from the governing standard's url"));
+/** @experimental This API is unstable and may change without notice. */
+export const ExtensionTypeCatalogSchema = Schema.Struct({
+    skill: ExtensionTypeDefinitionSchema,
+    "mcp-server": ExtensionTypeDefinitionSchema,
+    subagent: ExtensionTypeDefinitionSchema,
+    rule: ExtensionTypeDefinitionSchema,
+    hook: ExtensionTypeDefinitionSchema,
+    knowledge: ExtensionTypeDefinitionSchema,
+}).annotate({
+    identifier: "ExtensionTypeCatalog",
+    title: "Extension Type Catalog",
+    description: "Agent-agnostic catalog keyed by leaf extension type.",
+});
+//# sourceMappingURL=schema.js.map