@agentxm/extension-materialization 0.29.4 → 0.30.1

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

package/dist/src/testing.d.ts

@@ -1,71 +1,5 @@
-/**
- * In-memory materialization doubles for feature tests: a manager whose
- * surfaces are recorded rather than written, a retention policy that never
- * retains, and a structural serialization of a recipe's typed failure into the
- * plan-step vocabulary.
- *
- * These are deliberately behavioural, not mocks of a shape: a test asserts on
- * what the recorder observed, so a contract change that stops calling a
- * surface fails the test rather than passing silently.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { StepFailure } from "@agentxm/workspace-operations";
-import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
-import type { ExtensionTarget } from "@agentxm/workspace-state";
-import type { ExtensionManager, ManagerRequirements, MaterializationFacts } from "./manager-contract.js";
-import type { CallerStepFailure, UninstallRetentionPolicy } from "./extensions/operations.js";
 import { McpSecretStore } from "./mcps/secret-store.js";
-/** The manager surfaces one recipe touched, in the order it touched them. */
-export type RecordedManagerSurface = "materializeInstall" | "materializeUninstall" | "materializeDeactivate" | "upsertSettingsEntry" | "removeSettingsEntry" | "upsertLockfileEntry" | "removeLockfileEntry" | "listMaterializable" | "projectionPlans";
-/** What an in-memory manager observed while a recipe ran against it. */
-export interface RecordedManager<TRef extends ExtensionRef> {
-    readonly manager: ExtensionManager<TRef, MaterializationFacts, ManagerRequirements>;
-    /** Every surface the recipe touched, in call order. */
-    readonly surfaces: ReadonlyArray<RecordedManagerSurface>;
-    /** Targets currently declared in the recorder's settings. */
-    readonly configured: ReadonlySet<string>;
-    /** Targets currently observable as installed. */
-    readonly installed: ReadonlySet<string>;
-}
-/**
- * A materialization that observed nothing and acquired nothing. It satisfies
- * every per-type facts shape, so a feature test that never asserts on content
- * identity uses one value for any manager.
- */
-export declare const NO_MATERIALIZATION_FACTS: {
-    readonly observation: import("./manager-contract.js").MaterializationObservation;
-    readonly treeIntegrity: Option.Option<never>;
-    readonly sourceHash: Option.Option<never>;
-    readonly acquired: Option.Option<never>;
-    readonly removal: Option.Option<never>;
-};
-/**
- * A manager whose authoritative surfaces are in-memory sets. `materializable`
- * is what `listMaterializable` answers; anything installed through the
- * recorder becomes both configured and observable.
- */
-export declare const makeRecordedManager: <TRef extends ExtensionRef>(args: {
-    readonly type: TRef["type"];
-    readonly materializable: ReadonlyArray<TRef>;
-    /** Targets already installed and declared before the recipe runs. */
-    readonly installed?: ReadonlyArray<string>;
-}) => RecordedManager<TRef>;
-/** A retention policy that never retains a package for an installed Pack. */
-export declare const noUninstallRetention: UninstallRetentionPolicy;
-/** A retention policy that always retains, for the retained-by-pack settlement. */
-export declare const alwaysUninstallRetention: UninstallRetentionPolicy;
-/**
- * A structural serialization of a recipe's typed failure: the producing
- * family's own detail sentence under an `internal` category. Assertions bind
- * to this mapping, not to the application boundary's wording.
- */
-export declare const structuralStepFailure: <F>(failure: CallerStepFailure<F>) => StepFailure;
-/** A retention target's plan-step identity, for assertions on recorded steps. */
-export declare const recordedTargetName: (target: ExtensionTarget) => string;
 /** What an in-memory credential store recorded, and the layer that backs it. */
 export interface MemoryMcpSecretStore {
     readonly layer: Layer.Layer<McpSecretStore>;

package/dist/src/testing.js

@@ -1,96 +1,8 @@
-/**
- * In-memory materialization doubles for feature tests: a manager whose
- * surfaces are recorded rather than written, a retention policy that never
- * retains, and a structural serialization of a recipe's typed failure into the
- * plan-step vocabulary.
- *
- * These are deliberately behavioural, not mocks of a shape: a test asserts on
- * what the recorder observed, so a contract change that stops calling a
- * surface fails the test rather than passing silently.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
+/** Deterministic credential storage for materialization consumers. */
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import { StepFailure } from "@agentxm/workspace-operations";
-import { NO_MATERIALIZATION_OBSERVATION } from "./manager-contract.js";
-import { targetFromRef } from "./extensions/operations.js";
 import { McpSecretStore } from "./mcps/secret-store.js";
-/**
- * A materialization that observed nothing and acquired nothing. It satisfies
- * every per-type facts shape, so a feature test that never asserts on content
- * identity uses one value for any manager.
- */
-export const NO_MATERIALIZATION_FACTS = {
-    observation: NO_MATERIALIZATION_OBSERVATION,
-    treeIntegrity: Option.none(),
-    sourceHash: Option.none(),
-    acquired: Option.none(),
-    removal: Option.none(),
-};
-const NO_FACTS = NO_MATERIALIZATION_FACTS;
-/**
- * A manager whose authoritative surfaces are in-memory sets. `materializable`
- * is what `listMaterializable` answers; anything installed through the
- * recorder becomes both configured and observable.
- */
-export const makeRecordedManager = (args) => {
-    const surfaces = [];
-    const configured = new Set(args.installed ?? []);
-    const installed = new Set(args.installed ?? []);
-    const record = (surface, effect) => Effect.sync(() => surfaces.push(surface)).pipe(Effect.andThen(effect));
-    const manager = {
-        type: args.type,
-        isInstalled: ({ target }) => Effect.succeed(installed.has(target.name)),
-        materializeInstall: ({ ref }) => record("materializeInstall", Effect.sync(() => {
-            installed.add(targetFromRef(ref).name);
-            return NO_FACTS;
-        })),
-        materializeUninstall: ({ target }) => record("materializeUninstall", Effect.sync(() => {
-            installed.delete(target.name);
-            return NO_FACTS;
-        })),
-        materializeDeactivate: () => record("materializeDeactivate", Effect.succeed(NO_FACTS)),
-        getConfiguredSource: ({ target }) => Effect.succeed(configured.has(target.name) ? Option.some("workspace:") : Option.none()),
-        isConfigured: ({ target }) => Effect.succeed(configured.has(target.name)),
-        listMaterializable: () => record("listMaterializable", Effect.succeed(args.materializable)),
-        upsertSettingsEntry: ({ ref }) => record("upsertSettingsEntry", Effect.sync(() => {
-            configured.add(targetFromRef(ref).name);
-        })),
-        removeSettingsEntry: ({ target }) => record("removeSettingsEntry", Effect.sync(() => {
-            configured.delete(target.name);
-        })),
-        upsertLockfileEntry: () => record("upsertLockfileEntry", Effect.void),
-        removeLockfileEntry: () => record("removeLockfileEntry", Effect.void),
-    };
-    return { manager, surfaces, configured, installed };
-};
-/** A retention policy that never retains a package for an installed Pack. */
-export const noUninstallRetention = {
-    isRequiredByInstalledPack: () => Effect.succeed(false),
-};
-/** A retention policy that always retains, for the retained-by-pack settlement. */
-export const alwaysUninstallRetention = {
-    isRequiredByInstalledPack: () => Effect.succeed(true),
-};
-/**
- * A structural serialization of a recipe's typed failure: the producing
- * family's own detail sentence under an `internal` category. Assertions bind
- * to this mapping, not to the application boundary's wording.
- */
-export const structuralStepFailure = (failure) => {
-    const detail = typeof failure === "object" &&
-        failure !== null &&
-        "detail" in failure &&
-        typeof failure.detail === "string"
-        ? failure.detail
-        : String(failure);
-    return new StepFailure({ category: "internal", detail, cause: failure });
-};
-/** A retention target's plan-step identity, for assertions on recorded steps. */
-export const recordedTargetName = (target) => target.name;
 /**
  * An in-memory credential store for MCP install tests.
  *

package/package.json

@@ -4,16 +4,17 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.29.4",
-    "@agentxm/extension-content": "^0.29.4",
-    "@agentxm/extension-model": "^0.29.4",
-    "@agentxm/extension-resolution": "^0.29.4",
-    "@agentxm/extension-sources": "^0.29.4",
-    "@agentxm/registry-client": "^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",
+    "@agentxm/agent-integration": "^0.30.1",
+    "@agentxm/cli-maintenance": "^0.30.1",
+    "@agentxm/extension-content": "^0.30.1",
+    "@agentxm/extension-model": "^0.30.1",
+    "@agentxm/extension-resolution": "^0.30.1",
+    "@agentxm/extension-sources": "^0.30.1",
+    "@agentxm/registry-client": "^0.30.1",
+    "@agentxm/workspace-operations": "^0.30.1",
+    "@agentxm/workspace-projection": "^0.30.1",
+    "@agentxm/workspace-state": "^0.30.1",
+    "@agentxm/workspace-transactions": "^0.30.1",
     "@napi-rs/keyring": "^1.3.0",
     "effect": "4.0.0-rc.115"
   },
@@ -24,27 +25,23 @@
     "@fast-check/vitest": "^0.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^5.0.0",
-    "yaml": "^2.9.0"
+    "vitest": "^5.0.0"
   },
   "engines": {
     "node": ">=22.19.0"
   },
   "exports": {
     ".": {
-      "axm-source": "./src/index.ts",
-      "default": "./dist/src/index.js",
-      "types": "./dist/src/index.d.ts"
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
     },
     "./live": {
-      "axm-source": "./src/live.ts",
-      "default": "./dist/src/live.js",
-      "types": "./dist/src/live.d.ts"
+      "types": "./dist/src/live.d.ts",
+      "default": "./dist/src/live.js"
     },
     "./testing": {
-      "axm-source": "./src/testing.ts",
-      "default": "./dist/src/testing.js",
-      "types": "./dist/src/testing.d.ts"
+      "types": "./dist/src/testing.d.ts",
+      "default": "./dist/src/testing.js"
     }
   },
   "files": [
@@ -67,5 +64,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.4"
+  "version": "0.30.1"
 }

package/dist/src/desired-state/errors.d.ts

@@ -1,22 +0,0 @@
-/**
- * Failures deciding a retained re-materialization.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Schema from "effect/Schema";
-declare const RetainedContentUnusable_base: Schema.Class<RetainedContentUnusable, Schema.TaggedStruct<"RetainedContentUnusable", {
-    readonly extensionType: Schema.String;
-    readonly name: Schema.String;
-    /** The canonical observation status that made restoration impossible. */
-    readonly status: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/**
- * A retained transition asked to restore content the workspace accepted, and
- * that content is not usable. The transition refuses rather than re-resolving
- * the source, because re-acquiring is a different decision than restoring.
- */
-export declare class RetainedContentUnusable extends RetainedContentUnusable_base {
-    get detail(): string;
-}
-export {};
-//# sourceMappingURL=errors.d.ts.map

package/dist/src/desired-state/errors.js

@@ -1,22 +0,0 @@
-/**
- * Failures deciding a retained re-materialization.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Schema from "effect/Schema";
-/**
- * A retained transition asked to restore content the workspace accepted, and
- * that content is not usable. The transition refuses rather than re-resolving
- * the source, because re-acquiring is a different decision than restoring.
- */
-export class RetainedContentUnusable extends Schema.TaggedError()("RetainedContentUnusable", {
-    extensionType: Schema.String,
-    name: Schema.String,
-    /** The canonical observation status that made restoration impossible. */
-    status: Schema.String,
-}) {
-    get detail() {
-        return `Cannot rematerialize retained ${this.extensionType} ${this.name}: canonical content is ${this.status}`;
-    }
-}
-//# sourceMappingURL=errors.js.map