@agentxm/extension-resolution 0.28.14-preview.1789139351.5cd4595aa

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# @agentxm/extension-resolution
+
+Extension resolution policy for the AXM client: what a configured or requested
+extension resolves to, and whether that resolution may be accepted.
+
+- **Minimum release age** — `parseMinimumReleaseAge`,
+  `isVersionEntryEligibleAt`, `releaseAgeEvidence`, exemption and holdback
+  records, and the operator's per-invocation `ReleaseAgePosture`.
+- **Version selection under that policy** — `resolveVersionEntryWithReleaseAge`,
+  `resolveVersionEntryForReleaseAge`, and the named Registry target decisions
+  `decideNamedRegistryVersion` and `namedRegistryCandidates`.
+- **Configured-entry resolution** — `resolveConfiguredSkill` and its six
+  siblings, `resolveConfiguredRegistryEntry`, and the
+  `ResolvedConfiguredEntry` vocabulary the lockfile and plans carry.
+- **Pack dependency resolution** — `resolvePackDependencies`,
+  `resolvePackDependenciesWithReleaseAge`, the resolved-dependency map schema,
+  and `acceptedPackDependencyResolver` for deterministic recovery.
+- **Source authority** — `evaluateSourceAuthority`: whether a requested source
+  may replace the configured one for the same target.
+- **Publisher-binding trust** — `classifyPublisherBindingTransition` and the
+  proposal vocabulary. Shaping the resulting plan risk condition belongs to
+  the feature that owns the plan, not here.
+- **Official AXM skill compatibility** — `evaluateAxmSkillCompatibility`,
+  `evaluateAxmSkillCandidate`, `readAxmSkillWorkspaceCompatibility`.
+
+Exports `.` and `./live`.
+
+Dependency budget: `@agentxm/extension-model`, `@agentxm/registry-protocol`,
+`@agentxm/extension-content`, `@agentxm/extension-sources`, and
+`@agentxm/workspace-state`. Deciding what a configured entry resolves to needs
+workspace facts and source acquisition, so this package sits **above**
+`@agentxm/workspace-state`: state must never depend on it.
+
+## Provider contract
+
+`@agentxm/extension-sources` (an integration) fetches the Registry index, maps
+entries to refs, and probes archives, but it may not import this core package.
+It therefore declares ports whose vocabulary lives in
+`@agentxm/extension-model/unstable/sources/source-host-provider`:
+
+- `RegistryResolutionPolicy` — implemented structurally by this package's
+  decision functions and bound by the application composition root
+  (`apps/cli/src/cli-runtime/registry-resolution-policy-live.ts`).
+- `AxmSkillCandidateGate` — implemented by `AxmSkillCandidateGateLive` in this
+  package's `./live`.
+- `WorkspaceCatalog` — implemented by `@agentxm/workspace-projection`, which
+  owns the agent-selection facts the catalog reports.
+
+Selection semantics that the Registry itself defines (`selectVersion`,
+`resolveVersionEntry`: yanked handling and range maxima) stay in
+`@agentxm/registry-protocol/unstable/registry/version-selection`, which both
+the client integration and this package consume.
+
+Unstable and unsupported — use the [axm.sh](https://axm.sh) CLI.
+
+FSL-1.1-MIT © 2025-2026 AgentXM, Inc.

package/dist/src/accepted-pack-dependency-resolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pack member resolution from already accepted state.
+ *
+ * Recovering an accepted Pack must not re-select its members: every member
+ * ref comes from the accepted resolution recorded for that member's
+ * configured name, and a member without one is a conflict rather than a new
+ * selection. That is resolution authority, so the resolver is built here and
+ * the application only chooses when to use it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import type { AcceptedCanonicalRefError } from "@agentxm/workspace-state";
+import { ExtensionResolutionFailed } from "./errors.js";
+import type { PackDependencyRefResolver } from "./pack-dependency-resolution.js";
+/**
+ * Resolve every Pack member from the accepted resolution recorded for its
+ * configured name, refusing the recovery when a member has none.
+ */
+export declare const acceptedPackDependencyResolver: () => PackDependencyRefResolver<AcceptedCanonicalRefError | ExtensionResolutionFailed, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=accepted-pack-dependency-resolver.d.ts.map

package/dist/src/accepted-pack-dependency-resolver.js

@@ -0,0 +1,31 @@
+/**
+ * Pack member resolution from already accepted state.
+ *
+ * Recovering an accepted Pack must not re-select its members: every member
+ * ref comes from the accepted resolution recorded for that member's
+ * configured name, and a member without one is a conflict rather than a new
+ * selection. That is resolution authority, so the resolver is built here and
+ * the application only chooses when to use it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { acceptedLockedResolutionRef, WorkspaceMutations } from "@agentxm/workspace-state";
+import { ExtensionResolutionFailed } from "./errors.js";
+/**
+ * Resolve every Pack member from the accepted resolution recorded for its
+ * configured name, refusing the recovery when a member has none.
+ */
+export const acceptedPackDependencyResolver = () => ({ owner, type, name, root }) => Effect.gen(function* () {
+    const workspace = yield* WorkspaceMutations;
+    const accepted = yield* acceptedLockedResolutionRef({ workspace, type, name });
+    if (Option.isNone(accepted)) {
+        return yield* new ExtensionResolutionFailed({
+            category: "conflict",
+            detail: `Accepted Pack recovery for ${root} has no accepted ${type} resolution for ${owner}/${name}`,
+        });
+    }
+    return accepted.value;
+});
+//# sourceMappingURL=accepted-pack-dependency-resolver.js.map

package/dist/src/accepted-pack-hydration.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Recovering the accepted Pack reference a lock entry records.
+ *
+ * A lock row carries the accepted version and its manifest content identity,
+ * but not the member constraints the manifest declares, so a reference rebuilt
+ * from the lock alone would expand to an empty closure and record the wrong
+ * content identity. Fetching the accepted archive and decoding its manifest is
+ * the only way to recover those constraints without re-resolving — and
+ * re-resolving is exactly what an operation restoring accepted state must not
+ * do.
+ *
+ * This lives with resolution rather than with either feature because both the
+ * configured install closure and the reconciliation sweep's Pack recovery
+ * restore from the same accepted authority.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { ExtensionResolutionFailed } from "./errors.js";
+/**
+ * Complete an accepted Pack reference with the member constraints its accepted
+ * archive declares. The archive is fetched, its manifest decoded, and its
+ * identity and content checked against the lock before any member resolves
+ * from it, so a divergent archive refuses instead of silently reshaping the
+ * closure.
+ */
+export declare const hydrateAcceptedPackRef: (name: string, ref: PackRef) => Effect.Effect<PackRef, ExtensionResolutionFailed, WorkspaceMutations | SourceHostProviders | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=accepted-pack-hydration.d.ts.map

package/dist/src/accepted-pack-hydration.js

@@ -0,0 +1,93 @@
+/**
+ * Recovering the accepted Pack reference a lock entry records.
+ *
+ * A lock row carries the accepted version and its manifest content identity,
+ * but not the member constraints the manifest declares, so a reference rebuilt
+ * from the lock alone would expand to an empty closure and record the wrong
+ * content identity. Fetching the accepted archive and decoding its manifest is
+ * the only way to recover those constraints without re-resolving — and
+ * re-resolving is exactly what an operation restoring accepted state must not
+ * do.
+ *
+ * This lives with resolution rather than with either feature because both the
+ * configured install closure and the reconciliation sweep's Pack recovery
+ * restore from the same accepted authority.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { WorkspaceMutations, computePackManifestContentIdentity } from "@agentxm/workspace-state";
+import { ExtensionResolutionFailed } from "./errors.js";
+const refused = (fields) => new ExtensionResolutionFailed({
+    category: fields.category,
+    detail: fields.detail,
+    ...(fields.cause === undefined ? {} : { cause: fields.cause }),
+});
+/**
+ * Complete an accepted Pack reference with the member constraints its accepted
+ * archive declares. The archive is fetched, its manifest decoded, and its
+ * identity and content checked against the lock before any member resolves
+ * from it, so a divergent archive refuses instead of silently reshaping the
+ * closure.
+ */
+export const hydrateAcceptedPackRef = Effect.fn("ExtensionResolution.hydrateAcceptedPackRef")(function* (name, ref) {
+    const ws = yield* WorkspaceMutations;
+    const sources = yield* SourceHostProviders;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const locked = yield* ws.getLockedPack(name).pipe(Effect.mapError((cause) => refused({
+        category: "internal",
+        detail: `Accepted Pack lock for ${name} could not be read`,
+        cause,
+    })));
+    if (Option.isNone(locked)) {
+        return yield* refused({
+            category: "conflict",
+            detail: `Accepted Pack recovery has no lock authority for ${name}`,
+        });
+    }
+    const manifest = yield* Effect.scoped(Effect.gen(function* () {
+        const fetched = yield* sources.fetch(ref).pipe(Effect.mapError((cause) => refused({
+            category: "network",
+            detail: `Failed to fetch accepted Pack ${ref.owner}/packs/${ref.name}@${ref.version}`,
+            cause,
+        })));
+        const manifestPath = path.join(fetched.directory, PACK_MANIFEST_FILENAME);
+        const manifestText = yield* fs.readFileString(manifestPath).pipe(Effect.mapError((cause) => refused({
+            category: "validation",
+            detail: `Accepted Pack archive has no readable manifest at ${manifestPath}`,
+            cause,
+        })));
+        const manifestJson = yield* Effect.try({
+            try: () => JSON.parse(manifestText),
+            catch: (cause) => refused({
+                category: "validation",
+                detail: `Accepted Pack archive manifest is not valid JSON: ${manifestPath}`,
+                cause,
+            }),
+        });
+        return yield* Schema.decodeUnknownEffect(PackManifestSchema)(manifestJson).pipe(Effect.mapError((cause) => refused({
+            category: "validation",
+            detail: `Accepted Pack archive manifest is invalid: ${manifestPath}`,
+            cause,
+        })));
+    }));
+    const observedContentIdentity = computePackManifestContentIdentity(manifest);
+    if (manifest.owner !== ref.owner ||
+        manifest.name !== ref.name ||
+        manifest.version !== ref.version ||
+        observedContentIdentity !== locked.value.manifestContentIdentity) {
+        return yield* refused({
+            category: "conflict",
+            detail: `Accepted Pack ${ref.owner}/packs/${ref.name}@${ref.version} content ${locked.value.manifestContentIdentity} does not match fetched archive ${manifest.owner}/packs/${manifest.name}@${manifest.version} content ${observedContentIdentity}`,
+        });
+    }
+    return { ...ref, pack: { name: ref.pack.name, dependencies: manifest.dependencies } };
+});
+//# sourceMappingURL=accepted-pack-hydration.js.map

package/dist/src/axm-skill-candidate.d.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { AxmSkillCompatibilityUnavailable, AxmSkillIncompatible } from "./errors.js";
+import { type AxmSkillCompatibility } from "./axm-skill-compatibility.js";
+import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
+export interface ValidateAxmSkillCandidateArgs {
+    readonly ref: SkillExtensionRef;
+    readonly packageRoot: string;
+    readonly skillSourcePath: string;
+}
+/** Inspect candidate bytes and evaluate official AXM skill compatibility. */
+export declare const evaluateAxmSkillCandidate: (args: ValidateAxmSkillCandidateArgs) => Effect.Effect<AxmSkillCompatibility | null, AxmSkillCompatibilityUnavailable, FileSystem.FileSystem | Path.Path>;
+/** Validate official AXM skill bytes before any workspace state is changed. */
+export declare const validateAxmSkillCandidate: (args: ValidateAxmSkillCandidateArgs) => Effect.Effect<AxmSkillCompatibility | null, AxmSkillCompatibilityUnavailable | AxmSkillIncompatible, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=axm-skill-candidate.d.ts.map

package/dist/src/axm-skill-candidate.js

@@ -0,0 +1,80 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { AxmSkillCompatibilityUnavailable, AxmSkillIncompatible } from "./errors.js";
+import { AXM_SKILL_FQN, AxmSkillCompatibilityPolicy, evaluateAxmSkillCompatibility, } from "./axm-skill-compatibility.js";
+import { parseSkillMd } from "@agentxm/extension-content";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseManifest = (content) => Option.match(content, {
+    onNone: () => ({ official: false, version: null }),
+    onSome: (text) => {
+        try {
+            const value = JSON.parse(text);
+            if (!isRecord(value))
+                return { official: false, version: null };
+            return {
+                official: value["owner"] === "@agentxm" && value["type"] === "skill" && value["name"] === "axm",
+                version: typeof value["version"] === "string" ? value["version"] : null,
+            };
+        }
+        catch {
+            return { official: false, version: null };
+        }
+    },
+});
+const isKnownOfficialRef = (ref) => (ref.refType === "registry" || ref.refType === "workspace") &&
+    ref.owner === "@agentxm" &&
+    ref.name === "axm";
+const sourceForRef = (ref) => {
+    switch (ref.refType) {
+        case "registry":
+            return `${ref.owner}/skills/${ref.name}@${ref.version}`;
+        case "workspace":
+            return `workspace:${ref.owner}/skills/${ref.name}`;
+        case "git-hosted":
+        case "local":
+            return ref.location;
+    }
+};
+/** Inspect candidate bytes and evaluate official AXM skill compatibility. */
+export const evaluateAxmSkillCandidate = (args) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const [manifestContent, skillContent] = yield* Effect.all([
+        fs.readFileString(path.join(args.packageRoot, "skill.json")).pipe(Effect.option),
+        fs.readFileString(path.join(args.skillSourcePath, "SKILL.md")).pipe(Effect.option),
+    ]);
+    const manifest = parseManifest(manifestContent);
+    if (!isKnownOfficialRef(args.ref) && !manifest.official)
+        return null;
+    const parsedSkill = Option.flatMap(skillContent, (content) => parseSkillMd(content, "axm"));
+    const candidate = {
+        manifestVersion: manifest.version,
+        metadata: Option.match(parsedSkill, {
+            onNone: () => null,
+            onSome: (skill) => Option.getOrNull(skill.metadata),
+        }),
+        source: sourceForRef(args.ref),
+    };
+    const policy = yield* Effect.serviceOption(AxmSkillCompatibilityPolicy);
+    const result = Option.match(policy, {
+        onNone: () => evaluateAxmSkillCompatibility({ cliVersion: null, skill: candidate }),
+        onSome: (service) => service.evaluate({ fqn: AXM_SKILL_FQN, candidate }),
+    });
+    if (result === null) {
+        return yield* new AxmSkillCompatibilityUnavailable();
+    }
+    return result;
+});
+/** Validate official AXM skill bytes before any workspace state is changed. */
+export const validateAxmSkillCandidate = (args) => Effect.gen(function* () {
+    const result = yield* evaluateAxmSkillCandidate(args);
+    if (result === null)
+        return null;
+    if (result.status === "incompatible") {
+        return yield* new AxmSkillIncompatible({ compatibility: result });
+    }
+    return result;
+});
+//# sourceMappingURL=axm-skill-candidate.js.map

package/dist/src/axm-skill-compatibility.d.ts

@@ -0,0 +1,87 @@
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as ServiceMap from "effect/Context";
+export declare const AXM_SKILL_FQN = "@agentxm/skills/axm";
+export declare const AXM_SKILL_CLI_VERSION_METADATA_KEY = "axm.sh/cli-version";
+export declare const AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY = "axm.sh/cli-version-range";
+export declare const AXM_SKILL_BUNDLED_PREVIEW_COMMAND = "axm skills install @agentxm/skills/axm --bundled --preview";
+export declare const AXM_SKILL_BUNDLED_APPLY_COMMAND = "axm skills install @agentxm/skills/axm --bundled";
+export declare const AXM_SKILL_REGISTRY_PREVIEW_COMMAND = "axm skills update --name axm --preview";
+export declare const AXM_SKILL_REGISTRY_APPLY_COMMAND = "axm skills update --name axm";
+export declare const AxmSkillCompatibilityReasonSchema: Schema.Literals<readonly ["cli-version-unavailable", "axm-skill-missing", "axm-skill-manifest-invalid", "compatibility-metadata-missing", "compatibility-metadata-malformed", "skill-release-mismatch", "skill-release-range-mismatch", "cli-version-incompatible"]>;
+export type AxmSkillCompatibilityReason = typeof AxmSkillCompatibilityReasonSchema.Type;
+export declare const AxmSkillCompatibilityRecoveryActionSchema: Schema.Literals<readonly ["none", "inspect-cli", "upgrade-cli", "update-registry-skill", "install-bundled-skill", "preserve-authored-skill"]>;
+export type AxmSkillCompatibilityRecoveryAction = typeof AxmSkillCompatibilityRecoveryActionSchema.Type;
+export declare const AxmSkillCompatibilityRecoveryStepSchema: Schema.Struct<{
+    readonly boundary: Schema.Literals<readonly ["executable", "workspace", "verification"]>;
+    readonly command: Schema.String;
+    readonly preview: Schema.Boolean;
+}>;
+export type AxmSkillCompatibilityRecoveryStep = typeof AxmSkillCompatibilityRecoveryStepSchema.Type;
+export declare const AxmSkillCompatibilityRecoverySchema: Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["none", "inspect-cli", "upgrade-cli", "update-registry-skill", "install-bundled-skill", "preserve-authored-skill"]>;
+    readonly targetCliVersion: Schema.NullOr<Schema.String>;
+    readonly targetSkillVersion: Schema.NullOr<Schema.String>;
+    readonly nextAction: Schema.NullOr<Schema.String>;
+    readonly steps: Schema.$Array<Schema.Struct<{
+        readonly boundary: Schema.Literals<readonly ["executable", "workspace", "verification"]>;
+        readonly command: Schema.String;
+        readonly preview: Schema.Boolean;
+    }>>;
+}>;
+export type AxmSkillCompatibilityRecovery = typeof AxmSkillCompatibilityRecoverySchema.Type;
+export declare const formatAxmSkillCompatibilityTarget: (target: {
+    readonly targetCliVersion: string | null;
+    readonly targetSkillVersion: string | null;
+}) => string;
+export declare const AxmSkillCompatibilitySchema: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["compatible", "incompatible"]>;
+    readonly cliVersion: Schema.NullOr<Schema.String>;
+    readonly skillVersion: Schema.NullOr<Schema.String>;
+    readonly source: Schema.NullOr<Schema.String>;
+    readonly declaredCliVersion: Schema.NullOr<Schema.String>;
+    readonly declaredCliVersionRange: Schema.NullOr<Schema.String>;
+    readonly reasonCode: Schema.NullOr<Schema.Literals<readonly ["cli-version-unavailable", "axm-skill-missing", "axm-skill-manifest-invalid", "compatibility-metadata-missing", "compatibility-metadata-malformed", "skill-release-mismatch", "skill-release-range-mismatch", "cli-version-incompatible"]>>;
+    readonly detail: Schema.NullOr<Schema.String>;
+    readonly recovery: Schema.Struct<{
+        readonly action: Schema.Literals<readonly ["none", "inspect-cli", "upgrade-cli", "update-registry-skill", "install-bundled-skill", "preserve-authored-skill"]>;
+        readonly targetCliVersion: Schema.NullOr<Schema.String>;
+        readonly targetSkillVersion: Schema.NullOr<Schema.String>;
+        readonly nextAction: Schema.NullOr<Schema.String>;
+        readonly steps: Schema.$Array<Schema.Struct<{
+            readonly boundary: Schema.Literals<readonly ["executable", "workspace", "verification"]>;
+            readonly command: Schema.String;
+            readonly preview: Schema.Boolean;
+        }>>;
+    }>;
+}>;
+export type AxmSkillCompatibility = typeof AxmSkillCompatibilitySchema.Type;
+export interface AxmSkillCompatibilityCandidate {
+    readonly manifestVersion: string | null;
+    readonly metadata: Readonly<Record<string, string>> | null;
+    readonly source: string | null;
+}
+export interface AxmSkillCompatibilityInput {
+    readonly cliVersion: string | null;
+    readonly skill: AxmSkillCompatibilityCandidate | null;
+}
+export interface AxmSkillCompatibilityPolicyInput {
+    readonly fqn: string;
+    readonly candidate: AxmSkillCompatibilityCandidate | null;
+}
+export interface AxmSkillCompatibilityPolicyService {
+    readonly evaluate: (input: AxmSkillCompatibilityPolicyInput) => AxmSkillCompatibility | null;
+}
+declare const AxmSkillCompatibilityPolicy_base: ServiceMap.ServiceClass<AxmSkillCompatibilityPolicy, "@agentxm/extension-resolution/axm-skill-compatibility/AxmSkillCompatibilityPolicy", AxmSkillCompatibilityPolicyService>;
+export declare class AxmSkillCompatibilityPolicy extends AxmSkillCompatibilityPolicy_base {
+}
+export type AxmSkillCliVersionRangeValidation = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+};
+export declare const validateAxmSkillCliVersionRange: (value: string) => AxmSkillCliVersionRangeValidation;
+export declare const evaluateAxmSkillCompatibility: (input: AxmSkillCompatibilityInput) => AxmSkillCompatibility;
+export declare const makeAxmSkillCompatibilityPolicyLayer: (cliVersion: string | null) => Layer.Layer<AxmSkillCompatibilityPolicy>;
+export {};
+//# sourceMappingURL=axm-skill-compatibility.d.ts.map