@agentxm/extension-materialization 0.28.14-preview.1789139351.5cd4595aa

package/dist/src/packs/manager.js

@@ -0,0 +1,189 @@
+/**
+ * Pack manager service.
+ *
+ * Implements ExtensionManager<PackRef>. Delegates to existing
+ * pack materialization functions and workspace service methods.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { PackArchiveFetchFailed, PackDefinitionInvalid, PackInstallStateMissing, PackStagingFailed, } from "./errors.js";
+import { canReuseInstalledPackage, replaceCanonicalDirectoryWithInspection, } from "../extensions/canonical-directory.js";
+import { configuredPacksToDiskRefs } from "../extensions/materializable-from-disk.js";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { NO_MATERIALIZATION_OBSERVATION } from "../manager-contract.js";
+import { PackManager } from "../managers.js";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { copyExtensionDirectory } from "../extensions/copy-directory.js";
+import { computePackPathsForLayout } from "@agentxm/workspace-state";
+import { removeIfExists } from "@agentxm/workspace-state";
+import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
+import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
+import { configuredRowsByName } from "@agentxm/workspace-state";
+import { isObservedInstalled } from "@agentxm/workspace-state";
+import { acceptedCanonicalObservation, prepareAcceptedCanonicalTransition, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
+import { computePackManifestContentIdentity } from "@agentxm/workspace-state";
+import { computeMaterializedTreeIntegrity, } from "@agentxm/workspace-state";
+// Build pack SetPackArgs from a registry ref
+const buildSetPackArgs = (ref, versionRange, treeIntegrity) => ({
+    type: "registry",
+    sourceType: "registry",
+    packageFormat: "agentxm",
+    endpoint: ref.source.location,
+    extensionType: "pack",
+    workspaceName: ref.pack.name,
+    owner: ref.owner,
+    name: ref.pack.name,
+    resolvedVersion: decodeVersionSync(ref.version),
+    integrity: Option.getOrElse(ref.integrity, () => ""),
+    sourceName: ref.source.name,
+    publisherBindingId: ref.publisherBindingId,
+    treeIntegrity,
+    manifestContentIdentity: computePackManifestContentIdentity({
+        owner: ref.owner,
+        type: "pack",
+        name: ref.pack.name,
+        version: ref.version,
+        dependencies: ref.pack.dependencies,
+    }),
+    versionRange,
+});
+// -----------------------------------------------------------------------------
+// Live Layer
+// -----------------------------------------------------------------------------
+export const PackManagerLive = Layer.effect(PackManager, Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const sources = yield* SourceHostProviders;
+    const baseDir = ws.baseDir;
+    const noContent = {
+        observation: NO_MATERIALIZATION_OBSERVATION,
+        treeIntegrity: Option.none(),
+    };
+    const acquired = (treeIntegrity) => ({
+        observation: NO_MATERIALIZATION_OBSERVATION,
+        treeIntegrity: Option.some(treeIntegrity),
+    });
+    const materializeInstall = Effect.fn("PackManager.materializeInstall")(function* ({ ref, force, }) {
+        if (ref.refType === "registry") {
+            yield* validateExactResolvedVersion(`packs.${ref.pack.name}.resolvedVersion`, ref.version);
+        }
+        const packDir = computePackPathsForLayout(path.join, ws.layout, ref.refType === "workspace" ? "workspace" : ref.source.name, ref.owner, ref.pack.name).canonicalPath;
+        const canonicalExists = yield* fs.exists(packDir).pipe(Effect.orElseSucceed(() => false));
+        if (ref.refType === "workspace") {
+            if (ref.scope !== ws.scope || path.resolve(ref.location) !== path.resolve(packDir)) {
+                return yield* new PackDefinitionInvalid({
+                    detail: `Invalid workspace pack source location: ${ref.location}`,
+                });
+            }
+            if (!canonicalExists) {
+                return yield* new PackDefinitionInvalid({
+                    detail: `Workspace pack package is missing: ${packDir}`,
+                });
+            }
+            return noContent;
+        }
+        const lockedEntry = yield* ws.getLockedPack(ref.pack.name);
+        const lockedVersion = acceptedRegistryVersionForRef(lockedEntry, ref);
+        if (yield* canReuseInstalledPackage({
+            installedPath: packDir,
+            force: force === true,
+            refVersion: ref.version,
+            hasIntegrity: Option.isSome(ref.integrity),
+            ...(lockedVersion === undefined ? {} : { lockedVersion }),
+            existsFailureDetail: (target) => `Failed to check if canonical pack path exists: ${target}`,
+        })) {
+            if (Option.isSome(lockedEntry)) {
+                const observedTree = yield* computeMaterializedTreeIntegrity(packDir);
+                if (observedTree === lockedEntry.value.treeIntegrity) {
+                    return acquired(lockedEntry.value.treeIntegrity);
+                }
+            }
+        }
+        return yield* Effect.scoped(Effect.gen(function* () {
+            const fetched = yield* sources
+                .fetch(ref)
+                .pipe(Effect.mapError((e) => new PackArchiveFetchFailed({ message: e.message, cause: e })));
+            const materialized = yield* replaceCanonicalDirectoryWithInspection({
+                baseDir,
+                canonicalPath: packDir,
+                populate: (stagingPath) => copyExtensionDirectory(fetched.directory, stagingPath).pipe(Effect.mapError((cause) => new PackStagingFailed({ packDir, cause }))),
+                inspect: computeMaterializedTreeIntegrity,
+            });
+            return acquired(materialized.inspection);
+        }));
+    });
+    const materializeUninstall = Effect.fn("PackManager.materializeUninstall")(function* ({ target, }) {
+        const canonical = yield* acceptedCanonicalObservation({
+            workspace: ws,
+            type: "pack",
+            name: target.name,
+        });
+        const packDir = removableAcceptedCanonicalPath(canonical);
+        if (Option.isSome(packDir))
+            yield* removeIfExists(fs, packDir.value);
+        return noContent;
+    });
+    const materializeDeactivate = () => Effect.succeed(noContent);
+    const buildCurrentPackArgs = (ref, versionRange, materialization) => Effect.gen(function* () {
+        if (ref.refType !== "registry")
+            return Option.none();
+        const treeIntegrity = materialization.pipe(Option.flatMap((facts) => facts.treeIntegrity));
+        if (Option.isNone(treeIntegrity)) {
+            return yield* new PackInstallStateMissing({ name: ref.pack.name });
+        }
+        return Option.some(buildSetPackArgs(ref, versionRange, treeIntegrity.value));
+    });
+    return {
+        type: "pack",
+        isInstalled: Effect.fn("PackManager.isInstalled")(function* ({ target, }) {
+            return yield* isObservedInstalled(ws, "pack", target.name);
+        }),
+        materializeInstall,
+        prepareSourceTransition: ({ ref }) => prepareAcceptedCanonicalTransition({
+            workspace: ws,
+            type: "pack",
+            name: ref.pack.name,
+            ref,
+        }),
+        getConfiguredSource: Effect.fn("PackManager.getConfiguredSource")(function* ({ target }) {
+            const configured = yield* ws.getConfiguredPackEntries();
+            return Option.fromUndefinedOr(configured[target.name]?.source);
+        }),
+        listMaterializable: Effect.fn("PackManager.listMaterializable")(function* () {
+            const configured = yield* ws.records.rows("pack").pipe(Effect.map(configuredRowsByName));
+            return yield* configuredPacksToDiskRefs({ fs, path, baseDir, scope: ws.scope, layout: ws.layout }, configured);
+        }),
+        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,
+                });
+            }
+        }),
+        removeSettingsEntry: ({ target }) => ws.removePackSettings(target.name).pipe(Effect.withSpan("PackManager.removeSettingsEntry")),
+        upsertLockfileEntry: Effect.fn("PackManager.upsertLockfileEntry")(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);
+            }
+        }),
+        removeLockfileEntry: ({ target }) => ws.removePackLock(target.name).pipe(Effect.withSpan("PackManager.removeLockfileEntry")),
+    };
+}));
+//# sourceMappingURL=manager.js.map

package/dist/src/projection-participants-live.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Registration of the extension-type managers as projection participants.
+ *
+ * `workspace-projection` evaluates the invariant facts without knowing which
+ * capability materializes a unit; the owners register here instead. Each
+ * manager's failure family is restated in projection's participant vocabulary:
+ * projection's own failures pass through typed, and anything else becomes
+ * `ProjectionParticipantFailed` naming the unit and the failure the manager
+ * decided.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Layer from "effect/Layer";
+import { HookManager, KnowledgeManager, RuleManager, SubagentManager } from "./managers.js";
+import { ProjectionParticipants } from "@agentxm/workspace-projection";
+export declare const ProjectionParticipantsLive: Layer.Layer<ProjectionParticipants, never, SubagentManager | RuleManager | HookManager | KnowledgeManager>;
+//# sourceMappingURL=projection-participants-live.d.ts.map

package/dist/src/projection-participants-live.js

@@ -0,0 +1,66 @@
+/**
+ * Registration of the extension-type managers as projection participants.
+ *
+ * `workspace-projection` evaluates the invariant facts without knowing which
+ * capability materializes a unit; the owners register here instead. Each
+ * manager's failure family is restated in projection's participant vocabulary:
+ * projection's own failures pass through typed, and anything else becomes
+ * `ProjectionParticipantFailed` naming the unit and the failure the manager
+ * decided.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { HookManager, KnowledgeManager, RuleManager, SubagentManager } from "./managers.js";
+import { isProjectionError, mapProjectionPlanFailure, ProjectionParticipantFailed, ProjectionParticipants, } from "@agentxm/workspace-projection";
+/**
+ * A manager failure stated in projection's vocabulary. Projection's own
+ * family keeps its exact identity; every other failure is named by the unit it
+ * blocked and the failure the manager decided, without an application error
+ * envelope and without rendering.
+ */
+const toParticipantFailure = (unitId) => (failure) => isProjectionError(failure)
+    ? failure
+    : new ProjectionParticipantFailed({
+        unitId,
+        detail: `The owner of ${unitId} could not project it (${failure._tag}).`,
+    });
+const participant = (args) => {
+    const onFailure = toParticipantFailure(args.failureUnitId);
+    return {
+        units: args.units,
+        projectionPlans: () => args.manager.projectionPlans().pipe(Effect.map((plans) => plans.map((plan) => mapProjectionPlanFailure(plan, onFailure))), Effect.mapError(onFailure)),
+    };
+};
+export const ProjectionParticipantsLive = Layer.effect(ProjectionParticipants, Effect.gen(function* () {
+    const rules = yield* RuleManager;
+    const hooks = yield* HookManager;
+    const knowledge = yield* KnowledgeManager;
+    const subagents = yield* SubagentManager;
+    const onSubagentFailure = toParticipantFailure("subagent:native-profile");
+    return {
+        aggregates: [
+            participant({
+                units: ["rule:instructions-region"],
+                failureUnitId: "rule:instructions-region",
+                manager: rules,
+            }),
+            participant({
+                units: ["hook:agent-hook-entries", "hook:fallback-region"],
+                failureUnitId: "hook:agent-hook-entries",
+                manager: hooks,
+            }),
+            participant({
+                units: ["knowledge:discovery-region"],
+                failureUnitId: "knowledge:discovery-region",
+                manager: knowledge,
+            }),
+        ],
+        subagents: Option.some({
+            projectionObservation: (ref) => subagents.projectionObservation(ref).pipe(Effect.mapError(onSubagentFailure)),
+        }),
+    };
+}));
+//# sourceMappingURL=projection-participants-live.js.map

package/dist/src/projection-step-failure.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Conversions from the shared-projection failure family into the plan-step
+ * vocabulary.
+ *
+ * Projection states domain facts and owns no rendering, and the package that
+ * owns `StepFailure` cannot see it, so the capability that unions projection
+ * into `ExtensionManagerFailure` renders it. Category, detail, and suggestion
+ * strings are the plan pipeline's serialized contract: they stay
+ * byte-identical to the CLI boundary's `AppError` renderings of the same
+ * failures, exactly as `workspaceStateReadFailureToStepFailure` does for the
+ * workspace-state family.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { StepFailure } from "@agentxm/workspace-operations";
+import type { ProjectionError } from "@agentxm/workspace-projection";
+/** Translate one shared-projection failure into the plan-step vocabulary. */
+export declare const projectionErrorToStepFailure: (error: ProjectionError) => StepFailure;
+//# sourceMappingURL=projection-step-failure.d.ts.map

package/dist/src/projection-step-failure.js

@@ -0,0 +1,76 @@
+/**
+ * Conversions from the shared-projection failure family into the plan-step
+ * vocabulary.
+ *
+ * Projection states domain facts and owns no rendering, and the package that
+ * owns `StepFailure` cannot see it, so the capability that unions projection
+ * into `ExtensionManagerFailure` renders it. Category, detail, and suggestion
+ * strings are the plan pipeline's serialized contract: they stay
+ * byte-identical to the CLI boundary's `AppError` renderings of the same
+ * failures, exactly as `workspaceStateReadFailureToStepFailure` does for the
+ * workspace-state family.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { StepFailure } from "@agentxm/workspace-operations";
+/** Translate one shared-projection failure into the plan-step vocabulary. */
+export const projectionErrorToStepFailure = (error) => {
+    switch (error._tag) {
+        case "DesiredStateIncomplete":
+            return new StepFailure({
+                category: "conflict",
+                detail: `Desired state cannot be enumerated completely; fix pack and declaration problems first: ${error.problems}`,
+                cause: error,
+            });
+        case "AuthoredContributorUnsupported":
+            return new StepFailure({
+                category: "validation",
+                detail: `User workspaces do not support workspace-authored ${error.type} packages`,
+                cause: error,
+            });
+        case "ContributorIdentityInvalid":
+            return new StepFailure({
+                category: "validation",
+                detail: `Invalid workspace ${error.type} identity: ${error.identity}`,
+                cause: error,
+            });
+        case "ContributorUnresolved":
+            return new StepFailure({
+                category: "conflict",
+                detail: `Active ${error.type} has no accepted resolution: ${error.name}`,
+                cause: error,
+            });
+        case "ContributorTreeMismatch":
+            return new StepFailure({
+                category: "conflict",
+                detail: `Materialized package tree does not match the accepted lock entry: ${error.packageRoot}`,
+                suggestions: [
+                    {
+                        description: "Restore the accepted package with install or update, or fork it into the authored workspace tree before editing.",
+                    },
+                ],
+                cause: error,
+            });
+        case "ProjectionTargetUnsupported":
+            return new StepFailure({ category: "validation", detail: error.detail, cause: error });
+        case "ManagedRegionViolation":
+            return new StepFailure({
+                category: "conflict",
+                detail: error.reason === undefined
+                    ? `Cannot reconcile managed region: ${error.displayPath}`
+                    : `${error.reason}: ${error.displayPath}`,
+                cause: error,
+            });
+        case "ProjectionIoFailed":
+            return new StepFailure({
+                category: "internal",
+                detail: error.step === "inspect"
+                    ? `Failed to inspect managed-region target: ${error.path}`
+                    : error.step === "read"
+                        ? `Failed to read managed-region target: ${error.path}`
+                        : `Failed to reconcile managed-region target: ${error.path}`,
+                cause: error.cause,
+            });
+    }
+};
+//# sourceMappingURL=projection-step-failure.js.map

package/dist/src/registry-materialization.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Registry-backed canonical package materialization.
+ *
+ * The canonical-directory staging/swap machinery lives beside this module;
+ * this module owns only the registry fetch, verify, and extract path.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+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 * as HttpClient from "effect/unstable/http/HttpClient";
+import type { Version, VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import type { RegistryClientFailure } from "@agentxm/registry-client";
+import type { ExtensionName, ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import { ArchiveIntegrityMismatch } from "./extensions/errors.js";
+import { type CanonicalDirectoryReplacementError, type MaterializedPackage } from "./extensions/canonical-directory.js";
+import { type MaterializedTreeInvalid } from "@agentxm/workspace-state";
+export interface RegistryPackageMaterializationMessages {
+    readonly integrityMismatchDetail: string;
+}
+export interface MaterializeRegistryPackageArgs<E = never> {
+    readonly baseDir: string;
+    /**
+     * Canonical installed path for this extension. Bytes always land in a sibling
+     * staging directory first and are swapped in after validation.
+     */
+    readonly destinationPath: string;
+    readonly sourceLocation: URL;
+    readonly owner: Handle;
+    readonly type: ExtensionType;
+    readonly name: ExtensionName;
+    readonly version: Version | VersionRange;
+    readonly integrity: Option.Option<string>;
+    readonly messages: RegistryPackageMaterializationMessages;
+    readonly validate?: (stagingPath: string) => Effect.Effect<void, E, FileSystem.FileSystem | Path.Path>;
+}
+/**
+ * Fetch, verify, and extract a registry package into `destinationPath`.
+ *
+ * Always writes. Whether new bytes are needed at all is
+ * `canReuseInstalledPackage`'s decision, which the caller makes against the
+ * canonical installed path before choosing a destination.
+ *
+ * Registry client and archive-extraction failures stay typed in the channel;
+ * the application boundary converts them once.
+ */
+export declare const materializeRegistryPackageWithTreeIntegrity: <E = never>(args: MaterializeRegistryPackageArgs<E>) => Effect.Effect<MaterializedPackage, E | RegistryClientFailure | ArchiveIntegrityMismatch | CanonicalDirectoryReplacementError | MaterializedTreeInvalid, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+export declare const materializeRegistryPackage: <E = never>(args: MaterializeRegistryPackageArgs<E>) => Effect.Effect<string, ArchiveIntegrityMismatch | MaterializedTreeInvalid | RegistryClientFailure | CanonicalDirectoryReplacementError | E, FileSystem.FileSystem | Path.Path | HttpClient.HttpClient>;
+//# sourceMappingURL=registry-materialization.d.ts.map

package/dist/src/registry-materialization.js

@@ -0,0 +1,67 @@
+/**
+ * Registry-backed canonical package materialization.
+ *
+ * The canonical-directory staging/swap machinery lives beside this module;
+ * this module owns only the registry fetch, verify, and extract path.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+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 * as HttpClient from "effect/unstable/http/HttpClient";
+import { computeIntegrity, createRegistryClient, extractZip } from "@agentxm/registry-client";
+import { ArchiveIntegrityMismatch } from "./extensions/errors.js";
+import { recoverCanonicalDirectory, replaceCanonicalDirectoryWithInspection, } from "./extensions/canonical-directory.js";
+import { makeThrottledUnitProgress } from "@agentxm/workspace-operations";
+import { computeMaterializedTreeIntegrity, } from "@agentxm/workspace-state";
+const registryLocationForClient = (location) => location.protocol === "file:" ? location.pathname : location.href;
+/**
+ * Fetch, verify, and extract a registry package into `destinationPath`.
+ *
+ * Always writes. Whether new bytes are needed at all is
+ * `canReuseInstalledPackage`'s decision, which the caller makes against the
+ * canonical installed path before choosing a destination.
+ *
+ * Registry client and archive-extraction failures stay typed in the channel;
+ * the application boundary converts them once.
+ */
+export const materializeRegistryPackageWithTreeIntegrity = (args) => Effect.gen(function* () {
+    yield* recoverCanonicalDirectory({
+        baseDir: args.baseDir,
+        canonicalPath: args.destinationPath,
+    });
+    const client = yield* createRegistryClient(registryLocationForClient(args.sourceLocation));
+    // Continuous download progress reaches the lifecycle broadcast throttled:
+    // tens of events per archive, attributed to the unit that is running.
+    const reportProgress = yield* makeThrottledUnitProgress({ unit: "bytes" });
+    const { archive } = yield* client.getExtensionPackage({
+        owner: args.owner,
+        type: args.type,
+        name: args.name,
+        version: Option.some(args.version),
+        onProgress: (progress) => reportProgress(progress.done, progress.total),
+    });
+    if (Option.isSome(args.integrity)) {
+        const actualIntegrity = yield* computeIntegrity(archive);
+        if (actualIntegrity !== args.integrity.value) {
+            return yield* new ArchiveIntegrityMismatch({
+                subject: args.messages.integrityMismatchDetail,
+            });
+        }
+    }
+    const result = yield* replaceCanonicalDirectoryWithInspection({
+        baseDir: args.baseDir,
+        canonicalPath: args.destinationPath,
+        populate: (stagingPath) => extractZip(archive, stagingPath),
+        ...(args.validate === undefined ? {} : { validate: args.validate }),
+        inspect: computeMaterializedTreeIntegrity,
+    });
+    return {
+        canonicalPath: result.canonicalPath,
+        treeIntegrity: result.inspection,
+    };
+});
+export const materializeRegistryPackage = (args) => materializeRegistryPackageWithTreeIntegrity(args).pipe(Effect.map(({ canonicalPath }) => canonicalPath));
+//# sourceMappingURL=registry-materialization.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Typed failure family for the rule manager. Fields are domain facts; the
+ * application error boundary owns rendering, codes, and suggestions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+declare const RuleDefinitionInvalid_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: "RuleDefinitionInvalid";
+} & Readonly<A>;
+/**
+ * A rule package's source, manifest, or body did not validate. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export declare class RuleDefinitionInvalid extends RuleDefinitionInvalid_base<{
+    readonly detail: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const RuleInstallStateMissing_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: "RuleInstallStateMissing";
+} & Readonly<A>;
+/** A lock entry was requested before install recorded the package state. */
+export declare class RuleInstallStateMissing extends RuleInstallStateMissing_base<{
+    readonly name: string;
+    readonly kind: "tree-integrity" | "content-identity";
+}> {
+}
+/** Every failure the rule manager constructs. */
+export type RuleManagerError = RuleDefinitionInvalid | RuleInstallStateMissing;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/rules/errors.js

@@ -0,0 +1,17 @@
+/**
+ * Typed failure family for the rule manager. Fields are domain facts; the
+ * application error boundary owns rendering, codes, and suggestions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+/**
+ * A rule package's source, manifest, or body did not validate. `detail`
+ * carries the site's fact sentence verbatim.
+ */
+export class RuleDefinitionInvalid extends Data.TaggedError("RuleDefinitionInvalid") {
+}
+/** A lock entry was requested before install recorded the package state. */
+export class RuleInstallStateMissing extends Data.TaggedError("RuleInstallStateMissing") {
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * 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";
+import { RuleManager } from "../managers.js";
+import { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
+import type { MaterializationObservation } from "../manager-contract.js";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+export declare const ruleMaterializationObservation: (managedTarget: string, instructionItems: ReadonlyArray<{
+    readonly agentId: string;
+    readonly health: string;
+}>) => MaterializationObservation;
+export declare const RuleManagerLive: Layer.Layer<RuleManager, never, FileSystem.FileSystem | Path.Path | WorkspaceMutations | SourceHostProviders | WorkspaceCatalog>;
+//# sourceMappingURL=manager.d.ts.map