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

package/dist/src/configured-entry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Configured-entry resolution vocabulary: what one configured extension's
+ * requested source resolved to, and why a resolution could not be made.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type * as Option from "effect/Option";
+import type { HookExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/hook";
+import type { KnowledgeExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/knowledge";
+import type { McpServerExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/mcp-server";
+import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
+import type { RuleExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/rule";
+import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
+import type { SubagentExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/subagent";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import type { NamedRegistryResolution } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { ReleaseAgeBypassRecord, ReleaseAgeHoldbackRecord } from "./release-age-policy.js";
+export type ConfiguredEntryFailureReason = "entry-malformed" | "source-not-found" | "source-multiple-matches" | "source-resolution-failed" | "source-timeout";
+export interface ResolvedConfiguredEntry<TRef> {
+    readonly ref: TRef;
+    readonly versionRange: Option.Option<VersionRange>;
+    readonly releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+}
+export type ResolvedConfiguredSkill = ResolvedConfiguredEntry<SkillExtensionRef>;
+export type ResolvedConfiguredSubagent = ResolvedConfiguredEntry<SubagentExtensionRef>;
+export type ResolvedConfiguredRule = ResolvedConfiguredEntry<RuleExtensionRef>;
+export type ResolvedConfiguredHook = ResolvedConfiguredEntry<HookExtensionRef>;
+export type ResolvedConfiguredKnowledge = ResolvedConfiguredEntry<KnowledgeExtensionRef>;
+export type ResolvedConfiguredMcpServer = ResolvedConfiguredEntry<McpServerExtensionRef>;
+export type ResolvedConfiguredPack = ResolvedConfiguredEntry<PackRef>;
+export type ConfiguredRegistryResolution = NamedRegistryResolution & {
+    readonly versionRange: Option.Option<VersionRange>;
+    readonly acceptedVersion?: string;
+};
+//# sourceMappingURL=configured-entry.d.ts.map

package/dist/src/configured-entry.js

@@ -0,0 +1,8 @@
+/**
+ * Configured-entry resolution vocabulary: what one configured extension's
+ * requested source resolved to, and why a resolution could not be made.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export {};
+//# sourceMappingURL=configured-entry.js.map

package/dist/src/errors.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Typed failures extension resolution constructs. Fields are domain facts;
+ * the application error boundary owns rendering, codes, and suggestions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import type { AxmSkillCompatibility } from "./axm-skill-compatibility.js";
+declare const ExtensionResolutionFailed_base: Schema.Class<ExtensionResolutionFailed, Schema.TaggedStruct<"ExtensionResolutionFailed", {
+    readonly category: Schema.Literals<readonly ["conflict", "internal", "network", "not_found", "usage", "validation"]>;
+    readonly title: Schema.optional<Schema.String>;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly recover: Schema.optional<Schema.String>;
+    readonly cmd: Schema.optional<Schema.String>;
+    readonly suggestions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly cmd: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A resolution policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover`/`cmd` fold into the leading suggested action, and `title`,
+ * `detail`, `suggestions`, and `cause` carry over verbatim.
+ */
+export declare class ExtensionResolutionFailed extends ExtensionResolutionFailed_base {
+}
+declare const SourceAuthorityBlocked_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SourceAuthorityBlocked";
+} & Readonly<A>;
+/** Source-authority evaluation refused the requested transition. */
+export declare class SourceAuthorityBlocked extends SourceAuthorityBlocked_base<{
+    readonly detail: string;
+    readonly recovery: ReadonlyArray<{
+        readonly description: string;
+    }>;
+}> {
+}
+declare const AxmSkillCompatibilityUnavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AxmSkillCompatibilityUnavailable";
+} & Readonly<A>;
+/** The AXM compatibility policy did not evaluate the official AXM skill. */
+export declare class AxmSkillCompatibilityUnavailable extends AxmSkillCompatibilityUnavailable_base {
+}
+declare const AxmSkillIncompatible_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AxmSkillIncompatible";
+} & Readonly<A>;
+/**
+ * The official AXM skill candidate is incompatible with this CLI. Carries the
+ * policy's full compatibility verdict, whose recovery plan the application
+ * boundary renders into suggestions.
+ */
+export declare class AxmSkillIncompatible extends AxmSkillIncompatible_base<{
+    readonly compatibility: AxmSkillCompatibility;
+}> {
+}
+declare const PackDependencyInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackDependencyInvalid";
+} & Readonly<A>;
+/**
+ * A declared pack dependency cannot be resolved as requested. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export declare class PackDependencyInvalid extends PackDependencyInvalid_base<{
+    readonly detail: string;
+}> {
+}
+declare const PackDependencyConflict_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackDependencyConflict";
+} & Readonly<A>;
+/**
+ * A pack dependency resolution conflicts with workspace state. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export declare class PackDependencyConflict extends PackDependencyConflict_base<{
+    readonly detail: string;
+}> {
+}
+declare const PackConstraintShadowed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackConstraintShadowed";
+} & Readonly<A>;
+/** Workspace authority shadows a pack member outside the pack's constraint. */
+export declare class PackConstraintShadowed extends PackConstraintShadowed_base<{
+    readonly packSource: "workspace" | "registry";
+    readonly packFqn: string;
+    readonly memberFqn: string;
+    readonly constraint: string;
+    readonly workspaceVersion: string;
+}> {
+}
+declare const PackDependencyMissing_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackDependencyMissing";
+} & Readonly<A>;
+/** A pack dependency does not exist at its source. */
+export declare class PackDependencyMissing extends PackDependencyMissing_base<{
+    readonly dependencyTarget: string;
+}> {
+}
+declare const PackDependencyUnsatisfied_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PackDependencyUnsatisfied";
+} & Readonly<A>;
+/** No visible dependency version satisfies the pack's constraint. */
+export declare class PackDependencyUnsatisfied extends PackDependencyUnsatisfied_base<{
+    readonly dependencyTarget: string;
+    readonly constraint: string;
+}> {
+}
+/** Every failure pack dependency resolution constructs. */
+export type PackDependencyResolutionFailure = PackDependencyInvalid | PackDependencyConflict | PackConstraintShadowed | PackDependencyMissing | PackDependencyUnsatisfied;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,71 @@
+/**
+ * Typed failures extension resolution constructs. Fields are domain facts;
+ * the application error boundary owns rendering, codes, and suggestions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+import * as Schema from "effect/Schema";
+const CarriedSuggestedActionSchema = Schema.Struct({
+    description: Schema.String,
+    cmd: Schema.optional(Schema.String),
+    url: Schema.optional(Schema.String),
+});
+/**
+ * A resolution policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover`/`cmd` fold into the leading suggested action, and `title`,
+ * `detail`, `suggestions`, and `cause` carry over verbatim.
+ */
+export class ExtensionResolutionFailed extends Schema.TaggedError()("ExtensionResolutionFailed", {
+    category: Schema.Literals([
+        "conflict",
+        "internal",
+        "network",
+        "not_found",
+        "usage",
+        "validation",
+    ]),
+    title: Schema.optional(Schema.String),
+    detail: Schema.optional(Schema.String),
+    recover: Schema.optional(Schema.String),
+    cmd: Schema.optional(Schema.String),
+    suggestions: Schema.optional(Schema.Array(CarriedSuggestedActionSchema)),
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+/** Source-authority evaluation refused the requested transition. */
+export class SourceAuthorityBlocked extends Data.TaggedError("SourceAuthorityBlocked") {
+}
+/** The AXM compatibility policy did not evaluate the official AXM skill. */
+export class AxmSkillCompatibilityUnavailable extends Data.TaggedError("AxmSkillCompatibilityUnavailable") {
+}
+/**
+ * The official AXM skill candidate is incompatible with this CLI. Carries the
+ * policy's full compatibility verdict, whose recovery plan the application
+ * boundary renders into suggestions.
+ */
+export class AxmSkillIncompatible extends Data.TaggedError("AxmSkillIncompatible") {
+}
+/**
+ * A declared pack dependency cannot be resolved as requested. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export class PackDependencyInvalid extends Data.TaggedError("PackDependencyInvalid") {
+}
+/**
+ * A pack dependency resolution conflicts with workspace state. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export class PackDependencyConflict extends Data.TaggedError("PackDependencyConflict") {
+}
+/** Workspace authority shadows a pack member outside the pack's constraint. */
+export class PackConstraintShadowed extends Data.TaggedError("PackConstraintShadowed") {
+}
+/** A pack dependency does not exist at its source. */
+export class PackDependencyMissing extends Data.TaggedError("PackDependencyMissing") {
+}
+/** No visible dependency version satisfies the pack's constraint. */
+export class PackDependencyUnsatisfied extends Data.TaggedError("PackDependencyUnsatisfied") {
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @agentxm/extension-resolution public API.
+ *
+ * Extension resolution policy: which source is allowed to supply a
+ * configured extension, which visible version that source resolves to under
+ * the minimum-release-age policy, which publisher binding a proposed
+ * acceptance replaces, how a Pack's declared members resolve, and whether an
+ * official AXM skill candidate is compatible with this CLI. Pure over the
+ * Registry index contract and workspace state; the provider that fetches the
+ * index applies these through a port.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AxmSkillCompatibilityUnavailable, AxmSkillIncompatible, ExtensionResolutionFailed, PackConstraintShadowed, PackDependencyConflict, PackDependencyInvalid, PackDependencyMissing, PackDependencyUnsatisfied, SourceAuthorityBlocked, type PackDependencyResolutionFailure, } from "./errors.js";
+export { type ReleaseAgeBypassRecord, type ReleaseAgeHoldbackRecord, type ReleaseAgeOperationEvidence, type ReleaseAgeRecord, type ReleaseAgeRecordBase, filterMatureVersions, formatMinimumReleaseAgeSeconds, isVersionEntryEligibleAt, isVersionEntryMature, normalizeReleaseAgeRecords, parseMinimumReleaseAge, releaseAgeEvidence, releaseAgeExemptionForIdentity, releaseAgeHoldbackWarning, } from "./release-age-policy.js";
+export { type ReleaseAgeVersionResolution, resolveVersionEntryForReleaseAge, resolveVersionEntryWithReleaseAge, } from "./version-resolution.js";
+export { decideNamedRegistryVersion, namedRegistryCandidates, } from "./named-registry-resolution.js";
+export { ReleaseAgePosture, type ReleaseAgePostureValue } from "./release-age-posture.js";
+export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
+export { evaluateSourceAuthority, type SourceAuthorityBlockedCause, type SourceAuthorityBlockedFact, type SourceAuthorityDecision, type SourceAuthorityInput, type SourceAuthorityRelationship, type SourceAuthorityTarget, type WorkspaceAuthorityStatus, } from "./source-authority.js";
+export { type ConfiguredEntryFailureReason, type ConfiguredRegistryResolution, type ResolvedConfiguredEntry, type ResolvedConfiguredHook, type ResolvedConfiguredKnowledge, type ResolvedConfiguredMcpServer, type ResolvedConfiguredPack, type ResolvedConfiguredRule, type ResolvedConfiguredSkill, type ResolvedConfiguredSubagent, } from "./configured-entry.js";
+export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
+export { classifyPublisherBindingTransition, describePublisherBindingTransition, publisherTransitionWarning, registryBindingProposal, type PublisherBindingTransition, type RegistryBindingProposal, } from "./publisher-binding.js";
+export { ResolvedPackDependencyMapSchema, ResolvedPackDependencySchema, type ResolvedPackDependency, type ResolvedPackDependencyMap, } from "./resolved-pack-dependency.js";
+export { resolvePackDependencies, resolvePackDependenciesWithReleaseAge, type PackDependencyRefResolver, type ReleaseAgeAwarePackDependencyResolution, type ResolvedPackDependencies, type WorkspacePackDependencyResolution, type WorkspacePackDependencyResolver, } from "./pack-dependency-resolution.js";
+export { acceptedPackDependencyResolver } from "./accepted-pack-dependency-resolver.js";
+export { AXM_SKILL_BUNDLED_APPLY_COMMAND, AXM_SKILL_BUNDLED_PREVIEW_COMMAND, AXM_SKILL_CLI_VERSION_METADATA_KEY, AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY, AXM_SKILL_FQN, AXM_SKILL_REGISTRY_APPLY_COMMAND, AXM_SKILL_REGISTRY_PREVIEW_COMMAND, AxmSkillCompatibilityPolicy, AxmSkillCompatibilityRecoveryActionSchema, AxmSkillCompatibilityRecoverySchema, AxmSkillCompatibilityRecoveryStepSchema, AxmSkillCompatibilityReasonSchema, AxmSkillCompatibilitySchema, evaluateAxmSkillCompatibility, formatAxmSkillCompatibilityTarget, makeAxmSkillCompatibilityPolicyLayer, validateAxmSkillCliVersionRange, type AxmSkillCliVersionRangeValidation, type AxmSkillCompatibility, type AxmSkillCompatibilityCandidate, type AxmSkillCompatibilityInput, type AxmSkillCompatibilityPolicyInput, type AxmSkillCompatibilityPolicyService, type AxmSkillCompatibilityReason, type AxmSkillCompatibilityRecovery, type AxmSkillCompatibilityRecoveryAction, type AxmSkillCompatibilityRecoveryStep, } from "./axm-skill-compatibility.js";
+export { evaluateAxmSkillCandidate, validateAxmSkillCandidate, type ValidateAxmSkillCandidateArgs, } from "./axm-skill-candidate.js";
+export { declaresOfficialAxmSkill, readAxmSkillWorkspaceCompatibility, type ReadAxmSkillWorkspaceCompatibilityArgs, } from "./axm-skill-workspace-compatibility.js";
+export { classifyTargetedUpdate, resolveTargetedUpdateContext, type ClassifyTargetedUpdateArgs, type TargetedUpdateAuthority, type TargetedUpdateBlocker, type TargetedUpdateContext, type TargetedUpdateContextFailure, type TargetedUpdateEffect, type TargetedUpdateOwnership, type TargetedUpdatePublicContext, type TargetedUpdateTarget, type TargetedUpdateTargetType, } from "./update/targeted-update-context.js";
+export { detectHoldbackWarnings, resolveConstrainedVersion, type ConstraintResolutionResult, type PackConstraint, type UpdateConstraints, } from "./update/constraint-precedence.js";
+export { hydrateAcceptedPackRef } from "./accepted-pack-hydration.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,45 @@
+/**
+ * @agentxm/extension-resolution public API.
+ *
+ * Extension resolution policy: which source is allowed to supply a
+ * configured extension, which visible version that source resolves to under
+ * the minimum-release-age policy, which publisher binding a proposed
+ * acceptance replaces, how a Pack's declared members resolve, and whether an
+ * official AXM skill candidate is compatible with this CLI. Pure over the
+ * Registry index contract and workspace state; the provider that fetches the
+ * index applies these through a port.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AxmSkillCompatibilityUnavailable, AxmSkillIncompatible, ExtensionResolutionFailed, PackConstraintShadowed, PackDependencyConflict, PackDependencyInvalid, PackDependencyMissing, PackDependencyUnsatisfied, SourceAuthorityBlocked, } from "./errors.js";
+export { filterMatureVersions, formatMinimumReleaseAgeSeconds, isVersionEntryEligibleAt, isVersionEntryMature, normalizeReleaseAgeRecords, parseMinimumReleaseAge, releaseAgeEvidence, releaseAgeExemptionForIdentity, releaseAgeHoldbackWarning, } from "./release-age-policy.js";
+export { resolveVersionEntryForReleaseAge, resolveVersionEntryWithReleaseAge, } from "./version-resolution.js";
+export { decideNamedRegistryVersion, namedRegistryCandidates, } from "./named-registry-resolution.js";
+// The operator's posture for one invocation, and the bound on how long
+// resolving one configured entry may take.
+export { ReleaseAgePosture } from "./release-age-posture.js";
+export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
+// Which source may supply a configured extension.
+export { evaluateSourceAuthority, } from "./source-authority.js";
+// Configured-entry vocabulary and resolution.
+export {} from "./configured-entry.js";
+export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
+// Publisher binding trust classification.
+export { classifyPublisherBindingTransition, describePublisherBindingTransition, publisherTransitionWarning, registryBindingProposal, } from "./publisher-binding.js";
+// Pack dependency resolution.
+export { ResolvedPackDependencyMapSchema, ResolvedPackDependencySchema, } from "./resolved-pack-dependency.js";
+export { resolvePackDependencies, resolvePackDependenciesWithReleaseAge, } from "./pack-dependency-resolution.js";
+export { acceptedPackDependencyResolver } from "./accepted-pack-dependency-resolver.js";
+// Official AXM skill compatibility policy.
+export { AXM_SKILL_BUNDLED_APPLY_COMMAND, AXM_SKILL_BUNDLED_PREVIEW_COMMAND, AXM_SKILL_CLI_VERSION_METADATA_KEY, AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY, AXM_SKILL_FQN, AXM_SKILL_REGISTRY_APPLY_COMMAND, AXM_SKILL_REGISTRY_PREVIEW_COMMAND, AxmSkillCompatibilityPolicy, AxmSkillCompatibilityRecoveryActionSchema, AxmSkillCompatibilityRecoverySchema, AxmSkillCompatibilityRecoveryStepSchema, AxmSkillCompatibilityReasonSchema, AxmSkillCompatibilitySchema, evaluateAxmSkillCompatibility, formatAxmSkillCompatibilityTarget, makeAxmSkillCompatibilityPolicyLayer, validateAxmSkillCliVersionRange, } from "./axm-skill-compatibility.js";
+export { evaluateAxmSkillCandidate, validateAxmSkillCandidate, } from "./axm-skill-candidate.js";
+export { declaresOfficialAxmSkill, readAxmSkillWorkspaceCompatibility, } from "./axm-skill-workspace-compatibility.js";
+// Targeted update classification: who owns the declaration a named update
+// would move, whether it may move, and the freshness witness apply rechecks.
+export { classifyTargetedUpdate, resolveTargetedUpdateContext, } from "./update/targeted-update-context.js";
+// Which constraint governs an update when a workspace and its Packs each
+// declare one, and which newer releases that precedence holds back.
+export { detectHoldbackWarnings, resolveConstrainedVersion, } from "./update/constraint-precedence.js";
+export { hydrateAcceptedPackRef } from "./accepted-pack-hydration.js";
+//# sourceMappingURL=index.js.map

package/dist/src/live.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Implementation of the source-resolution composition port this package owns
+ * the policy for.
+ *
+ * `@agentxm/extension-sources` declares the official AXM skill candidate gate
+ * as a port because a supporting integration may not own AXM trust policy.
+ * Resolution owns that policy, so the Live is composed here rather than at
+ * the application boundary; the composition root only composes Layers.
+ *
+ * The catalog port's Live belongs to `@agentxm/workspace-projection`, which
+ * owns the agent-selection facts it reads.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Layer from "effect/Layer";
+import { AxmSkillCandidateGate } from "@agentxm/extension-sources";
+/**
+ * The gate renders the recovery command and target exactly as the registry
+ * host provider rendered them before the port existed. Its only failure is
+ * the policy declining to evaluate, which travels in `cause` so the
+ * application boundary renders the sentence it renders everywhere else.
+ */
+export declare const AxmSkillCandidateGateLive: Layer.Layer<AxmSkillCandidateGate, never, never>;
+//# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -0,0 +1,47 @@
+/**
+ * Implementation of the source-resolution composition port this package owns
+ * the policy for.
+ *
+ * `@agentxm/extension-sources` declares the official AXM skill candidate gate
+ * as a port because a supporting integration may not own AXM trust policy.
+ * Resolution owns that policy, so the Live is composed here rather than at
+ * the application boundary; the composition root only composes Layers.
+ *
+ * The catalog port's Live belongs to `@agentxm/workspace-projection`, which
+ * owns the agent-selection facts it reads.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { AxmSkillCandidateGate, AxmSkillGateUnavailable, } from "@agentxm/extension-sources";
+import { evaluateAxmSkillCandidate } from "./axm-skill-candidate.js";
+import { AXM_SKILL_BUNDLED_PREVIEW_COMMAND, formatAxmSkillCompatibilityTarget, } from "./axm-skill-compatibility.js";
+/**
+ * The gate renders the recovery command and target exactly as the registry
+ * host provider rendered them before the port existed. Its only failure is
+ * the policy declining to evaluate, which travels in `cause` so the
+ * application boundary renders the sentence it renders everywhere else.
+ */
+export const AxmSkillCandidateGateLive = Layer.succeed(AxmSkillCandidateGate, {
+    evaluate: (candidate) => evaluateAxmSkillCandidate({
+        ref: candidate.ref,
+        packageRoot: candidate.packageRoot,
+        skillSourcePath: candidate.skillSourcePath,
+    }).pipe(Effect.map((result) => result === null
+        ? null
+        : {
+            status: result.status,
+            detail: result.detail,
+            recoveryCommand: result.recovery.action === "update-registry-skill"
+                ? AXM_SKILL_BUNDLED_PREVIEW_COMMAND
+                : result.recovery.nextAction,
+            recoveryTarget: formatAxmSkillCompatibilityTarget(result.recovery),
+        }), Effect.mapError((failure) => new AxmSkillGateUnavailable({
+        category: "internal",
+        detail: "AXM compatibility policy did not evaluate the official AXM skill",
+        cause: failure,
+    }))),
+});
+//# sourceMappingURL=live.js.map

package/dist/src/named-registry-resolution.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Named Registry target resolution: the index-level decision and the ordered
+ * candidates a provider may verify before selecting, under one release-age
+ * evaluation and the caller's accepted identity.
+ *
+ * The provider that owns the index (`@agentxm/extension-sources`) consumes
+ * these through its `RegistryResolutionPolicy` port, so an integration never
+ * carries selection policy of its own.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { NamedRegistryCandidate, NamedRegistryFindOptions, NamedRegistryVersionDecision } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { ExtensionIndex } from "@agentxm/registry-protocol/unstable/registry/schema";
+/**
+ * Decide which version of a visible index a named request selects.
+ */
+export declare const decideNamedRegistryVersion: (index: ExtensionIndex, options: NamedRegistryFindOptions) => NamedRegistryVersionDecision;
+/**
+ * Candidates a provider may verify one by one when selection depends on
+ * archive content (the official AXM skill): selectable versions newest
+ * first, then, when no exemption applies, the under-age versions that would
+ * be held.
+ */
+export declare const namedRegistryCandidates: (index: ExtensionIndex, options: NamedRegistryFindOptions) => ReadonlyArray<NamedRegistryCandidate>;
+//# sourceMappingURL=named-registry-resolution.d.ts.map

package/dist/src/named-registry-resolution.js

@@ -0,0 +1,110 @@
+/**
+ * Named Registry target resolution: the index-level decision and the ordered
+ * candidates a provider may verify before selecting, under one release-age
+ * evaluation and the caller's accepted identity.
+ *
+ * The provider that owns the index (`@agentxm/extension-sources`) consumes
+ * these through its `RegistryResolutionPolicy` port, so an integration never
+ * carries selection policy of its own.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Option from "effect/Option";
+import * as semver from "semver";
+import { isVersionEntryEligibleAt, releaseAgeEvidence, releaseAgeExemptionForIdentity, } from "./release-age-policy.js";
+import { resolveVersionEntryForReleaseAge } from "./version-resolution.js";
+/** The accepted version counts only when the Registry identity still matches. */
+const acceptedVersionFor = (index, options) => options.accepted?.publisherBindingId === index.publisherBindingId
+    ? options.accepted.version
+    : undefined;
+const isExactRequest = (versionRange) => Option.isSome(versionRange) && semver.valid(versionRange.value) === versionRange.value;
+/**
+ * Decide which version of a visible index a named request selects.
+ */
+export const decideNamedRegistryVersion = (index, options) => {
+    const exemption = releaseAgeExemptionForIdentity(options.releaseAgeEvaluation, {
+        owner: index.owner,
+        type: index.type,
+        name: index.name,
+    });
+    const resolution = resolveVersionEntryForReleaseAge(index.versions, options.versionRange, options.releaseAgeEvaluation, exemption, acceptedVersionFor(index, options));
+    switch (resolution.kind) {
+        case "version_unsatisfied":
+            return isExactRequest(options.versionRange)
+                ? { kind: "not_found" }
+                : {
+                    kind: "version_unsatisfied",
+                    requestedRange: Option.getOrElse(options.versionRange, () => "*"),
+                };
+        case "policy_held":
+            return {
+                kind: "policy_held",
+                ...(Option.isSome(options.versionRange)
+                    ? { requestedRange: options.versionRange.value }
+                    : {}),
+                candidate: resolution.candidate,
+            };
+        case "exempted":
+            return {
+                kind: "exempted",
+                version: resolution.version.version,
+                bypassed: resolution.bypassed,
+                exemption: resolution.exemption,
+            };
+        case "selected":
+            return {
+                kind: "selected",
+                version: resolution.version.version,
+                ...(resolution.newerHeld === undefined ? {} : { newerHeld: resolution.newerHeld }),
+            };
+    }
+};
+const versionsMatchingRequest = (versions, versionRange) => {
+    const requested = Option.getOrElse(versionRange, () => "*");
+    const exact = isExactRequest(versionRange);
+    return versions
+        .filter((entry) => exact
+        ? entry.version === requested
+        : entry.yankedAt === undefined && semver.satisfies(entry.version, requested))
+        .sort((left, right) => semver.compareBuild(right.version, left.version));
+};
+/**
+ * Candidates a provider may verify one by one when selection depends on
+ * archive content (the official AXM skill): selectable versions newest
+ * first, then, when no exemption applies, the under-age versions that would
+ * be held.
+ */
+export const namedRegistryCandidates = (index, options) => {
+    const evaluation = options.releaseAgeEvaluation;
+    const exemption = releaseAgeExemptionForIdentity(evaluation, {
+        owner: index.owner,
+        type: index.type,
+        name: index.name,
+    });
+    const acceptedVersion = acceptedVersionFor(index, options);
+    const matching = versionsMatchingRequest(index.versions, options.versionRange);
+    const eligible = (entry) => isVersionEntryEligibleAt(entry, evaluation);
+    const selectable = matching
+        .filter((entry) => exemption !== undefined || entry.version === acceptedVersion || eligible(entry))
+        .map((entry) => ({
+        version: entry.version,
+        outcome: exemption !== undefined && !eligible(entry)
+            ? {
+                kind: "exempted",
+                bypassed: releaseAgeEvidence(entry, evaluation),
+                exemption,
+            }
+            : { kind: "selected" },
+    }));
+    const held = exemption === undefined
+        ? matching
+            .filter((entry) => !eligible(entry))
+            .map((entry) => ({
+            version: entry.version,
+            outcome: { kind: "held", candidate: releaseAgeEvidence(entry, evaluation) },
+        }))
+        : [];
+    return [...selectable, ...held];
+};
+//# sourceMappingURL=named-registry-resolution.js.map

package/dist/src/pack-dependency-resolution.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pack dependency resolution: every declared member resolved to one exact
+ * identity under the pack's constraints, workspace authority, and the
+ * minimum-release-age policy.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type * as Duration from "effect/Duration";
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { ExtensionName, ExtensionType, Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
+import type { ReleaseAgeEvaluation } from "@agentxm/extension-model/unstable/extensions/release-age";
+import type { RegistrySource } from "@agentxm/extension-model/unstable/sources/types";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import type { SourceHostProvidersService, SourceResolutionFailure } from "@agentxm/extension-sources";
+import { SourceAuthorityBlocked, type PackDependencyResolutionFailure } from "./errors.js";
+import type { ReleaseAgeBypassRecord, ReleaseAgeHoldbackRecord } from "./release-age-policy.js";
+import type { ResolvedPackDependencyMap } from "./resolved-pack-dependency.js";
+import type { SourceAuthorityBlockedFact } from "./source-authority.js";
+/** Failures pack dependency resolution can surface. */
+type PackDependencyResolutionError = SourceResolutionFailure | PackDependencyResolutionFailure | SourceAuthorityBlocked;
+/** Every extension type a pack can depend on — packs cannot nest. */
+type SupportedPackDependencyType = Exclude<ExtensionType, "pack">;
+export type WorkspacePackDependencyResolution = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "selected";
+    readonly ref: ExtensionRef;
+} | {
+    readonly kind: "blocked";
+    readonly fact: SourceAuthorityBlockedFact;
+};
+export type WorkspacePackDependencyResolver<E = never, R = never> = (args: {
+    readonly owner: Handle;
+    readonly type: SupportedPackDependencyType;
+    readonly name: ExtensionName;
+    readonly constraint: VersionRange;
+    readonly root: string;
+}) => Effect.Effect<WorkspacePackDependencyResolution, E, R>;
+/** Resolve a Pack member from an already-authorized immutable candidate. */
+export type PackDependencyRefResolver<E = never, R = never> = (args: {
+    readonly owner: Handle;
+    readonly type: SupportedPackDependencyType;
+    readonly name: ExtensionName;
+    readonly constraint: VersionRange;
+    readonly root: string;
+}) => Effect.Effect<ExtensionRef, E, R>;
+export interface ResolvedPackDependencies {
+    readonly resolvedSkills: ResolvedPackDependencyMap;
+    readonly resolvedMcpServers: ResolvedPackDependencyMap;
+    readonly resolvedSubagents: ResolvedPackDependencyMap;
+    readonly resolvedRules: ResolvedPackDependencyMap;
+    readonly resolvedHooks: ResolvedPackDependencyMap;
+    readonly resolvedKnowledge: ResolvedPackDependencyMap;
+    readonly dependencyRefs: ReadonlyArray<ExtensionRef>;
+}
+export type ReleaseAgeAwarePackDependencyResolution = {
+    readonly kind: "selected";
+    readonly dependencies: ResolvedPackDependencies;
+    readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+    readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+} | {
+    readonly kind: "policy_held";
+    readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+    readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+};
+export declare const resolvePackDependencies: <E = never, R = never>(pack: PackRef, sources: SourceHostProvidersService, minimumReleaseAge?: Option.Option<Duration.Duration>, sourceOverride?: RegistrySource, workspaceResolver?: WorkspacePackDependencyResolver<E, R>, dependencyResolver?: PackDependencyRefResolver<E, R>) => Effect.Effect<ResolvedPackDependencies, PackDependencyResolutionError | E, R>;
+export declare const resolvePackDependenciesWithReleaseAge: <E = never, R = never>(pack: PackRef, sources: SourceHostProvidersService, evaluation: ReleaseAgeEvaluation, sourceOverride?: RegistrySource, workspaceResolver?: WorkspacePackDependencyResolver<E, R>, dependencyResolver?: PackDependencyRefResolver<E, R>) => Effect.Effect<ReleaseAgeAwarePackDependencyResolution, PackDependencyResolutionError | E, R>;
+export {};
+//# sourceMappingURL=pack-dependency-resolution.d.ts.map