@agentxm/extension-lifecycle 0.28.12 → 0.28.13

package/dist/src/packs/uninstall/plan.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Uninstalling packs.
+ *
+ * Removing a pack removes every member no other origin still declares, in one
+ * transition: members first, while their pack-derived desired state is still
+ * observable, then the pack itself. A selected pack whose own manifest cannot
+ * be read is retired — its registration goes, its unverifiable content stays —
+ * and a graph incomplete for any other reason blocks instead.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager } from "@agentxm/extension-materialization";
+import { type ExtensionFqnParts, type ExtensionName, type Handle } from "@agentxm/extension-model/unstable/extensions";
+import { type Plan } from "@agentxm/workspace-operations";
+import { type DesiredPackageAuthority, type DesiredStateGraph, type PackExtensionTarget } from "@agentxm/workspace-state";
+import type { ExtensionLifecycleFailed } from "../../errors.js";
+import { type InstallStepRequirements } from "../../install/vocabulary.js";
+import { type PackRetirement } from "./readiness.js";
+/** How the request named the pack to remove. */
+export type PackUninstallSelector = {
+    readonly _tag: "ExactFqn";
+    readonly identity: ExtensionFqnParts & {
+        readonly type: "pack";
+    };
+} | {
+    readonly _tag: "SimpleName";
+    readonly name: string;
+};
+/** One pack the removal resolved, with the desired identity it was resolved from. */
+export interface ResolvedPackUninstallTarget extends PackExtensionTarget {
+    readonly owner: Handle;
+    readonly name: ExtensionName;
+    readonly authority: DesiredPackageAuthority;
+    readonly desiredIdentity: string;
+}
+/** The packs this removal withdraws. */
+export interface PackUninstallIntent {
+    readonly packsToUninstall: ReadonlyArray<ResolvedPackUninstallTarget>;
+}
+/**
+ * The pack this candidate was resolved from must still be the pack in the
+ * graph when the transition applies; otherwise the candidate describes a
+ * decision that is no longer available.
+ */
+export declare const validateResolvedPackUninstallTargets: (graph: DesiredStateGraph, targets: ReadonlyArray<ResolvedPackUninstallTarget>) => Effect.Effect<void, ExtensionLifecycleFailed>;
+/**
+ * Preview and apply must reach one decision from unchanged inputs. A target
+ * whose package became readable — or unreadable — between the two phases is a
+ * different decision, so the candidate is stale rather than applicable.
+ */
+export declare const validatePackRetirementFacts: (args: {
+    readonly planned: ReadonlyArray<PackRetirement>;
+    readonly observed: ReadonlyArray<PackRetirement> | undefined;
+}) => Effect.Effect<void, ExtensionLifecycleFailed>;
+/** Read the pack selector: an exact FQN, one name, or a glob over pack names. */
+export declare const parsePackUninstallSelectors: (selector: string) => Effect.Effect<ReadonlyArray<PackUninstallSelector>, ExtensionLifecycleFailed, InstallStepRequirements>;
+/** Resolve the selectors against the desired graph. */
+export declare const finalizePackUninstallIntent: (selectors: ReadonlyArray<PackUninstallSelector>) => Effect.Effect<PackUninstallIntent, ExtensionLifecycleFailed, InstallStepRequirements>;
+/** Everything the pack removal reads and writes through. */
+export type PackUninstallRequirements = InstallStepRequirements | Path.Path | FileSystem.FileSystem | HookManager | KnowledgeManager | McpServerManager | PackManager | RuleManager | SkillManager | SubagentManager;
+/** The single atomic closure a settled pack removal becomes. */
+export declare const planPackUninstall: (intent: PackUninstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, PackUninstallRequirements>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/packs/uninstall/plan.js

@@ -0,0 +1,344 @@
+/**
+ * Uninstalling packs.
+ *
+ * Removing a pack removes every member no other origin still declares, in one
+ * transition: members first, while their pack-derived desired state is still
+ * observable, then the pack itself. A selected pack whose own manifest cannot
+ * be read is retired — its registration goes, its unverifiable content stays —
+ * and a graph incomplete for any other reason blocks instead.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager, buildUninstallOperation, toLabel, } from "@agentxm/extension-materialization";
+import { parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions";
+import { operationPresentation, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, decodeDesiredExtensionIdentity, } from "@agentxm/workspace-state";
+import { expandGlob } from "../../glob.js";
+import { lifecycleStepFailure } from "../../step-failure.js";
+import { buildAggregateProjectionStep } from "../../install/aggregate-projection-step.js";
+import { installRefused } from "../../install/vocabulary.js";
+import { exclusiveMemberRetentionPolicy, makeWorkspaceRetentionPolicy, } from "../../uninstall/retention-policy.js";
+import { workspaceCanonicalNodePath } from "../../workspace-paths.js";
+import { buildAtomicPackGraphStep, validatePackGraphPostcondition } from "../graph-transition.js";
+import { PACK_UNINSTALL_GRAPH_BLOCKER_ID, planPackUninstallGraphReadiness, } from "./readiness.js";
+const normalizedPackIdentity = (identity) => identity.startsWith("workspace:") ? identity.slice("workspace:".length) : identity;
+const identityValidationError = (identity) => installRefused({
+    category: "validation",
+    detail: `Configured pack identity ${identity} is invalid`,
+});
+const readDesiredGraph = Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    return yield* ws
+        .getDesiredStateGraph()
+        .pipe(Effect.mapError((cause) => installRefused({ category: "internal", detail: "Desired state could not be read", cause })));
+});
+/**
+ * The pack this candidate was resolved from must still be the pack in the
+ * graph when the transition applies; otherwise the candidate describes a
+ * decision that is no longer available.
+ */
+export const validateResolvedPackUninstallTargets = (graph, targets) => Effect.gen(function* () {
+    for (const expected of targets) {
+        const current = graph.nodes.find((candidate) => candidate.type === "pack" && candidate.name === expected.name);
+        if (current === undefined) {
+            return yield* installRefused({
+                category: "conflict",
+                detail: `Pack ${expected.desiredIdentity} changed or was removed before uninstall`,
+                recover: "Inspect the current pack state, then retry the uninstall.",
+                cmd: `axm packs show ${expected.name}`,
+            });
+        }
+        const decoded = decodeDesiredExtensionIdentity(current.identity);
+        if (decoded === undefined || decoded.type !== "pack") {
+            return yield* identityValidationError(current.identity);
+        }
+        if (current.identity !== expected.desiredIdentity ||
+            decoded.authority !== expected.authority ||
+            decoded.owner !== expected.owner ||
+            decoded.name !== expected.name) {
+            return yield* installRefused({
+                category: "conflict",
+                detail: `Pack ${expected.desiredIdentity} changed or was removed before uninstall`,
+                recover: "Inspect the current pack state, then retry the uninstall.",
+                cmd: `axm packs show ${expected.name}`,
+            });
+        }
+    }
+});
+const retirementKey = (retirement) => `${retirement.pack}\u0000${retirement.reason}\u0000${retirement.manifestPath}`;
+const retirementSetKey = (retirements) => [...retirements].map(retirementKey).sort().join("\u0001");
+/**
+ * Preview and apply must reach one decision from unchanged inputs. A target
+ * whose package became readable — or unreadable — between the two phases is a
+ * different decision, so the candidate is stale rather than applicable.
+ */
+export const validatePackRetirementFacts = (args) => {
+    if (args.observed !== undefined &&
+        retirementSetKey(args.observed) === retirementSetKey(args.planned)) {
+        return Effect.void;
+    }
+    const packs = [...new Set([...args.planned].map((retirement) => retirement.pack))];
+    return Effect.fail(installRefused({
+        category: "conflict",
+        detail: packs.length === 0
+            ? "The pack graph changed before uninstall"
+            : `Pack package readability for ${packs.join(", ")} changed before uninstall`,
+        recover: "Inspect the current pack state, then retry the uninstall.",
+        cmd: "axm packs list",
+    }));
+};
+const uninstallPresentation = operationPresentation({ imperative: "uninstall", past: "Uninstalled", gerund: "Uninstalling" }, "pack");
+/** Read the pack selector: an exact FQN, one name, or a glob over pack names. */
+export const parsePackUninstallSelectors = Effect.fn("UninstallExtensions.parsePackSelectors")(function* (selector) {
+    const requested = parseExtensionFqnParts(selector);
+    if (requested !== undefined && requested.type !== "pack") {
+        return yield* installRefused({
+            category: "validation",
+            detail: `Expected a pack identity, received ${selector}`,
+        });
+    }
+    if (requested !== undefined) {
+        return [
+            {
+                _tag: "ExactFqn",
+                identity: { owner: requested.owner, type: "pack", name: requested.name },
+            },
+        ];
+    }
+    if (!selector.includes("*"))
+        return [{ _tag: "SimpleName", name: selector }];
+    const graph = yield* readDesiredGraph;
+    const names = expandGlob(selector, graph.nodes.filter((node) => node.type === "pack").map((node) => node.name));
+    return names.map((name) => ({ _tag: "SimpleName", name }));
+});
+/** Resolve the selectors against the desired graph. */
+export const finalizePackUninstallIntent = Effect.fn("UninstallExtensions.finalizePackIntent")(function* (selectors) {
+    const graph = yield* readDesiredGraph;
+    const targets = new Map();
+    for (const selector of selectors) {
+        const name = selector._tag === "ExactFqn" ? selector.identity.name : selector.name;
+        const candidates = graph.nodes.filter((candidate) => candidate.type === "pack" && candidate.name === name);
+        for (const node of candidates) {
+            const identity = decodeDesiredExtensionIdentity(node.identity);
+            if (identity === undefined || identity.type !== "pack") {
+                return yield* identityValidationError(node.identity);
+            }
+            if (selector._tag === "ExactFqn" && identity.owner !== selector.identity.owner)
+                continue;
+            targets.set(node.identity, {
+                type: "pack",
+                name: identity.name,
+                owner: identity.owner,
+                authority: identity.authority,
+                desiredIdentity: node.identity,
+            });
+        }
+    }
+    return { packsToUninstall: [...targets.values()] };
+});
+/** The single atomic closure a settled pack removal becomes. */
+export const planPackUninstall = Effect.fn("UninstallExtensions.planPacks")(function* (intent) {
+    const ws = yield* WorkspaceMutations;
+    const path = yield* Path.Path;
+    const packManager = yield* PackManager;
+    const skillManager = yield* SkillManager;
+    const subagentManager = yield* SubagentManager;
+    const ruleManager = yield* RuleManager;
+    const hookManager = yield* HookManager;
+    const knowledgeManager = yield* KnowledgeManager;
+    const mcpServerManager = yield* McpServerManager;
+    const observedGraph = yield* readDesiredGraph;
+    const graphReadiness = planPackUninstallGraphReadiness(observedGraph, intent.packsToUninstall.map((pack) => pack.desiredIdentity), ws.scope);
+    if (graphReadiness.readiness === "blocked") {
+        return {
+            _tag: "Plan",
+            name: "Uninstall packs",
+            description: Option.some("Pack graph readiness prevents this uninstall."),
+            presentation: uninstallPresentation,
+            jobs: [
+                {
+                    concurrency: 1,
+                    steps: [
+                        {
+                            readiness: "error",
+                            label: intent.packsToUninstall.map((pack) => pack.desiredIdentity).join(", ") ||
+                                "Pack graph",
+                            errorMessage: graphReadiness.detail,
+                            blockingConditionIds: [PACK_UNINSTALL_GRAPH_BLOCKER_ID],
+                            artifact: {
+                                path: "pack graph",
+                                scope: ws.scope,
+                                change: "unchanged",
+                                fileCount: 0,
+                                targets: graphReadiness.facts.flatMap((fact) => fact.authoritativeLocations.map((location) => ({
+                                    path: location,
+                                    change: "unchanged",
+                                }))),
+                            },
+                        },
+                    ],
+                },
+            ],
+            riskConditions: [
+                {
+                    level: "blocked",
+                    id: PACK_UNINSTALL_GRAPH_BLOCKER_ID,
+                    detail: graphReadiness.detail,
+                    errorCode: "conflict",
+                },
+            ],
+        };
+    }
+    if (intent.packsToUninstall.length === 0) {
+        return {
+            _tag: "Plan",
+            name: "Uninstall packs",
+            description: Option.none(),
+            presentation: uninstallPresentation,
+            jobs: [{ concurrency: 1, steps: [] }],
+        };
+    }
+    const graph = graphReadiness.graph;
+    const plannedRetirements = graphReadiness.retirements;
+    const retirementByIdentity = new Map(plannedRetirements.map((retirement) => [retirement.pack, retirement]));
+    // Only a selected pack can be retired, and members are never read from an
+    // unreadable manifest, so the lookup is keyed by the selected pack's name.
+    const retirementByPackName = new Map(intent.packsToUninstall.flatMap((pack) => {
+        const retirement = retirementByIdentity.get(normalizedPackIdentity(pack.desiredIdentity));
+        return retirement === undefined ? [] : [[pack.name, retirement]];
+    }));
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const allTargets = new Map();
+    for (const pack of intent.packsToUninstall) {
+        allTargets.set(`pack:${pack.name}`, pack);
+    }
+    const removingPackIdentities = new Set(intent.packsToUninstall.map((pack) => pack.desiredIdentity));
+    for (const node of graph.nodes) {
+        if (node.type === "pack")
+            continue;
+        const removedOrigin = node.origins.some((origin) => origin.type === "pack" && removingPackIdentities.has(origin.pack));
+        if (!removedOrigin)
+            continue;
+        const retainedOrigin = node.origins.some((origin) => origin.type === "settings" ||
+            (origin.type === "pack" && !removingPackIdentities.has(origin.pack)));
+        if (retainedOrigin)
+            continue;
+        allTargets.set(`${node.type}:${node.name}`, { type: node.type, name: node.name });
+    }
+    // Remove members while their pack-derived desired state is still
+    // observable, then retire the owning pack.
+    const packTargets = [...allTargets.values()].filter((target) => target.type === "pack");
+    const depTargets = [...allTargets.values()].filter((target) => target.type !== "pack");
+    const orderedTargets = [...depTargets, ...packTargets];
+    const sourcePathByTarget = new Map(graph.nodes.map((node) => [
+        `${node.type}:${node.name}`,
+        workspaceCanonicalNodePath(path, ws, node),
+    ]));
+    const steps = orderedTargets.map((target) => {
+        switch (target.type) {
+            case "pack": {
+                const retirement = retirementByPackName.get(target.name);
+                return buildUninstallOperation(packManager, retentionPolicy, {
+                    target,
+                    toStepFailure: lifecycleStepFailure,
+                    ...(retirement === undefined
+                        ? {}
+                        : {
+                            retirement: {
+                                // Results name workspace-relative paths, so the same
+                                // retirement reads identically from any workspace.
+                                manifestPath: path.relative(ws.baseDir, retirement.manifestPath),
+                                reason: retirement.reason,
+                            },
+                        }),
+                });
+            }
+            case "skill":
+                return buildUninstallOperation(skillManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                });
+            case "mcp-server":
+                return buildUninstallOperation(mcpServerManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                });
+            case "subagent":
+                return buildUninstallOperation(subagentManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                });
+            case "rule":
+                return buildUninstallOperation(ruleManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                    skipProjections: true,
+                });
+            case "hook":
+                return buildUninstallOperation(hookManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                    skipProjections: true,
+                });
+            case "knowledge":
+                return buildUninstallOperation(knowledgeManager, exclusiveMemberRetentionPolicy, {
+                    toStepFailure: lifecycleStepFailure,
+                    target,
+                    skipProjections: true,
+                });
+        }
+    });
+    const projectionStep = yield* buildAggregateProjectionStep({
+        types: new Set(orderedTargets.map((target) => target.type)),
+    });
+    const registrationOnly = plannedRetirements.length === 0
+        ? ""
+        : ` (${plannedRetirements.length} pack${plannedRetirements.length === 1 ? "" : "s"} unregistered without removing package content)`;
+    const graphStep = yield* buildAtomicPackGraphStep({
+        label: `${intent.packsToUninstall.length} pack${intent.packsToUninstall.length === 1 ? "" : "s"}`,
+        message: `Uninstalled ${intent.packsToUninstall.length} pack${intent.packsToUninstall.length === 1 ? "" : "s"} and ${depTargets.length} exclusive member${depTargets.length === 1 ? "" : "s"}${registrationOnly}`,
+        artifact: {
+            path: "pack graph",
+            scope: ws.scope,
+            change: "removed",
+            fileCount: orderedTargets.length,
+            targets: orderedTargets.map((target) => ({
+                path: sourcePathByTarget.get(`${target.type}:${target.name}`) ?? toLabel(target),
+                // Content AXM could not verify is preserved, so its canonical path is
+                // never reported as removed.
+                change: target.type === "pack" && retirementByPackName.has(target.name) ? "unchanged" : "removed",
+            })),
+        },
+        children: [
+            ...steps.map((step) => ({ step, coverage: "ineligible" })),
+            ...Option.toArray(projectionStep).map((step) => ({
+                step,
+                coverage: "ineligible",
+            })),
+        ],
+        preTransition: Effect.gen(function* () {
+            const currentGraph = yield* readDesiredGraph;
+            yield* validateResolvedPackUninstallTargets(currentGraph, intent.packsToUninstall);
+            const currentReadiness = planPackUninstallGraphReadiness(currentGraph, intent.packsToUninstall.map((pack) => pack.desiredIdentity), ws.scope);
+            yield* validatePackRetirementFacts({
+                planned: plannedRetirements,
+                observed: currentReadiness.readiness === "ready" ? currentReadiness.retirements : undefined,
+            });
+        }),
+        validate: validatePackGraphPostcondition({ absent: orderedTargets }),
+    });
+    return {
+        _tag: "Plan",
+        name: intent.packsToUninstall.length === 1
+            ? "Uninstall pack"
+            : `Uninstall ${intent.packsToUninstall.length} packs`,
+        description: Option.none(),
+        presentation: uninstallPresentation,
+        jobs: [{ concurrency: 1, steps: [graphStep] }],
+    };
+});
+//# sourceMappingURL=plan.js.map

package/dist/src/packs/uninstall/readiness.d.ts

@@ -0,0 +1,50 @@
+import type { DesiredStateGraph, DesiredStateProblem } from "@agentxm/workspace-state";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+/** Recovery-conformance identity for Pack uninstall planning on an incomplete graph. */
+export declare const PACK_UNINSTALL_GRAPH_BLOCKER_ID: "packs/uninstall/desired-state-graph-complete";
+/** Executable Pack-uninstall blocker identities covered by recovery conformance. */
+export declare const packUninstallRecoveryIdentifiers: readonly ["packs/uninstall/desired-state-graph-complete"];
+export interface PackUninstallGraphBlockerFact {
+    readonly problemType: DesiredStateProblem["type"] | "unknown";
+    readonly packs: ReadonlyArray<string>;
+    readonly member?: {
+        readonly type: string;
+        readonly name: string;
+    };
+    readonly authoritativeLocations: ReadonlyArray<string>;
+    readonly detail: string;
+}
+/** Why a selected Pack's own package could not be read. */
+export type PackRetirementReason = "missing" | "invalid";
+/**
+ * A selected Pack whose own package manifest is unreadable. Its registration is
+ * removable from positive evidence about the Pack itself; its content is not,
+ * because nothing about that content can be verified.
+ */
+export interface PackRetirement {
+    readonly pack: string;
+    readonly manifestPath: string;
+    readonly reason: PackRetirementReason;
+}
+export type PackUninstallGraphReadiness = {
+    readonly readiness: "ready";
+    readonly graph: DesiredStateGraph;
+    readonly retirements: ReadonlyArray<PackRetirement>;
+} | {
+    readonly readiness: "blocked";
+    readonly id: typeof PACK_UNINSTALL_GRAPH_BLOCKER_ID;
+    readonly facts: ReadonlyArray<PackUninstallGraphBlockerFact>;
+    readonly detail: string;
+};
+/**
+ * Build the Pack-uninstall readiness decision from the shared desired-state
+ * planner.
+ *
+ * The graph gate exists to stop a Pack transition computed from state AXM
+ * cannot read. A selected Pack whose own manifest is confirmed missing or
+ * undecodable is positive evidence about the removal target, not the absent
+ * evidence the gate guards against, so uninstall proceeds and removes only that
+ * Pack's registration. Incompleteness the target did not cause still blocks.
+ */
+export declare const planPackUninstallGraphReadiness: (graph: DesiredStateGraph, selectedPacks: ReadonlyArray<string>, scope: WorkspaceScope) => PackUninstallGraphReadiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/src/packs/uninstall/readiness.js

@@ -0,0 +1,130 @@
+import { planDesiredStateGraph } from "@agentxm/workspace-projection";
+import { workspaceCanonicalRoot, workspaceLockfilePath, workspaceSettingsPath, } from "../../workspace-paths.js";
+/** Recovery-conformance identity for Pack uninstall planning on an incomplete graph. */
+export const PACK_UNINSTALL_GRAPH_BLOCKER_ID = "packs/uninstall/desired-state-graph-complete";
+/** Executable Pack-uninstall blocker identities covered by recovery conformance. */
+export const packUninstallRecoveryIdentifiers = [PACK_UNINSTALL_GRAPH_BLOCKER_ID];
+const normalizedPack = (identity) => identity.startsWith("workspace:") ? identity.slice("workspace:".length) : identity;
+/**
+ * Problems the lock pass emits for a Pack as a consequence of its unreadable
+ * manifest. They add no information the gate does not already have from the
+ * primary problem, so they never block on their own account.
+ */
+const isCompanionProblem = (problem) => problem.type === "pack-manifest-content-mismatch" ||
+    problem.type === "pack-resolution-unavailable";
+/**
+ * Classify the selected Packs' own problems into retirements, or report that
+ * some selected Pack disagrees with the workspace in a way absence cannot
+ * explain. Readable-but-disagreeing state is drift, and stays blocked.
+ */
+const retirementsFor = (problems) => {
+    const problemsByPack = new Map();
+    for (const problem of problems) {
+        if (!("pack" in problem))
+            return undefined;
+        const pack = normalizedPack(problem.pack);
+        const existing = problemsByPack.get(pack);
+        if (existing === undefined)
+            problemsByPack.set(pack, [problem]);
+        else
+            existing.push(problem);
+    }
+    const retirements = [];
+    for (const [pack, packProblems] of problemsByPack) {
+        let unreadable;
+        for (const problem of packProblems) {
+            if (problem.type === "pack-manifest-unavailable") {
+                unreadable ??= { manifestPath: problem.path, reason: "missing" };
+                continue;
+            }
+            if (problem.type === "pack-manifest-invalid") {
+                unreadable ??= { manifestPath: problem.path, reason: "invalid" };
+                continue;
+            }
+            if (isCompanionProblem(problem))
+                continue;
+            return undefined;
+        }
+        if (unreadable === undefined)
+            return undefined;
+        retirements.push({ pack, ...unreadable });
+    }
+    return retirements;
+};
+const locationsFor = (problem, scope) => {
+    if ("path" in problem && problem.path !== undefined)
+        return [problem.path];
+    if ("pack" in problem)
+        return [workspaceSettingsPath(scope), workspaceLockfilePath(scope)];
+    return [workspaceSettingsPath(scope), `${workspaceCanonicalRoot(scope)}/*/packs/*/pack.json`];
+};
+const factFor = (problem, selectedPacks, scope) => {
+    const packs = "pack" in problem ? [normalizedPack(problem.pack)] : selectedPacks.map(normalizedPack);
+    const authoritativeLocations = locationsFor(problem, scope);
+    const member = "extensionType" in problem ? { type: problem.extensionType, name: problem.name } : undefined;
+    const subject = member === undefined ? `Pack ${packs.join(", ")}` : `${member.type} member ${member.name}`;
+    const problemDetail = "detail" in problem
+        ? problem.detail
+        : "constraints" in problem
+            ? `constraints ${problem.constraints.join(", ")}`
+            : "identities" in problem
+                ? `identities ${problem.identities.join(", ")}`
+                : problem.type;
+    return {
+        problemType: problem.type,
+        packs,
+        ...(member === undefined ? {} : { member }),
+        authoritativeLocations,
+        detail: `${subject}: ${problem.type} (${problemDetail}); authoritative location${authoritativeLocations.length === 1 ? "" : "s"}: ${authoritativeLocations.join(", ")}`,
+    };
+};
+/**
+ * Build the Pack-uninstall readiness decision from the shared desired-state
+ * planner.
+ *
+ * The graph gate exists to stop a Pack transition computed from state AXM
+ * cannot read. A selected Pack whose own manifest is confirmed missing or
+ * undecodable is positive evidence about the removal target, not the absent
+ * evidence the gate guards against, so uninstall proceeds and removes only that
+ * Pack's registration. Incompleteness the target did not cause still blocks.
+ */
+export const planPackUninstallGraphReadiness = (graph, selectedPacks, scope) => {
+    const decision = planDesiredStateGraph(graph);
+    if (decision.readiness === "ready")
+        return { ...decision, retirements: [] };
+    const selected = new Set(selectedPacks.map(normalizedPack));
+    const foreign = [];
+    const own = [];
+    for (const problem of decision.problems) {
+        if ("pack" in problem && selected.has(normalizedPack(problem.pack)))
+            own.push(problem);
+        else
+            foreign.push(problem);
+    }
+    if (foreign.length === 0 && own.length > 0) {
+        const retirements = retirementsFor(own);
+        if (retirements !== undefined)
+            return { readiness: "ready", graph, retirements };
+    }
+    const facts = decision.problems.length === 0
+        ? [
+            {
+                problemType: "unknown",
+                packs: selectedPacks.map(normalizedPack),
+                authoritativeLocations: [workspaceSettingsPath(scope), workspaceLockfilePath(scope)],
+                detail: `Pack ${selectedPacks.map(normalizedPack).join(", ")}: desired-state graph is incomplete; authoritative locations: ${workspaceSettingsPath(scope)}, ${workspaceLockfilePath(scope)}`,
+            },
+        ]
+        : decision.problems.map((problem) => factFor(problem, selectedPacks, scope));
+    const foreignPacks = [
+        ...new Set(foreign.flatMap((problem) => ("pack" in problem ? [normalizedPack(problem.pack)] : []))),
+    ];
+    const remedy = foreignPacks.length === 0 ? "" : `; restore or uninstall ${foreignPacks.join(", ")} first`;
+    return {
+        readiness: "blocked",
+        id: PACK_UNINSTALL_GRAPH_BLOCKER_ID,
+        facts,
+        detail: `Cannot uninstall Pack graph because desired state is incomplete: ${facts.map((fact) => fact.detail).join("; ")}${remedy}`,
+    };
+};
+//# sourceMappingURL=readiness.js.map

package/dist/src/publisher-binding.d.ts

@@ -1,53 +1,21 @@
 /**
- * Publisher binding trust classification.
+ * Publisher-change plan shaping.
  *
- * A Registry resolution binds a publisher identity. When an operation
- * proposes to replace an already accepted binding for the same configured
- * extension with a different one, that transition is a trust decision a
- * person makes at a prompt: no flag and no unattended mode can approve it.
- * Every route that can replace an accepted binding — root and type update
- * forms, reinstall and re-resolution, and pack closures — classifies the
- * transition from the structured accepted and proposed identities here, so
- * the same rule holds everywhere the transition can occur.
- *
- * A first acceptance is not a change, and an integrity mismatch while
- * reacquiring the same accepted identity remains a hard failure elsewhere.
+ * `@agentxm/extension-resolution` classifies whether a proposed Registry
+ * acceptance replaces an accepted publisher binding. This module turns that
+ * classification into plan vocabulary: the per-step warning, the
+ * interactive-only risk condition, and the blocking condition raised when an
+ * accepted resolution cannot be read at all.
  *
  * @experimental This API is unstable and may change without notice.
  */
 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 { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
-import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions";
-import type { Plan, PlanRiskCondition, RegistryBindingProposal } from "@agentxm/workspace-operations";
+import { type PublisherBindingTransition } from "@agentxm/extension-resolution";
+import type { Plan, PlanRiskCondition } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-export interface PublisherBindingTransition {
-    readonly extensionType: ExtensionType;
-    /** The configured (local) name whose accepted resolution changes publisher. */
-    readonly target: string;
-    readonly owner: string;
-    readonly packageName: string;
-    /** The accepted publisher binding being replaced. */
-    readonly accepted: string;
-    /** The publisher binding the operation proposes to accept. */
-    readonly proposed: string;
-}
 export declare const PUBLISHER_CHANGE_CONDITION_ID = "publisher-ownership-change";
-/** The structured proposal an extension ref makes, when it is a Registry ref. */
-export declare const registryBindingProposal: (ref: ExtensionRef) => RegistryBindingProposal | undefined;
-/**
- * Classify one proposed acceptance against the accepted resolution for the
- * same configured target. Only a Registry binding replacing a different
- * Registry binding is a publisher change.
- */
-export declare const classifyPublisherBindingTransition: (args: {
-    readonly accepted: Option.Option<ExtensionRef>;
-    readonly proposed: RegistryBindingProposal;
-}) => Option.Option<PublisherBindingTransition>;
-/** The warning a step carries when its acceptance changes publisher. */
-export declare const publisherTransitionWarning: (transition: PublisherBindingTransition) => string;
 /**
  * The interactive-only condition a plan carries when any of its steps
  * replaces an accepted publisher binding.