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

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

@@ -0,0 +1,248 @@
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as ServiceMap from "effect/Context";
+import * as semver from "semver";
+export const AXM_SKILL_FQN = "@agentxm/skills/axm";
+const AXM_SKILL_AGENTXM_SOURCE = `agentxm:${AXM_SKILL_FQN}`;
+export const AXM_SKILL_CLI_VERSION_METADATA_KEY = "axm.sh/cli-version";
+export const AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY = "axm.sh/cli-version-range";
+export const AXM_SKILL_BUNDLED_PREVIEW_COMMAND = "axm skills install @agentxm/skills/axm --bundled --preview";
+export const AXM_SKILL_BUNDLED_APPLY_COMMAND = "axm skills install @agentxm/skills/axm --bundled";
+export const AXM_SKILL_REGISTRY_PREVIEW_COMMAND = "axm skills update --name axm --preview";
+export const AXM_SKILL_REGISTRY_APPLY_COMMAND = "axm skills update --name axm";
+export const AxmSkillCompatibilityReasonSchema = Schema.Literals([
+    "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 const AxmSkillCompatibilityRecoveryActionSchema = Schema.Literals([
+    "none",
+    "inspect-cli",
+    "upgrade-cli",
+    "update-registry-skill",
+    "install-bundled-skill",
+    "preserve-authored-skill",
+]);
+export const AxmSkillCompatibilityRecoveryStepSchema = Schema.Struct({
+    boundary: Schema.Literals(["executable", "workspace", "verification"]),
+    command: Schema.String,
+    preview: Schema.Boolean,
+});
+export const AxmSkillCompatibilityRecoverySchema = Schema.Struct({
+    action: AxmSkillCompatibilityRecoveryActionSchema,
+    targetCliVersion: Schema.NullOr(Schema.String),
+    targetSkillVersion: Schema.NullOr(Schema.String),
+    nextAction: Schema.NullOr(Schema.String),
+    steps: Schema.Array(AxmSkillCompatibilityRecoveryStepSchema),
+});
+export const formatAxmSkillCompatibilityTarget = (target) => `AXM CLI ${target.targetCliVersion ?? "unknown"} + official AXM skill ${target.targetSkillVersion ?? "unknown"}`;
+export const AxmSkillCompatibilitySchema = Schema.Struct({
+    status: Schema.Literals(["compatible", "incompatible"]),
+    cliVersion: Schema.NullOr(Schema.String),
+    skillVersion: Schema.NullOr(Schema.String),
+    source: Schema.NullOr(Schema.String),
+    declaredCliVersion: Schema.NullOr(Schema.String),
+    declaredCliVersionRange: Schema.NullOr(Schema.String),
+    reasonCode: Schema.NullOr(AxmSkillCompatibilityReasonSchema),
+    detail: Schema.NullOr(Schema.String),
+    recovery: AxmSkillCompatibilityRecoverySchema,
+});
+export class AxmSkillCompatibilityPolicy extends ServiceMap.Service()("@agentxm/extension-resolution/axm-skill-compatibility/AxmSkillCompatibilityPolicy") {
+}
+const wildcardRangePattern = /(?:^|[.\s])(?:[xX*])(?:$|[.\s])/u;
+const compatibilitySatisfies = (version, range) => semver.satisfies(version, range, { includePrerelease: true });
+const comparatorSetIsBounded = (comparators) => {
+    let hasLowerBound = false;
+    let hasUpperBound = false;
+    for (const comparator of comparators) {
+        if (comparator.value.length === 0)
+            continue;
+        switch (comparator.operator) {
+            case "":
+                hasLowerBound = true;
+                hasUpperBound = true;
+                break;
+            case ">":
+            case ">=":
+                hasLowerBound = true;
+                break;
+            case "<":
+            case "<=":
+                hasUpperBound = true;
+                break;
+        }
+    }
+    return hasLowerBound && hasUpperBound;
+};
+export const validateAxmSkillCliVersionRange = (value) => {
+    if (value.length === 0 || value.trim() !== value || wildcardRangePattern.test(value)) {
+        return { valid: false };
+    }
+    if (semver.validRange(value) === null)
+        return { valid: false };
+    try {
+        const range = new semver.Range(value);
+        return range.set.length > 0 && range.set.every(comparatorSetIsBounded)
+            ? { valid: true }
+            : { valid: false };
+    }
+    catch {
+        return { valid: false };
+    }
+};
+const recoveryStep = (boundary, command, preview) => ({ boundary, command, preview });
+const bundledSkillRecovery = (cliVersion) => ({
+    action: "install-bundled-skill",
+    targetCliVersion: cliVersion,
+    targetSkillVersion: cliVersion,
+    nextAction: AXM_SKILL_BUNDLED_PREVIEW_COMMAND,
+    steps: [
+        recoveryStep("workspace", AXM_SKILL_BUNDLED_PREVIEW_COMMAND, true),
+        recoveryStep("workspace", AXM_SKILL_BUNDLED_APPLY_COMMAND, false),
+        recoveryStep("verification", "axm lint", false),
+    ],
+});
+const isAuthoredSource = (source) => source === "workspace";
+const isRegistrySource = (source) => source === AXM_SKILL_FQN ||
+    source?.startsWith(`${AXM_SKILL_FQN}@`) === true ||
+    source === AXM_SKILL_AGENTXM_SOURCE ||
+    source?.startsWith(`${AXM_SKILL_AGENTXM_SOURCE}@`) === true;
+const registrySkillRecovery = (cliVersion) => ({
+    action: "update-registry-skill",
+    targetCliVersion: cliVersion,
+    targetSkillVersion: cliVersion,
+    nextAction: AXM_SKILL_REGISTRY_PREVIEW_COMMAND,
+    steps: [
+        recoveryStep("workspace", AXM_SKILL_REGISTRY_PREVIEW_COMMAND, true),
+        recoveryStep("workspace", AXM_SKILL_REGISTRY_APPLY_COMMAND, false),
+        recoveryStep("verification", "axm lint", false),
+    ],
+});
+const deriveRecovery = (compatibility) => {
+    if (compatibility.status === "compatible") {
+        return {
+            action: "none",
+            targetCliVersion: compatibility.cliVersion,
+            targetSkillVersion: compatibility.skillVersion,
+            nextAction: null,
+            steps: [],
+        };
+    }
+    if (compatibility.reasonCode === "cli-version-unavailable") {
+        return {
+            action: "inspect-cli",
+            targetCliVersion: null,
+            targetSkillVersion: compatibility.skillVersion,
+            nextAction: "axm --version",
+            steps: [
+                recoveryStep("verification", "axm --version", false),
+                recoveryStep("verification", "axm lint", false),
+            ],
+        };
+    }
+    if (compatibility.reasonCode === "cli-version-incompatible" &&
+        compatibility.cliVersion !== null &&
+        compatibility.declaredCliVersionRange !== null) {
+        const minimum = semver.minVersion(compatibility.declaredCliVersionRange);
+        if (minimum !== null && semver.lt(compatibility.cliVersion, minimum)) {
+            return {
+                action: "upgrade-cli",
+                targetCliVersion: compatibility.declaredCliVersion ?? minimum.version,
+                targetSkillVersion: compatibility.skillVersion,
+                nextAction: "axm upgrade",
+                steps: [
+                    recoveryStep("executable", "axm upgrade", false),
+                    recoveryStep("verification", "axm lint", false),
+                ],
+            };
+        }
+    }
+    if (isAuthoredSource(compatibility.source)) {
+        return {
+            action: "preserve-authored-skill",
+            targetCliVersion: compatibility.cliVersion,
+            targetSkillVersion: compatibility.cliVersion,
+            nextAction: "axm help upgrade",
+            steps: [recoveryStep("verification", "axm help upgrade", false)],
+        };
+    }
+    if (isRegistrySource(compatibility.source) && compatibility.cliVersion !== null) {
+        return registrySkillRecovery(compatibility.cliVersion);
+    }
+    return compatibility.cliVersion === null
+        ? {
+            action: "inspect-cli",
+            targetCliVersion: null,
+            targetSkillVersion: compatibility.skillVersion,
+            nextAction: "axm --version",
+            steps: [recoveryStep("verification", "axm --version", false)],
+        }
+        : bundledSkillRecovery(compatibility.cliVersion);
+};
+const withRecovery = (compatibility) => ({
+    ...compatibility,
+    recovery: deriveRecovery(compatibility),
+});
+const incompatible = (fields, reasonCode, detail) => withRecovery({
+    status: "incompatible",
+    ...fields,
+    reasonCode,
+    detail,
+});
+export const evaluateAxmSkillCompatibility = (input) => {
+    const cliVersion = input.cliVersion === null ? null : semver.valid(input.cliVersion);
+    const skillVersion = input.skill?.manifestVersion ?? null;
+    const source = input.skill?.source ?? null;
+    const declaredCliVersion = input.skill?.metadata?.[AXM_SKILL_CLI_VERSION_METADATA_KEY] ?? null;
+    const declaredCliVersionRange = input.skill?.metadata?.[AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY] ?? null;
+    const fields = {
+        cliVersion,
+        skillVersion,
+        source,
+        declaredCliVersion,
+        declaredCliVersionRange,
+    };
+    if (cliVersion === null) {
+        return incompatible(fields, "cli-version-unavailable", "The running AXM CLI version is unavailable or invalid.");
+    }
+    if (input.skill === null) {
+        return incompatible(fields, "axm-skill-missing", "The official @agentxm/skills/axm skill is not installed.");
+    }
+    const validSkillVersion = input.skill.manifestVersion === null ? null : semver.valid(input.skill.manifestVersion);
+    if (validSkillVersion === null) {
+        return incompatible(fields, "axm-skill-manifest-invalid", "The official AXM skill manifest has a missing or invalid version.");
+    }
+    if (declaredCliVersion === null || declaredCliVersionRange === null) {
+        return incompatible(fields, "compatibility-metadata-missing", `The official AXM skill must declare ${AXM_SKILL_CLI_VERSION_METADATA_KEY} and ${AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY}.`);
+    }
+    if (semver.valid(declaredCliVersion) === null ||
+        !validateAxmSkillCliVersionRange(declaredCliVersionRange).valid) {
+        return incompatible(fields, "compatibility-metadata-malformed", "The official AXM skill compatibility metadata must contain an exact release and a bounded, wildcard-free semver range.");
+    }
+    if (validSkillVersion !== declaredCliVersion) {
+        return incompatible(fields, "skill-release-mismatch", `The AXM skill manifest reports ${validSkillVersion}, but ${AXM_SKILL_CLI_VERSION_METADATA_KEY} reports ${declaredCliVersion}.`);
+    }
+    if (!compatibilitySatisfies(declaredCliVersion, declaredCliVersionRange)) {
+        return incompatible(fields, "skill-release-range-mismatch", `The AXM skill release ${declaredCliVersion} is outside its declared CLI range ${declaredCliVersionRange}.`);
+    }
+    if (!compatibilitySatisfies(cliVersion, declaredCliVersionRange)) {
+        return incompatible(fields, "cli-version-incompatible", `AXM CLI ${cliVersion} is outside the official AXM skill range ${declaredCliVersionRange}.`);
+    }
+    return withRecovery({
+        status: "compatible",
+        ...fields,
+        reasonCode: null,
+        detail: null,
+    });
+};
+export const makeAxmSkillCompatibilityPolicyLayer = (cliVersion) => Layer.succeed(AxmSkillCompatibilityPolicy, {
+    evaluate: (input) => input.fqn === AXM_SKILL_FQN
+        ? evaluateAxmSkillCompatibility({ cliVersion, skill: input.candidate })
+        : null,
+});
+//# sourceMappingURL=axm-skill-compatibility.js.map

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

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import type { InstalledSkill, WorkspaceReadModel } from "@agentxm/workspace-state";
+import { type LockfileReadError, type SettingsReadError } from "@agentxm/workspace-state";
+import { type AxmSkillCompatibility, type AxmSkillCompatibilityPolicyService } from "./axm-skill-compatibility.js";
+/** Whether desired workspace state directly or transitively declares the official AXM skill. */
+export declare const declaresOfficialAxmSkill: (args: {
+    readonly declaredSource: string | null;
+    readonly installed: Option.Option<InstalledSkill>;
+}) => boolean;
+export interface ReadAxmSkillWorkspaceCompatibilityArgs {
+    readonly platform: {
+        readonly fs: FileSystem.FileSystem;
+        readonly path: Path.Path;
+    };
+    readonly workspace: Pick<WorkspaceReadModel, "scope" | "skills">;
+    readonly policy: AxmSkillCompatibilityPolicyService;
+}
+/** Read and evaluate the authoritative installed AXM skill without mutating the workspace. */
+export declare const readAxmSkillWorkspaceCompatibility: (args: ReadAxmSkillWorkspaceCompatibilityArgs) => Effect.Effect<Option.Option<AxmSkillCompatibility>, SettingsReadError | LockfileReadError>;
+//# sourceMappingURL=axm-skill-workspace-compatibility.d.ts.map

package/dist/src/axm-skill-workspace-compatibility.js

@@ -0,0 +1,110 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { printSkillLockSourceLocator, } from "@agentxm/workspace-state";
+import { parseSkillMd } from "@agentxm/extension-content";
+import { AXM_SKILL_FQN, } from "./axm-skill-compatibility.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const manifestVersion = (content) => {
+    try {
+        const parsed = JSON.parse(content);
+        if (!isRecord(parsed))
+            return null;
+        const version = parsed["version"];
+        return typeof version === "string" ? version : null;
+    }
+    catch {
+        return null;
+    }
+};
+const isOfficialSource = (source) => {
+    const registrySource = `agentxm:${AXM_SKILL_FQN}`;
+    return (source === AXM_SKILL_FQN ||
+        source.startsWith(`${AXM_SKILL_FQN}@`) ||
+        source === registrySource ||
+        source.startsWith(`${registrySource}@`) ||
+        source === "workspace");
+};
+const resolvesToOfficialAxmSkill = (installed) => Option.exists(installed.resolved, ({ lockEntry }) => lockEntry.type === "registry"
+    ? lockEntry.owner === "@agentxm" && lockEntry.name === "axm"
+    : lockEntry.packageOwner === "@agentxm" && lockEntry.packageName === "axm");
+/** Whether desired workspace state directly or transitively declares the official AXM skill. */
+export const declaresOfficialAxmSkill = (args) => (args.declaredSource !== null && isOfficialSource(args.declaredSource)) ||
+    Option.exists(args.installed, (installed) => installed.installationOrigin._tag === "pack-member" && resolvesToOfficialAxmSkill(installed));
+/** Read and evaluate the authoritative installed AXM skill without mutating the workspace. */
+export const readAxmSkillWorkspaceCompatibility = (args) => Effect.gen(function* () {
+    const declared = yield* args.workspace.skills.declaredByName("axm");
+    const installed = yield* args.workspace.skills.byName("axm");
+    const declaredSource = Option.match(declared, {
+        onNone: () => null,
+        onSome: ({ entry }) => entry.source,
+    });
+    if (!declaresOfficialAxmSkill({ declaredSource, installed })) {
+        return Option.none();
+    }
+    if (Option.isNone(installed)) {
+        const result = args.policy.evaluate({ fqn: AXM_SKILL_FQN, candidate: null });
+        if (result === null) {
+            return yield* Effect.die("AXM compatibility policy did not evaluate the official AXM skill");
+        }
+        return Option.some(result);
+    }
+    const installedSkill = installed.value;
+    const declaredEntry = installedSkill.installationOrigin._tag === "direct"
+        ? installedSkill.installationOrigin.declared.entry
+        : null;
+    const source = declaredEntry?.source ??
+        Option.match(installedSkill.resolved, {
+            onNone: () => null,
+            onSome: ({ lockEntry }) => printSkillLockSourceLocator("axm", lockEntry),
+        });
+    const actual = installedSkill.actual.find((occurrence) => {
+        if (occurrence.origin._tag !== "canonical-axm-skill")
+            return false;
+        if (occurrence.packageRoot === null)
+            return false;
+        const skillDirectory = occurrence.packageRoot;
+        const skillsDirectory = args.platform.path.dirname(skillDirectory);
+        const ownerDirectory = args.platform.path.dirname(skillsDirectory);
+        const projectAuthored = args.platform.path.basename(skillDirectory) === "axm" &&
+            args.platform.path.basename(skillsDirectory) === "skills";
+        return args.workspace.scope === "project"
+            ? projectAuthored
+            : projectAuthored && args.platform.path.basename(ownerDirectory) === "@agentxm";
+    });
+    if (actual === undefined) {
+        const result = args.policy.evaluate({ fqn: AXM_SKILL_FQN, candidate: null });
+        if (result === null) {
+            return yield* Effect.die("AXM compatibility policy did not evaluate the official AXM skill");
+        }
+        return Option.some(result);
+    }
+    const manifestContent = actual.packageRoot === null
+        ? Option.none()
+        : yield* args.platform.fs
+            .readFileString(args.platform.path.join(actual.packageRoot, "skill.json"))
+            .pipe(Effect.option);
+    const skillContent = actual.sourcePath === null
+        ? Option.none()
+        : yield* args.platform.fs.readFileString(actual.sourcePath).pipe(Effect.option);
+    const skill = Option.flatMap(skillContent, (content) => parseSkillMd(content, "axm"));
+    const installedManifestVersion = Option.match(manifestContent, {
+        onNone: () => null,
+        onSome: manifestVersion,
+    });
+    const candidate = {
+        manifestVersion: installedManifestVersion,
+        metadata: Option.match(skill, {
+            onNone: () => null,
+            onSome: (parsed) => Option.getOrNull(parsed.metadata),
+        }),
+        source: declaredEntry?.origin === "bundled"
+            ? `bundled:${AXM_SKILL_FQN}${installedManifestVersion === null ? "" : `@${installedManifestVersion}`}`
+            : source,
+    };
+    const result = args.policy.evaluate({ fqn: AXM_SKILL_FQN, candidate });
+    if (result === null) {
+        return yield* Effect.die("AXM compatibility policy did not evaluate the official AXM skill");
+    }
+    return Option.some(result);
+});
+//# sourceMappingURL=axm-skill-workspace-compatibility.js.map

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

@@ -0,0 +1,118 @@
+/**
+ * Configured-entry resolution: the requested source of every configured
+ * extension resolved to one accepted ref under the minimum-release-age
+ * policy, with the holdback and bypass evidence the operation records.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+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 { ReleaseAgeEvaluation } from "@agentxm/extension-model/unstable/extensions/release-age";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
+import type { SourceResolutionFailure } from "@agentxm/extension-sources";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import type { AcceptedCanonicalRefError } from "@agentxm/workspace-state";
+import type { ConfiguredRegistryResolution } from "./configured-entry.js";
+import { ExtensionResolutionFailed } from "./errors.js";
+import type { ReleaseAgeBypassRecord, ReleaseAgeHoldbackRecord } from "./release-age-policy.js";
+import { ReleaseAgePosture } from "./release-age-posture.js";
+export declare const makeConfiguredReleaseAgeEvaluation: () => Effect.Effect<{
+    minimumReleaseAge: import("effect/Duration").Duration;
+    evaluatedAt: DateTime.Utc;
+    mode: import("./release-age-posture.js").ReleaseAgePostureValue;
+    exclude: readonly import("@agentxm/extension-model/unstable/extensions/release-age").ScopedReleaseAgeExcludePattern[];
+}, ExtensionResolutionFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, WorkspaceMutations | ReleaseAgePosture>;
+export declare const resolveConfiguredRegistryEntry: (name: string, source: string, expectedType: ExtensionType, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<Option.Option<ConfiguredRegistryResolution>, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, SourceHostProviders | WorkspaceCatalog | WorkspaceMutations | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | Scope.Scope>;
+export declare const resolveConfiguredSkill: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/skill").RegistrySkillRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: SkillExtensionRef;
+    versionRange: Option.None<string & import("effect/Brand").Brand<"VersionRange">> | Option.Some<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredSubagent: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/subagent").RegistrySubagentRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: SubagentExtensionRef;
+    versionRange: Option.None<string & import("effect/Brand").Brand<"VersionRange">> | Option.Some<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredRule: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/rule").RegistryRuleRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: RuleExtensionRef;
+    versionRange: Option.None<string & import("effect/Brand").Brand<"VersionRange">> | Option.Some<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredHook: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/hook").RegistryHookRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: HookExtensionRef;
+    versionRange: Option.None<string & import("effect/Brand").Brand<"VersionRange">> | Option.Some<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredKnowledge: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/knowledge").RegistryKnowledgeRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: KnowledgeExtensionRef;
+    versionRange: Option.None<string & import("effect/Brand").Brand<"VersionRange">> | Option.Some<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredMcpServer: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/mcp-server").RegistryMcpServerRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: McpServerExtensionRef;
+    versionRange: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveConfiguredPack: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
+    ref: import("@agentxm/extension-model/unstable/extensions/refs/pack").RegistryPackRef;
+    versionRange: Option.Option<VersionRange>;
+    releaseAge?: {
+        readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
+        readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
+    };
+} | {
+    ref: PackRef;
+    versionRange: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+}, ExtensionResolutionFailed | SourceResolutionFailure | AcceptedCanonicalRefError, Scope.Scope | WorkspaceMutations | FileSystem.FileSystem | Path.Path | SourceHostProviders | WorkspaceCatalog | HttpClient.HttpClient>;
+//# sourceMappingURL=configured-entry-resolution.d.ts.map