@agentxm/extension-lifecycle 0.28.4-bootstrap.0

package/dist/src/mcps/operations/uninstall.js

@@ -0,0 +1,189 @@
+/**
+ * Uninstall MCP server executor — orchestrates per-server removal pipeline.
+ *
+ * Pipeline: resolve desired/observed state -> remove canonical source -> clear
+ * settings and accepted resolution.
+ * Simpler than skills — no agent symlinks.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { appendWarningsToMessage } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { removeIfExists } from "@agentxm/workspace-state";
+import { acceptedCanonicalObservation, acceptedLockedCanonicalPath, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
+import { agentConfigTarget, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
+import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { ExtensionLifecycleFailed } from "../../errors.js";
+const REQUIRED_AGENT_IDS = new Set([
+    "claude-code",
+    "opencode",
+    "github-copilot-cli",
+    "cursor",
+    "gemini-cli",
+    "codex",
+]);
+const formatAgentSyncWarning = (serverName, outcomes) => {
+    const warningMessage = outcomes
+        .map(({ agentId, outcome }) => outcome._tag === "success"
+        ? `${agentId}:success`
+        : outcome._tag === "fallback"
+            ? `${agentId}:fallback(${outcome.fallbackFrom}):${outcome.reason}`
+            : `${agentId}:${outcome.reason}`)
+        .join(", ");
+    return `MCP agent sync warnings for ${serverName}: ${warningMessage}`;
+};
+const summarizeAgentSync = (outcomes, warnings) => {
+    const degraded = outcomes.some(({ outcome }) => outcome._tag === "failed" || outcome._tag === "fallback");
+    const details = outcomes.map(({ agentId, outcome }) => outcome._tag === "success"
+        ? `${agentId}:success`
+        : outcome._tag === "fallback"
+            ? `${agentId}:fallback:${outcome.fallbackFrom}`
+            : `${agentId}:${outcome._tag}`);
+    return {
+        status: degraded ? "degraded" : "green",
+        details,
+        warnings,
+        agentIds: outcomes.map(({ agentId }) => agentId),
+    };
+};
+const syncConfiguredAgentsOnUninstall = (args) => Effect.gen(function* () {
+    const agentRepo = yield* CodingAgentRepository;
+    const warnings = [];
+    const unknownConfiguredAgentIds = yield* agentRepo.getUnknownConfiguredAgentIds();
+    if (args.strict && unknownConfiguredAgentIds.length > 0) {
+        const message = `Unknown configured agents in strict mode: ${unknownConfiguredAgentIds.join(", ")}`;
+        return yield* new ExtensionLifecycleFailed({
+            category: "not_found",
+            detail: message,
+        });
+    }
+    if (unknownConfiguredAgentIds.length > 0) {
+        warnings.push(`Skipping unknown configured agents: ${unknownConfiguredAgentIds.join(", ")}`);
+    }
+    const configuredAgents = yield* agentRepo.getConfiguredAgents();
+    const outcomes = yield* Effect.forEach(configuredAgents, (agent) => agent
+        .removeMcpServer({
+        workspaceRoot: args.wsBaseDir,
+        scope: args.scope,
+        serverName: args.serverName,
+    })
+        .pipe(Effect.map((outcome) => ({ agentId: agent.id, outcome }))), { concurrency: "unbounded" });
+    const misconfigured = Array.filter(outcomes, ({ outcome }) => outcome._tag === "misconfigured");
+    if (misconfigured.length > 0) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "internal",
+            detail: `MCP server ${args.serverName} could not be removed from configured agents`,
+        });
+    }
+    const failed = Array.filter(outcomes, ({ outcome }) => outcome._tag === "failed");
+    if (args.strict && failed.length > 0) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "internal",
+            detail: `MCP server ${args.serverName} removal sync failed in strict mode`,
+        });
+    }
+    const strictDisabledFailures = Array.filter(outcomes, ({ agentId, outcome }) => (outcome._tag === "disabled" ||
+        (outcome._tag === "fallback" && outcome.fallbackFrom === "disabled")) &&
+        args.strict &&
+        REQUIRED_AGENT_IDS.has(agentId));
+    if (strictDisabledFailures.length > 0) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "internal",
+            detail: `MCP server ${args.serverName} removal sync disabled for required configured agents`,
+        });
+    }
+    const warningOutcomes = Array.filter(outcomes, ({ outcome }) => outcome._tag === "unsupported" ||
+        outcome._tag === "disabled" ||
+        outcome._tag === "needs-input" ||
+        outcome._tag === "failed" ||
+        outcome._tag === "fallback");
+    if (warningOutcomes.length > 0) {
+        warnings.push(formatAgentSyncWarning(args.serverName, warningOutcomes));
+    }
+    return summarizeAgentSync(outcomes, warnings);
+});
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Uninstall-mcp-server operation handler.
+ *
+ * 1. Resolve configured and observed state
+ * 2. Remove canonical directory from disk (if exists)
+ * 3. Remove settings and accepted resolution
+ */
+export const uninstallMcpServer = (op) => Effect.gen(function* () {
+    const adapter = yield* LifecycleFailureAdapter;
+    const fs = yield* FileSystem.FileSystem;
+    const ws = yield* WorkspaceMutations;
+    const strictAgentSync = Option.getOrElse(op.args.strictAgentSync ?? Option.none(), () => false);
+    const desired = yield* ws.getDesiredStateGraph();
+    if (!desired.complete) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: "Cannot uninstall the MCP server while the desired extension graph is incomplete.",
+            recover: "Repair or reinstall the configured packs, then retry.",
+        });
+    }
+    const desiredNode = desired.nodes.find((node) => node.type === "mcp-server" && node.name === op.args.serverName);
+    const acceptedCanonical = yield* acceptedCanonicalObservation({
+        workspace: ws,
+        type: "mcp-server",
+        name: op.args.serverName,
+    });
+    const lockedCanonical = yield* acceptedLockedCanonicalPath({
+        workspace: ws,
+        type: "mcp-server",
+        name: op.args.serverName,
+    });
+    const removableCanonical = Option.orElse(removableAcceptedCanonicalPath(acceptedCanonical), () => lockedCanonical);
+    const installedOnDisk = yield* Option.match(removableCanonical, {
+        onNone: () => Effect.succeed(false),
+        onSome: (canonicalPath) => fs.exists(canonicalPath).pipe(Effect.catch(() => Effect.succeed(false))),
+    });
+    if (desiredNode === undefined && !installedOnDisk) {
+        return { result: "success", message: "not installed" };
+    }
+    if (desiredNode?.origins.some((origin) => origin.type === "pack") === true) {
+        yield* ws.removeMcpServerSettings(op.args.serverName);
+        return {
+            result: "success",
+            message: "Kept on disk because dependency is still required by an installed pack",
+        };
+    }
+    if (Option.isSome(removableCanonical))
+        yield* removeIfExists(fs, removableCanonical.value);
+    // Remove from settings + lockfile (best-effort; preserve warning in result).
+    const removeWarning = yield* ws.removeMcpServer(op.args.serverName).pipe(Effect.as(Option.none()), Effect.catch((e) => Effect.succeed(Option.some(`MCP server removal from settings failed: ${adapter.describeFailure(e)}`))));
+    const agentSync = yield* syncConfiguredAgentsOnUninstall({
+        wsBaseDir: ws.baseDir,
+        scope: ws.scope,
+        strict: strictAgentSync,
+        serverName: op.args.serverName,
+    });
+    const warnings = Option.match(removeWarning, {
+        onNone: () => agentSync.warnings,
+        onSome: (warning) => [warning, ...agentSync.warnings],
+    });
+    const agentTarget = agentConfigTarget("removed", agentSync.agentIds);
+    return {
+        result: "success",
+        message: appendWarningsToMessage(`Uninstalled ${op.args.serverName} (canonical=success, agent-sync=${agentSync.status})`, warnings),
+        artifact: mcpServerArtifact({
+            lockEntry: undefined,
+            scope: ws.scope,
+            change: "removed",
+            targets: [
+                mcpSettingsTarget(ws.scope, "removed"),
+                ...(agentTarget === undefined ? [] : [agentTarget]),
+            ],
+        }),
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=uninstall.js.map

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

@@ -0,0 +1,65 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { SourceAuthorityBlockedFact } from "@agentxm/extension-workspace";
+/** Failures pack dependency resolution can surface. */
+type PackDependencyResolutionError = SourceResolutionFailure | PackManagerError | SourceAuthorityBlocked;
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { Handle, ExtensionName, ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { ResolvedPackDependencyMap } from "./resolved-dependency.js";
+import type { SourceHostProvidersService, SourceResolutionFailure } from "@agentxm/extension-sources";
+import type { RegistrySource } from "@agentxm/extension-model/unstable/sources/types";
+import { SourceAuthorityBlocked, type PackManagerError } from "@agentxm/extension-workspace";
+import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
+import type * as Duration from "effect/Duration";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import type { ReleaseAgeBypassRecord, ReleaseAgeHoldbackRecord } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
+import type { ReleaseAgeEvaluation } from "@agentxm/extension-model/unstable/extensions/release-age";
+/** 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> = (args: {
+    readonly owner: Handle;
+    readonly type: SupportedPackDependencyType;
+    readonly name: ExtensionName;
+    readonly constraint: VersionRange;
+    readonly root: string;
+}) => Effect.Effect<WorkspacePackDependencyResolution, E>;
+/** Resolve a Pack member from an already-authorized immutable candidate. */
+export type PackDependencyRefResolver<E = never> = (args: {
+    readonly owner: Handle;
+    readonly type: SupportedPackDependencyType;
+    readonly name: ExtensionName;
+    readonly constraint: VersionRange;
+    readonly root: string;
+}) => Effect.Effect<ExtensionRef, E>;
+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>(pack: PackRef, sources: SourceHostProvidersService, minimumReleaseAge?: Option.Option<Duration.Duration>, sourceOverride?: RegistrySource, workspaceResolver?: WorkspacePackDependencyResolver<E>, dependencyResolver?: PackDependencyRefResolver<E>) => Effect.Effect<ResolvedPackDependencies, PackDependencyResolutionError | E>;
+export declare const resolvePackDependenciesWithReleaseAge: <E = never>(pack: PackRef, sources: SourceHostProvidersService, evaluation: ReleaseAgeEvaluation, sourceOverride?: RegistrySource, workspaceResolver?: WorkspacePackDependencyResolver<E>, dependencyResolver?: PackDependencyRefResolver<E>) => Effect.Effect<ReleaseAgeAwarePackDependencyResolution, PackDependencyResolutionError | E>;
+export {};
+//# sourceMappingURL=dependency-resolution.d.ts.map

package/dist/src/packs/dependency-resolution.js

@@ -0,0 +1,414 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { formatFqn, parseFqnOrThrow, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { SourceAuthorityBlocked, PackConstraintShadowed, PackDependencyConflict, PackDependencyInvalid, PackDependencyMissing, PackDependencyUnsatisfied, } from "@agentxm/extension-workspace";
+import * as semver from "semver";
+import { releaseAgeExemptionForIdentity } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
+const validateSelectedDependency = (candidate, expectedType, parsed, fqn, constraint) => {
+    if (candidate.type !== expectedType ||
+        (candidate.refType !== "registry" && candidate.refType !== "workspace") ||
+        candidate.owner !== parsed.owner ||
+        candidate.name !== parsed.name) {
+        return new PackDependencyConflict({
+            detail: `Authorized dependency resolution does not match pack dependency ${fqn}`,
+        });
+    }
+    if (!semver.satisfies(candidate.version, constraint)) {
+        return new PackDependencyConflict({
+            detail: `Authorized dependency ${fqn}@${candidate.version} does not satisfy ${constraint}`,
+        });
+    }
+    return Effect.succeed({
+        owner: parsed.owner,
+        type: expectedType,
+        name: parsed.name,
+        ref: candidate,
+    });
+};
+const registrySourceForDependency = (pack, owner, sourceOverride) => {
+    const source = sourceOverride ?? (pack.source.type === "registry" ? pack.source : undefined);
+    if (source === undefined) {
+        return Effect.fail(new PackDependencyInvalid({
+            detail: `Cannot resolve pack dependencies from non-registry source`,
+        }));
+    }
+    return Effect.succeed({
+        ...source,
+        owner: Option.some(owner),
+    });
+};
+const workspaceConstraintConflict = (pack, memberFqn, workspaceVersion, constraint) => new PackConstraintShadowed({
+    packSource: pack.source.type === "workspace" ? "workspace" : "registry",
+    packFqn: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
+    memberFqn,
+    constraint,
+    workspaceVersion,
+});
+const resolveDependencyRef = (pack, expectedType, fqn, constraint, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
+    const parsed = parseFqnOrThrow(fqn);
+    if (parsed.type !== expectedType) {
+        return yield* new PackDependencyInvalid({
+            detail: `Pack dependency type mismatch for expected ${expectedType}`,
+        });
+    }
+    if (workspaceResolver !== undefined) {
+        const workspace = yield* workspaceResolver({
+            owner: parsed.owner,
+            type: expectedType,
+            name: parsed.name,
+            constraint,
+            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
+        });
+        if (workspace.kind === "blocked") {
+            return yield* new SourceAuthorityBlocked({
+                detail: workspace.fact.detail,
+                recovery: workspace.fact.recovery,
+            });
+        }
+        if (workspace.kind === "selected") {
+            const candidate = workspace.ref;
+            if (candidate.type !== expectedType ||
+                candidate.refType !== "workspace" ||
+                candidate.owner !== parsed.owner ||
+                candidate.name !== parsed.name) {
+                return yield* new PackDependencyConflict({
+                    detail: `Configured workspace authority does not match pack dependency ${fqn}`,
+                });
+            }
+            if (!semver.satisfies(candidate.version, constraint)) {
+                return yield* workspaceConstraintConflict(pack, fqn, candidate.version, constraint);
+            }
+            return {
+                owner: parsed.owner,
+                type: expectedType,
+                name: parsed.name,
+                ref: candidate,
+            };
+        }
+    }
+    if (dependencyResolver !== undefined) {
+        const candidate = yield* dependencyResolver({
+            owner: parsed.owner,
+            type: expectedType,
+            name: parsed.name,
+            constraint,
+            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
+        });
+        return yield* validateSelectedDependency(candidate, expectedType, parsed, fqn, constraint);
+    }
+    const source = yield* registrySourceForDependency(pack, parsed.owner, sourceOverride);
+    const matches = yield* Effect.scoped(sources.find(source, {
+        names: [parsed.name],
+        type: expectedType,
+        owner: Option.some(parsed.owner),
+        versionRange: Option.some(constraint),
+        ...(minimumReleaseAge === undefined ? {} : { minimumReleaseAge }),
+    }));
+    const matchingRef = matches.find((candidate) => candidate.type === expectedType &&
+        candidate.refType === "registry" &&
+        candidate.owner === parsed.owner &&
+        candidate.name === parsed.name);
+    if (matchingRef === undefined) {
+        return yield* new PackDependencyInvalid({
+            detail: `Unable to resolve pack dependency ${fqn}@${constraint}`,
+        });
+    }
+    return {
+        owner: parsed.owner,
+        type: expectedType,
+        name: parsed.name,
+        ref: matchingRef,
+    };
+});
+const dependencyReleaseAgeRecord = (args) => ({
+    reason: "minimum-release-age",
+    target: args.dependencyTarget,
+    dependencyPath: [args.packTarget, args.dependencyTarget],
+    requestedRange: args.constraint,
+    ...(args.selectedVersion === undefined ? {} : { selectedVersion: args.selectedVersion }),
+    candidateVersion: args.evidence.version,
+    publishedAt: args.evidence.publishedAt,
+    eligibleAt: args.evidence.eligibleAt,
+    minimumReleaseAgeSeconds: args.evidence.minimumReleaseAgeSeconds,
+});
+const resolveDependencyRefWithReleaseAge = (pack, expectedType, fqn, constraint, sources, evaluation, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
+    const parsed = parseFqnOrThrow(fqn);
+    if (parsed.type !== expectedType) {
+        return yield* new PackDependencyInvalid({
+            detail: `Pack dependency type mismatch for expected ${expectedType}`,
+        });
+    }
+    if (workspaceResolver !== undefined) {
+        const workspace = yield* workspaceResolver({
+            owner: parsed.owner,
+            type: expectedType,
+            name: parsed.name,
+            constraint,
+            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
+        });
+        if (workspace.kind === "blocked") {
+            return yield* new SourceAuthorityBlocked({
+                detail: workspace.fact.detail,
+                recovery: workspace.fact.recovery,
+            });
+        }
+        if (workspace.kind === "selected") {
+            const candidate = workspace.ref;
+            if (candidate.type !== expectedType ||
+                candidate.refType !== "workspace" ||
+                candidate.owner !== parsed.owner ||
+                candidate.name !== parsed.name) {
+                return yield* new PackDependencyConflict({
+                    detail: `Configured workspace authority does not match pack dependency ${fqn}`,
+                });
+            }
+            if (!semver.satisfies(candidate.version, constraint)) {
+                return yield* workspaceConstraintConflict(pack, fqn, candidate.version, constraint);
+            }
+            return {
+                kind: "selected",
+                dependency: {
+                    owner: parsed.owner,
+                    type: expectedType,
+                    name: parsed.name,
+                    ref: candidate,
+                },
+                holdbacks: [],
+                bypasses: [],
+            };
+        }
+    }
+    if (dependencyResolver !== undefined) {
+        const candidate = yield* dependencyResolver({
+            owner: parsed.owner,
+            type: expectedType,
+            name: parsed.name,
+            constraint,
+            root: formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name }),
+        });
+        return {
+            kind: "selected",
+            dependency: yield* validateSelectedDependency(candidate, expectedType, parsed, fqn, constraint),
+            holdbacks: [],
+            bypasses: [],
+        };
+    }
+    const source = yield* registrySourceForDependency(pack, parsed.owner, sourceOverride);
+    const resolution = yield* Effect.scoped(sources.resolveNamedRegistry(source, {
+        name: parsed.name,
+        type: expectedType,
+        owner: parsed.owner,
+        versionRange: Option.some(constraint),
+        releaseAgeEvaluation: evaluation,
+    }));
+    const packTarget = formatFqn({ owner: pack.owner, type: "pack", name: pack.pack.name });
+    const dependencyTarget = formatFqn(parsed);
+    if (resolution.kind === "not_found") {
+        return yield* new PackDependencyMissing({ dependencyTarget });
+    }
+    if (resolution.kind === "version_unsatisfied") {
+        return yield* new PackDependencyUnsatisfied({ dependencyTarget, constraint });
+    }
+    if (resolution.kind === "policy_held") {
+        return {
+            kind: "policy_held",
+            holdback: dependencyReleaseAgeRecord({
+                packTarget,
+                dependencyTarget,
+                constraint,
+                evidence: resolution.candidate,
+            }),
+        };
+    }
+    const ref = resolution.ref;
+    return {
+        kind: "selected",
+        dependency: {
+            owner: parsed.owner,
+            type: expectedType,
+            name: parsed.name,
+            ref,
+        },
+        holdbacks: resolution.kind === "exempted" || resolution.newerHeld === undefined
+            ? []
+            : [
+                dependencyReleaseAgeRecord({
+                    packTarget,
+                    dependencyTarget,
+                    constraint,
+                    evidence: resolution.newerHeld,
+                    selectedVersion: ref.version,
+                }),
+            ],
+        bypasses: resolution.kind === "selected"
+            ? []
+            : [
+                {
+                    ...dependencyReleaseAgeRecord({
+                        packTarget,
+                        dependencyTarget,
+                        constraint,
+                        evidence: resolution.bypassed,
+                        selectedVersion: ref.version,
+                    }),
+                    ...resolution.exemption,
+                },
+            ],
+    };
+});
+const toResolvedMap = (dependencies) => Object.fromEntries(dependencies.map((dependency) => {
+    const ref = dependency.ref;
+    return [
+        formatFqn(dependency),
+        ref.refType === "registry"
+            ? {
+                source: "registry",
+                version: ref.version,
+                publisherBindingId: ref.publisherBindingId,
+                integrity: Option.getOrElse(ref.integrity, () => ""),
+            }
+            : {
+                source: "workspace",
+                version: ref.version,
+                sourceIdentity: `workspace:${ref.owner}/${toExtensionTypePlural(ref.type)}/${ref.name}`,
+                contentIdentity: ref.sourceHash,
+            },
+    ];
+}));
+const resolveDependencyGroup = (pack, dependencies, expectedType, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.forEach(dependencies, ([fqn, constraint]) => resolveDependencyRef(pack, expectedType, fqn, constraint, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver), { concurrency: "unbounded" });
+/**
+ * Group dependency FQNs by extension type.
+ *
+ * The `groups` record is keyed by every non-pack extension type, so a new type
+ * fails compile here rather than being silently dropped from pack membership.
+ */
+const partitionDependencies = (dependencies) => {
+    const groups = {
+        skill: [],
+        "mcp-server": [],
+        subagent: [],
+        rule: [],
+        hook: [],
+        knowledge: [],
+    };
+    const unsupported = [];
+    for (const [fqn, constraint] of Object.entries(dependencies)) {
+        const parsed = parseFqnOrThrow(fqn);
+        if (parsed.type === "pack") {
+            unsupported.push(fqn);
+            continue;
+        }
+        groups[parsed.type].push([fqn, constraint]);
+    }
+    return { groups, unsupported };
+};
+export const resolvePackDependencies = (pack, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
+    const dependencies = partitionDependencies(pack.pack.dependencies);
+    if (dependencies.unsupported.length > 0) {
+        return yield* new PackDependencyInvalid({
+            detail: `Pack declares ${dependencies.unsupported.length} unsupported dependency type${dependencies.unsupported.length === 1 ? "" : "s"}: ${dependencies.unsupported.join(", ")}`,
+        });
+    }
+    const resolveGroup = (type) => resolveDependencyGroup(pack, dependencies.groups[type], type, sources, minimumReleaseAge, sourceOverride, workspaceResolver, dependencyResolver);
+    const resolvedSkills = yield* resolveGroup("skill");
+    const resolvedMcpServers = yield* resolveGroup("mcp-server");
+    const resolvedSubagents = yield* resolveGroup("subagent");
+    const resolvedRules = yield* resolveGroup("rule");
+    const resolvedHooks = yield* resolveGroup("hook");
+    const resolvedKnowledge = yield* resolveGroup("knowledge");
+    return {
+        resolvedSkills: toResolvedMap(resolvedSkills),
+        resolvedMcpServers: toResolvedMap(resolvedMcpServers),
+        resolvedSubagents: toResolvedMap(resolvedSubagents),
+        resolvedRules: toResolvedMap(resolvedRules),
+        resolvedHooks: toResolvedMap(resolvedHooks),
+        resolvedKnowledge: toResolvedMap(resolvedKnowledge),
+        dependencyRefs: [
+            ...resolvedSkills,
+            ...resolvedMcpServers,
+            ...resolvedSubagents,
+            ...resolvedRules,
+            ...resolvedHooks,
+            ...resolvedKnowledge,
+        ].map((dependency) => dependency.ref),
+    };
+});
+export const resolvePackDependenciesWithReleaseAge = (pack, sources, evaluation, sourceOverride, workspaceResolver, dependencyResolver) => Effect.gen(function* () {
+    const packExemption = pack.refType === "registry"
+        ? releaseAgeExemptionForIdentity(evaluation, {
+            owner: pack.owner,
+            type: "pack",
+            name: pack.pack.name,
+        })
+        : undefined;
+    const dependencyEvaluation = packExemption?.bypassCause === "exclude"
+        ? { ...evaluation, grantedExemption: packExemption }
+        : evaluation;
+    const dependencies = partitionDependencies(pack.pack.dependencies);
+    if (dependencies.unsupported.length > 0) {
+        return yield* new PackDependencyInvalid({
+            detail: `Pack declares ${dependencies.unsupported.length} unsupported dependency type${dependencies.unsupported.length === 1 ? "" : "s"}: ${dependencies.unsupported.join(", ")}`,
+        });
+    }
+    const entries = [
+        ...dependencies.groups.skill.map(([fqn, constraint]) => ({
+            type: "skill",
+            fqn,
+            constraint,
+        })),
+        ...dependencies.groups["mcp-server"].map(([fqn, constraint]) => ({
+            type: "mcp-server",
+            fqn,
+            constraint,
+        })),
+        ...dependencies.groups.subagent.map(([fqn, constraint]) => ({
+            type: "subagent",
+            fqn,
+            constraint,
+        })),
+        ...dependencies.groups.rule.map(([fqn, constraint]) => ({
+            type: "rule",
+            fqn,
+            constraint,
+        })),
+        ...dependencies.groups.hook.map(([fqn, constraint]) => ({
+            type: "hook",
+            fqn,
+            constraint,
+        })),
+        ...dependencies.groups.knowledge.map(([fqn, constraint]) => ({
+            type: "knowledge",
+            fqn,
+            constraint,
+        })),
+    ];
+    const resolutions = yield* Effect.forEach(entries, ({ type, fqn, constraint }) => resolveDependencyRefWithReleaseAge(pack, type, fqn, constraint, sources, dependencyEvaluation, sourceOverride, workspaceResolver, dependencyResolver), { concurrency: "unbounded" });
+    const holdbacks = resolutions.flatMap((resolution) => resolution.kind === "policy_held" ? [resolution.holdback] : resolution.holdbacks);
+    const bypasses = resolutions.flatMap((resolution) => resolution.kind === "selected" ? resolution.bypasses : []);
+    if (resolutions.some((resolution) => resolution.kind === "policy_held")) {
+        return { kind: "policy_held", holdbacks, bypasses };
+    }
+    const selected = resolutions.flatMap((resolution) => resolution.kind === "selected" ? [resolution.dependency] : []);
+    const byType = (type) => selected.filter((dependency) => dependency.type === type);
+    const resolvedSkills = byType("skill");
+    const resolvedMcpServers = byType("mcp-server");
+    const resolvedSubagents = byType("subagent");
+    const resolvedRules = byType("rule");
+    const resolvedHooks = byType("hook");
+    const resolvedKnowledge = byType("knowledge");
+    return {
+        kind: "selected",
+        holdbacks,
+        bypasses,
+        dependencies: {
+            resolvedSkills: toResolvedMap(resolvedSkills),
+            resolvedMcpServers: toResolvedMap(resolvedMcpServers),
+            resolvedSubagents: toResolvedMap(resolvedSubagents),
+            resolvedRules: toResolvedMap(resolvedRules),
+            resolvedHooks: toResolvedMap(resolvedHooks),
+            resolvedKnowledge: toResolvedMap(resolvedKnowledge),
+            dependencyRefs: selected.map((dependency) => dependency.ref),
+        },
+    };
+});
+//# sourceMappingURL=dependency-resolution.js.map