@agentxm/extension-lifecycle 0.28.4-bootstrap.0

package/dist/src/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Typed failures for the extension-lifecycle feature. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @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>;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly recover: Schema.optional<Schema.String>;
+    readonly cmd: Schema.optional<Schema.String>;
+    readonly suggestions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly cmd: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A lifecycle policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover`/`cmd` fold into the leading suggested action, and `title`,
+ * `detail`, `suggestions`, and `cause` carry over verbatim.
+ */
+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

@@ -0,0 +1,45 @@
+/**
+ * Typed failures for the extension-lifecycle feature. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @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),
+    url: Schema.optional(Schema.String),
+});
+/**
+ * A lifecycle policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover`/`cmd` fold into the leading suggested action, and `title`,
+ * `detail`, `suggestions`, and `cause` carry over verbatim.
+ */
+export class ExtensionLifecycleFailed extends Schema.TaggedError()("ExtensionLifecycleFailed", {
+    category: Schema.Literals([
+        "conflict",
+        "internal",
+        "network",
+        "not_found",
+        "usage",
+        "validation",
+    ]),
+    title: Schema.optional(Schema.String),
+    detail: Schema.optional(Schema.String),
+    recover: Schema.optional(Schema.String),
+    cmd: Schema.optional(Schema.String),
+    suggestions: Schema.optional(Schema.Array(CarriedSuggestedActionSchema)),
+    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/failure-adapter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The application-supplied conversion from lifecycle failures to the plan
+ * step vocabulary and to display text. Error rendering is application-owned:
+ * the CLI implements this with the same dispatcher it uses at its output
+ * boundary, so step categories and details inside lifecycle plans stay
+ * byte-identical with rendered errors. The feature keeps only the
+ * requirement, never the mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { StepFailure } from "@agentxm/workspace-operations";
+export interface LifecycleFailureAdapterService {
+    /**
+     * Serialize any failure a lifecycle operation can surface — kernel manager
+     * failures, integration failures, and the feature's own typed failures —
+     * into the plan-step vocabulary.
+     */
+    readonly toStepFailure: (failure: unknown) => StepFailure;
+    /** Render one failure as the detail sentence the boundary would print. */
+    readonly describeFailure: (failure: unknown) => string;
+    /** Render one failure as the boundary envelope's `message` property. */
+    readonly describeFailureMessage: (failure: unknown) => string;
+}
+declare const LifecycleFailureAdapter_base: ServiceMap.ServiceClass<LifecycleFailureAdapter, "@agentxm/extension-lifecycle/failure-adapter/LifecycleFailureAdapter", LifecycleFailureAdapterService>;
+export declare class LifecycleFailureAdapter extends LifecycleFailureAdapter_base {
+}
+/**
+ * Serialize every failure of one lifecycle operation into the plan-step
+ * vocabulary through the application-supplied adapter.
+ */
+export declare const withAdaptedStepFailures: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, StepFailure, R | LifecycleFailureAdapter>;
+export {};
+//# sourceMappingURL=failure-adapter.d.ts.map

package/dist/src/failure-adapter.js

@@ -0,0 +1,23 @@
+/**
+ * The application-supplied conversion from lifecycle failures to the plan
+ * step vocabulary and to display text. Error rendering is application-owned:
+ * the CLI implements this with the same dispatcher it uses at its output
+ * boundary, so step categories and details inside lifecycle plans stay
+ * byte-identical with rendered errors. The feature keeps only the
+ * requirement, never the mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+export class LifecycleFailureAdapter extends ServiceMap.Service()("@agentxm/extension-lifecycle/failure-adapter/LifecycleFailureAdapter") {
+}
+/**
+ * Serialize every failure of one lifecycle operation into the plan-step
+ * vocabulary through the application-supplied adapter.
+ */
+export const withAdaptedStepFailures = (effect) => Effect.gen(function* () {
+    const adapter = yield* LifecycleFailureAdapter;
+    return yield* effect.pipe(Effect.mapError((failure) => adapter.toStepFailure(failure)));
+});
+//# sourceMappingURL=failure-adapter.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Hook-backed implementation of the workspace-state
+ * `ConfiguredAgentOutcomesProvider` port.
+ *
+ * The plan pipeline consumes the port; the hook manager owns the effective
+ * per-agent outcome facts. Only the composition root sees both, so the
+ * application wires this layer over the manager, supplying its own failure
+ * serialization so plan resolutions embed byte-identical step failures on
+ * either side of the seam.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Layer from "effect/Layer";
+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>;
+//# sourceMappingURL=configured-agent-outcomes-provider.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Hook-backed implementation of the workspace-state
+ * `ConfiguredAgentOutcomesProvider` port.
+ *
+ * The plan pipeline consumes the port; the hook manager owns the effective
+ * per-agent outcome facts. Only the composition root sees both, so the
+ * application wires this layer over the manager, supplying its own failure
+ * serialization so plan resolutions embed byte-identical step failures on
+ * either side of the seam.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ConfiguredAgentOutcomesProvider, ConfiguredAgentOutcomesUnavailable, } from "@agentxm/workspace-state";
+import { LifecycleFailureAdapter } from "../failure-adapter.js";
+import { HookManager } from "@agentxm/extension-workspace";
+export const HookConfiguredAgentOutcomesProviderLive = Layer.effect(ConfiguredAgentOutcomesProvider, Effect.gen(function* () {
+    const adapter = yield* LifecycleFailureAdapter;
+    const hookManager = yield* HookManager;
+    const configuredAgentOutcomes = hookManager.configuredAgentOutcomes;
+    if (configuredAgentOutcomes === undefined) {
+        return { byExtensionType: {} };
+    }
+    return {
+        byExtensionType: {
+            hook: (state) => configuredAgentOutcomes(state).pipe(Effect.mapError((failure) => {
+                const step = adapter.toStepFailure(failure);
+                return new ConfiguredAgentOutcomesUnavailable({
+                    category: step.category,
+                    detail: step.detail,
+                    ...(step.suggestions === undefined ? {} : { suggestions: step.suggestions }),
+                    ...(step.cause === undefined ? {} : { cause: step.cause }),
+                });
+            })),
+        },
+    };
+}));
+//# sourceMappingURL=configured-agent-outcomes-provider.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Hook manager service.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
+import { LifecycleFailureAdapter } from "../failure-adapter.js";
+import { HookManager } from "@agentxm/extension-workspace";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+export declare const HookManagerLive: Layer.Layer<HookManager, never, LifecycleFailureAdapter | SourceHostProviders | WorkspaceCatalog | WorkspaceMutations | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+//# sourceMappingURL=manager.d.ts.map