@agentxm/extension-lifecycle 0.28.11 → 0.28.13

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

@@ -0,0 +1,82 @@
+/**
+ * Returning a workspace-authored package to an external source.
+ *
+ * Demotion is the one transition that deliberately gives up workspace source
+ * authority: the authored package stops being the thing the workspace edits
+ * and becomes a package the workspace acquires again from a Registry, Git, or
+ * local source. Because that replaces content a person wrote, it is a
+ * confirmable risk rather than an ordinary install, the replacement is refused
+ * unless the target really is workspace-sourced and the replacement source
+ * really is external, and an entry that was disabled stays disabled once the
+ * external package is in place.
+ *
+ * `prepare` settles all of that and writes nothing. `previewOrApply` resolves
+ * the same candidate, so the preview a person reads and the apply that follows
+ * describe one decision.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { ExtensionManagers } from "@agentxm/extension-materialization";
+import { type ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import { type ExecutionCandidate, type PlanExecution } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, type WorkspaceSettingsReadFailure } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../errors.js";
+import type { InstallStepRequirements } from "../install/vocabulary.js";
+/** What a person named: the authored package, and the source that replaces it. */
+export interface DemoteRequest {
+    /** Owner-qualified identity of the workspace-authored package. */
+    readonly fqn: string;
+    /** The Registry, Git, or local source the package is acquired from next. */
+    readonly source: string;
+}
+/** The risk a demotion declares, which advance approval may satisfy. */
+export declare const DEMOTE_RISK_CONDITION_ID = "replace-workspace-authority";
+/** Everything a demotion step may require when it runs. */
+export type DemoteRequirements = InstallStepRequirements;
+/**
+ * A settled demotion: the replacement is resolved, the refusals are past, and
+ * nothing is written. The identity fields answer what the application renders
+ * around the frozen candidate.
+ */
+export interface DemoteCandidate {
+    readonly type: ExtensionType;
+    readonly name: string;
+    /** Owner-qualified identity of the package being demoted. */
+    readonly fqn: string;
+    /** Workspace-relative authored directory the apply removes. */
+    readonly authoredPath: string;
+    readonly execution: ExecutionCandidate<DemoteRequirements>;
+}
+/**
+ * Every failure settling a demotion can surface before anything is written:
+ * the feature's own refusals, the identity grammar, and whatever resolving
+ * the replacement against its source surfaced.
+ */
+export type DemoteFailure = Effect.Error<ReturnType<typeof settleDemotion>>;
+/** Everything settling a demotion reads before it freezes a candidate. */
+export type PrepareDemoteRequirements = Effect.Services<ReturnType<typeof settleDemotion>>;
+/**
+ * Settle a demotion: parse the identity, refuse a replacement that is not
+ * external or a target that is not workspace-authored, resolve the
+ * replacement package, and freeze the execution candidate.
+ */
+declare const settleDemotion: (request: DemoteRequest) => Effect.Effect<{
+    type: "mcp-server" | "skill" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    name: string & import("effect/Brand").Brand<"ExtensionName">;
+    fqn: string;
+    authoredPath: string;
+    execution: ExecutionCandidate<InstallStepRequirements, never>;
+}, ExtensionLifecycleFailed | import("@agentxm/workspace-state").PathTraversalDetected | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | WorkspaceSettingsReadFailure | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/workspace-state").LockEntrySourceMissing | import("@agentxm/workspace-state").LockEntryUrlInvalid | import("@agentxm/workspace-state").LockEntryNameInvalid | import("@agentxm/workspace-state").LockEntryEndpointConflict | import("@agentxm/workspace-state").LockEntrySourceTypeConflict | import("@agentxm/workspace-state").AcceptedResolutionMissing | import("@agentxm/workspace-state").InlineExtensionSourceMissing | import("@agentxm/workspace-state").PackageContentHashFailed | import("@agentxm/workspace-state").WorkspaceSourceInvalid | import("@agentxm/extension-model/unstable/extensions").FqnInvalidError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, FileSystem.FileSystem | Path.Path | WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | ExtensionManagers | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | import("@agentxm/extension-sources").SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog>;
+export declare const prepareDemote: (request: DemoteRequest) => Effect.Effect<DemoteCandidate, DemoteFailure, PrepareDemoteRequirements>;
+/** Preview or apply a settled demotion, resolving to one operation outcome. */
+export declare const previewOrApplyDemote: (candidate: DemoteCandidate, execution: PlanExecution) => Effect.Effect<import("@agentxm/workspace-operations").OperationResolution<never>, WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-transactions").WorkspaceTransitionAcquireFailure, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/workspace-operations").ResolvePlanInteraction | InstallStepRequirements>;
+/** The demotion use case: settle a request, then preview or apply it. */
+export declare const DemoteToExternalSource: {
+    readonly prepare: (request: DemoteRequest) => Effect.Effect<DemoteCandidate, DemoteFailure, PrepareDemoteRequirements>;
+    readonly previewOrApply: (candidate: DemoteCandidate, execution: PlanExecution) => Effect.Effect<import("@agentxm/workspace-operations").OperationResolution<never>, WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-transactions").WorkspaceTransitionAcquireFailure, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/workspace-operations").ResolvePlanInteraction | InstallStepRequirements>;
+};
+export {};
+//# sourceMappingURL=demote-to-external-source.d.ts.map

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

@@ -0,0 +1,233 @@
+/**
+ * Returning a workspace-authored package to an external source.
+ *
+ * Demotion is the one transition that deliberately gives up workspace source
+ * authority: the authored package stops being the thing the workspace edits
+ * and becomes a package the workspace acquires again from a Registry, Git, or
+ * local source. Because that replaces content a person wrote, it is a
+ * confirmable risk rather than an ordinary install, the replacement is refused
+ * unless the target really is workspace-sourced and the replacement source
+ * really is external, and an entry that was disabled stays disabled once the
+ * external package is in place.
+ *
+ * `prepare` settles all of that and writes nothing. `previewOrApply` resolves
+ * the same candidate, so the preview a person reads and the apply that follows
+ * describe one decision.
+ *
+ * @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 { ExtensionManagers, buildInstallOperation } from "@agentxm/extension-materialization";
+import { formatFqn, parseFqn, } from "@agentxm/extension-model/unstable/extensions";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "@agentxm/extension-resolution";
+import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../errors.js";
+import { lifecycleStepFailure } from "../step-failure.js";
+/** The risk a demotion declares, which advance approval may satisfy. */
+export const DEMOTE_RISK_CONDITION_ID = "replace-workspace-authority";
+// -----------------------------------------------------------------------------
+// Configured entry facts
+// -----------------------------------------------------------------------------
+/** The configured declaration a demotion replaces, as settings recorded it. */
+const configuredEntry = (ws, type, name) => {
+    switch (type) {
+        case "skill":
+            return ws.getConfiguredSkillEntries().pipe(Effect.map((entries) => entries[name]));
+        case "mcp-server":
+            return ws.getConfiguredMcpServerEntries().pipe(Effect.map((entries) => entries[name]));
+        case "subagent":
+            return ws.getConfiguredSubagentEntries().pipe(Effect.map((entries) => entries[name]));
+        case "rule":
+            return ws.getConfiguredRuleEntries().pipe(Effect.map((entries) => entries[name]));
+        case "hook":
+            return ws.getConfiguredHookEntries().pipe(Effect.map((entries) => entries[name]));
+        case "knowledge":
+            return ws.getConfiguredKnowledgeEntries().pipe(Effect.map((entries) => entries[name]));
+        case "pack":
+            return ws.getConfiguredPackEntries().pipe(Effect.map((entries) => entries[name]));
+    }
+};
+const entrySource = (entry) => {
+    if (typeof entry === "string")
+        return entry;
+    if (typeof entry !== "object" || entry === null || !("source" in entry))
+        return undefined;
+    return typeof entry.source === "string" ? entry.source : undefined;
+};
+const entryDisabled = (entry) => typeof entry === "object" && entry !== null && "enabled" in entry && entry.enabled === false;
+const restoreDisabledState = (ws, type, name) => {
+    const disable = (entry) => ({
+        ...entry,
+        enabled: false,
+    });
+    switch (type) {
+        case "skill":
+            return ws.updateSkillEntry(name, disable);
+        case "mcp-server":
+            return ws.updateMcpServerEntry(name, disable);
+        case "subagent":
+            return ws.updateSubagentEntry(name, disable);
+        case "rule":
+            return ws.updateRuleEntry(name, disable);
+        case "hook":
+            return ws.updateHookEntry(name, disable);
+        case "knowledge":
+            return ws.updateKnowledgeEntry(name, disable);
+        // A Pack declaration carries no activation of its own; its members do.
+        case "pack":
+            return Effect.void;
+    }
+};
+// -----------------------------------------------------------------------------
+// The replacement step
+// -----------------------------------------------------------------------------
+/**
+ * Resolve the replacement package from its new source and compose the install
+ * that replaces the authored content. `allowWorkspaceReplacement` is the one
+ * place source authority is deliberately overridden, and it is named here so
+ * no other route can reach it by accident.
+ */
+const replacementStep = Effect.fn("Demote.replacementStep")(function* (type, name, source) {
+    const managers = yield* ExtensionManagers;
+    const evaluation = yield* makeConfiguredReleaseAgeEvaluation();
+    // The one place source authority is deliberately overridden.
+    const common = {
+        toStepFailure: lifecycleStepFailure,
+        allowWorkspaceReplacement: true,
+    };
+    switch (type) {
+        case "skill":
+            return buildInstallOperation(managers.skill, {
+                ...common,
+                ...(yield* resolveConfiguredSkill(name, source, evaluation)),
+            });
+        case "mcp-server":
+            return buildInstallOperation(managers["mcp-server"], {
+                ...common,
+                ...(yield* resolveConfiguredMcpServer(name, source, evaluation)),
+            });
+        case "subagent":
+            return buildInstallOperation(managers.subagent, {
+                ...common,
+                ...(yield* resolveConfiguredSubagent(name, source, evaluation)),
+            });
+        case "rule":
+            return buildInstallOperation(managers.rule, {
+                ...common,
+                ...(yield* resolveConfiguredRule(name, source, evaluation)),
+            });
+        case "hook":
+            return buildInstallOperation(managers.hook, {
+                ...common,
+                ...(yield* resolveConfiguredHook(name, source, evaluation)),
+            });
+        case "knowledge":
+            return buildInstallOperation(managers.knowledge, {
+                ...common,
+                ...(yield* resolveConfiguredKnowledge(name, source, evaluation)),
+            });
+        case "pack":
+            return buildInstallOperation(managers.pack, {
+                ...common,
+                ...(yield* resolveConfiguredPack(name, source, evaluation)),
+            });
+    }
+});
+// -----------------------------------------------------------------------------
+// prepare
+// -----------------------------------------------------------------------------
+/**
+ * Settle a demotion: parse the identity, refuse a replacement that is not
+ * external or a target that is not workspace-authored, resolve the
+ * replacement package, and freeze the execution candidate.
+ */
+const settleDemotion = Effect.fn("Demote.prepare")(function* (request) {
+    const ws = yield* WorkspaceMutations;
+    const path = yield* Path.Path;
+    const fs = yield* FileSystem.FileSystem;
+    const parsed = yield* Effect.fromResult(parseFqn(request.fqn));
+    if (isWorkspaceSourceLocator(request.source)) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "usage",
+            detail: "Demotion target must be a registry, git, or local source",
+        });
+    }
+    const current = yield* configuredEntry(ws, parsed.type, parsed.name);
+    const currentSource = entrySource(current);
+    if (currentSource === undefined || !isWorkspaceSourceLocator(currentSource)) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: `${formatFqn(parsed)} is not workspace-sourced`,
+        });
+    }
+    if (ws.layout.scope !== "project") {
+        return yield* new ExtensionLifecycleFailed({
+            category: "usage",
+            detail: "Demote requires project scope",
+        });
+    }
+    const authoredDir = path.join(ws.layout.authoredRoot(parsed.type), parsed.name);
+    const operation = yield* replacementStep(parsed.type, parsed.name, request.source);
+    const wasDisabled = entryDisabled(current);
+    const step = operation.readiness === "error"
+        ? operation
+        : {
+            readiness: "warn",
+            label: `Demote ${formatFqn(parsed)}`,
+            warnMessage: "Future updates may replace this package from its new source",
+            run: Effect.gen(function* () {
+                const result = yield* operation.run;
+                if (wasDisabled) {
+                    yield* restoreDisabledState(ws, parsed.type, parsed.name).pipe(Effect.mapError(lifecycleStepFailure));
+                }
+                // The authored copy is what demotion gives up. Its absence is not
+                // a failure: the acquired package is already authoritative.
+                yield* fs
+                    .remove(authoredDir, { recursive: true })
+                    .pipe(Effect.catch(() => Effect.void));
+                return result;
+            }),
+        };
+    const plan = {
+        _tag: "Plan",
+        name: "Demote workspace extension",
+        description: Option.some("Remove workspace source protection; future updates may replace the package"),
+        presentation: operationPresentation({
+            imperative: "demote",
+            past: "Demoted",
+            gerund: "Demoting",
+        }),
+        jobs: [{ concurrency: 1, steps: [step] }],
+        riskConditions: [
+            {
+                level: "confirmable",
+                id: DEMOTE_RISK_CONDITION_ID,
+                detail: "The workspace-authored package will be replaced by an externally sourced package.",
+            },
+        ],
+    };
+    return {
+        type: parsed.type,
+        name: parsed.name,
+        fqn: formatFqn(parsed),
+        authoredPath: authoredDir,
+        execution: yield* prepareExecutionCandidate(plan),
+    };
+});
+export const prepareDemote = settleDemotion;
+// -----------------------------------------------------------------------------
+// previewOrApply
+// -----------------------------------------------------------------------------
+/** Preview or apply a settled demotion, resolving to one operation outcome. */
+export const previewOrApplyDemote = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+/** The demotion use case: settle a request, then preview or apply it. */
+export const DemoteToExternalSource = {
+    prepare: prepareDemote,
+    previewOrApply: previewOrApplyDemote,
+};
+//# sourceMappingURL=demote-to-external-source.js.map

package/dist/src/errors.d.ts

@@ -6,7 +6,6 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
-import { CoupledDependencyFailure } from "@agentxm/extension-workspace";
 declare const ExtensionLifecycleFailed_base: Schema.Class<ExtensionLifecycleFailed, Schema.TaggedStruct<"ExtensionLifecycleFailed", {
     readonly category: Schema.Literals<readonly ["conflict", "internal", "network", "not_found", "usage", "validation"]>;
     readonly title: Schema.optional<Schema.String>;
@@ -28,12 +27,5 @@ declare const ExtensionLifecycleFailed_base: Schema.Class<ExtensionLifecycleFail
  */
 export declare class ExtensionLifecycleFailed extends ExtensionLifecycleFailed_base {
 }
-/**
- * Carry a lifecycle dependency's failure opaquely through a kernel-typed
- * manager channel. The application boundary restores and converts the carried
- * failure, so rendering, exit codes, and machine output stay byte-identical
- * with the previous in-place conversion.
- */
-export declare const coupleLifecycleDependencyFailure: (failure: unknown) => CoupledDependencyFailure;
 export {};
 //# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -6,7 +6,6 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
-import { CoupledDependencyFailure } from "@agentxm/extension-workspace";
 const CarriedSuggestedActionSchema = Schema.Struct({
     description: Schema.String,
     cmd: Schema.optional(Schema.String),
@@ -35,11 +34,4 @@ export class ExtensionLifecycleFailed extends Schema.TaggedError()("ExtensionLif
     cause: Schema.optional(Schema.Unknown),
 }) {
 }
-/**
- * Carry a lifecycle dependency's failure opaquely through a kernel-typed
- * manager channel. The application boundary restores and converts the carried
- * failure, so rendering, exit codes, and machine output stay byte-identical
- * with the previous in-place conversion.
- */
-export const coupleLifecycleDependencyFailure = (failure) => new CoupledDependencyFailure({ failure });
 //# sourceMappingURL=errors.js.map

package/dist/src/glob.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
+ * are treated as literals. Matching is case-sensitive.
+ *
+ * @param pattern - The pattern to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order
+ */
+export declare const expandGlob: (pattern: string, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export declare const expandGlobs: (patterns: ReadonlyArray<string>, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export declare const isGlobPattern: (input: string) => boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/src/glob.js

@@ -0,0 +1,75 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
+ * are treated as literals. Matching is case-sensitive.
+ *
+ * @param pattern - The pattern to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order
+ */
+export const expandGlob = (pattern, names) => {
+    const matches = (name) => {
+        let patternIndex = 0;
+        let nameIndex = 0;
+        let wildcardIndex = -1;
+        let wildcardNameIndex = 0;
+        while (nameIndex < name.length) {
+            const token = pattern[patternIndex];
+            if (token !== undefined && token !== "*" && token === name[nameIndex]) {
+                patternIndex += 1;
+                nameIndex += 1;
+            }
+            else if (token === "*") {
+                wildcardIndex = patternIndex;
+                wildcardNameIndex = nameIndex;
+                patternIndex += 1;
+            }
+            else if (wildcardIndex >= 0) {
+                patternIndex = wildcardIndex + 1;
+                wildcardNameIndex += 1;
+                nameIndex = wildcardNameIndex;
+            }
+            else {
+                return false;
+            }
+        }
+        while (pattern[patternIndex] === "*") {
+            patternIndex += 1;
+        }
+        return patternIndex === pattern.length;
+    };
+    return names.filter(matches);
+};
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export const expandGlobs = (patterns, names) => {
+    const matched = new Set();
+    for (const pattern of patterns) {
+        for (const name of expandGlob(pattern, names)) {
+            matched.add(name);
+        }
+    }
+    return names.filter((n) => matched.has(n));
+};
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export const isGlobPattern = (input) => input.includes("*");
+//# sourceMappingURL=glob.js.map

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

@@ -10,9 +10,13 @@
  *
  * @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 * as HttpClient from "effect/unstable/http/HttpClient";
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import { ConfiguredAgentOutcomesProvider } from "@agentxm/workspace-state";
-import { LifecycleFailureAdapter } from "../failure-adapter.js";
-import { HookManager } from "@agentxm/extension-workspace";
-export declare const HookConfiguredAgentOutcomesProviderLive: Layer.Layer<ConfiguredAgentOutcomesProvider, never, LifecycleFailureAdapter | HookManager>;
+import { StepFailureConversion } from "../step-failure-conversion.js";
+import { HookManager } from "@agentxm/extension-materialization";
+export declare const HookConfiguredAgentOutcomesProviderLive: Layer.Layer<ConfiguredAgentOutcomesProvider, never, StepFailureConversion | FileSystem.FileSystem | Path.Path | NativeWriteAuthority | HttpClient.HttpClient | HookManager>;
 //# sourceMappingURL=configured-agent-outcomes-provider.d.ts.map

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

@@ -11,20 +11,27 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import { ConfiguredAgentOutcomesProvider, ConfiguredAgentOutcomesUnavailable, } from "@agentxm/workspace-state";
-import { LifecycleFailureAdapter } from "../failure-adapter.js";
-import { HookManager } from "@agentxm/extension-workspace";
+import { StepFailureConversion } from "../step-failure-conversion.js";
+import { HookManager } from "@agentxm/extension-materialization";
 export const HookConfiguredAgentOutcomesProviderLive = Layer.effect(ConfiguredAgentOutcomesProvider, Effect.gen(function* () {
-    const adapter = yield* LifecycleFailureAdapter;
+    const adapter = yield* StepFailureConversion;
     const hookManager = yield* HookManager;
+    // The provider's members answer with no requirements of their own, so this
+    // layer is the boundary that composes what the manager needs.
+    const managerLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, yield* FileSystem.FileSystem), Layer.succeed(Path.Path, yield* Path.Path), Layer.succeed(HttpClient.HttpClient, yield* HttpClient.HttpClient), Layer.succeed(NativeWriteAuthority, yield* NativeWriteAuthority));
     const configuredAgentOutcomes = hookManager.configuredAgentOutcomes;
     if (configuredAgentOutcomes === undefined) {
         return { byExtensionType: {} };
     }
     return {
         byExtensionType: {
-            hook: (state) => configuredAgentOutcomes(state).pipe(Effect.mapError((failure) => {
+            hook: (state) => configuredAgentOutcomes(state).pipe(Effect.provide(managerLayer), Effect.mapError((failure) => {
                 const step = adapter.toStepFailure(failure);
                 return new ConfiguredAgentOutcomesUnavailable({
                     category: step.category,

package/dist/src/hooks/install/plan.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Installing hooks packages.
+ *
+ * A hook becomes observable through each agent's own hook configuration, so
+ * its planned artifact is the set of configured-agent outcomes, and an agent
+ * that cannot accept the hook blocks the closure rather than failing mid-way.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { HookManager } from "@agentxm/extension-materialization";
+import { type Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { HookExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/hook";
+import type { Source } from "@agentxm/extension-model/unstable/sources/types";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { type JobStepArtifact, type JobStepArtifactTarget, type Plan } from "@agentxm/workspace-operations";
+import { type ConfiguredAgentOutcome, type HookLockEntry } from "@agentxm/workspace-state";
+import type { ExtensionLifecycleFailed } from "../../errors.js";
+import { type HookInstallIntent, type InstallStepRequirements, type ResolveInstallRequirements } from "../../install/vocabulary.js";
+/** A hooks source after grammar parsing, before anything is discovered. */
+export interface ParsedHookInstallRequest {
+    readonly source: Source;
+    readonly names: ReadonlyArray<string>;
+    readonly owner: Option.Option<Handle>;
+    readonly versionRange: Option.Option<VersionRange>;
+}
+/** The artifact an applied hook install reports, from its accepted lock entry. */
+export declare const hookInstallArtifact: (args: {
+    readonly lockEntry: HookLockEntry;
+    readonly installedBefore: boolean;
+    readonly scope: JobStepArtifact["scope"];
+    readonly agents: ReadonlyArray<string>;
+    readonly targets: ReadonlyArray<JobStepArtifactTarget>;
+    readonly agentOutcomes?: ReadonlyArray<ConfiguredAgentOutcome>;
+}) => JobStepArtifact;
+/** Read the hooks source grammar: which owner, which names, which range. */
+export declare const parseHookInstallRequest: (source: string) => Effect.Effect<ParsedHookInstallRequest, ExtensionLifecycleFailed, ResolveInstallRequirements>;
+/** Discover the hooks packages the parsed source offers. */
+export declare const discoverHookRefs: (request: ParsedHookInstallRequest) => Effect.Effect<ReadonlyArray<HookExtensionRef>, ExtensionLifecycleFailed, ResolveInstallRequirements>;
+/** Settle which hooks packages this request installs, or refuse when none matched. */
+export declare const finalizeHookInstallIntent: (request: ParsedHookInstallRequest, refs: ReadonlyArray<HookExtensionRef>) => Effect.Effect<HookInstallIntent, ExtensionLifecycleFailed>;
+/** The closures a settled hook intent becomes. */
+export declare const planHookInstall: (intent: HookInstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | HookManager>;
+//# sourceMappingURL=plan.d.ts.map