@agentxm/extension-model 0.28.4-bootstrap.0

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

@@ -0,0 +1,29 @@
+/**
+ * Open standards referenced by the extension type catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** @experimental This API is unstable and may change without notice. */
+export declare const STANDARDS: {
+    readonly skills: {
+        readonly id: "agent-skills";
+        readonly name: "Agent Skills";
+        readonly url: "https://agentskills.io";
+    };
+    readonly mcp: {
+        readonly id: "mcp";
+        readonly name: "Model Context Protocol";
+        readonly url: "https://modelcontextprotocol.io";
+    };
+    readonly rules: {
+        readonly id: "agents-md";
+        readonly name: "AGENTS.md";
+        readonly url: "https://agents.md";
+    };
+    readonly okf: {
+        readonly id: "okf-0.2";
+        readonly name: "Open Knowledge Format 0.2";
+        readonly url: "https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md";
+    };
+};
+//# sourceMappingURL=standards.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * Open standards referenced by the extension type catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** @experimental This API is unstable and may change without notice. */
+export const STANDARDS = {
+    skills: {
+        id: "agent-skills",
+        name: "Agent Skills",
+        url: "https://agentskills.io",
+    },
+    mcp: {
+        id: "mcp",
+        name: "Model Context Protocol",
+        url: "https://modelcontextprotocol.io",
+    },
+    rules: {
+        id: "agents-md",
+        name: "AGENTS.md",
+        url: "https://agents.md",
+    },
+    okf: {
+        id: "okf-0.2",
+        name: "Open Knowledge Format 0.2",
+        url: "https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md",
+    },
+};
+//# sourceMappingURL=standards.js.map

package/dist/src/unstable/extensions/common.d.ts

@@ -0,0 +1,539 @@
+/**
+ * Common schema definitions shared across AXM configuration files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+/**
+ * Author information for a manifest.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const AuthorSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly email: Schema.optional<Schema.String>;
+    readonly url: Schema.optional<Schema.String>;
+}>;
+/**
+ * Author information in runtime/domain models.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface Author {
+    readonly name: string;
+    readonly email: Option.Option<string>;
+    readonly url: Option.Option<string>;
+}
+/** Convert schema-decoded author shape into runtime/domain Author. */
+export declare const toAuthor: (author: Schema.Schema.Type<typeof AuthorSchema>) => Author;
+/**
+ * Repository field for extension manifests. Accepts either a URL string
+ * (or shorthand like `github:owner/repo`) or an npm-style object with
+ * optional `type` and `directory` for monorepo subpaths.
+ *
+ * Matches the shape accepted by npm's `package.json` `repository` field.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RepositorySchema: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly type: Schema.optional<Schema.NonEmptyString>;
+    readonly url: Schema.NonEmptyString;
+    readonly directory: Schema.optional<Schema.NonEmptyString>;
+}>]>;
+/**
+ * Inferred type for {@link RepositorySchema}.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type Repository = Schema.Schema.Type<typeof RepositorySchema>;
+/**
+ * Bugs field for extension manifests. Accepts either a URL string or an
+ * npm-style object with optional `url` and `email`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const BugsSchema: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly url: Schema.optional<Schema.NonEmptyString>;
+    readonly email: Schema.optional<Schema.NonEmptyString>;
+}>]>;
+/**
+ * Inferred type for {@link BugsSchema}.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type Bugs = Schema.Schema.Type<typeof BugsSchema>;
+/**
+ * License field for extension manifests.
+ *
+ * Accepts valid SPDX license expressions plus the npm-compatible
+ * `UNLICENSED` literal for proprietary code that grants no license.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LicenseSchema: Schema.String;
+/** How an extension type is distributed. All current types are registry-distributed. */
+export type ExtensionDistribution = "registry";
+/**
+ * Where an extension type's installed artifacts live: in per-agent locations
+ * AXM can collide with, in workspace-owned locations, or nowhere of its own
+ * (container types like pack).
+ */
+export type ExtensionPlacement = "per-agent" | "workspace" | "container";
+/** What a governing standard covers for a type, when one exists. */
+export type StandardGoverns = "package-body" | "runtime-protocol" | "host-file";
+/** Workspace-level capability a type participates in. */
+export type WorkspaceCapabilityKey = "instructions";
+/**
+ * One extension type's naming and capability-axis row. Every CONDITIONAL
+ * parity obligation is a predicate over the five axis columns.
+ */
+interface ExtensionTypeRow {
+    readonly plural: string;
+    readonly label: string;
+    readonly pluralLabel: string;
+    readonly sentenceLabel: string;
+    readonly pluralSentenceLabel: string;
+    readonly distribution: ExtensionDistribution;
+    readonly placement: ExtensionPlacement;
+    readonly governs: StandardGoverns | null;
+    readonly installInputs: boolean;
+    readonly workspaceCapability: WorkspaceCapabilityKey | null;
+}
+/**
+ * Single source of truth for extension type naming. Row order is the canonical
+ * display order. Every other type-naming export in this module derives from
+ * this table, so a new extension type is exactly one row here: a missing
+ * column is TS2741, an excess column is TS2353, and every downstream
+ * `satisfies Record<ExtensionType, _>` table fails until the new type is
+ * decided everywhere.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const EXTENSION_TYPE_TABLE: {
+    readonly skill: {
+        readonly plural: "skills";
+        readonly label: "Skill";
+        readonly pluralLabel: "Skills";
+        readonly sentenceLabel: "skill";
+        readonly pluralSentenceLabel: "skills";
+        readonly distribution: "registry";
+        readonly placement: "per-agent";
+        readonly governs: "package-body";
+        readonly installInputs: false;
+        readonly workspaceCapability: null;
+    };
+    readonly "mcp-server": {
+        readonly plural: "mcps";
+        readonly label: "MCP Server";
+        readonly pluralLabel: "MCP Servers";
+        readonly sentenceLabel: "MCP server";
+        readonly pluralSentenceLabel: "MCP servers";
+        readonly distribution: "registry";
+        readonly placement: "per-agent";
+        readonly governs: "runtime-protocol";
+        readonly installInputs: true;
+        readonly workspaceCapability: null;
+    };
+    readonly subagent: {
+        readonly plural: "subagents";
+        readonly label: "Subagent";
+        readonly pluralLabel: "Subagents";
+        readonly sentenceLabel: "subagent";
+        readonly pluralSentenceLabel: "subagents";
+        readonly distribution: "registry";
+        readonly placement: "per-agent";
+        readonly governs: null;
+        readonly installInputs: false;
+        readonly workspaceCapability: null;
+    };
+    readonly rule: {
+        readonly plural: "rules";
+        readonly label: "Rule";
+        readonly pluralLabel: "Rules";
+        readonly sentenceLabel: "rule";
+        readonly pluralSentenceLabel: "rules";
+        readonly distribution: "registry";
+        readonly placement: "workspace";
+        readonly governs: "host-file";
+        readonly installInputs: false;
+        readonly workspaceCapability: "instructions";
+    };
+    readonly hook: {
+        readonly plural: "hooks";
+        readonly label: "Hook";
+        readonly pluralLabel: "Hooks";
+        readonly sentenceLabel: "hook";
+        readonly pluralSentenceLabel: "hooks";
+        readonly distribution: "registry";
+        readonly placement: "per-agent";
+        readonly governs: null;
+        readonly installInputs: false;
+        readonly workspaceCapability: null;
+    };
+    readonly knowledge: {
+        readonly plural: "knowledge";
+        readonly label: "Knowledge";
+        readonly pluralLabel: "Knowledge";
+        readonly sentenceLabel: "knowledge bundle";
+        readonly pluralSentenceLabel: "knowledge bundles";
+        readonly distribution: "registry";
+        readonly placement: "workspace";
+        readonly governs: "package-body";
+        readonly installInputs: false;
+        readonly workspaceCapability: null;
+    };
+    readonly pack: {
+        readonly plural: "packs";
+        readonly label: "Pack";
+        readonly pluralLabel: "Packs";
+        readonly sentenceLabel: "pack";
+        readonly pluralSentenceLabel: "packs";
+        readonly distribution: "registry";
+        readonly placement: "container";
+        readonly governs: null;
+        readonly installInputs: false;
+        readonly workspaceCapability: null;
+    };
+};
+export type ExtensionType = keyof typeof EXTENSION_TYPE_TABLE;
+export type ExtensionTypePlural = (typeof EXTENSION_TYPE_TABLE)[ExtensionType]["plural"];
+export declare const extensionTypes: ReadonlyArray<ExtensionType>;
+export declare const extensionTypePluralSegments: ReadonlyArray<ExtensionTypePlural>;
+export declare const isExtensionType: (value: string | undefined) => value is ExtensionType;
+export declare const isExtensionTypePlural: (value: string | undefined) => value is ExtensionTypePlural;
+export declare const extensionTypeFromPlural: Record<ExtensionTypePlural, ExtensionType>;
+export declare const extensionTypeToPlural: Record<ExtensionType, ExtensionTypePlural>;
+export declare const toExtensionType: (segment: ExtensionTypePlural) => ExtensionType;
+export declare const toExtensionTypePlural: (type: ExtensionType) => ExtensionTypePlural;
+export declare const extensionTypeLabels: Record<ExtensionType, string>;
+export declare const extensionTypePluralLabels: Record<ExtensionTypePlural, string>;
+export declare const extensionTypeSentenceLabels: Record<ExtensionType, string>;
+export declare const extensionTypePluralSentenceLabels: Record<ExtensionTypePlural, string>;
+/**
+ * Plural extension-type segments that may appear as dependency keys —
+ * everything except `packs`. Packs cannot depend on other packs.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type NonPackExtensionTypePlural = Exclude<ExtensionTypePlural, "packs">;
+export declare const nonPackExtensionTypePluralSegments: ReadonlyArray<NonPackExtensionTypePlural>;
+type ExtensionTypeRows = typeof EXTENSION_TYPE_TABLE;
+/**
+ * Extension types whose table row matches an axis value. Derived, never
+ * hand-written: an axis change on a row updates every union below, and the
+ * exact-membership pins in extension-type-table.type-test.ts fail compile in
+ * both directions if a union gains or loses a member.
+ */
+type TypesWhere<Axis extends keyof ExtensionTypeRow, Value> = {
+    [Key in ExtensionType]: ExtensionTypeRows[Key][Axis] extends Value ? Key : never;
+}[ExtensionType];
+/** Extension types materialized into agent-owned locations. */
+export type PerAgentType = TypesWhere<"placement", "per-agent">;
+/** Extension types materialized into workspace-owned locations. */
+export type WorkspaceType = TypesWhere<"placement", "workspace">;
+/** Extension types that coordinate other extensions instead of projecting directly. */
+export type ContainerType = TypesWhere<"placement", "container">;
+/** Registry-distributed non-container extension types. */
+export type RegistryType = PerAgentType | WorkspaceType;
+/** Extension types whose installs accept user-provided inputs. */
+export type InputType = TypesWhere<"installInputs", true>;
+/** Extension types whose governing standard covers the package body. */
+export type BodyGovernedType = TypesWhere<"governs", "package-body">;
+/**
+ * Extension types a standard governs at all. The agent catalog records a
+ * standards-compliance grade for exactly these, so the grade is never
+ * hand-applied per capability schema.
+ */
+export type SpecTrackedType = TypesWhere<"governs", StandardGoverns>;
+/**
+ * Extension types that double as a workspace-level capability toggle. These
+ * carry workspace configuration of their own, so surfaces that split extension
+ * management from workspace management group them with the workspace.
+ */
+export type WorkspaceCapabilityType = TypesWhere<"workspaceCapability", WorkspaceCapabilityKey>;
+export declare const PER_AGENT_EXTENSION_TYPES: ReadonlyArray<PerAgentType>;
+export declare const WORKSPACE_EXTENSION_TYPES: ReadonlyArray<WorkspaceType>;
+export declare const CONTAINER_EXTENSION_TYPES: ReadonlyArray<ContainerType>;
+export declare const REGISTRY_EXTENSION_TYPES: ReadonlyArray<RegistryType>;
+export declare const INPUT_EXTENSION_TYPES: ReadonlyArray<InputType>;
+export declare const BODY_GOVERNED_EXTENSION_TYPES: ReadonlyArray<BodyGovernedType>;
+export declare const SPEC_TRACKED_EXTENSION_TYPES: ReadonlyArray<SpecTrackedType>;
+export declare const WORKSPACE_CAPABILITY_EXTENSION_TYPES: ReadonlyArray<WorkspaceCapabilityType>;
+/** Extension types managed purely as extensions, with no workspace capability. */
+export declare const EXTENSION_ONLY_TYPES: ReadonlyArray<Exclude<ExtensionType, WorkspaceCapabilityType>>;
+/**
+ * Fully qualified name regex: `@<handle>/<type>/<name>` where handle and name
+ * use the canonical handle, plural extension type, and extension name grammar.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const FQN_PATTERN: RegExp;
+/**
+ * Fully qualified name regex restricted to non-pack extension types. Matches
+ * `@<handle>/<type>/<name>` where `<type>` is any plural extension type other
+ * than `packs`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const NON_PACK_FQN_PATTERN: RegExp;
+/**
+ * Fully qualified name regex restricted to the pack extension type. Matches
+ * `@<handle>/packs/<name>`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PACK_FQN_PATTERN: RegExp;
+/**
+ * Canonical extension short name regex.
+ */
+export declare const EXTENSION_NAME_PATTERN: RegExp;
+/**
+ * Canonical extension short name schema shared by generic extension surfaces.
+ */
+export declare const ExtensionNameSchema: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+export type ExtensionName = Schema.Schema.Type<typeof ExtensionNameSchema>;
+export declare const decodeExtensionNameSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"ExtensionName">;
+/**
+ * Extension type enumeration.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionTypeSchema: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+/**
+ * Plural extension-type segment enumeration used by route/FQN surfaces.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionTypePluralSchema: Schema.Literals<readonly ("skills" | "mcps" | "subagents" | "rules" | "hooks" | "knowledge" | "packs")[]>;
+/**
+ * Structured FQN parts schema composed from the canonical handle, type, and name schemas.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionFqnPartsSchema: Schema.Struct<{
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+}>;
+/**
+ * Inferred type for parsed FQN parts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type ExtensionFqnParts = Schema.Schema.Type<typeof ExtensionFqnPartsSchema>;
+/**
+ * Parse a fully qualified name string into validated structured parts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const parseExtensionFqnParts: (input: string) => ExtensionFqnParts | undefined;
+/**
+ * Parse an extension spec string (with optional version constraint) into parts.
+ * Strips the version constraint suffix and returns the validated FQN parts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const parseExtensionSpecParts: (input: string) => ExtensionFqnParts | undefined;
+/**
+ * Fully qualified name string schema validated against the composed handle,
+ * type, and name patterns. Annotated so JSON Schema generation surfaces a
+ * `pattern` and a top-level `ExtensionFqn` definition that `Schema.Record`
+ * keys can reference via `propertyNames`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionFqnSchema: Schema.String;
+/**
+ * Inferred type for ExtensionFqn schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type ExtensionFqn = Schema.Schema.Type<typeof ExtensionFqnSchema>;
+/**
+ * Fully qualified name string schema restricted to non-pack extension types.
+ * Used wherever pack-typed FQNs are not permitted, like the keys of a pack
+ * manifest's `dependencies` map.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const NonPackExtensionFqnSchema: Schema.String;
+/**
+ * Inferred type for NonPackExtensionFqn schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type NonPackExtensionFqn = Schema.Schema.Type<typeof NonPackExtensionFqnSchema>;
+/**
+ * Fully qualified name string schema restricted to the pack extension type.
+ * Used wherever only pack-typed FQNs are permitted, like the items of a
+ * non-pack manifest's `recommendedPacks` list.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackFqnSchema: Schema.String;
+/**
+ * Inferred type for PackFqn schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PackFqn = Schema.Schema.Type<typeof PackFqnSchema>;
+/**
+ * Extension spec — fully qualified extension name with an optional version
+ * constraint suffix. Accepts `@owner/type/name` or `@owner/type/name@constraint`
+ * where the FQN portion validates through ExtensionFqnSchema and the optional
+ * constraint validates as a semver VersionRange.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionSpecSchema: Schema.brand<Schema.NonEmptyString, "ExtensionSpec">;
+/**
+ * Inferred type for ExtensionSpec schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type ExtensionSpec = Schema.Schema.Type<typeof ExtensionSpecSchema>;
+/**
+ * Pack spec — fully qualified pack name with an optional version constraint
+ * suffix. Accepts `@owner/packs/name` or `@owner/packs/name@constraint` where
+ * the FQN portion validates through PackFqnSchema and the optional constraint
+ * validates as a semver VersionRange.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackSpecSchema: Schema.brand<Schema.NonEmptyString, "PackSpec">;
+/**
+ * Inferred type for PackSpec schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PackSpec = Schema.Schema.Type<typeof PackSpecSchema>;
+/**
+ * Map of fully-qualified extension names to semver constraints.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionDependencyConstraintMapSchema: Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+/**
+ * Inferred type for extension dependency constraint maps.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type ExtensionDependencyConstraintMap = Schema.Schema.Type<typeof ExtensionDependencyConstraintMapSchema>;
+/**
+ * Map of non-pack fully-qualified extension names to semver constraints.
+ * Used for pack manifest `dependencies`, which cannot include other packs.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const NonPackExtensionDependencyConstraintMapSchema: Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+/**
+ * Inferred type for non-pack extension dependency constraint maps.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type NonPackExtensionDependencyConstraintMap = Schema.Schema.Type<typeof NonPackExtensionDependencyConstraintMapSchema>;
+/**
+ * Publish-time packaging options.
+ *
+ * Declared in the manifest rather than in workspace settings so the policy
+ * travels with the package: whoever publishes a checkout produces the same
+ * archive. Absent means every file under the package directory is published,
+ * which is the default and the only behavior before this field existed.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionVisibilitySchema: Schema.Literals<readonly ["public", "private"]>;
+/** @experimental This API is unstable and may change without notice. */
+export type ExtensionVisibility = Schema.Schema.Type<typeof ExtensionVisibilitySchema>;
+export declare const PublishOptionsSchema: Schema.Struct<{
+    readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+    readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type PublishOptions = Schema.Schema.Type<typeof PublishOptionsSchema>;
+/**
+ * Common base fields shared across manifest types.
+ * Type-specific manifests provide their own `type` and `name` fields explicitly.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const CommonManifestBaseFields: {
+    publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    owner: Schema.brand<Schema.String, "Handle">;
+    version: Schema.brand<Schema.String, "Version">;
+    description: Schema.optional<Schema.String>;
+    keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    homepage: Schema.optional<Schema.String>;
+    license: Schema.optional<Schema.String>;
+    bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+};
+/**
+ * Fields shared across non-pack extension manifests. These describe how an
+ * extension relates to packs.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const NonPackManifestFields: {
+    enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
+    recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    standalone: Schema.optional<Schema.Boolean>;
+};
+/**
+ * Agent identifier enumeration for supported coding agents.
+ *
+ * Derived from `AGENT_IDS` in agents/types.ts — compile-time enforced,
+ * no manual sync required.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const AgentIdSchema: Schema.Literals<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"]>;
+/**
+ * Agent identifiers users may persist in `axm.json`.
+ *
+ * Synthetic materialization targets such as `universal` are known agents, but
+ * they are injected by repository code rather than configured by users.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ConfigurableAgentIdSchema: Schema.Literals<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"]>;
+/**
+ * Inferred type for AgentId schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type AgentId = Schema.Schema.Type<typeof AgentIdSchema>;
+/** @experimental This API is unstable and may change without notice. */
+export type ConfigurableAgentId = Schema.Schema.Type<typeof ConfigurableAgentIdSchema>;
+export {};
+//# sourceMappingURL=common.d.ts.map