@agentxm/extension-materialization 0.29.2 → 0.30.1

package/dist/src/mcps/manager.js

@@ -1,3 +1,5 @@
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+import { LifecyclePostconditionViolated } from "../extensions/errors.js";
 /**
  * MCP server extension manager service.
  *
@@ -12,10 +14,10 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { McpInstallStateMissing, McpRegistryOnlyInstall } from "./errors.js";
-import { applyProjectionPlans, planSingletonProjection } from "@agentxm/workspace-projection";
+import { applyProjectionPlans, inspectMcpServerAcrossAgents, planSingletonProjection, } from "@agentxm/workspace-projection";
 import { McpConfigIoFailed, removeMcpServerFromManifest } from "@agentxm/agent-integration";
 import { NO_MATERIALIZATION_OBSERVATION } from "../manager-contract.js";
-import { McpServerManager } from "../managers.js";
+import { McpServerManager, } from "../managers.js";
 import { configuredMcpServersToDiskRefs } from "../extensions/materializable-from-disk.js";
 import { mcpRegistryResolutionKey, WorkspaceMutations } from "@agentxm/workspace-state";
 import { canReuseInstalledPackage } from "../extensions/canonical-directory.js";
@@ -159,12 +161,79 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
     });
     const materializeUninstall = makeMaterializeRemoval(false);
     const materializeDeactivate = makeMaterializeRemoval(true);
+    const configuredAgentOutcomesForEntry = Effect.fn("McpServerManager.configuredAgentOutcomesForEntry")(function* ({ name, entry, state, }) {
+        const configuredAgentIds = yield* ws.getConfiguredAgents();
+        const canonical = entry.kind === "inline"
+            ? Option.none()
+            : (yield* acceptedCanonicalObservation({
+                workspace: ws,
+                type: "mcp-server",
+                name,
+            })).pipe(Option.flatMap(({ observation }) => Option.fromUndefinedOr(observation.path)));
+        const inspections = yield* inspectMcpServerAcrossAgents({
+            workspaceRoot: baseDir,
+            scope: ws.scope,
+            agentIds: configuredAgentIds,
+            serverName: name,
+            entry: { ...entry, enabled: true },
+            canonicalPaths: Option.match(canonical, { onNone: () => [], onSome: (value) => [value] }),
+            state,
+        });
+        return inspections.map((inspection) => ({
+            extensionType: "mcp-server",
+            name,
+            agentId: inspection.agentId,
+            outcome: inspection.status === "match"
+                ? state
+                : inspection.status === "unsupported"
+                    ? "unsupported"
+                    : inspection.status === "blocked"
+                        ? "blocked"
+                        : "failed",
+            reasonCode: inspection.status === "match"
+                ? "supported"
+                : inspection.status === "absent"
+                    ? "projection-missing"
+                    : inspection.status === "drift"
+                        ? "stale-projection"
+                        : `mcp-${inspection.status}`,
+            reason: inspection.reason ??
+                (inspection.status === "match"
+                    ? `${inspection.agentId} has a matching MCP projection.`
+                    : inspection.status === "absent"
+                        ? `The expected ${inspection.agentId} projection is missing.`
+                        : inspection.status === "drift"
+                            ? `The expected ${inspection.agentId} projection is stale.`
+                            : `MCP projection status is ${inspection.status}.`),
+            ...(inspection.path.length === 0 ? {} : { path: inspection.path }),
+        }));
+    });
+    const configuredAgentOutcomes = (state) => Effect.gen(function* () {
+        const entries = yield* ws.getConfiguredMcpServerEntries();
+        return (yield* Effect.forEach(Object.entries(entries).filter(([, entry]) => state === "projected" || entry.enabled), ([name, entry]) => configuredAgentOutcomesForEntry({ name, entry, state }), { concurrency: "unbounded" })).flat();
+    });
     return {
         type: "mcp-server",
         isInstalled: Effect.fn("McpServerManager.isInstalled")(function* ({ target, }) {
             return yield* isObservedInstalled(ws, "mcp-server", target.name);
         }),
         materializeInstall,
+        acquireCanonical: materializeInstall,
+        materializeRetained: ({ target }) => Effect.gen(function* () {
+            const canonical = yield* usableAcceptedCanonical({
+                workspace: ws,
+                type: "mcp-server",
+                name: target.name,
+            });
+            if (Option.isNone(canonical) || canonical.value.ref.type !== "mcp-server") {
+                return yield* new LifecyclePostconditionViolated({
+                    postcondition: "materialize-observable",
+                    targetType: "mcp-server",
+                    targetName: target.name,
+                });
+            }
+            return yield* materializeInstall({ ref: canonical.value.ref });
+        }),
         prepareSourceTransition: ({ ref }) => prepareAcceptedCanonicalTransition({
             workspace: ws,
             type: "mcp-server",
@@ -187,9 +256,11 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
         }),
         materializeUninstall,
         materializeDeactivate,
-        upsertSettingsEntry: ({ ref, versionRange, materialization, }) => {
+        configuredAgentOutcomes,
+        configuredAgentOutcomesForEntry,
+        acceptedResolution: ({ ref, materialization, }) => {
             if (ref.refType !== "registry")
-                return Effect.void.pipe(Effect.withSpan("McpServerManager.upsertSettingsEntry"));
+                return Effect.succeed(Option.none());
             const registryRef = ref;
             return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
                 const treeIntegrity = materialization.pipe(Option.flatMap((facts) => facts.treeIntegrity));
@@ -197,56 +268,25 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
                     return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
                 }
                 const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity.value);
-                return ws.setMcpServer({
-                    name: ref.server.name,
-                    resolutionKey: mcpRegistryResolutionKey({
+                return Effect.succeed(Option.some({
+                    key: mcpRegistryResolutionKey({
                         authority: registryRef.source.location,
                         owner: registryRef.owner,
                         name: registryRef.server.name,
                     }),
-                    lockEntry,
-                    versionRange,
-                });
-            }), Effect.withSpan("McpServerManager.upsertSettingsEntry"));
-        },
-        removeSettingsEntry: ({ target }) => ws
-            .removeMcpServerSettings(target.name)
-            .pipe(Effect.withSpan("McpServerManager.removeSettingsEntry")),
-        upsertLockfileEntry: ({ ref, materialization, }) => {
-            if (ref.refType !== "registry")
-                return ws
-                    .removeMcpServerLock(ref.server.name)
-                    .pipe(Effect.withSpan("McpServerManager.upsertLockfileEntry"));
-            const registryRef = ref;
-            return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
-                const treeIntegrity = materialization.pipe(Option.flatMap((facts) => facts.treeIntegrity));
-                if (Option.isNone(treeIntegrity)) {
-                    return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
-                }
-                const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity.value);
-                return ws.setMcpServerLock({
-                    name: ref.server.name,
-                    resolutionKey: mcpRegistryResolutionKey({
-                        authority: registryRef.source.location,
-                        owner: registryRef.owner,
-                        name: registryRef.server.name,
-                    }),
-                    lockEntry,
-                    versionRange: Option.none(),
-                });
-            }), Effect.withSpan("McpServerManager.upsertLockfileEntry"));
+                    entry: lockEntry,
+                }));
+            }), Effect.withSpan("McpServerManager.acceptedResolution"));
         },
-        removeLockfileEntry: ({ materialization, }) => {
+        withdrawnResolutionKeys: ({ materialization, }) => {
             const removal = materialization.pipe(Option.flatMap((facts) => facts.removal));
             if (Option.isNone(removal)) {
-                return Effect.void.pipe(Effect.withSpan("McpServerManager.removeLockfileEntry"));
+                return Effect.succeed([]);
             }
             if (removal.value.retainShared || Option.isNone(removal.value.resolutionKey)) {
-                return Effect.void.pipe(Effect.withSpan("McpServerManager.removeLockfileEntry"));
+                return Effect.succeed([]);
             }
-            return ws
-                .removeMcpServerLock(removal.value.resolutionKey.value)
-                .pipe(Effect.withSpan("McpServerManager.removeLockfileEntry"));
+            return Effect.succeed([removal.value.resolutionKey.value]);
         },
     };
 }));

package/dist/src/packs/manager.js

@@ -1,3 +1,5 @@
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+import { LifecyclePostconditionViolated } from "../extensions/errors.js";
 /**
  * Pack manager service.
  *
@@ -145,6 +147,7 @@ export const PackManagerLive = Layer.effect(PackManager, Effect.gen(function* ()
             return yield* isObservedInstalled(ws, "pack", target.name);
         }),
         materializeInstall,
+        acquireCanonical: materializeInstall,
         prepareSourceTransition: ({ ref }) => prepareAcceptedCanonicalTransition({
             workspace: ws,
             type: "pack",
@@ -161,29 +164,29 @@ export const PackManagerLive = Layer.effect(PackManager, Effect.gen(function* ()
         }),
         materializeUninstall,
         materializeDeactivate,
-        upsertSettingsEntry: Effect.fn("PackManager.upsertSettingsEntry")(function* ({ ref, versionRange, materialization, }) {
-            const args = yield* buildCurrentPackArgs(ref, versionRange, materialization);
-            if (Option.isSome(args)) {
-                yield* ws.setPack(args.value);
-            }
-            else {
-                yield* ws.setPackEntry(ref.pack.name, {
-                    source: "workspace",
-                    enabled: true,
+        materializeRetained: ({ target }) => Effect.gen(function* () {
+            const canonical = yield* usableAcceptedCanonical({
+                workspace: ws,
+                type: "pack",
+                name: target.name,
+            });
+            if (Option.isNone(canonical) || canonical.value.ref.type !== "pack") {
+                return yield* new LifecyclePostconditionViolated({
+                    postcondition: "materialize-observable",
+                    targetType: "pack",
+                    targetName: target.name,
                 });
             }
+            return yield* materializeDeactivate({ target });
         }),
-        removeSettingsEntry: ({ target }) => ws.removePackSettings(target.name).pipe(Effect.withSpan("PackManager.removeSettingsEntry")),
-        upsertLockfileEntry: Effect.fn("PackManager.upsertLockfileEntry")(function* ({ ref, materialization, }) {
+        acceptedResolution: Effect.fn("PackManager.acceptedResolution")(function* ({ ref, materialization, }) {
             const args = yield* buildCurrentPackArgs(ref, Option.none(), materialization);
-            if (Option.isSome(args)) {
-                yield* ws.setPackLock(args.value);
-            }
-            else {
-                yield* ws.removePackLock(ref.pack.name);
-            }
+            return Option.map(args, ({ versionRange: _versionRange, ...entry }) => ({
+                key: ref.pack.name,
+                entry,
+            }));
         }),
-        removeLockfileEntry: ({ target }) => ws.removePackLock(target.name).pipe(Effect.withSpan("PackManager.removeLockfileEntry")),
+        withdrawnResolutionKeys: ({ target }) => Effect.succeed([target.name]),
     };
 }));
 //# sourceMappingURL=manager.js.map

package/dist/src/rules/manager.d.ts

@@ -1,8 +1,3 @@
-/**
- * Rule manager service.
- *
- * @experimental This API is unstable and may change without notice.
- */
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";

package/dist/src/rules/manager.js

@@ -1,3 +1,5 @@
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+import { LifecyclePostconditionViolated } from "../extensions/errors.js";
 /**
  * Rule manager service.
  *
@@ -424,6 +426,22 @@ export const RuleManagerLive = Layer.effect(RuleManager, Effect.gen(function* ()
         aggregateProjectionObservation: Ref.get(lastProjection),
         isInstalled: ({ target }) => isObservedInstalled(ws, "rule", target.name).pipe(Effect.withSpan("RuleManager.isInstalled")),
         materializeInstall,
+        acquireCanonical: materializeInstall,
+        materializeRetained: ({ target }) => Effect.gen(function* () {
+            const canonical = yield* usableAcceptedCanonical({
+                workspace: ws,
+                type: "rule",
+                name: target.name,
+            });
+            if (Option.isNone(canonical) || canonical.value.ref.type !== "rule") {
+                return yield* new LifecyclePostconditionViolated({
+                    postcondition: "materialize-observable",
+                    targetType: "rule",
+                    targetName: target.name,
+                });
+            }
+            return yield* materializeInstall({ ref: canonical.value.ref });
+        }),
         prepareSourceTransition: ({ ref }) => provide(prepareAcceptedCanonicalTransition({
             workspace: ws,
             type: "rule",
@@ -448,45 +466,17 @@ export const RuleManagerLive = Layer.effect(RuleManager, Effect.gen(function* ()
         }),
         materializeUninstall,
         materializeDeactivate,
-        upsertSettingsEntry: Effect.fn("RuleManager.upsertSettingsEntry")(function* ({ ref, versionRange, materialization, }) {
-            const lockEntry = yield* buildLockEntry(ref, materialization);
-            if (Option.isNone(lockEntry)) {
-                yield* ws.setRuleEntry(ref.rule.name, {
-                    source: "workspace",
-                    enabled: true,
-                });
-                return;
-            }
-            if (lockEntry.value.type === "registry") {
-                yield* validateExactResolvedVersion(`rules.${ref.rule.name}.resolvedVersion`, lockEntry.value.resolvedVersion);
-            }
-            yield* ws.setRule({
-                name: ref.rule.name,
-                lockEntry: lockEntry.value,
-                versionRange,
-            });
-        }),
-        removeSettingsEntry: Effect.fn("RuleManager.removeSettingsEntry")(function* ({ target }) {
-            yield* ws.removeRuleSettings(target.name);
-        }),
-        upsertLockfileEntry: Effect.fn("RuleManager.upsertLockfileEntry")(function* ({ ref, materialization, }) {
+        acceptedResolution: Effect.fn("RuleManager.acceptedResolution")(function* ({ ref, materialization, }) {
             const lockEntry = yield* buildLockEntry(ref, materialization);
             if (Option.isNone(lockEntry)) {
-                yield* ws.removeRuleLock(ref.rule.name);
-                return;
+                return Option.none();
             }
             if (lockEntry.value.type === "registry") {
                 yield* validateExactResolvedVersion(`rules.${ref.rule.name}.resolvedVersion`, lockEntry.value.resolvedVersion);
             }
-            yield* ws.setRuleLock({
-                name: ref.rule.name,
-                lockEntry: lockEntry.value,
-                versionRange: Option.none(),
-            });
-        }),
-        removeLockfileEntry: Effect.fn("RuleManager.removeLockfileEntry")(function* ({ target }) {
-            yield* ws.removeRuleLock(target.name);
+            return Option.some({ key: ref.rule.name, entry: lockEntry.value });
         }),
+        withdrawnResolutionKeys: ({ target }) => Effect.succeed([target.name]),
     };
 }));
 //# sourceMappingURL=manager.js.map

package/dist/src/skills/errors.d.ts

@@ -5,7 +5,8 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-import type { AxmSkillCompatibilityUnavailable, AxmSkillIncompatible } from "@agentxm/extension-resolution";
+import type { AxmSkillCompatibilityUnavailable } from "@agentxm/cli-maintenance/official-skill/application";
+import type { AxmSkillIncompatible } from "@agentxm/cli-maintenance/official-skill/domain";
 declare const SkillDefinitionInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "SkillDefinitionInvalid";
 } & Readonly<A>;

package/dist/src/skills/manager.js

@@ -1,3 +1,5 @@
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+import { LifecyclePostconditionViolated } from "../extensions/errors.js";
 /**
  * Skill extension manager service.
  *
@@ -216,6 +218,45 @@ export const SkillManagerLive = Layer.effect(SkillManager, Effect.gen(function*
             return yield* isObservedInstalled(ws, "skill", target.name);
         }),
         materializeInstall,
+        acquireCanonical: ({ ref, force }) => Effect.gen(function* () {
+            const locked = yield* ws.getLockedSkill(ref.skill.name);
+            const materialized = yield* materializeSkillCanonical({
+                ref,
+                sanitizedName: sanitizeName(ref.skill.name),
+                baseDir,
+                layout: ws.layout,
+                reuse: {
+                    force: force === true,
+                    lockedVersion: ref.refType === "registry" ? acceptedRegistryVersionForRef(locked, ref) : undefined,
+                    lockedTreeIntegrity: Option.isSome(locked) ? locked.value.treeIntegrity : undefined,
+                },
+            });
+            const sourceHash = ref.refType === "workspace"
+                ? ref.sourceHash
+                : ref.refType === "registry"
+                    ? yield* computePackageContentHash(path.dirname(materialized.skillSrcPath))
+                    : yield* computeSkillSourceHash(materialized.skillSrcPath);
+            return {
+                sourceHash: Option.some(sourceHash),
+                treeIntegrity: Option.fromUndefinedOr(materialized.treeIntegrity),
+                observation: { agents: [], targets: [] },
+            };
+        }),
+        materializeRetained: ({ target }) => Effect.gen(function* () {
+            const canonical = yield* usableAcceptedCanonical({
+                workspace: ws,
+                type: "skill",
+                name: target.name,
+            });
+            if (Option.isNone(canonical) || canonical.value.ref.type !== "skill") {
+                return yield* new LifecyclePostconditionViolated({
+                    postcondition: "materialize-observable",
+                    targetType: "skill",
+                    targetName: target.name,
+                });
+            }
+            return yield* materializeInstall({ ref: canonical.value.ref });
+        }),
         prepareSourceTransition: ({ ref }) => prepareAcceptedCanonicalTransition({
             workspace: ws,
             type: "skill",
@@ -249,49 +290,7 @@ export const SkillManagerLive = Layer.effect(SkillManager, Effect.gen(function*
         }),
         materializeUninstall,
         materializeDeactivate,
-        upsertSettingsEntry: Effect.fn("SkillManager.upsertSettingsEntry")(function* ({ ref, versionRange, materialization, }) {
-            const workspaceRelativeLocalSourcePath = ref.refType === "local"
-                ? makeWorkspaceRelativeSourcePath(path, baseDir, ref.sourcePath ?? stripFileProtocol(ref.location))
-                : Option.none();
-            if (ref.refType === "local" && Option.isNone(workspaceRelativeLocalSourcePath)) {
-                return yield* new SkillDefinitionInvalid({
-                    detail: `Local skill source path must stay within the workspace root: ${ref.source.path}`,
-                });
-            }
-            const sourceHash = Option.getOrUndefined(materialization.pipe(Option.flatMap((facts) => facts.sourceHash)));
-            const treeIntegrity = Option.getOrUndefined(materialization.pipe(Option.flatMap((facts) => facts.treeIntegrity)));
-            if (ref.refType === "workspace") {
-                return yield* ws.setSkillEntry(ref.skill.name, {
-                    source: "workspace",
-                    enabled: true,
-                });
-            }
-            if (sourceHash === undefined || treeIntegrity === undefined) {
-                return yield* new SkillInstallStateMissing({
-                    name: ref.skill.name,
-                    kind: "content-identity",
-                });
-            }
-            const lockEntry = buildSkillLockEntry(ref, workspaceRelativeLocalSourcePath, sourceHash, treeIntegrity);
-            if (lockEntry === undefined) {
-                return yield* new SkillInstallStateMissing({
-                    name: ref.skill.name,
-                    kind: "external-resolution",
-                });
-            }
-            if (lockEntry.type === "registry") {
-                yield* validateExactResolvedVersion(`skills.${ref.skill.name}.resolvedVersion`, lockEntry.resolvedVersion);
-            }
-            return yield* ws.setSkill({
-                name: ref.skill.name,
-                lockEntry,
-                versionRange,
-            });
-        }),
-        removeSettingsEntry: ({ target }) => ws
-            .removeSkillFromSettings(target.name)
-            .pipe(Effect.withSpan("SkillManager.removeSettingsEntry")),
-        upsertLockfileEntry: Effect.fn("SkillManager.upsertLockfileEntry")(function* ({ ref, materialization, }) {
+        acceptedResolution: Effect.fn("SkillManager.acceptedResolution")(function* ({ ref, materialization, }) {
             const workspaceRelativeLocalSourcePath = ref.refType === "local"
                 ? makeWorkspaceRelativeSourcePath(path, baseDir, ref.sourcePath ?? stripFileProtocol(ref.location))
                 : Option.none();
@@ -301,8 +300,7 @@ export const SkillManagerLive = Layer.effect(SkillManager, Effect.gen(function*
                 });
             }
             if (ref.refType === "workspace") {
-                yield* ws.removeSkillLock(ref.skill.name);
-                return;
+                return Option.none();
             }
             const sourceHash = Option.getOrUndefined(materialization.pipe(Option.flatMap((facts) => facts.sourceHash)));
             const treeIntegrity = Option.getOrUndefined(materialization.pipe(Option.flatMap((facts) => facts.treeIntegrity)));
@@ -322,15 +320,9 @@ export const SkillManagerLive = Layer.effect(SkillManager, Effect.gen(function*
             if (lockEntry.type === "registry") {
                 yield* validateExactResolvedVersion(`skills.${ref.skill.name}.resolvedVersion`, lockEntry.resolvedVersion);
             }
-            return yield* ws.setSkillLock({
-                name: ref.skill.name,
-                lockEntry,
-                versionRange: Option.none(),
-            });
+            return Option.some({ key: ref.skill.name, entry: lockEntry });
         }),
-        removeLockfileEntry: ({ target }) => ws
-            .removeSkillLock(target.name)
-            .pipe(Effect.withSpan("SkillManager.removeLockfileEntry")),
+        withdrawnResolutionKeys: ({ target }) => Effect.succeed([target.name]),
     };
 }));
 // -----------------------------------------------------------------------------

package/dist/src/skills/materialization.d.ts

@@ -35,10 +35,10 @@ export declare const materializeSkillCanonical: (args: {
 }) => Effect.Effect<{
     skillSrcPath: string & import("effect/Brand").Brand<"AbsolutePath">;
     treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
-}, import("../index.ts").CanonicalPackageProbeFailed | import("../index.ts").PackageCopyFailed | import("@agentxm/extension-resolution").AxmSkillCompatibilityUnavailable | import("@agentxm/extension-resolution").AxmSkillIncompatible | import("@agentxm/workspace-state").MaterializedTreeInvalid | import("../extensions/canonical-directory.js").CanonicalDirectoryReplacementError, FileSystem.FileSystem | Path.Path> | Effect.Effect<{
+}, import("../index.ts").CanonicalPackageProbeFailed | import("../index.ts").PackageCopyFailed | import("@agentxm/cli-maintenance/official-skill/application").AxmSkillCompatibilityUnavailable | import("@agentxm/cli-maintenance/official-skill/domain").AxmSkillIncompatible | import("@agentxm/workspace-state").MaterializedTreeInvalid | import("../extensions/canonical-directory.js").CanonicalDirectoryReplacementError, FileSystem.FileSystem | Path.Path> | Effect.Effect<{
     skillSrcPath: string & import("effect/Brand").Brand<"AbsolutePath">;
     treeIntegrity: string & import("effect/Brand").Brand<"TreeIntegrity">;
-}, import("../index.ts").CanonicalPackageProbeFailed | import("../index.ts").ArchiveIntegrityMismatch | import("@agentxm/extension-resolution").AxmSkillCompatibilityUnavailable | import("@agentxm/extension-resolution").AxmSkillIncompatible | import("@agentxm/workspace-state").MaterializedTreeInvalid | import("@agentxm/registry-client").RegistryClientFailure | import("../extensions/canonical-directory.js").CanonicalDirectoryReplacementError, FileSystem.FileSystem | Path.Path | import("effect/unstable/http/HttpClient").HttpClient> | Effect.Effect<MaterializedSkillCanonical, import("@agentxm/workspace-state").PathTraversalDetected | import("@agentxm/extension-resolution").AxmSkillCompatibilityUnavailable | import("@agentxm/extension-resolution").AxmSkillIncompatible, FileSystem.FileSystem | Path.Path>;
+}, import("../index.ts").CanonicalPackageProbeFailed | import("../index.ts").ArchiveIntegrityMismatch | import("@agentxm/cli-maintenance/official-skill/application").AxmSkillCompatibilityUnavailable | import("@agentxm/cli-maintenance/official-skill/domain").AxmSkillIncompatible | import("@agentxm/workspace-state").MaterializedTreeInvalid | import("@agentxm/registry-client").RegistryClientFailure | import("../extensions/canonical-directory.js").CanonicalDirectoryReplacementError, FileSystem.FileSystem | Path.Path | import("effect/unstable/http/HttpClient").HttpClient> | Effect.Effect<MaterializedSkillCanonical, import("@agentxm/workspace-state").PathTraversalDetected | import("@agentxm/cli-maintenance/official-skill/application").AxmSkillCompatibilityUnavailable | import("@agentxm/cli-maintenance/official-skill/domain").AxmSkillIncompatible, FileSystem.FileSystem | Path.Path>;
 export declare const ensureSkillAgentArtifact: (args: {
     readonly canonicalSkillSrcPath: string;
     readonly targetDir: string;

package/dist/src/skills/skill-artifact.d.ts

@@ -29,7 +29,11 @@ export declare const skillArtifactFromTargets: (args: {
     readonly change: JobStepArtifact["change"];
     readonly workspaceTargets?: ReadonlyArray<JobStepArtifactTarget>;
 }) => Effect.Effect<{
-    targets?: JobStepArtifactTarget[];
+    targets?: (JobStepArtifactTarget | {
+        agentIds?: readonly string[];
+        path: string;
+        change: "created" | "updated" | "removed" | "unchanged";
+    })[];
     path: string;
     scope: "project" | "user";
     agents: readonly string[];

package/dist/src/subagents/manager.js

@@ -1,3 +1,5 @@
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+import { LifecyclePostconditionViolated } from "../extensions/errors.js";
 /**
  * Subagent extension manager service.
  *
@@ -633,6 +635,31 @@ export const SubagentManagerLive = Layer.effect(SubagentManager, Effect.gen(func
             return yield* isObservedInstalled(ws, "subagent", target.name);
         }),
         materializeInstall,
+        acquireCanonical: ({ ref, force }) => Effect.gen(function* () {
+            const { sanitized, paths: { canonicalPath, subagentSrcPath }, } = getCanonicalPaths(ref);
+            const treeIntegrity = yield* materializeCanonical(ref, sanitized, canonicalPath, subagentSrcPath, force === true);
+            yield* readSubagentContent(subagentSrcPath, ref.subagent.name);
+            return {
+                sourceHash: Option.some(yield* computePackageContentHash(canonicalPath)),
+                treeIntegrity: Option.fromUndefinedOr(treeIntegrity),
+                observation: { agents: [], targets: [] },
+            };
+        }),
+        materializeRetained: ({ target }) => Effect.gen(function* () {
+            const canonical = yield* usableAcceptedCanonical({
+                workspace: ws,
+                type: "subagent",
+                name: target.name,
+            });
+            if (Option.isNone(canonical) || canonical.value.ref.type !== "subagent") {
+                return yield* new LifecyclePostconditionViolated({
+                    postcondition: "materialize-observable",
+                    targetType: "subagent",
+                    targetName: target.name,
+                });
+            }
+            return yield* materializeInstall({ ref: canonical.value.ref });
+        }),
         prepareSourceTransition: ({ ref }) => prepareAcceptedCanonicalTransition({
             workspace: ws,
             type: "subagent",
@@ -651,7 +678,7 @@ export const SubagentManagerLive = Layer.effect(SubagentManager, Effect.gen(func
         }),
         materializeUninstall,
         materializeDeactivate,
-        upsertSettingsEntry: Effect.fn("SubagentManager.upsertSettingsEntry")(function* ({ ref, versionRange, materialization, }) {
+        acceptedResolution: Effect.fn("SubagentManager.acceptedResolution")(function* ({ ref, materialization, }) {
             const workspaceRelativeLocalSourcePath = ref.refType === "local"
                 ? makeWorkspaceRelativeSourcePath(path, baseDir, ref.sourcePath ?? stripFileProtocol(ref.location))
                 : Option.none();
@@ -660,50 +687,8 @@ export const SubagentManagerLive = Layer.effect(SubagentManager, Effect.gen(func
                     detail: `Local subagent source path must stay within the workspace root: ${ref.source.path}`,
                 });
             }
-            const state = acquiredState(materialization);
             if (ref.refType === "workspace") {
-                return yield* ws.setSubagentEntry(ref.subagent.name, {
-                    source: "workspace",
-                    enabled: true,
-                });
-            }
-            if (state === undefined) {
-                return yield* new SubagentInstallStateMissing({
-                    name: ref.subagent.name,
-                    kind: "content-identity",
-                });
-            }
-            const lockEntry = buildSubagentLockEntry(ref, state.sourceHash, state.treeIntegrity, workspaceRelativeLocalSourcePath);
-            if (lockEntry === undefined) {
-                return yield* new SubagentInstallStateMissing({
-                    name: ref.subagent.name,
-                    kind: "external-resolution",
-                });
-            }
-            if (lockEntry.type === "registry") {
-                yield* validateExactResolvedVersion(`subagents.${ref.subagent.name}.resolvedVersion`, lockEntry.resolvedVersion);
-            }
-            return yield* ws.setSubagent({
-                name: ref.subagent.name,
-                lockEntry,
-                versionRange,
-            });
-        }),
-        removeSettingsEntry: ({ target }) => ws
-            .removeSubagentSettings(target.name)
-            .pipe(Effect.withSpan("SubagentManager.removeSettingsEntry")),
-        upsertLockfileEntry: Effect.fn("SubagentManager.upsertLockfileEntry")(function* ({ ref, materialization, }) {
-            const workspaceRelativeLocalSourcePath = ref.refType === "local"
-                ? makeWorkspaceRelativeSourcePath(path, baseDir, ref.sourcePath ?? stripFileProtocol(ref.location))
-                : Option.none();
-            if (ref.refType === "local" && Option.isNone(workspaceRelativeLocalSourcePath)) {
-                return yield* new SubagentDefinitionInvalid({
-                    detail: `Local subagent source path must stay within the workspace root: ${ref.source.path}`,
-                });
-            }
-            if (ref.refType === "workspace") {
-                yield* ws.removeSubagentLock(ref.subagent.name);
-                return;
+                return Option.none();
             }
             const state = acquiredState(materialization);
             if (state === undefined) {
@@ -722,15 +707,9 @@ export const SubagentManagerLive = Layer.effect(SubagentManager, Effect.gen(func
             if (lockEntry.type === "registry") {
                 yield* validateExactResolvedVersion(`subagents.${ref.subagent.name}.resolvedVersion`, lockEntry.resolvedVersion);
             }
-            return yield* ws.setSubagentLock({
-                name: ref.subagent.name,
-                lockEntry,
-                versionRange: Option.none(),
-            });
+            return Option.some({ key: ref.subagent.name, entry: lockEntry });
         }),
-        removeLockfileEntry: ({ target }) => ws
-            .removeSubagentLock(target.name)
-            .pipe(Effect.withSpan("SubagentManager.removeLockfileEntry")),
+        withdrawnResolutionKeys: ({ target }) => Effect.succeed([target.name]),
     };
 }));
 //# sourceMappingURL=manager.js.map