@agentxm/extension-lifecycle 0.30.1 → 0.30.2

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

@@ -15,9 +15,10 @@ import * as Path from "effect/Path";
 import { SkillManager, skillArtifactFromTargets, } from "@agentxm/extension-materialization";
 import { buildUninstallOperation } from "@agentxm/workspace-reconciliation";
 import { resolveInstalledIdentifierNameOrInput } from "@agentxm/extension-sources";
+import { parseExtensionFqnParts } from "@agentxm/extension-model/unstable/extensions";
 import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { WorkspaceMutations, acquiredExtensionDisplayPathFromLockEntry, installedRowsByName, sanitizeName, } 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 "@agentxm/workspace-reconciliation";
@@ -48,13 +49,19 @@ export const parseSkillUninstallRequest = Effect.fn("UninstallExtensions.parseSk
     if (selector.includes("*") && matched.length === 0) {
         return { targets: [] };
     }
+    // An identifier nothing installed answers to still names one skill: its
+    // extension name, never the fully qualified spelling as a name.
+    const unresolvedName = (input) => {
+        const fqn = parseExtensionFqnParts(input);
+        return fqn?.type === "skill" ? fqn.name : input;
+    };
     const names = matched.length > 0
         ? matched
         : [
             yield* resolveInstalledIdentifierNameOrInput({
                 input: selector,
                 resourceType: "skill",
-            }).pipe(Effect.mapError((cause) => installRefused({
+            }).pipe(Effect.map((name) => (name === selector.trim() ? unresolvedName(name) : name)), Effect.mapError((cause) => installRefused({
                 category: "not_found",
                 detail: `Skill "${selector}" could not be resolved`,
                 cause,

package/dist/src/step-failure.js

@@ -85,6 +85,18 @@ const carriedFailure = (failure) => {
 export const lifecycleStepFailure = (failure) => {
     if (failure instanceof StepFailure)
         return failure;
+    if (failure._tag === "McpSharedTargetConflict") {
+        return new StepFailure({
+            category: "conflict",
+            detail: failure.reason,
+            suggestions: [
+                {
+                    description: "Use an MCP package whose transport and symbolic inputs are supported by every configured reader of the shared target.",
+                },
+            ],
+            cause: failure,
+        });
+    }
     if (failure instanceof ExtensionLifecycleFailed) {
         return new StepFailure({
             category: failure.category,

package/dist/src/subagents/application/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Subagents selection application contract and workflow.
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Array from "effect/Array";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { SubagentExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/subagent";
+import { type SubagentSelectionRequest } from "../domain/selection.js";
+declare const SubagentSelectionNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SubagentSelectionNotFound";
+} & Readonly<A>;
+export declare class SubagentSelectionNotFound extends SubagentSelectionNotFound_base<{
+    readonly requested: ReadonlyArray<string>;
+    readonly available: ReadonlyArray<string>;
+}> {
+}
+declare const SubagentSelectionCancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SubagentSelectionCancelled";
+} & Readonly<A>;
+export declare class SubagentSelectionCancelled extends SubagentSelectionCancelled_base<{
+    readonly message: string;
+}> {
+}
+declare const SubagentSelectionUnavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SubagentSelectionUnavailable";
+} & Readonly<A>;
+/** The interface could not obtain a choice; this is distinct from cancellation. */
+export declare class SubagentSelectionUnavailable extends SubagentSelectionUnavailable_base<{
+    readonly cause?: unknown;
+}> {
+}
+declare const SubagentSelectionInteraction_base: Context.ServiceClass<SubagentSelectionInteraction, "@agentxm/extension-lifecycle/subagents/SubagentSelectionInteraction", {
+    readonly select: (candidates: Array.NonEmptyReadonlyArray<SubagentExtensionRef>) => Effect.Effect<ReadonlyArray<SubagentExtensionRef>, SubagentSelectionCancelled | SubagentSelectionUnavailable>;
+}>;
+export declare class SubagentSelectionInteraction extends SubagentSelectionInteraction_base {
+}
+export type SubagentSelectionFailure = SubagentSelectionNotFound | SubagentSelectionCancelled | SubagentSelectionUnavailable;
+/** Resolve the subagent-owned decision through this capability's interaction port. */
+export declare const determineSubagentsToInstall: (candidates: readonly [SubagentExtensionRef, ...SubagentExtensionRef[]], request: SubagentSelectionRequest) => Effect.Effect<readonly SubagentExtensionRef[], SubagentSelectionFailure, SubagentSelectionInteraction>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/subagents/application/index.js

@@ -0,0 +1,37 @@
+/**
+ * Subagents selection application contract and workflow.
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Array from "effect/Array";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { decideSubagentSelection } from "../domain/selection.js";
+export class SubagentSelectionNotFound extends Data.TaggedError("SubagentSelectionNotFound") {
+}
+export class SubagentSelectionCancelled extends Data.TaggedError("SubagentSelectionCancelled") {
+}
+/** The interface could not obtain a choice; this is distinct from cancellation. */
+export class SubagentSelectionUnavailable extends Data.TaggedError("SubagentSelectionUnavailable") {
+}
+export class SubagentSelectionInteraction extends Context.Service()("@agentxm/extension-lifecycle/subagents/SubagentSelectionInteraction") {
+}
+/** Resolve the subagent-owned decision through this capability's interaction port. */
+export const determineSubagentsToInstall = Effect.fn("Subagents.determineSelection")(function* (candidates, request) {
+    const names = Array.map(candidates, (ref) => ref.subagent.name);
+    const decision = decideSubagentSelection(names, request);
+    switch (decision.kind) {
+        case "selected":
+            return candidates.filter((ref) => decision.names.includes(ref.subagent.name));
+        case "unmatched":
+            return yield* new SubagentSelectionNotFound({
+                requested: request.requestedSubagents,
+                available: names,
+            });
+        case "choice-required": {
+            const interaction = yield* SubagentSelectionInteraction;
+            return yield* interaction.select(candidates);
+        }
+    }
+});
+//# sourceMappingURL=index.js.map

package/dist/src/subagents/domain/selection.d.ts

@@ -0,0 +1,22 @@
+import type * as Array from "effect/Array";
+export interface SubagentSelectionRequest {
+    readonly requestedSubagents: ReadonlyArray<string>;
+    readonly all: boolean;
+    readonly nonInteractive: boolean;
+}
+export type SubagentSelectionDecision = {
+    readonly kind: "selected";
+    readonly names: ReadonlyArray<string>;
+} | {
+    readonly kind: "choice-required";
+} | {
+    readonly kind: "unmatched";
+};
+/**
+ * Select this request's subagents, preserving source order.
+ * Named patterns take precedence over all/unattended selection. The existing
+ * union-of-matches behavior is retained; unresolved selector requirements remain
+ * explicit in the installation specification.
+ */
+export declare const decideSubagentSelection: (names: Array.NonEmptyReadonlyArray<string>, request: SubagentSelectionRequest) => SubagentSelectionDecision;
+//# sourceMappingURL=selection.d.ts.map

package/dist/src/subagents/domain/selection.js

@@ -0,0 +1,18 @@
+import { expandGlobs } from "@agentxm/extension-model/unstable/extensions/name-patterns";
+/**
+ * Select this request's subagents, preserving source order.
+ * Named patterns take precedence over all/unattended selection. The existing
+ * union-of-matches behavior is retained; unresolved selector requirements remain
+ * explicit in the installation specification.
+ */
+export const decideSubagentSelection = (names, request) => {
+    if (request.requestedSubagents.length > 0) {
+        const matched = expandGlobs(request.requestedSubagents, names);
+        return matched.length === 0 ? { kind: "unmatched" } : { kind: "selected", names: matched };
+    }
+    if (request.all || request.nonInteractive || names.length === 1) {
+        return { kind: "selected", names };
+    }
+    return { kind: "choice-required" };
+};
+//# sourceMappingURL=selection.js.map

package/dist/src/subagents/install/plan.d.ts

@@ -18,8 +18,8 @@ import { type SourceResolutionFailure } from "@agentxm/extension-sources";
 import { type Plan } from "@agentxm/workspace-operations";
 import type { ExtensionLifecycleFailed } from "../../errors.js";
 import { type RegistryLookupProbe } from "../../install/registry-source-resolution.js";
-import { ExtensionSelectionInteraction, type ExtensionSelectionCancelled } from "../../install/selection-interaction.js";
 import { type InstallStepRequirements, type ResolveInstallRequirements, type SubagentInstallIntent } from "../../install/vocabulary.js";
+import { SubagentSelectionInteraction, type SubagentSelectionFailure } from "../application/index.js";
 /** A subagent source after grammar parsing, before anything is discovered. */
 export interface ParsedSubagentInstallRequest {
     readonly source: Source;
@@ -43,7 +43,7 @@ export declare const parseSubagentInstallRequest: (args: SubagentInstallArgs) =>
 /** Discover the subagents the parsed source offers, or refuse when it has none. */
 export declare const discoverSubagentRefs: (request: ParsedSubagentInstallRequest) => Effect.Effect<ReadonlyArray<SubagentExtensionRef>, ExtensionLifecycleFailed, ResolveInstallRequirements>;
 /** Settle which of the discovered subagents this request installs. */
-export declare const finalizeSubagentInstallIntent: (request: ParsedSubagentInstallRequest, discovered: ReadonlyArray<SubagentExtensionRef>) => Effect.Effect<SubagentInstallIntent, ExtensionLifecycleFailed | ExtensionSelectionCancelled, ExtensionSelectionInteraction>;
+export declare const finalizeSubagentInstallIntent: (request: ParsedSubagentInstallRequest, discovered: ReadonlyArray<SubagentExtensionRef>) => Effect.Effect<SubagentInstallIntent, ExtensionLifecycleFailed | SubagentSelectionFailure, SubagentSelectionInteraction>;
 /** The closures a settled subagent intent becomes. */
 export declare const planSubagentInstall: (intent: SubagentInstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | SubagentManager>;
 //# sourceMappingURL=plan.d.ts.map

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

@@ -19,9 +19,8 @@ import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { sourceFailureDetail, } from "../../install/registry-source-resolution.js";
-import { ExtensionSelectionInteraction, } from "../../install/selection-interaction.js";
 import { installRefused, } from "../../install/vocabulary.js";
-import { determineSubagentsToInstall } from "./selection.js";
+import { determineSubagentsToInstall, SubagentSelectionInteraction, } from "../application/index.js";
 import { resolveSubagentInstallSource } from "./source.js";
 const isRemoteReadNotImplemented = (error) => sourceFailureDetail(error).includes("not implemented");
 const discoverHowToFix = (source, error) => {

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

@@ -13,7 +13,7 @@ import { NO_MATERIALIZATION_OBSERVATION, SubagentManager, } from "@agentxm/exten
 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 "@agentxm/workspace-reconciliation";

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 | 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 | ExtensionSelectionInteraction | BundledAxmSkillAsset | AgentExecutableResolver | import("@agentxm/workspace-state/live").WorkspaceStateServices | import("@agentxm/workspace-projection").ProjectionParticipants>>;
+    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

@@ -31,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";
 /**
@@ -156,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

@@ -5,6 +5,7 @@ export declare const rootUninstallableTypeSegments: readonly ("knowledge" | "rul
 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.js

@@ -23,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":
@@ -90,9 +91,21 @@ 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",
@@ -126,11 +139,22 @@ export const prepareUninstallExtensions = Effect.fn("UninstallExtensions.prepare
     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 ||
-                ((artifact.targets?.length ?? 0) === 0 && (artifact.references?.length ?? 0) === 0))
+            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"),

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("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | 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