@agentxm/extension-lifecycle 0.29.2 → 0.30.1

package/dist/src/demote/demote-to-external-source.d.ts

@@ -69,7 +69,7 @@ declare const settleDemotion: (request: DemoteRequest) => Effect.Effect<{
     fqn: string;
     authoredPath: string;
     execution: ExecutionCandidate<InstallStepRequirements, never>;
-}, ExtensionLifecycleFailed | import("@agentxm/workspace-state").PathTraversalDetected | 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").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | WorkspaceSettingsReadFailure | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/workspace-state").LockEntrySourceMissing | import("@agentxm/workspace-state").LockEntryUrlInvalid | import("@agentxm/workspace-state").LockEntryNameInvalid | import("@agentxm/workspace-state").LockEntryEndpointConflict | import("@agentxm/workspace-state").LockEntrySourceTypeConflict | import("@agentxm/workspace-state").AcceptedResolutionMissing | import("@agentxm/workspace-state").InlineExtensionSourceMissing | import("@agentxm/workspace-state").PackageContentHashFailed | import("@agentxm/workspace-state").WorkspaceSourceInvalid | import("@agentxm/extension-model/unstable/extensions").FqnInvalidError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, FileSystem.FileSystem | Path.Path | WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | ExtensionManagers | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | import("@agentxm/extension-sources").SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog>;
+}, ExtensionLifecycleFailed | import("@agentxm/workspace-state").PathTraversalDetected | 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").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | WorkspaceSettingsReadFailure | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/workspace-state").LockEntrySourceMissing | import("@agentxm/workspace-state").LockEntryUrlInvalid | import("@agentxm/workspace-state").LockEntryNameInvalid | import("@agentxm/workspace-state").LockEntryEndpointConflict | import("@agentxm/workspace-state").LockEntrySourceTypeConflict | import("@agentxm/workspace-state").AcceptedResolutionMissing | import("@agentxm/workspace-state").InlineExtensionSourceMissing | import("@agentxm/workspace-state").PackageContentHashFailed | import("@agentxm/workspace-state").WorkspaceSourceInvalid | import("@agentxm/extension-model/unstable/extensions").FqnInvalidError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, FileSystem.FileSystem | Path.Path | WorkspaceMutations | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | ExtensionManagers | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | import("@agentxm/extension-sources").SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog>;
 export declare const prepareDemote: (request: DemoteRequest) => Effect.Effect<DemoteCandidate, DemoteFailure, PrepareDemoteRequirements>;
 /** Preview or apply a settled demotion, resolving to one operation outcome. */
 export declare const previewOrApplyDemote: (candidate: DemoteCandidate, execution: PlanExecution) => Effect.Effect<import("@agentxm/workspace-operations").OperationResolution<never>, WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-transactions").WorkspaceTransitionAcquireFailure, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/workspace-operations").ResolvePlanInteraction | InstallStepRequirements>;

package/dist/src/demote/demote-to-external-source.js

@@ -20,7 +20,8 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
-import { ExtensionManagers, buildInstallOperation } from "@agentxm/extension-materialization";
+import { ExtensionManagers } from "@agentxm/extension-materialization";
+import { buildInstallOperation } from "@agentxm/workspace-reconciliation";
 import { formatFqn, parseFqn, } from "@agentxm/extension-model/unstable/extensions";
 import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
 import { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "@agentxm/extension-resolution";
@@ -88,7 +89,7 @@ const restoreDisabledState = (ws, type, name) => {
 // -----------------------------------------------------------------------------
 /**
  * Resolve the replacement package from its new source and compose the install
- * that replaces the authored content. `allowWorkspaceReplacement` is the one
+ * that replaces the authored content. `sourceReplacements` is the one
  * place source authority is deliberately overridden, and it is named here so
  * no other route can reach it by accident.
  */
@@ -98,43 +99,71 @@ const replacementStep = Effect.fn("Demote.replacementStep")(function* (type, nam
     // The one place source authority is deliberately overridden.
     const common = {
         toStepFailure: lifecycleStepFailure,
-        allowWorkspaceReplacement: true,
+        sourceReplacements: [{ type, name }],
     };
     switch (type) {
         case "skill":
-            return buildInstallOperation(managers.skill, {
-                ...common,
-                ...(yield* resolveConfiguredSkill(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredSkill(name, source, evaluation);
+                return buildInstallOperation(managers.skill, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "mcp-server":
-            return buildInstallOperation(managers["mcp-server"], {
-                ...common,
-                ...(yield* resolveConfiguredMcpServer(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredMcpServer(name, source, evaluation);
+                return buildInstallOperation(managers["mcp-server"], {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "subagent":
-            return buildInstallOperation(managers.subagent, {
-                ...common,
-                ...(yield* resolveConfiguredSubagent(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredSubagent(name, source, evaluation);
+                return buildInstallOperation(managers.subagent, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "rule":
-            return buildInstallOperation(managers.rule, {
-                ...common,
-                ...(yield* resolveConfiguredRule(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredRule(name, source, evaluation);
+                return buildInstallOperation(managers.rule, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "hook":
-            return buildInstallOperation(managers.hook, {
-                ...common,
-                ...(yield* resolveConfiguredHook(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredHook(name, source, evaluation);
+                return buildInstallOperation(managers.hook, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "knowledge":
-            return buildInstallOperation(managers.knowledge, {
-                ...common,
-                ...(yield* resolveConfiguredKnowledge(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredKnowledge(name, source, evaluation);
+                return buildInstallOperation(managers.knowledge, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
         case "pack":
-            return buildInstallOperation(managers.pack, {
-                ...common,
-                ...(yield* resolveConfiguredPack(name, source, evaluation)),
+            return yield* Effect.gen(function* () {
+                const resolved = yield* resolveConfiguredPack(name, source, evaluation);
+                return buildInstallOperation(managers.pack, {
+                    ...common,
+                    ...resolved,
+                    declaration: { name, versionRange: resolved.versionRange },
+                });
             });
     }
 });

package/dist/src/hooks/configured-agent-outcomes-provider.d.ts

@@ -1,8 +1,8 @@
 /**
- * Hook-backed implementation of the workspace-state
+ * Extension-manager-backed implementation of the workspace-state
  * `ConfiguredAgentOutcomesProvider` port.
  *
- * The plan pipeline consumes the port; the hook manager owns the effective
+ * The plan pipeline consumes the port; extension managers own the effective
  * per-agent outcome facts. Only the composition root sees both, so the
  * application wires this layer over the manager, supplying its own failure
  * serialization so plan resolutions embed byte-identical step failures on
@@ -17,6 +17,6 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import { ConfiguredAgentOutcomesProvider } from "@agentxm/workspace-state";
 import { StepFailureConversion } from "../step-failure-conversion.js";
-import { HookManager } from "@agentxm/extension-materialization";
-export declare const HookConfiguredAgentOutcomesProviderLive: Layer.Layer<ConfiguredAgentOutcomesProvider, never, StepFailureConversion | FileSystem.FileSystem | Path.Path | NativeWriteAuthority | HttpClient.HttpClient | HookManager>;
+import { HookManager, McpServerManager } from "@agentxm/extension-materialization";
+export declare const ConfiguredAgentOutcomesProviderLive: Layer.Layer<ConfiguredAgentOutcomesProvider, never, StepFailureConversion | FileSystem.FileSystem | Path.Path | NativeWriteAuthority | HttpClient.HttpClient | HookManager | McpServerManager>;
 //# sourceMappingURL=configured-agent-outcomes-provider.d.ts.map

package/dist/src/hooks/configured-agent-outcomes-provider.js

@@ -1,8 +1,8 @@
 /**
- * Hook-backed implementation of the workspace-state
+ * Extension-manager-backed implementation of the workspace-state
  * `ConfiguredAgentOutcomesProvider` port.
  *
- * The plan pipeline consumes the port; the hook manager owns the effective
+ * The plan pipeline consumes the port; extension managers own the effective
  * per-agent outcome facts. Only the composition root sees both, so the
  * application wires this layer over the manager, supplying its own failure
  * serialization so plan resolutions embed byte-identical step failures on
@@ -18,28 +18,34 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import { ConfiguredAgentOutcomesProvider, ConfiguredAgentOutcomesUnavailable, } from "@agentxm/workspace-state";
 import { StepFailureConversion } from "../step-failure-conversion.js";
-import { HookManager } from "@agentxm/extension-materialization";
-export const HookConfiguredAgentOutcomesProviderLive = Layer.effect(ConfiguredAgentOutcomesProvider, Effect.gen(function* () {
+import { HookManager, McpServerManager } from "@agentxm/extension-materialization";
+export const ConfiguredAgentOutcomesProviderLive = Layer.effect(ConfiguredAgentOutcomesProvider, Effect.gen(function* () {
     const adapter = yield* StepFailureConversion;
     const hookManager = yield* HookManager;
+    const mcpServerManager = yield* McpServerManager;
     // The provider's members answer with no requirements of their own, so this
     // layer is the boundary that composes what the manager needs.
     const managerLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, yield* FileSystem.FileSystem), Layer.succeed(Path.Path, yield* Path.Path), Layer.succeed(HttpClient.HttpClient, yield* HttpClient.HttpClient), Layer.succeed(NativeWriteAuthority, yield* NativeWriteAuthority));
-    const configuredAgentOutcomes = hookManager.configuredAgentOutcomes;
-    if (configuredAgentOutcomes === undefined) {
-        return { byExtensionType: {} };
-    }
+    const mapFailure = (failure) => {
+        const step = adapter.toStepFailure(failure);
+        return new ConfiguredAgentOutcomesUnavailable({
+            category: step.category,
+            detail: step.detail,
+            ...(step.suggestions === undefined ? {} : { suggestions: step.suggestions }),
+            ...(step.cause === undefined ? {} : { cause: step.cause }),
+        });
+    };
+    const configuredHookOutcomes = hookManager.configuredAgentOutcomes;
     return {
         byExtensionType: {
-            hook: (state) => configuredAgentOutcomes(state).pipe(Effect.provide(managerLayer), Effect.mapError((failure) => {
-                const step = adapter.toStepFailure(failure);
-                return new ConfiguredAgentOutcomesUnavailable({
-                    category: step.category,
-                    detail: step.detail,
-                    ...(step.suggestions === undefined ? {} : { suggestions: step.suggestions }),
-                    ...(step.cause === undefined ? {} : { cause: step.cause }),
-                });
-            })),
+            ...(configuredHookOutcomes === undefined
+                ? {}
+                : {
+                    hook: (state) => configuredHookOutcomes(state).pipe(Effect.provide(managerLayer), Effect.mapError(mapFailure)),
+                }),
+            "mcp-server": (state) => mcpServerManager
+                .configuredAgentOutcomes(state)
+                .pipe(Effect.provide(managerLayer), Effect.mapError(mapFailure)),
         },
     };
 }));

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

@@ -9,7 +9,8 @@
  */
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { HookManager, buildInstallOperation } from "@agentxm/extension-materialization";
+import { HookManager } from "@agentxm/extension-materialization";
+import { buildInstallOperation } from "@agentxm/workspace-reconciliation";
 import { parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
 import { HOOK_EXTENSION_DIR } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
 import { SourceHostProviders, resolveSource } from "@agentxm/extension-sources";
@@ -137,8 +138,10 @@ export const planHookInstall = Effect.fn("InstallExtensions.planHooks")(function
         const operation = buildInstallOperation(hookManager, {
             toStepFailure: lifecycleStepFailure,
             ref,
-            versionRange,
-            skipProjections: deferProjections,
+            declaration: { name: ref.hook.name, versionRange },
+            ...(deferProjections
+                ? { enclosingClosure: { projections: [ref.type], postconditions: [] } }
+                : {}),
             installedBefore: Effect.succeed(installedBefore),
             message: `Installed ${ref.hook.name}`,
             buildArtifact: ({ installedBefore }) => Effect.gen(function* () {

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

@@ -9,11 +9,12 @@
  */
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { HookManager, buildUninstallOperation } from "@agentxm/extension-materialization";
+import { HookManager } from "@agentxm/extension-materialization";
+import { buildUninstallOperation } from "@agentxm/workspace-reconciliation";
 import { WorkspaceMutations, acquiredExtensionDisplayPathFromLockEntry, } from "@agentxm/workspace-state";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { installRefused } from "../../install/vocabulary.js";
-import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { makeWorkspaceRetentionPolicy } from "@agentxm/workspace-reconciliation";
 import { workspaceCanonicalRoot, workspaceLockfilePath, workspaceSettingsPath, } from "../../workspace-paths.js";
 const hookUninstallArtifactTargets = (entry, retained, targetName, scope) => {
     if (Option.isNone(entry))
@@ -47,7 +48,7 @@ export const parseHookUninstallRequest = Effect.fn("UninstallExtensions.parseHoo
 export const planHookUninstall = Effect.fn("UninstallExtensions.planHooks")(function* (intent) {
     const ws = yield* WorkspaceMutations;
     const hookManager = yield* HookManager;
-    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws, lifecycleStepFailure);
     const steps = yield* Effect.forEach(intent.targets, (target) => Effect.gen(function* () {
         const lockEntry = yield* ws
             .getLockedHookEntry(target.name)

package/dist/src/index.d.ts

@@ -30,12 +30,11 @@ export { planRuleInstall } from "./rules/install/plan.js";
 export { planSkillInstall } from "./skills/install/plan.js";
 export { planSubagentInstall } from "./subagents/install/plan.js";
 export { BUNDLED_AXM_SKILL_AUTHORED_BLOCKER, BundledAxmSkillAsset, bundledAxmSkillCanonicalPath, inspectBundledAxmSkillReadiness, installBundledAxmSkill, type BundledAxmSkillAssetService, type BundledAxmSkillReadiness, type BundledAxmSkillSourceFile, } from "./skills/install/bundled.js";
-export { buildAtomicPackGraphStep, validatePackGraphPostcondition, type AtomicPackGraphChild, } from "./packs/graph-transition.js";
+export { validatePackGraphPostcondition } from "./packs/graph-transition.js";
 export { buildPackMemberInstallStep, type PackMemberRef } from "./packs/member-install-step.js";
 export { configuredPackConstraintBlockPlan, prospectivePackConstraintProblems, relevantPackConstraintProblems, } from "./packs/constraint-gate.js";
 export { UninstallExtensions, prepareUninstallExtensions, previewOrApplyUninstallExtensions, type PrepareUninstallRequirements, type UninstallExtensionsCandidate, type UninstallExtensionsFailure, type UninstallExtensionsRequest, } from "./uninstall/uninstall-extensions.js";
 export { resolveRootUninstallIntent, rootUninstallableTypeSegments, type RootUninstallIntent, type RootUninstallableType, } from "./uninstall/root-intent.js";
-export { exclusiveMemberRetentionPolicy, makeWorkspaceRetentionPolicy, } from "./uninstall/retention-policy.js";
 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";

package/dist/src/index.js

@@ -35,13 +35,12 @@ export { planSubagentInstall } from "./subagents/install/plan.js";
 // The bundled official AXM skill, and the asset port the application fills.
 export { BUNDLED_AXM_SKILL_AUTHORED_BLOCKER, BundledAxmSkillAsset, bundledAxmSkillCanonicalPath, inspectBundledAxmSkillReadiness, installBundledAxmSkill, } from "./skills/install/bundled.js";
 // Pack graph transitions: the atomic step and its desired-state predicate.
-export { buildAtomicPackGraphStep, validatePackGraphPostcondition, } from "./packs/graph-transition.js";
+export { validatePackGraphPostcondition } from "./packs/graph-transition.js";
 export { buildPackMemberInstallStep } from "./packs/member-install-step.js";
 export { configuredPackConstraintBlockPlan, prospectivePackConstraintProblems, relevantPackConstraintProblems, } from "./packs/constraint-gate.js";
 // Uninstall: withdrawing extensions, as one use case behind every spelling.
 export { UninstallExtensions, prepareUninstallExtensions, previewOrApplyUninstallExtensions, } from "./uninstall/uninstall-extensions.js";
 export { resolveRootUninstallIntent, rootUninstallableTypeSegments, } from "./uninstall/root-intent.js";
-export { exclusiveMemberRetentionPolicy, makeWorkspaceRetentionPolicy, } from "./uninstall/retention-policy.js";
 export { PACK_UNINSTALL_GRAPH_BLOCKER_ID, packUninstallRecoveryIdentifiers, planPackUninstallGraphReadiness, } from "./packs/uninstall/readiness.js";
 export {} from "./packs/uninstall/plan.js";
 // Skill lifecycle operations

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

@@ -2,8 +2,8 @@ import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import type { ExtensionLifecycleFailed } from "../errors.js";
 import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
-export declare const rootInstallableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[];
-export declare const RootInstallableTypeSegmentSchema: Schema.Literals<readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[]>;
+export declare const rootInstallableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "skills" | "subagents" | "packs" | "mcps")[];
+export declare const RootInstallableTypeSegmentSchema: Schema.Literals<readonly ("knowledge" | "rules" | "hooks" | "skills" | "subagents" | "packs" | "mcps")[]>;
 export type RootInstallableTypeSegment = typeof RootInstallableTypeSegmentSchema.Type;
 export type RootInstallableType = InstallableExtensionType;
 export interface RootInstallIntent {

package/dist/src/install/vocabulary.d.ts

@@ -15,7 +15,8 @@ import type * as Path from "effect/Path";
 import type * as Scope from "effect/Scope";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
 import type { NativeWriteAuthority } from "@agentxm/agent-integration";
-import type { ManagerRequirements, McpSecretStore, RecipeRequirements } from "@agentxm/extension-materialization";
+import type { ManagerRequirements, McpSecretStore } from "@agentxm/extension-materialization";
+import type { RecipeRequirements } from "@agentxm/workspace-reconciliation";
 import type { ExtensionName } from "@agentxm/extension-model/unstable/extensions";
 import type { HookExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/hook";
 import type { KnowledgeExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/knowledge";
@@ -29,8 +30,8 @@ import type { VersionRange } from "@agentxm/extension-model/unstable/version-con
 import type { ExtensionResolutionFailed, PackDependencyRefResolver } from "@agentxm/extension-resolution";
 import type { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
 import type { ApprovalRecoveryMissing, CandidateFingerprintFailed, OperationJournal, PlanInteractionFailed, ResolvePlanInteraction } from "@agentxm/workspace-operations";
-import type { CodingAgentRepository } from "@agentxm/workspace-projection";
-import type { AcceptedCanonicalRefError, ConfiguredAgentOutcomesProvider, LockfileValidationError, WorkspaceMutations, WorkspaceSettingsReadFailure, WorkspaceStateReadFailure } from "@agentxm/workspace-state";
+import type { CodingAgentRepository, WorkspaceInvariantFacts } from "@agentxm/workspace-projection";
+import type { AcceptedCanonicalRefError, ConfiguredAgentOutcomesProvider, LockfileValidationError, LockfileReader, WorkspaceMutations, WorkspaceSettingsReadFailure, WorkspaceStateReadFailure } from "@agentxm/workspace-state";
 import type { FootprintRecorder, WorkspaceTransactionScope, WorkspaceTransitionAcquireFailure } from "@agentxm/workspace-transactions";
 import { ExtensionLifecycleFailed } from "../errors.js";
 /**
@@ -41,7 +42,7 @@ import { ExtensionLifecycleFailed } from "../errors.js";
  * composed once at the application's runtime boundary; nothing is captured
  * into a step's closure on the way, and no failure adapter is among them.
  */
-export type InstallStepRequirements = ManagerRequirements | RecipeRequirements | McpSecretStore | CodingAgentRepository | WorkspaceMutations | NativeWriteAuthority;
+export type InstallStepRequirements = ManagerRequirements | RecipeRequirements | McpSecretStore | CodingAgentRepository | LockfileReader | WorkspaceInvariantFacts | WorkspaceMutations | NativeWriteAuthority;
 /**
  * What routing a source locator, probing configured registries, and reading
  * what a source contains all need.

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

@@ -9,7 +9,8 @@
  */
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { KnowledgeManager, extensionRefLifecycleWarnings, extensionRefRegistryLifecycle, targetFromRef, toLabelWithCompanions, toStepKey, } from "@agentxm/extension-materialization";
+import { KnowledgeManager } from "@agentxm/extension-materialization";
+import { extensionRefLifecycleWarnings, extensionRefRegistryLifecycle, targetFromRef, toLabelWithCompanions, toStepKey, } from "@agentxm/workspace-reconciliation";
 import { parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
 import { SourceHostProviders, resolveSource } from "@agentxm/extension-sources";
 import { operationPresentation, } from "@agentxm/workspace-operations";

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

@@ -12,14 +12,15 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
-import { KnowledgeManager, KnowledgeUnavailable, buildUninstallOperation, } from "@agentxm/extension-materialization";
+import { KnowledgeManager, KnowledgeUnavailable } from "@agentxm/extension-materialization";
+import { buildUninstallOperation } from "@agentxm/workspace-reconciliation";
 import { makeWorkspaceRelativePath } from "@agentxm/extension-model/unstable/path-types";
 import { resolveInstructionsConfig } from "@agentxm/workspace-projection";
 import { WorkspaceMutations, acceptedCanonicalObservation, computeExtensionPathsForLayout, extensionPathSourceFromLockEntry, } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 import { lifecycleStepFailure } from "../../step-failure.js";
 import { installRefused } from "../../install/vocabulary.js";
-import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { makeWorkspaceRetentionPolicy } from "@agentxm/workspace-reconciliation";
 const lockCanonicalRoot = (path, layout, locked) => computeExtensionPathsForLayout(path.join, layout, extensionPathSourceFromLockEntry(locked), "knowledge", locked.workspaceName).canonicalPath;
 /** Settle whether this Knowledge bundle has anything to remove. */
 export const parseKnowledgeUninstallRequest = Effect.fn("UninstallExtensions.parseKnowledgeRequest")(function* (selector) {
@@ -107,7 +108,7 @@ const inspectOwnership = Effect.fn("UninstallExtensions.inspectKnowledgeOwnershi
 export const planKnowledgeUninstall = Effect.fn("UninstallExtensions.planKnowledge")(function* (intent) {
     const ws = yield* WorkspaceMutations;
     const manager = yield* KnowledgeManager;
-    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws, lifecycleStepFailure);
     /** The accepted ownership fact, not on-disk presence, decides removability. */
     const isAcceptedTargetPresent = (target) => Effect.gen(function* () {
         const graph = yield* ws.getDesiredStateGraph();

package/dist/src/live.d.ts

@@ -7,5 +7,5 @@
  * @experimental All exports from this module are unstable and may change without notice.
  * @packageDocumentation
  */
-export { HookConfiguredAgentOutcomesProviderLive } from "./hooks/configured-agent-outcomes-provider.js";
+export { ConfiguredAgentOutcomesProviderLive } from "./hooks/configured-agent-outcomes-provider.js";
 //# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -7,5 +7,5 @@
  * @experimental All exports from this module are unstable and may change without notice.
  * @packageDocumentation
  */
-export { HookConfiguredAgentOutcomesProviderLive } from "./hooks/configured-agent-outcomes-provider.js";
+export { ConfiguredAgentOutcomesProviderLive } from "./hooks/configured-agent-outcomes-provider.js";
 //# sourceMappingURL=live.js.map

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

@@ -12,7 +12,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { installMcpServer } from "@agentxm/extension-materialization";
+import { installMcpServer } from "@agentxm/workspace-reconciliation";
 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";
@@ -287,8 +287,7 @@ export const planMcpServerInstall = Effect.fn("InstallExtensions.planMcpServer")
                                 localName: intent.localName,
                                 nonInteractive: intent.nonInteractive,
                                 force: intent.force,
-                                versionRange: intent.versionRange,
-                                skipSettings: Option.none(),
+                                declaration: { name: intent.localName, versionRange: intent.versionRange },
                                 env: Option.some(intent.env ?? {}),
                             },
                         }).pipe(Effect.mapError(lifecycleStepFailure)),

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

@@ -35,7 +35,7 @@ export const disableMcpServer = (op) => Effect.gen(function* () {
                 workspaceRoot: ws.baseDir,
                 scope: ws.scope,
                 serverName: op.args.serverName,
-                disableOnly: true,
+                disableOnly: false,
             }), { concurrency: "unbounded" });
             yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({
                 agentId: agent.id,

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

@@ -7,8 +7,8 @@ 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, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/workspace-projection";
-import { NativeWriteAuthority, syncInlineMcpServerToAgents } from "@agentxm/agent-integration";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
+import { NativeWriteAuthority, syncInlineMcpServerToAgents, syncManifestMcpServerToAgents, } from "@agentxm/agent-integration";
 import { normalizeHandle, parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
@@ -117,37 +117,22 @@ 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 agentIds = agents.map(({ id }) => id);
     const outcomes = yield* runWorkspaceTransaction({
         transition: Effect.gen(function* () {
-            const synced = yield* applyProjectionPlansWithResults(agents.map((agent) => planSingletonProjection({
-                unitId: "mcp-server:native-config-entry",
-                targetFile: "mcp:configured-agents",
-                contributor: op.args,
-                adapter: {
-                    observe: () => Effect.succeed({
-                        unitId: "mcp-server:native-config-entry",
-                        path: `${agent.id}:${op.args.serverName}`,
-                        present: false,
-                        current: false,
-                        expectedContributors: [op.args.serverName],
-                        observedContributors: [],
-                    }),
-                    apply: () => Effect.gen(function* () {
-                        return yield* agent.addMcpServer({
-                            workspaceRoot: ws.baseDir,
-                            scope: ws.scope,
-                            serverName: op.args.serverName,
-                            canonicalPath,
-                            owner,
-                            resolvedVersion,
-                            enabled: true,
-                            configValues: entry.env,
-                        });
-                    }),
-                },
-            })));
-            yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({
-                agentId: agent.id,
+            const synced = yield* syncManifestMcpServerToAgents({
+                agentIds,
+                workspaceRoot: ws.baseDir,
+                scope: ws.scope,
+                serverName: op.args.serverName,
+                canonicalPath,
+                owner,
+                resolvedVersion,
+                enabled: true,
+                configValues: entry.env,
+            });
+            yield* requireSuccessfulMcpSync(op.args.serverName, agentIds.map((agentId, index) => ({
+                agentId,
                 outcome: synced[index] ?? {
                     _tag: "failed",
                     reason: "Agent sync returned no outcome",
@@ -161,17 +146,17 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
         }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)),
         validate: () => Effect.void,
     });
-    const warnings = mcpSyncWarnings(op.args.serverName, agents.map((agent, index) => ({
-        agentId: agent.id,
+    const warnings = mcpSyncWarnings(op.args.serverName, agentIds.map((agentId, index) => ({
+        agentId,
         outcome: outcomes[index] ?? {
             _tag: "failed",
             reason: "Agent sync returned no outcome",
         },
     })));
-    const agentOutcomes = agents.flatMap((agent, index) => {
+    const agentOutcomes = agentIds.flatMap((agentId, index) => {
         const outcome = outcomes[index];
         return outcome !== undefined && "targets" in outcome
-            ? [{ agentId: agent.id, targets: outcome.targets }]
+            ? [{ agentId, targets: outcome.targets }]
             : [];
     });
     return {

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

@@ -18,7 +18,8 @@ import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { removeIfExists } from "@agentxm/workspace-state";
 import { acceptedCanonicalObservation, acceptedLockedCanonicalPath, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-import { agentConfigTarget, collectSecretInputNames, deleteMcpSecrets, mcpServerArtifact, mcpSettingsTarget, readMcpServerManifest, McpSecretStore, } from "@agentxm/extension-materialization";
+import { agentConfigTarget, mcpServerArtifact, mcpSettingsTarget, McpSecretStore, } from "@agentxm/extension-materialization";
+import { collectSecretInputNames, deleteMcpSecrets, readMcpServerManifest, } from "@agentxm/workspace-reconciliation";
 import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 const REQUIRED_AGENT_IDS = new Set([

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

@@ -13,11 +13,13 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
-import { McpServerManager, buildUninstallOperation, collectSecretInputNames, deleteMcpSecrets, mcpServerArtifact, mcpSourceTarget, readMcpServerManifest, } from "@agentxm/extension-materialization";
+import { McpServerManager, mcpServerArtifact, mcpSourceTarget, } from "@agentxm/extension-materialization";
+import { collectSecretInputNames, deleteMcpSecrets, readMcpServerManifest, } from "@agentxm/workspace-reconciliation";
+import { buildUninstallOperation } from "@agentxm/workspace-reconciliation";
 import { appendWarningsToMessage, } from "@agentxm/workspace-operations";
 import { WorkspaceMutations, acceptedLockedCanonicalPath, } from "@agentxm/workspace-state";
 import { lifecycleStepFailure } from "../../step-failure.js";
-import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { makeWorkspaceRetentionPolicy } from "@agentxm/workspace-reconciliation";
 import { workspaceLockfilePath, workspaceSettingsPath } from "../../workspace-paths.js";
 /** One local connection name is removed at a time. */
 export const parseMcpServerUninstallRequest = (selector) => ({
@@ -28,7 +30,7 @@ export const planMcpServerUninstall = Effect.fn("UninstallExtensions.planMcpServ
     const ws = yield* WorkspaceMutations;
     const mcpServerManager = yield* McpServerManager;
     const path = yield* Path.Path;
-    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws, lifecycleStepFailure);
     const steps = intent.targets.map((target) => {
         const step = buildUninstallOperation(mcpServerManager, retentionPolicy, {
             toStepFailure: lifecycleStepFailure,
@@ -63,7 +65,14 @@ export const planMcpServerUninstall = Effect.fn("UninstallExtensions.planMcpServ
                     onNone: () => new Set(),
                     onSome: collectSecretInputNames,
                 });
-                const secretDeletionWarnings = unchanged || desiredNode === undefined || desiredNode.authority === "inline"
+                const remaining = yield* ws
+                    .getDesiredStateGraph()
+                    .pipe(Effect.mapError(lifecycleStepFailure));
+                const remainsDesired = remaining.nodes.some((node) => node.type === "mcp-server" && node.name === target.name);
+                const secretDeletionWarnings = unchanged ||
+                    remainsDesired ||
+                    desiredNode === undefined ||
+                    desiredNode.authority === "inline"
                     ? []
                     : (yield* deleteMcpSecrets({
                         scopeRoot: path.resolve(ws.baseDir),

package/dist/src/packs/graph-transition.d.ts

@@ -11,32 +11,7 @@
  */
 import * as Effect from "effect/Effect";
 import { WorkspaceMutations, type DesiredExtensionNode } from "@agentxm/workspace-state";
-import { type JobStepArtifact, type PlannedJobStep } from "@agentxm/workspace-operations";
 import type { ExtensionLifecycleFailed } from "../errors.js";
-import { type LifecycleStepFailure } from "../step-failure.js";
-import { type InstallStepRequirements } from "../install/vocabulary.js";
-export interface AtomicPackGraphChild {
-    readonly step: PlannedJobStep<InstallStepRequirements>;
-    readonly coverage: "eligible" | "ineligible";
-}
-/**
- * What a pack transition checks before it writes and after it commits. The
- * checks are the planner's, so their failure family and their requirements
- * travel with them rather than being fixed here.
- */
-export interface AtomicPackGraphStepArgs<E extends LifecycleStepFailure, R> {
-    readonly label: string;
-    readonly message: string;
-    readonly artifact: JobStepArtifact;
-    readonly children: ReadonlyArray<AtomicPackGraphChild>;
-    readonly reportUnchangedWhenChildrenUnchanged?: boolean;
-    /** A stale-candidate check that runs under the transition, before any write. */
-    readonly preTransition?: Effect.Effect<void, E, R>;
-    /** The desired-graph predicate the committed transition must satisfy. */
-    readonly validate: Effect.Effect<void, E, R>;
-}
-/** Wrap a pack transition's children in one workspace transaction. */
-export declare const buildAtomicPackGraphStep: <E extends LifecycleStepFailure, R>(args: AtomicPackGraphStepArgs<E, R>) => Effect.Effect<PlannedJobStep<InstallStepRequirements | R>>;
 interface RequiredPack {
     readonly name: string;
     readonly identity: string;