@agentxm/extension-lifecycle 0.29.4 → 0.30.2

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

@@ -9,13 +9,14 @@
  */
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { NO_MATERIALIZATION_OBSERVATION, SubagentManager, buildUninstallOperation, } from "@agentxm/extension-materialization";
+import { NO_MATERIALIZATION_OBSERVATION, SubagentManager, } from "@agentxm/extension-materialization";
+import { buildUninstallOperation } from "@agentxm/workspace-reconciliation";
 import { parseExtensionFqnParts } from "@agentxm/extension-model/unstable/extensions";
 import { WorkspaceMutations, acquiredExtensionDisplayPathFromLockEntry, } from "@agentxm/workspace-state";
-import { expandGlob } from "../../glob.js";
+import { expandGlob } from "@agentxm/extension-model/unstable/extensions/name-patterns";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { installRefused } from "../../install/vocabulary.js";
-import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { makeWorkspaceRetentionPolicy } from "@agentxm/workspace-reconciliation";
 import { workspaceCanonicalPath, workspaceCanonicalRoot, workspaceLockfilePath, workspaceSettingsPath, } from "../../workspace-paths.js";
 const resolvedVersion = (entry) => entry !== undefined && entry.type === "registry" ? entry.resolvedVersion : undefined;
 const subagentSourceTarget = (args) => args.lockEntry === undefined
@@ -77,7 +78,7 @@ export const parseSubagentUninstallRequest = Effect.fn("UninstallExtensions.pars
 export const planSubagentUninstall = Effect.fn("UninstallExtensions.planSubagents")(function* (intent) {
     const ws = yield* WorkspaceMutations;
     const subagentManager = yield* SubagentManager;
-    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws, lifecycleStepFailure);
     // The accepted resolution names the package the removal retires, and the
     // removal deletes it, so it is read before the step runs.
     const steps = yield* Effect.forEach(intent.targets, (target) => Effect.gen(function* () {

package/dist/src/testing.d.ts

@@ -18,7 +18,8 @@ import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace
 import { ReleaseAgePosture } from "@agentxm/extension-resolution";
 import { SourceHostProviders } from "@agentxm/extension-sources";
 import { type ResolvePlanInteractionTestState } from "@agentxm/workspace-operations/testing";
-import { ExtensionSelectionInteraction } from "./install/selection-interaction.js";
+import { SkillSelectionInteraction } from "./skills/application/index.js";
+import { SubagentSelectionInteraction } from "./subagents/application/index.js";
 import { BundledAxmSkillAsset } from "./skills/install/bundled.js";
 import { StepFailureConversion } from "./step-failure-conversion.js";
 /**
@@ -99,7 +100,7 @@ export declare const makeLifecycleFixture: (options?: LifecycleFixtureOptions) =
         readonly type: "skill" | "subagent";
         readonly offered: ReadonlyArray<string>;
     }>;
-    provide: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | import("@agentxm/workspace-state").WorkspaceMutationsError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | Exclude<R, StepFailureConversion | import("@agentxm/workspace-state").WorkspaceMutations | import("@agentxm/workspace-transactions").WorkspaceTransactionScope | import("@agentxm/workspace-projection").CodingAgentRepository | import("@agentxm/agent-integration").NativeWriteAuthority | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/extension-materialization").ExtensionManagers | import("@agentxm/workspace-transactions").FootprintRecorder | HttpClient.HttpClient | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/extension-materialization").McpSecretStore | ReleaseAgePosture | import("@agentxm/workspace-operations").ResolvePlanInteraction | SourceHostProviders | import("@agentxm/extension-materialization").SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog | import("@agentxm/extension-materialization").HookManager | import("@agentxm/extension-materialization").KnowledgeManager | import("@agentxm/extension-materialization").RuleManager | import("@agentxm/extension-materialization").SkillManager | import("@agentxm/extension-materialization").McpServerManager | import("@agentxm/extension-materialization").PackManager | ExtensionSelectionInteraction | BundledAxmSkillAsset | AgentExecutableResolver | import("@agentxm/workspace-state/live").WorkspaceStateServices | import("@agentxm/workspace-projection").ProjectionParticipants | import("@agentxm/workspace-projection").WorkspaceInvariantFacts>>;
+    provide: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | import("@agentxm/workspace-state").WorkspaceMutationsError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | Exclude<R, StepFailureConversion | import("@agentxm/workspace-state").WorkspaceMutations | import("@agentxm/workspace-transactions").WorkspaceTransactionScope | import("@agentxm/workspace-projection").CodingAgentRepository | import("@agentxm/agent-integration").NativeWriteAuthority | HttpClient.HttpClient | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/extension-materialization").ExtensionManagers | import("@agentxm/extension-materialization").HookManager | import("@agentxm/extension-materialization").SkillManager | import("@agentxm/extension-materialization").RuleManager | import("@agentxm/extension-materialization").KnowledgeManager | import("@agentxm/extension-materialization").PackManager | import("@agentxm/extension-materialization").McpServerManager | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/extension-materialization").McpSecretStore | ReleaseAgePosture | import("@agentxm/workspace-operations").ResolvePlanInteraction | SourceHostProviders | import("@agentxm/extension-materialization").SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog | import("@agentxm/workspace-projection").WorkspaceInvariantFacts | SkillSelectionInteraction | SubagentSelectionInteraction | BundledAxmSkillAsset | AgentExecutableResolver | import("@agentxm/workspace-state/live").WorkspaceStateServices | import("@agentxm/workspace-projection").ProjectionParticipants>>;
     cleanup: () => void;
 };
 export type LifecycleFixture = ReturnType<typeof makeLifecycleFixture>;

package/dist/src/testing.js

@@ -21,7 +21,8 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import { AgentExecutableResolver } from "@agentxm/agent-integration";
 import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
 import { ExtensionManagersLive, HookManagerLive, KnowledgeManagerLive, McpSecretStoreLive, McpServerManagerLive, PackManagerLive, ProjectionParticipantsLive, RuleManagerLive, SkillManagerLive, SubagentManagerLive, } from "@agentxm/extension-materialization/live";
-import { ReleaseAgePosture, decideNamedRegistryVersion, makeAxmSkillCompatibilityPolicyLayer, namedRegistryCandidates, resolveVersionEntryWithReleaseAge, } from "@agentxm/extension-resolution";
+import { ReleaseAgePosture, decideNamedRegistryVersion, namedRegistryCandidates, resolveVersionEntryWithReleaseAge, } from "@agentxm/extension-resolution";
+import { makeAxmSkillCompatibilityPolicyLayer } from "@agentxm/cli-maintenance/official-skill/composition";
 import { AxmSkillCandidateGateLive } from "@agentxm/extension-resolution/live";
 import { RegistryResolutionPolicy, SourceHostProviders } from "@agentxm/extension-sources";
 import { SourceHostProvidersLive } from "@agentxm/extension-sources/live";
@@ -30,7 +31,8 @@ import { PlanInvocationTest, ResolvePlanInteractionTest, } from "@agentxm/worksp
 import { CodingAgentRepositoryLive, NativeWriteAuthorityLive, WorkspaceCatalogLive, WorkspaceInvariantFactsLive, } from "@agentxm/workspace-projection/live";
 import { layer as WorkspaceLayerLive } from "@agentxm/workspace-state/live";
 import { ExtensionLifecycleFailed } from "./errors.js";
-import { ExtensionSelectionInteraction } from "./install/selection-interaction.js";
+import { SkillSelectionInteraction } from "./skills/application/index.js";
+import { SubagentSelectionInteraction } from "./subagents/application/index.js";
 import { BundledAxmSkillAsset } from "./skills/install/bundled.js";
 import { StepFailureConversion } from "./step-failure-conversion.js";
 /**
@@ -155,19 +157,20 @@ export const makeLifecycleFixture = (options = {}) => {
         }),
     });
     const selectionCalls = [];
-    const selection = Layer.succeed(ExtensionSelectionInteraction, {
-        selectSkills: (candidates) => {
+    const selection = Layer.mergeAll(Layer.succeed(SkillSelectionInteraction, {
+        select: (candidates) => {
             selectionCalls.push({ type: "skill", offered: candidates.map((ref) => ref.skill.name) });
             return Effect.succeed(options.select === "none" ? [] : candidates);
         },
-        selectSubagents: (candidates) => {
+    }), Layer.succeed(SubagentSelectionInteraction, {
+        select: (candidates) => {
             selectionCalls.push({
                 type: "subagent",
                 offered: candidates.map((ref) => ref.subagent.name),
             });
             return Effect.succeed(options.select === "none" ? [] : candidates);
         },
-    });
+    }));
     const environment = ConfigProvider.layer(ConfigProvider.fromEnv({ env: { AXM_USER_HOME: home } }));
     // Activation never fetches a source: it turns on what the workspace already
     // acquired. A fixture that could fetch would be describing installation.

package/dist/src/uninstall/root-intent.d.ts

@@ -1,10 +1,11 @@
 import * as Effect from "effect/Effect";
 import type { ExtensionLifecycleFailed } from "../errors.js";
 import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
-export declare const rootUninstallableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[];
+export declare const rootUninstallableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "skills" | "subagents" | "packs" | "mcps")[];
 export type RootUninstallableType = InstallableExtensionType;
 export interface RootUninstallIntent {
     readonly source: string;
+    readonly owner: string;
     readonly type: RootUninstallableType;
     readonly name: string;
 }

package/dist/src/uninstall/root-intent.js

@@ -94,6 +94,7 @@ export const resolveRootUninstallIntent = Effect.fn("UninstallExtensions.resolve
     }
     return {
         source,
+        owner: parsed.owner,
         type: toInstallableExtensionType(parsed.type),
         name: parsed.name,
     };

package/dist/src/uninstall/undesired-target.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Refusing to uninstall an installed package the workspace does not configure.
+ *
+ * Uninstall withdraws desired intent. An installed package that no desired
+ * route reaches is not intent to withdraw; sync reconciles it, so uninstall
+ * refuses before planning rather than reporting a removal it cannot own.
+ */
+import * as Effect from "effect/Effect";
+import type { InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { LockfileReader, WorkspaceMutations } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../errors.js";
+/** The single extension a literal uninstall selector names. */
+export interface UninstallSubject {
+    readonly type: InstallableExtensionType;
+    readonly name: string;
+    /** The owner handle, when the selector spelled a fully qualified name. */
+    readonly owner: string | undefined;
+}
+/** The subject a typed selector names, or none for a glob. */
+export declare const typedUninstallSubject: (type: InstallableExtensionType, selector: string) => UninstallSubject | undefined;
+/**
+ * Fail when no desired route reaches the subject while an installed package
+ * for it sits in the install root.
+ */
+export declare const refuseUndesiredInstalledTarget: (subject: UninstallSubject) => Effect.Effect<undefined, ExtensionLifecycleFailed, import("effect/FileSystem").FileSystem | import("effect/Path").Path | WorkspaceMutations | LockfileReader>;
+//# sourceMappingURL=undesired-target.d.ts.map

package/dist/src/uninstall/undesired-target.js

@@ -0,0 +1,56 @@
+/**
+ * Refusing to uninstall an installed package the workspace does not configure.
+ *
+ * Uninstall withdraws desired intent. An installed package that no desired
+ * route reaches is not intent to withdraw; sync reconciles it, so uninstall
+ * refuses before planning rather than reporting a removal it cannot own.
+ */
+import * as Effect from "effect/Effect";
+import { parseExtensionFqnParts, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { LockfileReader, WorkspaceMutations, observeInstallRoot } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../errors.js";
+/** The subject a typed selector names, or none for a glob. */
+export const typedUninstallSubject = (type, selector) => {
+    const trimmed = selector.trim();
+    if (trimmed.includes("*"))
+        return undefined;
+    const fqn = parseExtensionFqnParts(trimmed);
+    return fqn !== undefined && fqn.type === type
+        ? { type, name: fqn.name, owner: fqn.owner }
+        : { type, name: trimmed, owner: undefined };
+};
+const readFailed = (cause) => new ExtensionLifecycleFailed({
+    category: "internal",
+    detail: "Installed packages could not be observed",
+    cause,
+});
+/**
+ * Fail when no desired route reaches the subject while an installed package
+ * for it sits in the install root.
+ */
+export const refuseUndesiredInstalledTarget = Effect.fn("UninstallExtensions.refuseUndesiredInstalledTarget")(function* (subject) {
+    const ws = yield* WorkspaceMutations;
+    const graph = yield* ws.getDesiredStateGraph().pipe(Effect.mapError(readFailed));
+    if (graph.nodes.some((node) => node.type === subject.type && node.name === subject.name))
+        return;
+    const inventory = yield* observeInstallRoot({
+        layout: ws.layout,
+        graph,
+        locks: yield* LockfileReader,
+    }).pipe(Effect.mapError(readFailed));
+    const installed = inventory.leftovers.some((entry) => entry.type === subject.type &&
+        entry.name === subject.name &&
+        (subject.owner === undefined || entry.owner === subject.owner));
+    if (!installed)
+        return;
+    const identity = subject.owner === undefined
+        ? subject.name
+        : `${subject.owner}/${toExtensionTypePlural(subject.type)}/${subject.name}`;
+    return yield* new ExtensionLifecycleFailed({
+        category: "conflict",
+        title: "Extension is not configured",
+        detail: `${subject.type} ${identity} is installed but not configured; axm sync removes installed packages that are not configured.`,
+        cmd: "axm sync",
+    });
+});
+//# sourceMappingURL=undesired-target.js.map

package/dist/src/uninstall/uninstall-extensions.d.ts

@@ -13,7 +13,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import type { InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
 import { type ExecutionCandidate, type OperationResolution, type PlanExecution } from "@agentxm/workspace-operations";
-import type { ExtensionLifecycleFailed } from "../errors.js";
+import { ExtensionLifecycleFailed } from "../errors.js";
 import { type PackUninstallRequirements } from "../packs/uninstall/plan.js";
 import type { InstallExecutionFailure, PrepareInstallRequirements } from "../install/vocabulary.js";
 /** One uninstall request, whatever command spelling produced it. */

package/dist/src/uninstall/uninstall-extensions.js

@@ -11,7 +11,10 @@
  */
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import { proposeDesiredState, prepareUninstallArtifact, collectCleanupStep, buildReconciliationClosure, } from "@agentxm/workspace-reconciliation";
+import { lifecycleStepFailure } from "../step-failure.js";
 import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { ExtensionLifecycleFailed } from "../errors.js";
 import { parseHookUninstallRequest, planHookUninstall } from "../hooks/uninstall/plan.js";
 import { parseKnowledgeUninstallRequest, planKnowledgeUninstall, } from "../knowledge/uninstall/plan.js";
 import { parseMcpServerUninstallRequest, planMcpServerUninstall } from "../mcps/uninstall/plan.js";
@@ -20,6 +23,7 @@ import { parseRuleUninstallRequest, planRuleUninstall } from "../rules/uninstall
 import { parseSkillUninstallRequest, planSkillUninstall } from "../skills/uninstall/plan.js";
 import { parseSubagentUninstallRequest, planSubagentUninstall, } from "../subagents/uninstall/plan.js";
 import { resolveRootUninstallIntent } from "./root-intent.js";
+import { refuseUndesiredInstalledTarget, typedUninstallSubject } from "./undesired-target.js";
 const planForType = (type, selector) => {
     switch (type) {
         case "skill":
@@ -87,23 +91,119 @@ const planForType = (type, selector) => {
 /** Settle a removal without writing anything. */
 export const prepareUninstallExtensions = Effect.fn("UninstallExtensions.prepare")(function* (request) {
     const resolved = yield* Option.match(request.type, {
-        onSome: (type) => Effect.succeed({ type, selector: request.selector }),
-        onNone: () => resolveRootUninstallIntent(request.selector).pipe(Effect.map((intent) => ({ type: intent.type, selector: intent.name }))),
+        onSome: (type) => Effect.succeed({
+            type,
+            selector: request.selector,
+            subject: typedUninstallSubject(type, request.selector),
+        }),
+        onNone: () => resolveRootUninstallIntent(request.selector).pipe(Effect.map((intent) => ({
+            type: intent.type,
+            selector: intent.name,
+            subject: { type: intent.type, name: intent.name, owner: intent.owner },
+        }))),
     });
+    // An installed package no desired route reaches is sync's to reconcile, not
+    // intent this removal can withdraw.
+    if (resolved.type !== "pack" && resolved.subject !== undefined)
+        yield* refuseUndesiredInstalledTarget(resolved.subject);
     const planned = yield* planForType(resolved.type, resolved.selector);
+    const proposal = yield* proposeDesiredState(planned.names.map((name) => ({ kind: "remove", type: resolved.type, name }))).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
+        category: "conflict",
+        detail: "Cannot derive desired state after uninstall",
+        cause,
+    })));
     // The plan's own name stands whichever spelling produced it: the removal a
     // person asked for is type-specific, and the plan name is what they read.
     // Only the presented subject varies — the root form routes across every
     // type, so it presents the default subject rather than the one this
     // request happened to settle on.
+    const leafType = resolved.type === "pack" ? undefined : resolved.type;
+    const artifacts = leafType === undefined
+        ? []
+        : yield* Effect.forEach(planned.names, (name) => prepareUninstallArtifact({ type: leafType, name }, proposal)).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: "Cannot establish uninstall effects",
+            cause,
+        })));
+    const artifactByName = new Map(planned.names.flatMap((name, index) => artifacts[index] === undefined ? [] : [[name, artifacts[index]]]));
+    const cleanupAdapter = {
+        toStepFailure: (cause) => lifecycleStepFailure(new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: "detail" in cause ? cause.detail : cause._tag,
+            cause,
+        })),
+    };
+    const activeNames = (type) => new Set(proposal.after.nodes
+        .filter((node) => node.type === type && node.enabled)
+        .map((node) => node.name));
+    const jobs = yield* Effect.forEach(planned.plan.jobs, (job) => Effect.gen(function* () {
+        const steps = yield* Effect.forEach(job.steps, (step) => Effect.gen(function* () {
+            const artifact = artifactByName.get(step.label ?? "");
+            if (artifact === undefined || step.readiness === "error" || leafType === undefined)
+                return step;
+            if ((artifact.targets?.length ?? 0) === 0 && (artifact.references?.length ?? 0) === 0) {
+                // Nothing exists to withdraw: the planner's descriptive artifact
+                // would name paths that are neither present nor changed, so the
+                // step declares none, and a result that changed nothing reports
+                // the empty evidence instead.
+                const { artifact: _descriptive, ...withoutArtifact } = step;
+                return {
+                    ...withoutArtifact,
+                    run: step.run.pipe(Effect.map((result) => result.result === "success" &&
+                        (result.disposition === "unchanged" || result.artifact?.change === "unchanged")
+                        ? { ...result, artifact }
+                        : result)),
+                };
+            }
+            const cleanup = yield* collectCleanupStep({
+                expectedSkillNames: activeNames("skill"),
+                expectedSubagentNames: activeNames("subagent"),
+                expectedMcpServerNames: activeNames("mcp-server"),
+                expectedHookNames: activeNames("hook"),
+                subjects: [{ type: leafType, name: step.label }],
+                adapter: cleanupAdapter,
+            }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
+                category: "conflict",
+                detail: "Cannot establish owned uninstall outputs",
+                cause,
+            })));
+            const removal = {
+                ...step,
+                artifact,
+                run: step.run.pipe(Effect.map((result) => result.result === "success" ? { ...result, artifact } : result)),
+            };
+            if (Option.isNone(cleanup))
+                return removal;
+            return yield* buildReconciliationClosure({
+                label: step.label,
+                message: `Uninstalled ${step.label}`,
+                artifact,
+                children: [
+                    { step: cleanup.value, coverage: "ineligible" },
+                    { step: removal, coverage: "eligible" },
+                ],
+                toStepFailure: (failure) => failure._tag === "StepFailure" ? failure : cleanupAdapter.toStepFailure(failure),
+                validate: Effect.void,
+            });
+        }));
+        return { ...job, steps };
+    }));
     const plan = {
         ...planned.plan,
+        jobs,
         presentation: operationPresentation({ imperative: "uninstall", past: "Uninstalled", gerund: "Uninstalling" }, Option.getOrUndefined(request.type)),
     };
     // Every removal withdraws the extension's per-agent projection, so the
     // candidate carries the configured-agent operation the resolution projects
     // before the removal and verifies after it.
-    const configuredAgentOperations = planned.names.map((name) => ({ extensionType: resolved.type, name, plannedState: "absent" }));
+    const configuredAgentOperations = planned.names.map((name) => {
+        const retained = proposal.after.nodes.find((node) => node.type === resolved.type && node.name === name);
+        return {
+            extensionType: resolved.type,
+            name,
+            plannedState: retained === undefined ? "absent" : retained.enabled ? "enabled" : "disabled",
+        };
+    });
     const execution = yield* prepareExecutionCandidate(plan, { configuredAgentOperations });
     return {
         type: resolved.type,

package/dist/src/update/root-request.d.ts

@@ -18,8 +18,8 @@ import { ExtensionLifecycleFailed } from "../errors.js";
 import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
 import { type ExtensionName, type Handle } from "@agentxm/extension-model/unstable/extensions";
 import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
-export declare const rootUpdatableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[];
-export declare const RootUpdatableTypeSegmentSchema: Schema.Literals<readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[]>;
+export declare const rootUpdatableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "skills" | "subagents" | "packs" | "mcps")[];
+export declare const RootUpdatableTypeSegmentSchema: Schema.Literals<readonly ("knowledge" | "rules" | "hooks" | "skills" | "subagents" | "packs" | "mcps")[]>;
 export type RootUpdatableTypeSegment = typeof RootUpdatableTypeSegmentSchema.Type;
 export type RootUpdatableType = InstallableExtensionType;
 /** One Registry identity a root update names, with the range it requested. */

package/dist/src/update/selective/plan.d.ts

@@ -10,9 +10,8 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-import * as Effect from "effect/Effect";
 import type * as Option from "effect/Option";
-import type { JobStepResult, Plan, StepFailure } from "@agentxm/workspace-operations";
+import type { Plan, PlannedJobStep } from "@agentxm/workspace-operations";
 import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
 import type { SubagentExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/subagent";
 import type { SkillLockEntry, SubagentLockEntry } from "@agentxm/workspace-state";
@@ -40,6 +39,6 @@ export interface SelectiveUpdateUnit<TOperation> {
  * steps are the selected entries, each either unchanged or dispatched to the
  * install operation that advances it.
  */
-export declare const buildSelectiveUpdatePlan: <TOperation, R>(units: ReadonlyArray<SelectiveUpdateUnit<TOperation>>, acceptedResolutions: Readonly<Record<string, AcceptedEntry | undefined>>, name: string, description: Option.Option<string>, makeRunClosure: (operation: TOperation) => Effect.Effect<JobStepResult, StepFailure, R>) => Plan<R>;
+export declare const buildSelectiveUpdatePlan: <TOperation, R>(units: ReadonlyArray<SelectiveUpdateUnit<TOperation>>, acceptedResolutions: Readonly<Record<string, AcceptedEntry | undefined>>, name: string, description: Option.Option<string>, makeStep: (operation: TOperation) => PlannedJobStep<R>) => Plan<R>;
 export {};
 //# sourceMappingURL=plan.d.ts.map

package/dist/src/update/selective/plan.js

@@ -41,7 +41,7 @@ const unchangedStep = (label) => ({
  * steps are the selected entries, each either unchanged or dispatched to the
  * install operation that advances it.
  */
-export const buildSelectiveUpdatePlan = (units, acceptedResolutions, name, description, makeRunClosure) => ({
+export const buildSelectiveUpdatePlan = (units, acceptedResolutions, name, description, makeStep) => ({
     _tag: "Plan",
     name,
     description,
@@ -52,7 +52,7 @@ export const buildSelectiveUpdatePlan = (units, acceptedResolutions, name, descr
                 const accepted = acceptedResolutions[unit.name];
                 const needsUpdate = accepted === undefined || unit.force || hasChanged(unit.ref, accepted);
                 return needsUpdate
-                    ? { readiness: "ready", label: unit.name, run: makeRunClosure(unit.operation) }
+                    ? { ...makeStep(unit.operation), label: unit.name }
                     : unchangedStep(unit.name);
             }),
         },

package/dist/src/update/selective/requirements.d.ts

@@ -2,16 +2,12 @@
  * What a selective update's plan steps declare at execution time.
  *
  * A selective advance runs the same install operation the install routes run,
- * so its steps carry the install step requirements plus the two services that
- * operation reaches for directly: the source providers it re-fetches through,
- * and the boundary's failure conversion. Those requirements travel with the
+ * so its steps carry the install step requirements. Those requirements travel with the
  * step and are composed once at the application's runtime boundary — nothing
  * is captured into a step's closure on the way.
  *
  * @experimental This API is unstable and may change without notice.
  */
-import type { SourceHostProviders } from "@agentxm/extension-sources";
 import type { InstallStepRequirements } from "../../install/vocabulary.js";
-import type { StepFailureConversion } from "../../step-failure-conversion.js";
-export type SelectiveUpdateStepRequirements = InstallStepRequirements | SourceHostProviders | StepFailureConversion;
+export type SelectiveUpdateStepRequirements = InstallStepRequirements;
 //# sourceMappingURL=requirements.d.ts.map

package/dist/src/update/selective/requirements.js

@@ -2,9 +2,7 @@
  * What a selective update's plan steps declare at execution time.
  *
  * A selective advance runs the same install operation the install routes run,
- * so its steps carry the install step requirements plus the two services that
- * operation reaches for directly: the source providers it re-fetches through,
- * and the boundary's failure conversion. Those requirements travel with the
+ * so its steps carry the install step requirements. Those requirements travel with the
  * step and are composed once at the application's runtime boundary — nothing
  * is captured into a step's closure on the way.
  *

package/dist/src/update/selective/selection.js

@@ -14,7 +14,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { parseSourceQualifiedRegistrySourcePatternParts } from "@agentxm/extension-model/unstable/extensions";
 import { resolveInstalledIdentifierNameOrInput, resolveSource, SourceHostProviders, } from "@agentxm/extension-sources";
-import { expandGlobs } from "../../glob.js";
+import { expandGlobs } from "@agentxm/extension-model/unstable/extensions/name-patterns";
 /**
  * Whether a positional selector names the same origin an entry declares.
  * Two Registry patterns compare by their parsed parts; anything else

package/dist/src/update/selective/skills.d.ts

@@ -16,9 +16,7 @@
  */
 import * as Effect from "effect/Effect";
 import { SourceHostProviders } from "@agentxm/extension-sources";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "../../errors.js";
-import type { SelectiveUpdateStepRequirements } from "./requirements.js";
 import { type SelectiveUpdateSelectors } from "./selection.js";
 /** Everything `skills update` needs beyond the workspace it runs in. */
 export interface SelectiveSkillUpdateRequest extends SelectiveUpdateSelectors {
@@ -47,9 +45,9 @@ export declare const prepareSelectiveSkillUpdate: (request: SelectiveSkillUpdate
     outcome: "planned";
     subjectType: "skill";
     planName: string;
-    execution: import("@agentxm/workspace-operations").ExecutionCandidate<SelectiveUpdateStepRequirements, never>;
+    execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("../../index.ts").InstallStepRequirements, never>;
     reason?: never;
     message?: never;
     planDescription?: never;
-}, ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, import("effect/FileSystem").FileSystem | import("effect/Path").Path | WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog>;
+}, ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/extension-materialization").SkillManager | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog | import("../../index.ts").InstallStepRequirements>;
 //# sourceMappingURL=skills.d.ts.map

package/dist/src/update/selective/skills.js

@@ -27,7 +27,7 @@ import { operationPresentation, prepareExecutionCandidate, } from "@agentxm/work
 import { acceptedResolutionRef, configuredRowsByName, WorkspaceMutations, } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 import { withPublisherTrustConditions } from "../../publisher-binding.js";
-import { installSkill } from "../../skills/operations/install.js";
+import { planSkillInstallationStep } from "../../skills/install/plan.js";
 import { buildSelectiveUpdatePlan } from "./plan.js";
 import { selectUpdateTargets, } from "./selection.js";
 import { ignoreVersionConstraintsCondition, selectiveUpdatePlanName, } from "./vocabulary.js";
@@ -47,14 +47,6 @@ const allSkillResolutionsFailed = new ExtensionLifecycleFailed({
     recover: "Review the registries declared under `sources` in workspace settings",
     cmd: "axm help settings",
 });
-/**
- * The install operation reports more than the plan vocabulary carries. Only
- * the outcome and its sentence cross into the step result; a failed step
- * carries the typed failure the boundary renders.
- */
-const toJobStepResult = (result) => result.result === "error" && result.error !== undefined
-    ? { result: "error", message: result.message, error: result.error }
-    : { result: "success", message: result.message };
 const skippedSkillStep = (outcome) => ({
     readiness: "ready",
     label: `Skip ${outcome.name}`,
@@ -522,24 +514,27 @@ export const prepareSelectiveSkillUpdate = Effect.fn("SelectiveSkillUpdate.prepa
         if (warnings.length > 0)
             warningsBySkill.set(item.ref.skill.name, warnings);
     }
-    const units = resolved.map((item) => ({
-        name: item.ref.skill.name,
-        ref: item.ref,
-        force: request.ignoreVersionConstraints || item.ref.refType !== "registry",
-        operation: {
-            name: "install-skill",
-            args: {
-                ref: item.ref,
-                force: request.ignoreVersionConstraints || item.ref.refType !== "registry",
-                versionRange: item.versionRange,
-                skipSettings: Option.none(),
-                strictUnknownAgents: Option.none(),
-                sourceName: Option.none(),
-            },
-        },
-    }));
-    const makeRunClosure = (operation) => installSkill(operation).pipe(Effect.map(toJobStepResult), Effect.map(appendWarningsToResult(warningsBySkill.get(operation.args.ref.skill.name) ?? [])));
-    const rawPlan = buildSelectiveUpdatePlan(units, lockedSkills, PLAN_NAME, Option.some(PLAN_DESCRIPTION), makeRunClosure);
+    const units = yield* Effect.forEach(resolved, (item) => Effect.gen(function* () {
+        const force = request.ignoreVersionConstraints || item.ref.refType !== "registry";
+        const step = yield* planSkillInstallationStep({
+            ref: item.ref,
+            force,
+            operation: "update",
+        });
+        const operation = step.readiness === "error"
+            ? step
+            : {
+                ...step,
+                run: step.run.pipe(Effect.map(appendWarningsToResult(warningsBySkill.get(item.ref.skill.name) ?? []))),
+            };
+        return {
+            name: item.ref.skill.name,
+            ref: item.ref,
+            force,
+            operation,
+        };
+    }), { concurrency: 1 });
+    const rawPlan = buildSelectiveUpdatePlan(units, lockedSkills, PLAN_NAME, Option.some(PLAN_DESCRIPTION), (step) => step);
     const basePlanWithWarnings = {
         ...rawPlan,
         presentation: operationPresentation({ imperative: "update", past: "Updated", gerund: "Updating" }, "skill"),

package/dist/src/update/selective/subagents.d.ts

@@ -15,7 +15,6 @@ import { SourceHostProviders } from "@agentxm/extension-sources";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 import { StepFailureConversion } from "../../step-failure-conversion.js";
-import type { SelectiveUpdateStepRequirements } from "./requirements.js";
 import { type SelectiveUpdateSelectors } from "./selection.js";
 /** Everything `subagents update` needs beyond the workspace it runs in. */
 export interface SelectiveSubagentUpdateRequest extends SelectiveUpdateSelectors {
@@ -44,9 +43,9 @@ export declare const prepareSelectiveSubagentUpdate: (request: SelectiveSubagent
     outcome: "planned";
     subjectType: "subagent";
     planName: string;
-    execution: import("@agentxm/workspace-operations").ExecutionCandidate<SelectiveUpdateStepRequirements, never>;
+    execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("../../index.ts").InstallStepRequirements, never>;
     reason?: never;
     message?: never;
     planDescription?: never;
-}, ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, StepFailureConversion | import("effect/FileSystem").FileSystem | import("effect/Path").Path | WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | SourceHostProviders | SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog>;
+}, ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, StepFailureConversion | import("effect/FileSystem").FileSystem | import("effect/Path").Path | WorkspaceMutations | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | SourceHostProviders | SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog>;
 //# sourceMappingURL=subagents.d.ts.map