@agentxm/extension-lifecycle 0.28.5 → 0.28.6

package/dist/src/hooks/manager.js

@@ -539,11 +539,16 @@ export const HookManagerLive = Layer.effect(HookManager, Effect.gen(function* ()
                 .map(({ agentId }) => agentId);
             return fallbackAgentIds.length === 0 ? [] : [{ ...contributor, fallbackAgentIds }];
         });
-        const selectNative = (agentId) => () => Effect.succeed(contributors.filter((contributor) => outcomes.some((outcome) => outcome.name === contributor.name &&
-            outcome.agentId === agentId &&
-            outcome.mechanism === "native" &&
-            (outcome.outcome === "projected" || outcome.outcome === "current"))));
-        const selectFallback = () => Effect.succeed(fallbackContributors);
+        // Every reachable Hook contributor is decided from desired state
+        // alone, so hook units never exclude one.
+        const selectNative = (agentId) => () => Effect.succeed({
+            contributors: contributors.filter((contributor) => outcomes.some((outcome) => outcome.name === contributor.name &&
+                outcome.agentId === agentId &&
+                outcome.mechanism === "native" &&
+                (outcome.outcome === "projected" || outcome.outcome === "current"))),
+            exclusions: [],
+        });
+        const selectFallback = () => Effect.succeed({ contributors: fallbackContributors, exclusions: [] });
         const fallbackAgentIds = Array.from(new Set(fallbackContributors.flatMap(({ fallbackAgentIds }) => fallbackAgentIds)));
         const materialization = {
             agents: configuredAgents,

package/dist/src/index.d.ts

@@ -10,7 +10,6 @@
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, type LifecycleFailureAdapterService, } from "./failure-adapter.js";
-export { LifecycleResolutionProgress, type LifecycleResolutionProgressService, } from "./resolution-progress.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, type InstallExtensionCommandWorkflowActions, } from "./workflows/install-command/workflow.js";
@@ -20,7 +19,6 @@ export { ensureSkillAgentArtifact, removeSkillAgentArtifact } from "./skills/mat
 export { getSkillDisplayName } from "./skills/utils.js";
 export { computeSkillSourceHash, gitHostedSkillArtifactSource, installSkill, type InstallSkillOperation, type InstallSkillOperationArgs, } from "./skills/operations/install.js";
 export type { InstallResult } from "./skills/operations/install-result.js";
-export { uninstallSkill, type UninstallSkillOperation, type UninstallSkillOperationArgs, } from "./skills/operations/uninstall.js";
 export { enableSkill, type EnableSkillOperation } from "./skills/operations/enable.js";
 export { disableSkill, type DisableSkillOperation } from "./skills/operations/disable.js";
 export { collectSecretInputNames, deleteMcpSecrets, installMcpServer, mcpSecretAccount, readMcpServerManifest, type InstallMcpServerOperation, type InstallMcpServerOperationArgs, } from "./mcps/operations/install.js";

package/dist/src/index.js

@@ -10,7 +10,6 @@
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, } from "./failure-adapter.js";
-export { LifecycleResolutionProgress, } from "./resolution-progress.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, } from "./workflows/install-command/workflow.js";
@@ -20,7 +19,6 @@ export { materializeRegistryPackage, materializeRegistryPackageWithTreeIntegrity
 export { ensureSkillAgentArtifact, removeSkillAgentArtifact } from "./skills/materialization.js";
 export { getSkillDisplayName } from "./skills/utils.js";
 export { computeSkillSourceHash, gitHostedSkillArtifactSource, installSkill, } from "./skills/operations/install.js";
-export { uninstallSkill, } from "./skills/operations/uninstall.js";
 export { enableSkill } from "./skills/operations/enable.js";
 export { disableSkill } from "./skills/operations/disable.js";
 // MCP server lifecycle operations

package/dist/src/knowledge/manager.js

@@ -11,7 +11,7 @@ import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Result from "effect/Result";
 import { PlatformError } from "effect/PlatformError";
-import { KnowledgeDefinitionInvalid, KnowledgeDesiredStateUnreconcilable, KnowledgeInstallStateMissing, KnowledgeIoFailed, KnowledgeObservableContractViolated, KnowledgeResolutionMissing, KnowledgeUnavailable, applyProjectionPlans, planAggregateProjection, requireCompleteGraph, KNOWLEDGE_REGION_OWNER, reconcileKnowledgeDiscovery, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
+import { KnowledgeDefinitionInvalid, KnowledgeDesiredStateUnreconcilable, KnowledgeInstallStateMissing, KnowledgeIoFailed, KnowledgeObservableContractViolated, KnowledgeResolutionMissing, KnowledgeUnavailable, applyProjectionPlans, formatProjectionExclusions, planAggregateProjection, requireCompleteGraph, KNOWLEDGE_REGION_OWNER, reconcileKnowledgeDiscovery, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
 import { canReuseInstalledPackage, materializeExternalPackage } from "@agentxm/extension-workspace";
 import { materializeRegistryPackage } from "../registry-materialization.js";
 import { computeExtensionPathsForLayout, extensionPathSourceFromLockEntry, } from "@agentxm/workspace-state";
@@ -299,21 +299,64 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
             .filter(isSourcedDesiredExtension)
             .filter((node) => node.type === "knowledge" && node.enabled))
         : new KnowledgeDesiredStateUnreconcilable()));
+    /**
+     * Classify a bundle whose package could not be inspected. Only the
+     * bundle's own content is in question here: resolution facts have already
+     * succeeded, so the two truthful answers are that the package is gone or
+     * that its content is invalid.
+     */
+    const excludedContributor = (name, root, failure) => Effect.gen(function* () {
+        const probe = yield* Effect.result(fs.exists(path.join(root, KNOWLEDGE_MANIFEST_FILENAME)));
+        const manifestPresent = Result.isSuccess(probe) && probe.success;
+        if (!manifestPresent)
+            return { contributor: name, reason: "package-missing" };
+        return {
+            contributor: name,
+            reason: "package-invalid",
+            detail: failure._tag === "KnowledgeDefinitionInvalid"
+                ? failure.detail
+                : adapter.describeFailure(failure),
+        };
+    });
+    /**
+     * Resolve the contributor set for the discovery region. A bundle that
+     * fails inspection cannot supply a row, so it is excluded and reported
+     * rather than failing every other bundle's command with it. Resolution
+     * failures — a missing lock entry, an unsupported workspace-authored
+     * bundle — remain fail-closed: they are AXM state problems, not bundle
+     * content problems.
+     */
     const selectKnowledgeBundles = (graph, locked, configured, config, instructionFilesEnabled) => Effect.forEach(graph.nodes.filter((node) => node.type === "knowledge" && node.enabled), (node) => Effect.gen(function* () {
         const root = yield* desiredCanonicalRoot(node, locked[node.name]);
-        const inspected = yield* inspectPackage(root);
         const workspaceInstructionEntry = configured[node.name]?.instructionEntry;
-        const resolution = resolveKnowledgeInstructionEntry({
+        const resolveInclusion = (manifestInstructionEntry) => resolveKnowledgeInstructionEntry({
             bundleEnabled: node.enabled,
             instructionFilesEnabled,
             knowledgeInstructionsEnabled: config.instructions,
             ...(workspaceInstructionEntry === undefined ? {} : { workspaceInstructionEntry }),
-            ...(inspected.manifest.instructionEntry === undefined
-                ? {}
-                : { manifestInstructionEntry: inspected.manifest.instructionEntry }),
+            ...(manifestInstructionEntry === undefined ? {} : { manifestInstructionEntry }),
         });
-        return resolution.included ? [toProjectionBundle(root, inspected)] : [];
-    })).pipe(Effect.map((bundles) => bundles.flat()));
+        const inspection = yield* Effect.result(inspectPackage(root));
+        if (Result.isFailure(inspection)) {
+            // A bundle the workspace would not publish anyway is simply
+            // absent from the region; reporting it would be noise.
+            return resolveInclusion().included
+                ? {
+                    contributors: [],
+                    exclusions: [yield* excludedContributor(node.name, root, inspection.failure)],
+                }
+                : { contributors: [], exclusions: [] };
+        }
+        const inspected = inspection.success;
+        const resolution = resolveInclusion(inspected.manifest.instructionEntry);
+        return {
+            contributors: resolution.included ? [toProjectionBundle(root, inspected)] : [],
+            exclusions: [],
+        };
+    })).pipe(Effect.map((selections) => ({
+        contributors: selections.flatMap(({ contributors }) => contributors),
+        exclusions: selections.flatMap(({ exclusions }) => exclusions),
+    })));
     const resolveKnowledgeProjection = () => Effect.gen(function* () {
         const graph = yield* ws.getDesiredStateGraph();
         const locked = yield* getKnowledgeLockEntries(ws);
@@ -362,12 +405,18 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
     });
     const projectionPlans = () => makeKnowledgeProjectionPlan().pipe(Effect.map((plan) => [plan]));
     const applyKnowledgeProjection = projectionPlans().pipe(Effect.flatMap(applyProjectionPlans));
-    const reconcileDiscovery = (options) => resolveKnowledgeProjection().pipe(Effect.flatMap(({ graph, locked, configured, config, instructionsTarget }) => requireCompleteGraph(graph).pipe(Effect.flatMap((completeGraph) => selectKnowledgeBundles(completeGraph, locked, configured, config, instructionsTarget.enabled)), Effect.flatMap((bundles) => runKnowledgeProjectionAdapter({
-        bundles,
+    const reconcileDiscovery = (options) => resolveKnowledgeProjection().pipe(Effect.flatMap(({ graph, locked, configured, config, instructionsTarget }) => requireCompleteGraph(graph).pipe(Effect.flatMap((completeGraph) => selectKnowledgeBundles(completeGraph, locked, configured, config, instructionsTarget.enabled)), Effect.flatMap(({ contributors, exclusions }) => runKnowledgeProjectionAdapter({
+        bundles: contributors,
         config,
         instructionsTarget,
         ...(options?.dryRun === undefined ? {} : { dryRun: options.dryRun }),
-    })))));
+    }).pipe(Effect.map((result) => ({
+        ...result,
+        warnings: formatProjectionExclusions({
+            exclusions,
+            targetFile: instructionsTarget.path,
+        }),
+    })))))));
     const buildLockEntry = (ref) => Effect.gen(function* () {
         const state = lastInstallState.get(ref.knowledge.name);
         switch (ref.refType) {
@@ -487,7 +536,7 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
         const discovery = discovered.success;
         return {
             changed: prepared.length > 0 || discovery.changed,
-            warnings: [],
+            warnings: discovery.warnings,
             artifacts: discovery.artifacts,
         };
     });

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

@@ -6,12 +6,11 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { CodingAgentRepository, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository } from "@agentxm/extension-workspace";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
 import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 export const disableMcpServer = (op) => Effect.gen(function* () {
@@ -28,48 +27,13 @@ export const disableMcpServer = (op) => Effect.gen(function* () {
         });
     }
     const agents = yield* agentRepo.getConfiguredAgents();
-    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
-        entry,
-        agentIds: agents.map((agent) => agent.id),
-        scope: ws.scope,
-    });
-    if (sharedTargetConflict !== undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: sharedTargetConflict,
-        });
-    }
     const outcomes = yield* ws.runTransaction({
         transition: Effect.gen(function* () {
-            const synced = yield* Effect.forEach(agents, (agent) => Effect.gen(function* () {
-                if (isMcpServerApplicableToAgent(entry, agent.id)) {
-                    return yield* agent.removeMcpServer({
-                        workspaceRoot: ws.baseDir,
-                        scope: ws.scope,
-                        serverName: op.args.serverName,
-                        disableOnly: true,
-                    });
-                }
-                const inspection = yield* inspectAgentMcpServer({
-                    workspaceRoot: ws.baseDir,
-                    scope: ws.scope,
-                    agentId: agent.id,
-                    serverName: op.args.serverName,
-                    entry,
-                });
-                if (inspection.status === "unmanaged") {
-                    return yield* new ExtensionLifecycleFailed({
-                        category: "conflict",
-                        detail: `${agent.id} has an unmanaged MCP server named ${op.args.serverName}; AXM will not remove it while applying the target policy`,
-                    });
-                }
-                return inspection.status === "drift"
-                    ? yield* agent.removeMcpServer({
-                        workspaceRoot: ws.baseDir,
-                        scope: ws.scope,
-                        serverName: op.args.serverName,
-                    })
-                    : { _tag: "success", targets: [] };
+            const synced = yield* Effect.forEach(agents, (agent) => agent.removeMcpServer({
+                workspaceRoot: ws.baseDir,
+                scope: ws.scope,
+                serverName: op.args.serverName,
+                disableOnly: true,
             }), { concurrency: "unbounded" });
             yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({
                 agentId: agent.id,

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

@@ -7,14 +7,13 @@ import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { CodingAgentRepository, syncInlineMcpServerToAgents, McpSharedTargetConflict, applyProjectionPlansWithResults, planSingletonProjection, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository, syncInlineMcpServerToAgents, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/extension-workspace";
 import { normalizeHandle, parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
 import { usableAcceptedCanonicalObservation } from "@agentxm/workspace-state";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
 import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 const enableArtifact = (args) => {
@@ -116,17 +115,6 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
     const owner = trustedIdentity?.type === "mcp-server" ? trustedIdentity.owner : normalizeHandle("@local");
     const resolvedVersion = accepted?.type === "registry" ? accepted.resolvedVersion : "0.0.0";
     const agents = yield* agentRepo.getConfiguredAgents();
-    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
-        entry,
-        agentIds: agents.map((agent) => agent.id),
-        scope: ws.scope,
-    });
-    if (sharedTargetConflict !== undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: sharedTargetConflict,
-        });
-    }
     const outcomes = yield* ws.runTransaction({
         transition: Effect.gen(function* () {
             const synced = yield* applyProjectionPlansWithResults(agents.map((agent) => planSingletonProjection({
@@ -143,27 +131,6 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
                         observedContributors: [],
                     }),
                     apply: () => Effect.gen(function* () {
-                        if (!isMcpServerApplicableToAgent(entry, agent.id)) {
-                            const inspection = yield* inspectAgentMcpServer({
-                                workspaceRoot: ws.baseDir,
-                                scope: ws.scope,
-                                agentId: agent.id,
-                                serverName: op.args.serverName,
-                                entry,
-                            });
-                            if (inspection.status === "unmanaged") {
-                                return yield* new McpSharedTargetConflict({
-                                    reason: `${agent.id} has an unmanaged MCP server named ${op.args.serverName}; AXM will not remove it while applying the target policy`,
-                                });
-                            }
-                            return inspection.status === "drift"
-                                ? yield* agent.removeMcpServer({
-                                    workspaceRoot: ws.baseDir,
-                                    scope: ws.scope,
-                                    serverName: op.args.serverName,
-                                })
-                                : { _tag: "success", targets: [] };
-                        }
                         return yield* agent.addMcpServer({
                             workspaceRoot: ws.baseDir,
                             scope: ws.scope,

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

@@ -12,7 +12,6 @@ import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { CodingAgentRepository } from "@agentxm/extension-workspace";
-import type { ConfigurableAgentId } from "@agentxm/extension-model/unstable/agent-capabilities";
 import type { StepFailure } from "@agentxm/workspace-operations";
 import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
@@ -43,8 +42,6 @@ export type InstallMcpServerOperationArgs = {
      * The transport boundary resolves flag, CI, and TTY state.
      */
     readonly nonInteractive: boolean;
-    /** Restrict this server to a reviewed subset of configured agents. */
-    readonly agents?: ReadonlyArray<ConfigurableAgentId>;
 };
 /**
  * Add an MCP server to the workspace.

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

@@ -21,7 +21,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { createHash } from "node:crypto";
-import { CodingAgentRepository, McpSharedTargetConflict, applyProjectionPlansWithResults, planSingletonProjection, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/extension-workspace";
 import { isPathSafe, mcpRegistryResolutionKey } from "@agentxm/workspace-state";
 import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
@@ -33,7 +33,6 @@ import { printSourceParams } from "@agentxm/extension-model/unstable/sources/pri
 import { computeMaterializedTreeIntegrity } from "@agentxm/workspace-state";
 import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
 import { MCP_SERVER_MANIFEST_FILENAME, McpServerManifestSchema, } from "@agentxm/extension-model/unstable/mcps/manifest-schema";
-import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
 import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget, mcpSourceTarget, } from "./artifact.js";
 import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
@@ -295,17 +294,6 @@ const syncConfiguredAgentsOnInstall = (args) => Effect.gen(function* () {
         warnings.push(`Skipping unknown configured agents: ${unknownConfiguredAgentIds.join(", ")}`);
     }
     const configuredAgents = yield* agentRepo.getConfiguredAgents();
-    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
-        entry: args.entry,
-        agentIds: configuredAgents.map((agent) => agent.id),
-        scope: args.scope,
-    });
-    if (sharedTargetConflict !== undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: sharedTargetConflict,
-        });
-    }
     let outcomes;
     if (args.nothingRunnable) {
         outcomes = configuredAgents.map((agent) => ({
@@ -331,28 +319,6 @@ const syncConfiguredAgentsOnInstall = (args) => Effect.gen(function* () {
                     observedContributors: [],
                 }),
                 apply: () => Effect.gen(function* () {
-                    if (!isMcpServerApplicableToAgent(args.entry, agent.id)) {
-                        const inspection = yield* inspectAgentMcpServer({
-                            workspaceRoot: args.wsBaseDir,
-                            scope: args.scope,
-                            agentId: agent.id,
-                            serverName: args.serverName,
-                            entry: args.entry,
-                        });
-                        if (inspection.status === "unmanaged") {
-                            return yield* new McpSharedTargetConflict({
-                                reason: `${agent.id} has an unmanaged MCP server named ${args.serverName}; AXM will not remove it while applying the target policy`,
-                            });
-                        }
-                        const outcome = inspection.status === "drift"
-                            ? yield* agent.removeMcpServer({
-                                workspaceRoot: args.wsBaseDir,
-                                scope: args.scope,
-                                serverName: args.serverName,
-                            })
-                            : { _tag: "success", targets: [] };
-                        return { agentId: agent.id, outcome };
-                    }
                     const outcome = yield* agent.addMcpServer({
                         workspaceRoot: args.wsBaseDir,
                         scope: args.scope,
@@ -525,13 +491,11 @@ export const installMcpServer = (op) => Effect.gen(function* () {
     }
     const persistedEnv = redactSettingsEnv(mergedEnv, secretNames);
     const enabled = currentEntry?.enabled ?? true;
-    const agents = op.args.agents ?? currentEntry?.agents;
     const settingsEntry = {
         kind: "sourced",
         source: ref.refType === "workspace" ? "workspace" : printSourceParams(ref.source),
         env: persistedEnv,
         enabled,
-        ...(agents === undefined ? {} : { agents }),
     };
     const writeEffect = op.args.skipStateWrites === true
         ? Effect.void
@@ -555,7 +519,6 @@ export const installMcpServer = (op) => Effect.gen(function* () {
                     versionRange: op.args.versionRange,
                     env: persistedEnv,
                     enabled,
-                    ...(agents === undefined ? {} : { agents }),
                 });
     yield* writeEffect;
     const projectionNames = ref.refType === "registry" && lockedVersion !== undefined && lockedVersion !== ref.version

package/dist/src/registry-materialization.js

@@ -17,6 +17,7 @@ import { computeIntegrity } from "./internal/integrity.js";
 import { ArchiveIntegrityMismatch, recoverCanonicalDirectory, replaceCanonicalDirectoryWithInspection, } from "@agentxm/extension-workspace";
 import { CoupledDependencyFailure } from "@agentxm/extension-workspace";
 import { coupleLifecycleDependencyFailure } from "./errors.js";
+import { makeThrottledUnitProgress } from "@agentxm/workspace-operations";
 import { computeMaterializedTreeIntegrity, } from "@agentxm/workspace-state";
 const registryLocationForClient = (location) => location.protocol === "file:" ? location.pathname : location.href;
 /**
@@ -35,12 +36,16 @@ export const materializeRegistryPackageWithTreeIntegrity = (args) => Effect.gen(
         canonicalPath: args.destinationPath,
     });
     const client = yield* createRegistryClient(registryLocationForClient(args.sourceLocation));
+    // Continuous download progress reaches the lifecycle broadcast throttled:
+    // tens of events per archive, attributed to the unit that is running.
+    const reportProgress = yield* makeThrottledUnitProgress({ unit: "bytes" });
     const { archive } = yield* client
         .getExtensionPackage({
         owner: args.owner,
         type: args.type,
         name: args.name,
         version: Option.some(args.version),
+        onProgress: (progress) => reportProgress(progress.done, progress.total),
     })
         .pipe(Effect.mapError(coupleLifecycleDependencyFailure));
     if (Option.isSome(args.integrity)) {

package/dist/src/rules/manager.js

@@ -334,7 +334,9 @@ export const RuleManagerLive = Layer.effect(RuleManager, Effect.gen(function* ()
             unitId: "rule:instructions-region",
             targetFile: target.absolute,
             graph,
-            select: (completeGraph) => selectRuleContributors({ graph: completeGraph, locked }),
+            // Rule contributors are decided from desired state alone, so the
+            // instructions region never excludes one.
+            select: (completeGraph) => selectRuleContributors({ graph: completeGraph, locked }).pipe(Effect.map((contributors) => ({ contributors, exclusions: [] }))),
             adapter: {
                 observe: (input) => reconcileRulesRegion({ input, target, instructions, dryRun: true }).pipe(Effect.map(({ projectionUnitObservation }) => projectionUnitObservation)),
                 apply: (input) => reconcileRulesRegion({ input, target, instructions }).pipe(Effect.asVoid),

package/dist/src/workflows/install-command/workflow.d.ts

@@ -11,7 +11,6 @@ import type * as Scope from "effect/Scope";
 import type { Plan } from "@agentxm/workspace-operations";
 import type { OperationResolution } from "@agentxm/workspace-operations";
 import type { PlanExecution } from "@agentxm/workspace-operations";
-import { LifecycleResolutionProgress } from "../../resolution-progress.js";
 /**
  * Type-specific actions for install command workflows.
  *
@@ -53,5 +52,5 @@ export declare const runInstallCommandWorkflow: <Args, Parsed, Req, Ref, Intent,
     readonly execution: PlanExecution;
     readonly transformIntent?: (intent: Intent) => Intent;
     readonly transformPlan?: (plan: Plan) => Effect.Effect<Plan, TransformError, TransformRequirements>;
-}) => Effect.Effect<OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | ParseError | ResolveError | TransformError | import("@agentxm/workspace-operations").CandidateFingerprintFailed | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-state").WorkspaceTransitionAcquireFailure | import("@agentxm/workspace-state").LockfileValidationError, import("@agentxm/workspace-state").WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/Path").Path | LifecycleResolutionProgress | import("@agentxm/workspace-operations").ResolvePlanInteraction | Exclude<TransformRequirements, Scope.Scope>>;
+}) => Effect.Effect<OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | ParseError | ResolveError | TransformError | import("@agentxm/workspace-operations").CandidateFingerprintFailed | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-state").WorkspaceTransitionAcquireFailure | import("@agentxm/workspace-state").LockfileValidationError, import("@agentxm/workspace-state").WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("@agentxm/workspace-operations").ResolvePlanInteraction | Exclude<TransformRequirements, Scope.Scope>>;
 //# sourceMappingURL=workflow.d.ts.map

package/dist/src/workflows/install-command/workflow.js

@@ -7,8 +7,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Effect from "effect/Effect";
-import { previewOrApplyPlan } from "@agentxm/workspace-operations";
-import { LifecycleResolutionProgress } from "../../resolution-progress.js";
+import { observeUnit, previewOrApplyPlan, publishPhaseStarted, } from "@agentxm/workspace-operations";
 // -----------------------------------------------------------------------------
 // Install Command Workflow
 // -----------------------------------------------------------------------------
@@ -20,8 +19,10 @@ import { LifecycleResolutionProgress } from "../../resolution-progress.js";
  */
 export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(function* () {
     const parsed = yield* actions.parseArgs(args);
-    const sourceRequests = yield* actions.resolveSourceRequests(parsed);
-    const refs = yield* actions.discoverRefs(sourceRequests);
+    // Source resolution is the first lifecycle phase: requested sources become
+    // concrete refs, observed as one unit under `resolution`.
+    yield* publishPhaseStarted("resolution");
+    const refs = yield* observeUnit({ id: "extension-sources", label: "extension sources" }, Effect.flatMap(actions.resolveSourceRequests(parsed), (sourceRequests) => actions.discoverRefs(sourceRequests)));
     const finalizedIntent = yield* actions.finalizeIntent(parsed, refs);
     const intent = options?.transformIntent?.(finalizedIntent) ?? finalizedIntent;
     const plan = yield* actions.buildPlan(intent);
@@ -34,8 +35,7 @@ export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(fu
  * finalizeIntent -> buildPlan -> previewOrApplyPlan.
  */
 export const runInstallCommandWorkflow = (args, actions, options) => Effect.gen(function* () {
-    const progress = yield* LifecycleResolutionProgress;
-    const plan = yield* progress.withSourceResolution(buildInstallCommandPlan(args, actions, options));
+    const plan = yield* buildInstallCommandPlan(args, actions, options);
     return yield* previewOrApplyPlan(plan, { execution: options.execution });
 }).pipe(Effect.scoped, Effect.map((resolution) => resolution));
 //# sourceMappingURL=workflow.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/extension-lifecycle",
-  "version": "0.28.5",
+  "version": "0.28.6",
   "description": "AXM extension-lifecycle feature: install, update, uninstall, enable, and disable policy across root and type-specific command forms for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -43,13 +43,13 @@
   "dependencies": {
     "effect": "4.0.0-rc.112",
     "semver": "^7.8.5",
-    "@agentxm/extension-model": "^0.28.5",
-    "@agentxm/extension-workspace": "^0.28.5",
-    "@agentxm/registry-client": "^0.28.5",
-    "@agentxm/registry-protocol": "^0.28.5",
-    "@agentxm/extension-sources": "^0.28.5",
-    "@agentxm/workspace-operations": "^0.28.5",
-    "@agentxm/workspace-state": "^0.28.5"
+    "@agentxm/extension-sources": "^0.28.6",
+    "@agentxm/extension-model": "^0.28.6",
+    "@agentxm/extension-workspace": "^0.28.6",
+    "@agentxm/registry-client": "^0.28.6",
+    "@agentxm/workspace-operations": "^0.28.6",
+    "@agentxm/workspace-state": "^0.28.6",
+    "@agentxm/registry-protocol": "^0.28.6"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",

package/dist/src/resolution-progress.d.ts

@@ -1,18 +0,0 @@
-/**
- * Presentation port for the source-resolution phase of lifecycle workflows.
- * The feature marks where progress feedback belongs; the application owns the
- * mechanism and wording (the CLI renders a spinner around the phase).
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-import type * as Effect from "effect/Effect";
-export interface LifecycleResolutionProgressService {
-    /** Surround the source-resolution phase with the application's progress feedback. */
-    readonly withSourceResolution: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-}
-declare const LifecycleResolutionProgress_base: ServiceMap.ServiceClass<LifecycleResolutionProgress, "@agentxm/extension-lifecycle/resolution-progress/LifecycleResolutionProgress", LifecycleResolutionProgressService>;
-export declare class LifecycleResolutionProgress extends LifecycleResolutionProgress_base {
-}
-export {};
-//# sourceMappingURL=resolution-progress.d.ts.map

package/dist/src/resolution-progress.js

@@ -1,11 +0,0 @@
-/**
- * Presentation port for the source-resolution phase of lifecycle workflows.
- * The feature marks where progress feedback belongs; the application owns the
- * mechanism and wording (the CLI renders a spinner around the phase).
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-export class LifecycleResolutionProgress extends ServiceMap.Service()("@agentxm/extension-lifecycle/resolution-progress/LifecycleResolutionProgress") {
-}
-//# sourceMappingURL=resolution-progress.js.map

package/dist/src/skills/operations/uninstall.d.ts

@@ -1,40 +0,0 @@
-/**
- * Uninstall skill executor — orchestrates per-skill removal pipeline.
- *
- * Pipeline: resolve desired/observed state -> remove agent artifacts
- * concurrently -> remove canonical source -> clear settings and accepted resolution.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
-import type { OperationHandler } from "@agentxm/workspace-operations";
-import type { Operation } from "@agentxm/workspace-operations";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-/**
- * Args for the uninstall-skill operation.
- */
-export interface UninstallSkillOperationArgs {
-    readonly skillName: string;
-    /** Agent filter for partial uninstall. Empty = all agents. */
-    readonly agents: ReadonlyArray<string>;
-}
-/**
- * Remove a skill from the workspace.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type UninstallSkillOperation = Operation<"uninstall-skill", UninstallSkillOperationArgs>;
-/**
- * Uninstall-skill operation handler.
- *
- * Reads workspace paths from the WorkspaceMutations service, then orchestrates:
- * 1. Sanitize skill name for filesystem
- * 2. Resolve configured and observed state
- * 3. Remove agent symlinks concurrently (skip missing)
- * 4. Remove from all known canonical locations (full uninstall only)
- * 5. Remove or update settings and accepted resolution
- */
-export declare const uninstallSkill: OperationHandler<UninstallSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | LifecycleFailureAdapter>;
-//# sourceMappingURL=uninstall.d.ts.map

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

@@ -1,157 +0,0 @@
-/**
- * Uninstall skill executor — orchestrates per-skill removal pipeline.
- *
- * Pipeline: resolve desired/observed state -> remove agent artifacts
- * concurrently -> remove canonical source -> clear settings and accepted resolution.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Layer from "effect/Layer";
-import { DefaultCodingAgentRepository } from "@agentxm/extension-workspace";
-import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
-import { ExtensionLifecycleFailed } from "../../errors.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { removeIfExists } from "@agentxm/workspace-state";
-import { sanitizeName } from "@agentxm/workspace-state";
-import { acceptedCanonicalObservation, acceptedLockedCanonicalPath, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-// Operation types
-// -----------------------------------------------------------------------------
-const isKnownAgentId = (id) => Object.hasOwn(AGENTS, id);
-// -----------------------------------------------------------------------------
-// Public API
-// -----------------------------------------------------------------------------
-/**
- * Uninstall-skill operation handler.
- *
- * Reads workspace paths from the WorkspaceMutations service, then orchestrates:
- * 1. Sanitize skill name for filesystem
- * 2. Resolve configured and observed state
- * 3. Remove agent symlinks concurrently (skip missing)
- * 4. Remove from all known canonical locations (full uninstall only)
- * 5. Remove or update settings and accepted resolution
- */
-export const uninstallSkill = (op) => Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const ws = yield* WorkspaceMutations;
-    const base = ws.baseDir;
-    const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
-    const sanitizedName = sanitizeName(op.args.skillName);
-    const desired = yield* ws.getDesiredStateGraph();
-    if (!desired.complete) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: "Cannot uninstall the skill while the desired extension graph is incomplete.",
-            recover: "Repair or reinstall the configured packs, then retry.",
-        });
-    }
-    const desiredNode = desired.nodes.find((node) => node.type === "skill" && node.name === op.args.skillName);
-    const acceptedCanonical = yield* acceptedCanonicalObservation({
-        workspace: ws,
-        type: "skill",
-        name: op.args.skillName,
-    });
-    const lockedCanonical = yield* acceptedLockedCanonicalPath({
-        workspace: ws,
-        type: "skill",
-        name: op.args.skillName,
-    });
-    const removableCanonical = Option.orElse(removableAcceptedCanonicalPath(acceptedCanonical), () => lockedCanonical);
-    const installedOnDisk = yield* Option.match(removableCanonical, {
-        onNone: () => Effect.succeed(false),
-        onSome: (canonicalPath) => fs.exists(canonicalPath).pipe(Effect.catch(() => Effect.succeed(false))),
-    });
-    if (desiredNode === undefined && !installedOnDisk) {
-        return { result: "success", message: "not installed" };
-    }
-    // Determine which configured agent artifacts to remove. Per-agent state is
-    // derived from settings and disk rather than persisted in the lockfile.
-    const agentFilter = op.args.agents;
-    const isPartialUninstall = agentFilter.length > 0;
-    const materializationAgents = yield* DefaultCodingAgentRepository.getMaterializationAgents().pipe(Effect.provideService(WorkspaceMutations, ws));
-    const agentsToRemove = isPartialUninstall
-        ? agentFilter
-        : materializationAgents.map((agent) => agent.id);
-    const remainingAgents = materializationAgents
-        .map((agent) => agent.id)
-        .filter((agent) => !agentsToRemove.includes(agent));
-    const agentsById = new Map(materializationAgents.map((agent) => [agent.id, agent]));
-    const resolveAgentArtifactPath = (agentId) => {
-        const configuredAgent = agentsById.get(agentId);
-        const agentEffect = configuredAgent !== undefined
-            ? Effect.succeed(Option.some(configuredAgent))
-            : isKnownAgentId(agentId)
-                ? DefaultCodingAgentRepository.get(agentId).pipe(Effect.map(Option.some))
-                : Effect.succeed(Option.none());
-        return agentEffect.pipe(Effect.flatMap((agentOption) => {
-            if (Option.isNone(agentOption))
-                return Effect.succeed(Option.none());
-            return agentOption.value
-                .resolveEffectiveSkillsDir({ workspaceRoot: base })
-                .pipe(Effect.map((outcome) => outcome._tag === "supported"
-                ? Option.some(path.normalize(path.join(outcome.dir, sanitizedName)))
-                : Option.none()));
-        }), Effect.provide(fsPathLayer));
-    };
-    const retainedArtifactOptions = yield* Effect.forEach(remainingAgents, resolveAgentArtifactPath, { concurrency: "unbounded" });
-    const retainedArtifactPaths = new Set(retainedArtifactOptions.flatMap((artifactPath) => Option.isSome(artifactPath) ? [artifactPath.value] : []));
-    // Remove agent symlinks/copies concurrently using adapter-derived paths.
-    yield* Effect.forEach(agentsToRemove, (agentId) => {
-        const configuredAgent = agentsById.get(agentId);
-        const agentEffect = configuredAgent !== undefined
-            ? Effect.succeed(Option.some(configuredAgent))
-            : isKnownAgentId(agentId)
-                ? DefaultCodingAgentRepository.get(agentId).pipe(Effect.map(Option.some))
-                : Effect.succeed(Option.none());
-        return agentEffect.pipe(Effect.flatMap((agentOption) => {
-            if (Option.isNone(agentOption)) {
-                return Effect.succeed({
-                    _tag: "unsupported",
-                    reason: `Unknown coding agent: ${agentId}`,
-                });
-            }
-            return agentOption.value.resolveEffectiveSkillsDir({ workspaceRoot: base });
-        }), Effect.provide(fsPathLayer), Effect.flatMap((outcome) => outcome._tag === "supported"
-            ? (() => {
-                const artifactPath = path.normalize(path.join(outcome.dir, sanitizedName));
-                return retainedArtifactPaths.has(artifactPath)
-                    ? Effect.void
-                    : fs
-                        .remove(artifactPath, { recursive: true })
-                        .pipe(Effect.catch(() => Effect.void));
-            })()
-            : Effect.void));
-    }, { concurrency: "unbounded" });
-    // Handle partial vs full uninstall
-    if (isPartialUninstall) {
-        const agentList = [...agentsToRemove].join(", ");
-        return {
-            result: "success",
-            message: `Uninstalled ${op.args.skillName} from ${agentList}`,
-        };
-    }
-    const packOwned = desiredNode?.origins.some((origin) => origin.type === "pack") ?? false;
-    if (packOwned) {
-        // Pack still references this skill — remove from settings only, keep lockfile + disk
-        yield* ws.removeSkillFromSettings(op.args.skillName).pipe(Effect.catch(() => Effect.void));
-        return {
-            result: "success",
-            message: `Uninstalled ${op.args.skillName}`,
-        };
-    }
-    // Full uninstall removes only the canonical package proven by accepted authority.
-    if (Option.isSome(removableCanonical))
-        yield* removeIfExists(fs, removableCanonical.value);
-    // Remove from both settings and lockfile (swallow errors on full uninstall)
-    yield* ws.removeSkill(op.args.skillName).pipe(Effect.catch(() => Effect.void));
-    return {
-        result: "success",
-        message: `Uninstalled ${op.args.skillName}`,
-    };
-}).pipe(withAdaptedStepFailures);
-//# sourceMappingURL=uninstall.js.map