@agentxm/extension-lifecycle 0.30.1 → 0.30.2

package/dist/src/index.d.ts

@@ -15,7 +15,6 @@ export type { SetActivationExecutionFailure } from "./activation/errors.js";
 export { PUBLISHER_CHANGE_CONDITION_ID, publisherChangeRiskCondition, withPublisherTrust, withPublisherTrustConditions, } from "./publisher-binding.js";
 export { InstallExtensions, prepareInstallExtensions, previewOrApplyInstallExtensions, type InstallDiagnostics, type InstallExtensionsCandidate, type InstallExtensionsFailure, type InstallExtensionsRequest, type InstallSubject, } from "./install/install-extensions.js";
 export { installRefused, type HookInstallIntent, type InstallStepRequirements, type KnowledgeInstallIntent, type McpServerInstallIntent, type PackInstallIntent, type PackRecoveryDependencyResolver, type PrepareInstallRequirements, type ResolveInstallRequirements, type RuleInstallIntent, type SkillInstallIntent, type SubagentInstallIntent, } from "./install/vocabulary.js";
-export { ExtensionSelectionCancelled, ExtensionSelectionInteraction, type ExtensionSelectionFailure, type ExtensionSelectionInteractionService, } from "./install/selection-interaction.js";
 export { resolveRootInstallIntent, rootInstallableTypeSegments, RootInstallableTypeSegmentSchema, type RootInstallIntent, type RootInstallableType, type RootInstallableTypeSegment, } from "./install/root-intent.js";
 export { installCommandFor, perTypeInstallPluralSegments } from "./install/per-type-install.js";
 export { buildConfiguredInstallPlan, buildConfiguredPackInstallPlan, type ConfiguredInstallPlanResult, type ConfiguredInstallRequirements, type ConfiguredInstallableType, } from "./install/configured.js";
@@ -38,8 +37,6 @@ export { resolveRootUninstallIntent, rootUninstallableTypeSegments, type RootUni
 export { PACK_UNINSTALL_GRAPH_BLOCKER_ID, packUninstallRecoveryIdentifiers, planPackUninstallGraphReadiness, type PackRetirement, type PackUninstallGraphReadiness, } from "./packs/uninstall/readiness.js";
 export { type PackUninstallIntent, type PackUninstallRequirements, type ResolvedPackUninstallTarget, } from "./packs/uninstall/plan.js";
 export { getSkillDisplayName } from "./skills/utils.js";
-export { gitHostedSkillArtifactSource, installSkill, type InstallSkillOperation, type InstallSkillOperationArgs, } from "./skills/operations/install.js";
-export type { InstallResult } from "./skills/operations/install-result.js";
 export { enableSkill, type EnableSkillOperation } from "./skills/operations/enable.js";
 export { disableSkill, type DisableSkillOperation } from "./skills/operations/disable.js";
 export { uninstallMcpServer, type UninstallMcpServerOperation, type UninstallMcpServerOperationArgs, } from "./mcps/operations/uninstall.js";

package/dist/src/index.js

@@ -17,7 +17,6 @@ export { PUBLISHER_CHANGE_CONDITION_ID, publisherChangeRiskCondition, withPublis
 // already declares, as one use case behind every command spelling.
 export { InstallExtensions, prepareInstallExtensions, previewOrApplyInstallExtensions, } from "./install/install-extensions.js";
 export { installRefused, } from "./install/vocabulary.js";
-export { ExtensionSelectionCancelled, ExtensionSelectionInteraction, } from "./install/selection-interaction.js";
 export { resolveRootInstallIntent, rootInstallableTypeSegments, RootInstallableTypeSegmentSchema, } from "./install/root-intent.js";
 export { installCommandFor, perTypeInstallPluralSegments } from "./install/per-type-install.js";
 export { buildConfiguredInstallPlan, buildConfiguredPackInstallPlan, } from "./install/configured.js";
@@ -45,7 +44,6 @@ export { PACK_UNINSTALL_GRAPH_BLOCKER_ID, packUninstallRecoveryIdentifiers, plan
 export {} from "./packs/uninstall/plan.js";
 // Skill lifecycle operations
 export { getSkillDisplayName } from "./skills/utils.js";
-export { gitHostedSkillArtifactSource, installSkill, } from "./skills/operations/install.js";
 export { enableSkill } from "./skills/operations/enable.js";
 export { disableSkill } from "./skills/operations/disable.js";
 // MCP server lifecycle operations. Installation itself is a materialization

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

@@ -23,8 +23,8 @@ import type { ExtensionResolutionFailed } from "@agentxm/extension-resolution";
 import type { ExtensionLifecycleFailed } from "../errors.js";
 import { BundledAxmSkillAsset } from "../skills/install/bundled.js";
 import { type ConfiguredInstallRequirements } from "./configured.js";
-import type { ExtensionSelectionCancelled } from "./selection-interaction.js";
-import { ExtensionSelectionInteraction } from "./selection-interaction.js";
+import { SkillSelectionInteraction, type SkillSelectionFailure } from "../skills/application/index.js";
+import { SubagentSelectionInteraction, type SubagentSelectionFailure } from "../subagents/application/index.js";
 import { type InstallExecutionFailure, type InstallStepRequirements, type PrepareInstallRequirements } from "./vocabulary.js";
 /**
  * What the request installs: the extensions the workspace already declares,
@@ -91,9 +91,9 @@ export interface InstallExtensionsCandidate {
  * A configured entry's resolution refusal travels with its own category and
  * sentence rather than as this feature's generic refusal.
  */
-export type InstallExtensionsFailure = ExtensionLifecycleFailed | ExtensionResolutionFailed | ExtensionSelectionCancelled | InstallExecutionFailure;
+export type InstallExtensionsFailure = ExtensionLifecycleFailed | ExtensionResolutionFailed | SkillSelectionFailure | SubagentSelectionFailure | InstallExecutionFailure;
 /** Settle an install without writing anything. */
-export declare const prepareInstallExtensions: (request: InstallExtensionsRequest) => Effect.Effect<InstallExtensionsCandidate, InstallExtensionsFailure, PrepareInstallRequirements | ConfiguredInstallRequirements | ExtensionSelectionInteraction | BundledAxmSkillAsset>;
+export declare const prepareInstallExtensions: (request: InstallExtensionsRequest) => Effect.Effect<InstallExtensionsCandidate, InstallExtensionsFailure, PrepareInstallRequirements | ConfiguredInstallRequirements | SkillSelectionInteraction | SubagentSelectionInteraction | BundledAxmSkillAsset>;
 /**
  * Everything resolving a settled install writes through: the candidate's own
  * step requirements plus the operation boundary that presents, journals, and
@@ -104,7 +104,7 @@ export type ResolveInstallExtensionsRequirements = PrepareInstallRequirements |
 export declare const previewOrApplyInstallExtensions: (candidate: InstallExtensionsCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution, InstallExtensionsFailure, ResolveInstallExtensionsRequirements>;
 /** The install use case: settle a request, then preview or apply it. */
 export declare const InstallExtensions: {
-    readonly prepare: (request: InstallExtensionsRequest) => Effect.Effect<InstallExtensionsCandidate, InstallExtensionsFailure, PrepareInstallRequirements | ConfiguredInstallRequirements | ExtensionSelectionInteraction | BundledAxmSkillAsset>;
+    readonly prepare: (request: InstallExtensionsRequest) => Effect.Effect<InstallExtensionsCandidate, InstallExtensionsFailure, PrepareInstallRequirements | ConfiguredInstallRequirements | SkillSelectionInteraction | SubagentSelectionInteraction | BundledAxmSkillAsset>;
     readonly previewOrApply: (candidate: InstallExtensionsCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution, InstallExtensionsFailure, ResolveInstallExtensionsRequirements>;
 };
 //# sourceMappingURL=install-extensions.d.ts.map

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

@@ -31,7 +31,8 @@ import { BundledAxmSkillAsset, planBundledAxmSkillInstall } from "../skills/inst
 import { buildConfiguredInstallPlan } from "./configured.js";
 import { formatRegistryProbe } from "./registry-source-resolution.js";
 import { resolveRootInstallIntent } from "./root-intent.js";
-import { ExtensionSelectionInteraction } from "./selection-interaction.js";
+import { SkillSelectionInteraction, } from "../skills/application/index.js";
+import { SubagentSelectionInteraction, } from "../subagents/application/index.js";
 import { installRefused, } from "./vocabulary.js";
 const EMPTY_DIAGNOSTICS = { resolutionLines: [], companionPackages: [] };
 const emptyPlan = (request) => ({

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

@@ -14,7 +14,7 @@ import { type ExtensionName, type Handle } from "@agentxm/extension-model/unstab
 import type { McpServerExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/mcp-server";
 import type { RegistrySource } from "@agentxm/extension-model/unstable/sources/types";
 import { type Plan } from "@agentxm/workspace-operations";
-import type { ExtensionLifecycleFailed } from "../../errors.js";
+import { ExtensionLifecycleFailed } from "../../errors.js";
 import { type InstallStepRequirements, type McpServerInstallIntent, type ResolveInstallRequirements } from "../../install/vocabulary.js";
 /** An MCP install request after grammar parsing, before anything is discovered. */
 export interface ParsedMcpServerInstallRequest {

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

@@ -9,16 +9,21 @@
  * @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 * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { installMcpServer } from "@agentxm/workspace-reconciliation";
+import { installMcpServer, readMcpServerManifest } from "@agentxm/workspace-reconciliation";
+import { materializeRegistryPackage } from "@agentxm/extension-materialization";
+import { validateManifestMcpServerTargets } from "@agentxm/agent-integration";
 import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
 import { ExtensionNameSchema, } from "@agentxm/extension-model/unstable/extensions";
 import { intersectVersionConstraints } from "@agentxm/extension-model/unstable/version-constraints";
 import { SourceHostProviders, resolveSource } from "@agentxm/extension-sources";
 import { operationPresentation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations, mcpRegistryResolutionKey } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../../errors.js";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { registryLoginSuggestions } from "../../install/registry-login-suggestion.js";
 import { parseRegistryInstallTarget } from "../../install/registry-install-target.js";
@@ -267,6 +272,58 @@ export const planMcpServerInstall = Effect.fn("InstallExtensions.planMcpServer")
             });
         }
     }
+    yield* Effect.scoped(Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const ref = intent.ref;
+        // Inspect verified package bytes outside the workspace. A fresh install
+        // has no canonical manifest for the usual projection inspection to read.
+        const manifestPath = ref.refType === "registry"
+            ? yield* Effect.gen(function* () {
+                const scratch = yield* fs.makeTempDirectoryScoped({ prefix: "axm-mcp-preflight-" });
+                return yield* materializeRegistryPackage({
+                    baseDir: scratch,
+                    destinationPath: path.join(scratch, "package"),
+                    sourceLocation: ref.source.location,
+                    owner: ref.owner,
+                    type: "mcp-server",
+                    name: ref.name,
+                    version: ref.version,
+                    integrity: ref.integrity,
+                    messages: {
+                        integrityMismatchDetail: `Integrity mismatch for ${ref.name}@${ref.version}`,
+                    },
+                });
+            })
+            : ref.location;
+        const manifest = yield* readMcpServerManifest(manifestPath);
+        if (Option.isNone(manifest)) {
+            return yield* installRefused({
+                category: "validation",
+                detail: `Cannot read MCP manifest for ${intent.localName}`,
+            });
+        }
+        const entries = yield* ws.getConfiguredMcpServerEntries();
+        yield* validateManifestMcpServerTargets({
+            manifest: manifest.value,
+            agentIds: yield* ws.getConfiguredAgents(),
+            scope: ws.scope,
+            serverName: intent.localName,
+            values: { ...entries[intent.localName]?.env, ...intent.env },
+            enabled: entries[intent.localName]?.enabled ?? true,
+        }).pipe(Effect.mapError((cause) => installRefused({
+            category: "conflict",
+            detail: cause.reason,
+            recover: "Use an MCP package whose transport and symbolic inputs are supported by every configured reader of the shared target.",
+            cause,
+        })));
+    })).pipe(Effect.mapError((cause) => cause instanceof ExtensionLifecycleFailed
+        ? cause
+        : installRefused({
+            category: "validation",
+            detail: `Cannot inspect MCP package ${intent.localName}`,
+            cause,
+        })));
     return {
         _tag: "Plan",
         name: "Install MCP server",

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

@@ -19,7 +19,7 @@ import { buildUninstallOperation, prepareUninstallArtifact, collectCleanupStep,
 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 { expandGlob } from "@agentxm/extension-model/unstable/extensions/name-patterns";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { buildAggregateProjectionStep } from "../../install/aggregate-projection-step.js";
 import { installRefused } from "../../install/vocabulary.js";

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

@@ -0,0 +1,42 @@
+/**
+ * Skills 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 { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
+import { type SkillSelectionRequest } from "../domain/selection.js";
+declare const SkillSelectionNotFound_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: "SkillSelectionNotFound";
+} & Readonly<A>;
+export declare class SkillSelectionNotFound extends SkillSelectionNotFound_base<{
+    readonly requested: ReadonlyArray<string>;
+    readonly available: ReadonlyArray<string>;
+}> {
+}
+declare const SkillSelectionCancelled_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: "SkillSelectionCancelled";
+} & Readonly<A>;
+export declare class SkillSelectionCancelled extends SkillSelectionCancelled_base<{
+    readonly message: string;
+}> {
+}
+declare const SkillSelectionUnavailable_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: "SkillSelectionUnavailable";
+} & Readonly<A>;
+/** The interface could not obtain a choice; this is distinct from cancellation. */
+export declare class SkillSelectionUnavailable extends SkillSelectionUnavailable_base<{
+    readonly cause?: unknown;
+}> {
+}
+declare const SkillSelectionInteraction_base: Context.ServiceClass<SkillSelectionInteraction, "@agentxm/extension-lifecycle/skills/SkillSelectionInteraction", {
+    readonly select: (candidates: Array.NonEmptyReadonlyArray<SkillExtensionRef>) => Effect.Effect<ReadonlyArray<SkillExtensionRef>, SkillSelectionCancelled | SkillSelectionUnavailable>;
+}>;
+export declare class SkillSelectionInteraction extends SkillSelectionInteraction_base {
+}
+export type SkillSelectionFailure = SkillSelectionNotFound | SkillSelectionCancelled | SkillSelectionUnavailable;
+/** Resolve the skill-owned decision through this capability's interaction port. */
+export declare const determineSkillsToInstall: (candidates: readonly [SkillExtensionRef, ...SkillExtensionRef[]], request: SkillSelectionRequest) => Effect.Effect<readonly SkillExtensionRef[], SkillSelectionFailure, SkillSelectionInteraction>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * Skills 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 { decideSkillSelection } from "../domain/selection.js";
+export class SkillSelectionNotFound extends Data.TaggedError("SkillSelectionNotFound") {
+}
+export class SkillSelectionCancelled extends Data.TaggedError("SkillSelectionCancelled") {
+}
+/** The interface could not obtain a choice; this is distinct from cancellation. */
+export class SkillSelectionUnavailable extends Data.TaggedError("SkillSelectionUnavailable") {
+}
+export class SkillSelectionInteraction extends Context.Service()("@agentxm/extension-lifecycle/skills/SkillSelectionInteraction") {
+}
+/** Resolve the skill-owned decision through this capability's interaction port. */
+export const determineSkillsToInstall = Effect.fn("Skills.determineSelection")(function* (candidates, request) {
+    const names = Array.map(candidates, (ref) => ref.skill.name);
+    const decision = decideSkillSelection(names, request);
+    switch (decision.kind) {
+        case "selected":
+            return candidates.filter((ref) => decision.names.includes(ref.skill.name));
+        case "unmatched":
+            return yield* new SkillSelectionNotFound({
+                requested: request.requestedSkills,
+                available: names,
+            });
+        case "choice-required": {
+            const interaction = yield* SkillSelectionInteraction;
+            return yield* interaction.select(candidates);
+        }
+    }
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,22 @@
+import type * as Array from "effect/Array";
+export interface SkillSelectionRequest {
+    readonly requestedSkills: ReadonlyArray<string>;
+    readonly all: boolean;
+    readonly nonInteractive: boolean;
+}
+export type SkillSelectionDecision = {
+    readonly kind: "selected";
+    readonly names: ReadonlyArray<string>;
+} | {
+    readonly kind: "choice-required";
+} | {
+    readonly kind: "unmatched";
+};
+/**
+ * Select this request's skills, 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 decideSkillSelection: (names: Array.NonEmptyReadonlyArray<string>, request: SkillSelectionRequest) => SkillSelectionDecision;
+//# sourceMappingURL=selection.d.ts.map

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

@@ -0,0 +1,18 @@
+import { expandGlobs } from "@agentxm/extension-model/unstable/extensions/name-patterns";
+/**
+ * Select this request's skills, 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 decideSkillSelection = (names, request) => {
+    if (request.requestedSkills.length > 0) {
+        const matched = expandGlobs(request.requestedSkills, 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/skills/install/artifact.d.ts

@@ -0,0 +1,4 @@
+import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
+import type { JobStepArtifactSource } from "@agentxm/workspace-operations";
+export declare const gitHostedSkillArtifactSource: (ref: SkillExtensionRef) => JobStepArtifactSource | undefined;
+//# sourceMappingURL=artifact.d.ts.map

package/dist/src/skills/install/artifact.js

@@ -0,0 +1,29 @@
+import * as Option from "effect/Option";
+const gitHostedSourceOrigin = (ref) => {
+    const source = ref.source;
+    switch (source.type) {
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+            return `${source.url.origin}/${source.owner}/${source.repo}`;
+        case "azurerepos":
+            return `${source.url.origin}/${source.organization}/${source.project}/_git/${source.repo}`;
+        case "git":
+            return source.url.href;
+    }
+};
+export const gitHostedSkillArtifactSource = (ref) => {
+    if (ref.refType !== "git-hosted")
+        return undefined;
+    const gitTreeHash = ref.gitTreeSha;
+    const gitRef = Option.getOrUndefined(ref.source.ref);
+    const directory = ref.sourcePath === undefined || ref.sourcePath.length === 0 ? "." : ref.sourcePath;
+    return {
+        type: ref.source.type,
+        origin: gitHostedSourceOrigin(ref),
+        ...(gitRef !== undefined ? { ref: gitRef } : {}),
+        directory,
+        gitTreeHash,
+    };
+};
+//# sourceMappingURL=artifact.js.map

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

@@ -21,12 +21,11 @@ import { type PackageUrlParts } from "@agentxm/extension-model/unstable/packagin
 import type { Source } from "@agentxm/extension-model/unstable/sources/types";
 import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
 import { type SourceResolutionFailure } from "@agentxm/extension-sources";
-import { type Plan } from "@agentxm/workspace-operations";
+import { type Plan, type PlannedJobStep } from "@agentxm/workspace-operations";
 import type { ExtensionLifecycleFailed } from "../../errors.js";
 import type { RegistryLookupProbe } from "../../install/registry-source-resolution.js";
-import type { ExtensionSelectionCancelled } from "../../install/selection-interaction.js";
-import { ExtensionSelectionInteraction } from "../../install/selection-interaction.js";
 import { type InstallStepRequirements, type ResolveInstallRequirements, type SkillInstallIntent } from "../../install/vocabulary.js";
+import { SkillSelectionInteraction, type SkillSelectionFailure } from "../application/index.js";
 /** A skill source after grammar parsing, before anything is discovered. */
 export interface ParsedSkillInstallRequest {
     readonly source: Source;
@@ -66,7 +65,19 @@ export declare const parseSkillInstallRequest: (args: SkillInstallArgs) => Effec
 /** Discover the skills the parsed source offers, or refuse when it has none. */
 export declare const discoverSkillRefs: (request: ParsedSkillInstallRequest) => Effect.Effect<ReadonlyArray<SkillExtensionRef>, ExtensionLifecycleFailed, ResolveInstallRequirements>;
 /** Settle which of the discovered skills this request installs. */
-export declare const finalizeSkillInstallIntent: (request: ParsedSkillInstallRequest, discovered: ReadonlyArray<SkillExtensionRef>) => Effect.Effect<SkillInstallIntent, ExtensionLifecycleFailed | ExtensionSelectionCancelled, ExtensionSelectionInteraction>;
+export declare const finalizeSkillInstallIntent: (request: ParsedSkillInstallRequest, discovered: ReadonlyArray<SkillExtensionRef>) => Effect.Effect<SkillInstallIntent, ExtensionLifecycleFailed | SkillSelectionFailure, SkillSelectionInteraction>;
+/** Installing declares intent; an update advances the resolution of existing intent. */
+export type SkillInstallationStepInput = {
+    readonly ref: SkillExtensionRef;
+    readonly force: boolean;
+} & ({
+    readonly operation: "install";
+    readonly versionRange: Option.Option<VersionRange>;
+} | {
+    readonly operation: "update";
+});
+/** One skill-owned application step, shared by install and selective update. */
+export declare const planSkillInstallationStep: (input: SkillInstallationStepInput) => Effect.Effect<PlannedJobStep<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | SkillManager | FileSystem.FileSystem | Path.Path | HttpClient.HttpClient>;
 /** The closures a settled skill intent becomes. */
 export declare const planSkillInstall: (intent: SkillInstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | SkillManager | FileSystem.FileSystem | Path.Path | HttpClient.HttpClient>;
 //# sourceMappingURL=plan.d.ts.map

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

@@ -28,11 +28,10 @@ import { createRegistryClient } from "@agentxm/registry-client";
 import { operationPresentation, } from "@agentxm/workspace-operations";
 import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { WorkspaceMutations, sanitizeName } from "@agentxm/workspace-state";
-import { gitHostedSkillArtifactSource } from "../operations/install.js";
+import { gitHostedSkillArtifactSource } from "./artifact.js";
 import { lifecycleStepFailure } from "../../step-failure.js";
-import { ExtensionSelectionInteraction } from "../../install/selection-interaction.js";
 import { installRefused, } from "../../install/vocabulary.js";
-import { determineSkillsToInstall } from "./selection.js";
+import { determineSkillsToInstall, SkillSelectionInteraction, } from "../application/index.js";
 import { resolveSkillInstallSource } from "./source.js";
 const noSkillsFoundHowToFix = (source) => {
     if (source.type === "registry") {
@@ -317,104 +316,121 @@ const targetChangeBeforeInstall = (args) => Effect.gen(function* () {
     const exists = yield* fs.exists(args.linkPath).pipe(Effect.catch(() => Effect.succeed(false)));
     return exists ? "updated" : "created";
 });
-/** The closures a settled skill intent becomes. */
-export const planSkillInstall = Effect.fn("InstallExtensions.planSkills")(function* (intent) {
+/** One skill-owned application step, shared by install and selective update. */
+export const planSkillInstallationStep = (input) => Effect.gen(function* () {
     const ws = yield* WorkspaceMutations;
     const skillManager = yield* SkillManager;
     const agentRepo = yield* CodingAgentRepository;
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const steps = yield* Effect.forEach(intent.skillsToInstall, (entry) => Effect.gen(function* () {
-        const ref = entry.ref;
-        const previousLockEntry = yield* ws
-            .getLockedSkill(ref.skill.name)
-            .pipe(Effect.catch(() => Effect.succeed(Option.none())));
-        const previousVersion = Option.match(previousLockEntry, {
-            onNone: () => undefined,
-            onSome: previousResolvedVersion,
-        });
-        const { skillSrcPath } = yield* ws.getSkillDir(ref.skill.name, skillPathSourceFor(ref));
-        const sourceHashBeforeInstall = Option.match(previousLockEntry, {
-            onNone: () => undefined,
-            onSome: previousSourceHash,
-        }) ??
-            (yield* Effect.gen(function* () {
-                const exists = yield* fs
-                    .exists(skillSrcPath)
-                    .pipe(Effect.catch(() => Effect.succeed(false)));
-                if (!exists)
-                    return undefined;
-                return yield* computeSkillSourceHash(skillSrcPath);
-            }));
-        const configuredAgents = yield* agentRepo.getMaterializationAgents();
-        const resolvedAgents = yield* Effect.forEach(configuredAgents, (agent) => agent
-            .resolveEffectiveSkillsDir({ workspaceRoot: ws.baseDir })
-            .pipe(Effect.map((outcome) => ({ agentId: agent.id, outcome }))), { concurrency: "unbounded" });
-        const sanitizedName = sanitizeName(ref.skill.name);
-        const installableTargets = resolvedAgents.flatMap(({ agentId, outcome }) => outcome._tag === "supported"
-            ? [{ agentId, targetDir: path.normalize(outcome.dir) }]
-            : []);
-        const targetLocations = yield* groupInstallTargetsByDirectory(installableTargets, ws.baseDir);
-        const artifactAgents = artifactAgentIdsFromTargets(installableTargets);
-        const targets = yield* Effect.forEach(targetLocations, (location) => {
-            const linkPath = path.join(location.targetDir, sanitizedName);
-            return targetChangeBeforeInstall({
-                linkPath,
-                canonicalSkillSrcPath: skillSrcPath,
-            }).pipe(Effect.map((change) => {
-                const agentIds = artifactTargetAgentIds(location.agentIds);
-                return {
-                    path: path.relative(ws.baseDir, linkPath),
-                    change,
-                    ...(agentIds.length > 0 ? { agentIds } : {}),
-                };
-            }));
-        }, { concurrency: "unbounded" });
-        const firstTarget = targets[0];
-        const rawDisplayPath = firstTarget === undefined ? path.relative(ws.baseDir, skillSrcPath) : firstTarget.path;
-        const version = ref.refType === "registry" ? ref.version : undefined;
-        const installedBefore = yield* skillManager
-            .isInstalled({ target: { type: "skill", name: ref.skill.name } })
-            .pipe(Effect.catch(() => Effect.succeed(false)));
-        const releaseAgeWarning = yield* brandNewReleaseAgeWarning(ref, installedBefore);
-        return withPlanWarning(buildInstallOperation(skillManager, {
-            toStepFailure: lifecycleStepFailure,
-            ref,
-            declaration: { name: ref.skill.name, versionRange: entry.versionRange },
-            force: intent.force === true,
-            installedBefore: Effect.succeed(installedBefore),
-            buildArtifact: ({ installedBefore }) => Effect.gen(function* () {
-                const fileCount = yield* countFiles(fs, path, skillSrcPath);
-                const currentSourceHash = yield* computeSkillSourceHash(skillSrcPath);
-                const sameVersion = previousVersion === version;
-                const sameSource = sourceHashBeforeInstall === currentSourceHash;
-                const fallbackChange = !installedBefore
-                    ? "created"
-                    : sameVersion && sameSource
-                        ? "unchanged"
-                        : "updated";
-                const artifactChange = artifactChangeFromTargets(fallbackChange, targets);
-                const sourceDetails = gitHostedSkillArtifactSource(ref);
-                return {
-                    path: rawDisplayPath.length === 0 ? "." : rawDisplayPath,
-                    scope: ws.scope,
-                    agents: artifactAgents,
-                    ...(version !== undefined ? { version } : {}),
-                    change: artifactChange,
-                    ...(previousVersion !== undefined && previousVersion !== version
-                        ? { previousVersion }
-                        : {}),
-                    fileCount,
-                    ...(targets.length > 0 ? { targets } : {}),
-                    ...(sourceDetails !== undefined ? { source: sourceDetails } : {}),
-                };
-            }),
-        }), releaseAgeWarning);
-    }).pipe(Effect.mapError((cause) => installRefused({
-        category: "internal",
-        detail: `Skill install planning failed for ${entry.ref.skill.name}`,
-        cause,
-    }))), { concurrency: 1 });
+    const ref = input.ref;
+    const previousLockEntry = yield* ws
+        .getLockedSkill(ref.skill.name)
+        .pipe(Effect.catch(() => Effect.succeed(Option.none())));
+    const previousVersion = Option.match(previousLockEntry, {
+        onNone: () => undefined,
+        onSome: previousResolvedVersion,
+    });
+    const { skillSrcPath } = yield* ws.getSkillDir(ref.skill.name, skillPathSourceFor(ref));
+    const sourceHashBeforeInstall = Option.match(previousLockEntry, {
+        onNone: () => undefined,
+        onSome: previousSourceHash,
+    }) ??
+        (yield* Effect.gen(function* () {
+            const exists = yield* fs
+                .exists(skillSrcPath)
+                .pipe(Effect.catch(() => Effect.succeed(false)));
+            if (!exists)
+                return undefined;
+            return yield* computeSkillSourceHash(skillSrcPath);
+        }));
+    const configuredAgents = yield* agentRepo.getMaterializationAgents();
+    const resolvedAgents = yield* Effect.forEach(configuredAgents, (agent) => agent
+        .resolveEffectiveSkillsDir({ workspaceRoot: ws.baseDir })
+        .pipe(Effect.map((outcome) => ({ agentId: agent.id, outcome }))), { concurrency: "unbounded" });
+    const unknownAgents = yield* agentRepo.getUnknownConfiguredAgentIds();
+    const skippedAgents = resolvedAgents.flatMap(({ agentId, outcome }) => outcome._tag === "unsupported" || outcome._tag === "disabled"
+        ? [`${agentId}: ${outcome.reason}`]
+        : []);
+    const warnings = [
+        ...(unknownAgents.length === 0
+            ? []
+            : [`Skipping unknown configured agents: ${unknownAgents.join(", ")}`]),
+        ...(skippedAgents.length === 0
+            ? []
+            : [`Skipping non-installable configured agents: ${skippedAgents.join(", ")}`]),
+    ];
+    const sanitizedName = sanitizeName(ref.skill.name);
+    const installableTargets = resolvedAgents.flatMap(({ agentId, outcome }) => outcome._tag === "supported" ? [{ agentId, targetDir: path.normalize(outcome.dir) }] : []);
+    const targetLocations = yield* groupInstallTargetsByDirectory(installableTargets, ws.baseDir);
+    const artifactAgents = artifactAgentIdsFromTargets(installableTargets);
+    const targets = yield* Effect.forEach(targetLocations, (location) => {
+        const linkPath = path.join(location.targetDir, sanitizedName);
+        return targetChangeBeforeInstall({
+            linkPath,
+            canonicalSkillSrcPath: skillSrcPath,
+        }).pipe(Effect.map((change) => {
+            const agentIds = artifactTargetAgentIds(location.agentIds);
+            return {
+                path: path.relative(ws.baseDir, linkPath),
+                change,
+                ...(agentIds.length > 0 ? { agentIds } : {}),
+            };
+        }));
+    }, { concurrency: "unbounded" });
+    const firstTarget = targets[0];
+    const rawDisplayPath = firstTarget === undefined ? path.relative(ws.baseDir, skillSrcPath) : firstTarget.path;
+    const version = ref.refType === "registry" ? ref.version : undefined;
+    const installedBefore = yield* skillManager
+        .isInstalled({ target: { type: "skill", name: ref.skill.name } })
+        .pipe(Effect.catch(() => Effect.succeed(false)));
+    const releaseAgeWarning = input.operation === "install"
+        ? yield* brandNewReleaseAgeWarning(ref, installedBefore)
+        : Option.none();
+    const step = withPlanWarning(buildInstallOperation(skillManager, {
+        toStepFailure: lifecycleStepFailure,
+        ref,
+        ...(input.operation === "install"
+            ? { declaration: { name: ref.skill.name, versionRange: input.versionRange } }
+            : {}),
+        force: input.force,
+        installedBefore: Effect.succeed(installedBefore),
+        buildArtifact: ({ installedBefore }) => Effect.gen(function* () {
+            const fileCount = yield* countFiles(fs, path, skillSrcPath);
+            const currentSourceHash = yield* computeSkillSourceHash(skillSrcPath);
+            const sameVersion = previousVersion === version;
+            const sameSource = sourceHashBeforeInstall === currentSourceHash;
+            const fallbackChange = !installedBefore
+                ? "created"
+                : sameVersion && sameSource
+                    ? "unchanged"
+                    : "updated";
+            const artifactChange = artifactChangeFromTargets(fallbackChange, targets);
+            const sourceDetails = gitHostedSkillArtifactSource(ref);
+            return {
+                path: rawDisplayPath.length === 0 ? "." : rawDisplayPath,
+                scope: ws.scope,
+                agents: artifactAgents,
+                ...(version !== undefined ? { version } : {}),
+                change: artifactChange,
+                ...(previousVersion !== undefined && previousVersion !== version
+                    ? { previousVersion }
+                    : {}),
+                fileCount,
+                ...(targets.length > 0 ? { targets } : {}),
+                ...(sourceDetails !== undefined ? { source: sourceDetails } : {}),
+            };
+        }),
+    }), releaseAgeWarning);
+    return warnings.length === 0 ? step : withPlanWarning(step, Option.some(warnings.join("; ")));
+}).pipe(Effect.mapError((cause) => installRefused({
+    category: "internal",
+    detail: `Skill install planning failed for ${input.ref.skill.name}`,
+    cause,
+})), Effect.withSpan("SkillInstallation.planStep"));
+/** The closures a settled skill intent becomes. */
+export const planSkillInstall = Effect.fn("InstallExtensions.planSkills")(function* (intent) {
+    const steps = yield* Effect.forEach(intent.skillsToInstall, (entry) => planSkillInstallationStep({ ...entry, operation: "install", force: intent.force === true }), { concurrency: 1 });
     return {
         _tag: "Plan",
         name: intent.skillsToInstall.length === 0