@agentxm/extension-lifecycle 0.29.1 → 0.29.4

package/dist/src/activation/set-activation.js

@@ -188,9 +188,17 @@ export const prepareSetActivation = (request) => Effect.gen(function* () {
             if (entry === undefined) {
                 return unchanged(request, request.name, `MCP server "${request.name}" is not configured`);
             }
-            if (entry.enabled === request.enabled) {
+            if (!request.enabled && entry.enabled === request.enabled) {
                 return unchanged(request, request.name, `MCP server "${request.name}" is already ${verb}`);
             }
+            const managers = yield* ExtensionManagers;
+            const agentOutcomes = request.enabled
+                ? yield* managers["mcp-server"].configuredAgentOutcomesForEntry({
+                    name: request.name,
+                    entry,
+                    state: "projected",
+                })
+                : [];
             return {
                 _tag: "SetActivation",
                 type: "mcp-server",
@@ -202,7 +210,7 @@ export const prepareSetActivation = (request) => Effect.gen(function* () {
                 instructions: Option.none(),
                 blocked: Option.none(),
                 warning: Option.none(),
-                agentOutcomes: [],
+                agentOutcomes,
             };
         }
         case "rule": {
@@ -424,7 +432,7 @@ const dematerializeMember = (node) => Effect.gen(function* () {
                 workspaceRoot: ws.baseDir,
                 scope: ws.scope,
                 serverName: node.name,
-                disableOnly: true,
+                disableOnly: false,
             })
                 .pipe(Effect.flatMap((outcome) => outcome._tag === "disabled" ||
                 outcome._tag === "nothing-runnable" ||
@@ -617,7 +625,12 @@ const executorStep = (candidate, kind) => {
             : candidate.enabled
                 ? enableMcpServer({ name: "enable-mcp-server", args: { serverName: candidate.name } })
                 : disableMcpServer({ name: "disable-mcp-server", args: { serverName: candidate.name } });
-    return { label: candidate.name, readiness: "ready", run };
+    return {
+        label: candidate.name,
+        readiness: "ready",
+        ...(candidate.agentOutcomes.length === 0 ? {} : { agentOutcomes: candidate.agentOutcomes }),
+        run,
+    };
 };
 /**
  * The step for a type whose transition this use case composes itself: the

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/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/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/package.json

@@ -4,31 +4,32 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.29.1",
-    "@agentxm/extension-content": "^0.29.1",
-    "@agentxm/extension-materialization": "^0.29.1",
-    "@agentxm/extension-model": "^0.29.1",
-    "@agentxm/extension-resolution": "^0.29.1",
-    "@agentxm/extension-sources": "^0.29.1",
-    "@agentxm/registry-auth": "^0.29.1",
-    "@agentxm/registry-client": "^0.29.1",
-    "@agentxm/registry-protocol": "^0.29.1",
-    "@agentxm/workspace-operations": "^0.29.1",
-    "@agentxm/workspace-projection": "^0.29.1",
-    "@agentxm/workspace-state": "^0.29.1",
-    "@agentxm/workspace-transactions": "^0.29.1",
+    "@agentxm/agent-integration": "^0.29.4",
+    "@agentxm/extension-content": "^0.29.4",
+    "@agentxm/extension-materialization": "^0.29.4",
+    "@agentxm/extension-model": "^0.29.4",
+    "@agentxm/extension-resolution": "^0.29.4",
+    "@agentxm/extension-sources": "^0.29.4",
+    "@agentxm/registry-auth": "^0.29.4",
+    "@agentxm/registry-client": "^0.29.4",
+    "@agentxm/registry-protocol": "^0.29.4",
+    "@agentxm/workspace-operations": "^0.29.4",
+    "@agentxm/workspace-projection": "^0.29.4",
+    "@agentxm/workspace-state": "^0.29.4",
+    "@agentxm/workspace-transactions": "^0.29.4",
     "@napi-rs/keyring": "^1.3.0",
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.115",
     "fflate": "^0.8.3"
   },
   "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.",
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/vitest": "4.0.0-rc.112",
+    "@effect/platform-node": "4.0.0-rc.115",
+    "@effect/vitest": "4.0.0-rc.115",
+    "@fast-check/vitest": "^0.5.0",
     "@types/bun": "^1.3.14",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.10",
+    "vitest": "^5.0.0",
     "yaml": "^2.9.0"
   },
   "engines": {
@@ -71,5 +72,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.1"
+  "version": "0.29.4"
 }