@agentxm/extension-lifecycle 0.28.4-bootstrap.0

package/dist/src/subagents/operations/artifact.d.ts

@@ -0,0 +1,18 @@
+import type { JobStepArtifact, JobStepArtifactTarget } from "@agentxm/workspace-operations";
+export declare const SUBAGENT_CONFIG_SURFACE = ".axm (config/lockfile)";
+export declare const subagentConfigTarget: (change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
+export declare const renderedSubagentTargets: (renderedFiles: Readonly<Record<string, ReadonlyArray<{
+    readonly path: string;
+}>>>, change: JobStepArtifactTarget["change"]) => ReadonlyArray<JobStepArtifactTarget>;
+export declare const subagentLifecycleArtifact: (args: {
+    readonly name: string;
+    readonly scope: JobStepArtifact["scope"];
+    readonly agents?: ReadonlyArray<string>;
+    readonly version?: string;
+    readonly change: JobStepArtifact["change"];
+    readonly renderedFiles?: Readonly<Record<string, ReadonlyArray<{
+        readonly path: string;
+    }>>>;
+    readonly renderedChange?: JobStepArtifactTarget["change"];
+}) => JobStepArtifact;
+//# sourceMappingURL=artifact.d.ts.map

package/dist/src/subagents/operations/artifact.js

@@ -0,0 +1,43 @@
+export const SUBAGENT_CONFIG_SURFACE = ".axm (config/lockfile)";
+export const subagentConfigTarget = (change) => ({
+    path: SUBAGENT_CONFIG_SURFACE,
+    change,
+});
+export const renderedSubagentTargets = (renderedFiles, change) => {
+    const byPath = new Map();
+    for (const [agentId, files] of Object.entries(renderedFiles)) {
+        for (const file of files) {
+            const existing = byPath.get(file.path);
+            if (existing === undefined) {
+                byPath.set(file.path, [agentId]);
+                continue;
+            }
+            if (!existing.includes(agentId)) {
+                existing.push(agentId);
+            }
+        }
+    }
+    return [...byPath.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([path, agentIds]) => ({
+        path,
+        change,
+        ...(agentIds.length > 0 ? { agentIds } : {}),
+    }));
+};
+export const subagentLifecycleArtifact = (args) => {
+    const renderedTargets = args.renderedFiles === undefined
+        ? []
+        : renderedSubagentTargets(args.renderedFiles, args.renderedChange ?? args.change);
+    const targets = [subagentConfigTarget("updated"), ...renderedTargets];
+    return {
+        path: renderedTargets[0]?.path ?? SUBAGENT_CONFIG_SURFACE,
+        scope: args.scope,
+        ...(args.agents === undefined || args.agents.length === 0 ? {} : { agents: args.agents }),
+        ...(args.version === undefined ? {} : { version: args.version }),
+        change: args.change,
+        fileCount: targets.length,
+        targets,
+    };
+};
+//# sourceMappingURL=artifact.js.map

package/dist/src/subagents/operations/disable.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Disable subagent executor — removes rendered files but preserves canonical source.
+ *
+ * Materialized artifacts are observed directly. Accepted-resolution rows identify
+ * source content but do not prove that canonical or projected files exist.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import type { OperationHandler } from "@agentxm/workspace-operations";
+import type { Operation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+/**
+ * Disable a subagent (remove rendered files but keep settings/lockfile entry).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type DisableSubagentOperation = Operation<"disable-subagent", {
+    readonly subagentName: string;
+}>;
+/**
+ * Disable-subagent operation handler.
+ *
+ * Determines lifecycle from the workspace read model, removes observable
+ * rendered files, and promotes implicit pack members to a direct disabled
+ * preference. Canonical source files are preserved for later re-enablement.
+ */
+export declare const disableSubagent: OperationHandler<DisableSubagentOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+//# sourceMappingURL=disable.d.ts.map

package/dist/src/subagents/operations/disable.js

@@ -0,0 +1,116 @@
+/**
+ * Disable subagent executor — removes rendered files but preserves canonical source.
+ *
+ * Materialized artifacts are observed directly. Accepted-resolution rows identify
+ * source content but do not prove that canonical or projected files exist.
+ *
+ * @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 Option from "effect/Option";
+import { CodingAgentRepository, findManagedSubagentFiles } from "@agentxm/extension-workspace";
+import { ExtensionLifecycleFailed } from "../../errors.js";
+import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { subagentLifecycleArtifact } from "./artifact.js";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { RenderedFilePathSchema } from "@agentxm/workspace-state";
+import { sanitizeName } from "@agentxm/workspace-state";
+import { installedRowsByName } from "@agentxm/workspace-state";
+const decodeRenderedFilePath = Schema.decodeUnknownSync(RenderedFilePathSchema);
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Disable-subagent operation handler.
+ *
+ * Determines lifecycle from the workspace read model, removes observable
+ * rendered files, and promotes implicit pack members to a direct disabled
+ * preference. Canonical source files are preserved for later re-enablement.
+ */
+export const disableSubagent = (op) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const agentRepo = yield* CodingAgentRepository;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
+    // Read lifecycle to determine promotion needs
+    const installedSubagents = yield* ws.records
+        .rows("subagent")
+        .pipe(Effect.map(installedRowsByName));
+    const installed = installedSubagents[op.args.subagentName];
+    const isImplicit = installed !== undefined && installed.lifecycle === "implicit";
+    const graph = yield* ws.getDesiredStateGraph();
+    if (!graph.complete) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: "Cannot disable the subagent while pack-derived desired state is unresolved.",
+        });
+    }
+    const desiredBeforeDisable = graph.nodes.find((node) => node.type === "subagent" && node.name === op.args.subagentName);
+    const renderedFiles = {};
+    const configuredAgents = yield* agentRepo.getConfiguredAgents();
+    yield* ws.runTransaction({
+        transition: Effect.gen(function* () {
+            if (isImplicit) {
+                const source = desiredBeforeDisable?.source ?? Option.getOrElse(installed.source, () => undefined);
+                if (source === undefined) {
+                    return yield* new ExtensionLifecycleFailed({
+                        category: "internal",
+                        detail: `Cannot determine source for implicit subagent "${op.args.subagentName}"`,
+                        suggestions: [{ description: "Provide a source when disabling this subagent" }],
+                    });
+                }
+                yield* ws.setSubagentEntry(op.args.subagentName, {
+                    source,
+                    enabled: false,
+                });
+            }
+            else {
+                yield* ws.updateSubagentEntry(op.args.subagentName, (entry) => ({
+                    ...entry,
+                    enabled: false,
+                }));
+            }
+            yield* Effect.forEach(configuredAgents, (agent) => agent.resolveEffectiveSubagentsDir({ workspaceRoot: ws.baseDir, scope: ws.scope }).pipe(Effect.provide(fsPathLayer), Effect.flatMap((resolved) => resolved._tag === "supported"
+                ? findManagedSubagentFiles(resolved.dir, sanitizeName(op.args.subagentName)).pipe(Effect.provide(fsPathLayer), Effect.flatMap((managedPaths) => {
+                    renderedFiles[agent.id] = managedPaths.map((filePath) => ({
+                        path: path.relative(ws.baseDir, filePath),
+                    }));
+                    return agent
+                        .removeSubagent({
+                        workspaceRoot: ws.baseDir,
+                        scope: ws.scope,
+                        subagentName: op.args.subagentName,
+                        renderedFilePaths: managedPaths.map((filePath) => decodeRenderedFilePath(path.relative(ws.baseDir, filePath))),
+                    })
+                        .pipe(Effect.flatMap((outcome) => outcome._tag === "conflict"
+                        ? new ExtensionLifecycleFailed({
+                            category: "conflict",
+                            detail: `Subagent removal failed for ${agent.id}: ${outcome.reason}`,
+                        })
+                        : Effect.void));
+                }))
+                : Effect.void)), { concurrency: "unbounded" });
+        }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)),
+        validate: () => Effect.void,
+    });
+    return {
+        result: "success",
+        message: `Disabled ${op.args.subagentName}`,
+        artifact: subagentLifecycleArtifact({
+            name: op.args.subagentName,
+            scope: ws.scope,
+            ...(configuredAgents.length === 0
+                ? {}
+                : { agents: configuredAgents.map((agent) => agent.id) }),
+            change: "updated",
+            renderedFiles,
+            renderedChange: "removed",
+        }),
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=disable.js.map

package/dist/src/subagents/operations/enable.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Enable subagent executor — re-renders agent-native files for a previously disabled subagent.
+ *
+ * Enabling requires canonical content backed by a usable accepted resolution.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import type { OperationHandler } from "@agentxm/workspace-operations";
+import type { Operation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+/**
+ * Enable a previously disabled subagent (re-render files and update state).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type EnableSubagentOperation = Operation<"enable-subagent", {
+    readonly subagentName: string;
+}>;
+/**
+ * Enable-subagent operation handler.
+ *
+ * Resolves accepted canonical content, renders to configured agents, and then
+ * updates the desired settings entry.
+ */
+export declare const enableSubagent: OperationHandler<EnableSubagentOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+//# sourceMappingURL=enable.d.ts.map

package/dist/src/subagents/operations/enable.js

@@ -0,0 +1,160 @@
+/**
+ * Enable subagent executor — re-renders agent-native files for a previously disabled subagent.
+ *
+ * Enabling requires canonical content backed by a usable accepted resolution.
+ *
+ * @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 Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { CodingAgentRepository, subagentContentFilename, subagentContentPath, warnOnOrphanOverrides, managedSubagentFile, } from "@agentxm/extension-workspace";
+import { ExtensionLifecycleFailed } from "../../errors.js";
+import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { RenderedFilesMapSchema } from "@agentxm/workspace-state";
+import { makeWorkspaceRelativePath } from "@agentxm/extension-model/unstable/path-types";
+import { parseSubagentMd } from "@agentxm/registry-protocol/unstable/content/subagent-content";
+import { subagentLifecycleArtifact } from "./artifact.js";
+import { usableAcceptedCanonical } from "@agentxm/workspace-state";
+/**
+ * Strip the meta-only `agentOverrides` key from a frontmatter map so it does
+ * not leak into rendered files.
+ */
+const stripAgentOverrides = (fm) => {
+    if (!("agentOverrides" in fm))
+        return fm;
+    const { agentOverrides: _agentOverrides, ...rest } = fm;
+    return rest;
+};
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Enable-subagent operation handler.
+ *
+ * Resolves accepted canonical content, renders to configured agents, and then
+ * updates the desired settings entry.
+ */
+export const enableSubagent = (op) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const ws = yield* WorkspaceMutations;
+    const agentRepo = yield* CodingAgentRepository;
+    const canonical = yield* usableAcceptedCanonical({
+        workspace: ws,
+        type: "subagent",
+        name: op.args.subagentName,
+    });
+    if (Option.isNone(canonical) || canonical.value.ref.type !== "subagent") {
+        return yield* new ExtensionLifecycleFailed({
+            category: "not_found",
+            detail: `Accepted subagent content for "${op.args.subagentName}" is not usable`,
+            suggestions: [
+                {
+                    description: "Try reinstalling the subagent.",
+                    cmd: "axm subagents install <source>",
+                },
+            ],
+        });
+    }
+    const baseDir = ws.baseDir;
+    const subagentSrcPath = canonical.value.ref.refType === "registry" || canonical.value.ref.refType === "workspace"
+        ? path.join(canonical.value.observation.path, "src")
+        : canonical.value.observation.path;
+    // Read and parse the subagent content file
+    const expectedFilename = subagentContentFilename(op.args.subagentName);
+    const contentPath = subagentContentPath(path.join, subagentSrcPath, op.args.subagentName);
+    const sourcePath = makeWorkspaceRelativePath(path, baseDir, contentPath);
+    if (Option.isNone(sourcePath)) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "internal",
+            detail: `Subagent source path escapes workspace root: ${contentPath}`,
+        });
+    }
+    const managedFile = managedSubagentFile(canonical.value.ref, sourcePath.value);
+    const rawContent = yield* fs.readFileString(contentPath).pipe(Effect.mapError((error) => new ExtensionLifecycleFailed({
+        category: "internal",
+        detail: `Failed to read ${expectedFilename} from ${subagentSrcPath}`,
+        suggestions: [
+            {
+                description: `Ensure the subagent content file exists at ${contentPath}.`,
+            },
+        ],
+        cause: error,
+    })));
+    const parsed = yield* parseSubagentMd(rawContent, op.args.subagentName).pipe();
+    const frontmatter = Option.getOrElse(parsed.frontmatter, () => ({}));
+    const agentOverrides = Option.getOrUndefined(parsed.agentOverrides);
+    const renderFrontmatter = stripAgentOverrides(frontmatter);
+    // Render to all configured agents
+    const configuredAgents = yield* agentRepo.getConfiguredAgents();
+    yield* warnOnOrphanOverrides(`Subagent "${op.args.subagentName}"`, agentOverrides, configuredAgents.map((a) => a.id));
+    const renderedFilesMap = {};
+    yield* ws.runTransaction({
+        transition: Effect.gen(function* () {
+            yield* Effect.forEach(configuredAgents, (agent) => agent
+                .addSubagent({
+                workspaceRoot: baseDir,
+                scope: ws.scope,
+                managedFile,
+                input: {
+                    agentId: agent.id,
+                    name: op.args.subagentName,
+                    body: parsed.body,
+                    frontmatter: renderFrontmatter,
+                    agentOverrides: agentOverrides?.[agent.id],
+                },
+                force: false,
+            })
+                .pipe(Effect.flatMap((outcome) => {
+                if (outcome._tag === "conflict") {
+                    return new ExtensionLifecycleFailed({
+                        category: "conflict",
+                        detail: `Subagent rendering failed for ${agent.id}: ${outcome.reason}`,
+                    });
+                }
+                if (outcome._tag !== "success")
+                    return Effect.void;
+                return Effect.forEach(outcome.renderedFilePaths, (renderedPath) => {
+                    const relativePath = makeWorkspaceRelativePath(path, baseDir, renderedPath);
+                    if (Option.isNone(relativePath)) {
+                        return Effect.fail(new ExtensionLifecycleFailed({
+                            category: "internal",
+                            detail: `Rendered subagent path escapes workspace root: ${renderedPath}`,
+                        }));
+                    }
+                    return Effect.succeed({ path: relativePath.value });
+                }).pipe(Effect.map((entries) => {
+                    renderedFilesMap[agent.id] = entries;
+                }));
+            })), { concurrency: "unbounded" });
+            yield* ws.updateSubagentEntry(op.args.subagentName, (entry) => ({
+                ...entry,
+                enabled: true,
+            }));
+        }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)),
+        validate: () => Effect.void,
+    });
+    const decodeRenderedFiles = Schema.decodeUnknownSync(RenderedFilesMapSchema);
+    const renderedFiles = decodeRenderedFiles(renderedFilesMap);
+    const version = canonical.value.accepted?.type === "registry"
+        ? canonical.value.accepted.resolvedVersion
+        : undefined;
+    return {
+        result: "success",
+        message: `Enabled ${op.args.subagentName}`,
+        artifact: subagentLifecycleArtifact({
+            name: op.args.subagentName,
+            scope: ws.scope,
+            agents: configuredAgents.map((agent) => agent.id),
+            ...(version === undefined ? {} : { version }),
+            change: "updated",
+            renderedFiles,
+            renderedChange: "updated",
+        }),
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=enable.js.map

package/dist/src/workflows/install-command/workflow.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared install command workflow orchestration.
+ *
+ * Defines the `InstallExtensionCommandWorkflowActions` interface and
+ * `runInstallCommandWorkflow` function shared by all install command handlers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { Plan } from "@agentxm/workspace-operations";
+import type { OperationResolution } from "@agentxm/workspace-operations";
+import type { PlanExecution } from "@agentxm/workspace-operations";
+import { LifecycleResolutionProgress } from "../../resolution-progress.js";
+/**
+ * Type-specific actions for install command workflows.
+ *
+ * Each extension type provides its own implementation of these actions.
+ * The generic type parameters allow full type safety per extension type.
+ *
+ * @typeParam Args - Raw command arguments from the active CLI parser
+ * @typeParam Parsed - Parsed/validated arguments
+ * @typeParam Req - Source request type (for resolution)
+ * @typeParam Ref - Extension ref type (discovery output)
+ * @typeParam Intent - Command-specific install intent
+ * @typeParam ParseError - Failures the argument/plan phases surface
+ * @typeParam ResolveError - Failures the interactive resolution phases surface
+ */
+export interface InstallExtensionCommandWorkflowActions<Args, Parsed, Req, Ref, Intent, ParseError, ResolveError = ParseError> {
+    readonly parseArgs: (args: Args) => Effect.Effect<Parsed, ParseError>;
+    readonly resolveSourceRequests: (parsed: Parsed) => Effect.Effect<ReadonlyArray<Req>, ResolveError>;
+    readonly discoverRefs: (reqs: ReadonlyArray<Req>) => Effect.Effect<ReadonlyArray<Ref>, ParseError, Scope.Scope>;
+    readonly finalizeIntent: (parsed: Parsed, refs: ReadonlyArray<Ref>) => Effect.Effect<Intent, ResolveError>;
+    readonly buildPlan: (intent: Intent) => Effect.Effect<Plan, ParseError>;
+}
+/**
+ * Run the canonical install command workflow.
+ *
+ * Executes phases in order: parse -> resolveSource -> discover ->
+ * finalizeIntent -> buildPlan -> previewOrApplyPlan.
+ */
+export declare const buildInstallCommandPlan: <Args, Parsed, Req, Ref, Intent, ParseError, ResolveError, TransformError = never, TransformRequirements = never>(args: Args, actions: InstallExtensionCommandWorkflowActions<Args, Parsed, Req, Ref, Intent, ParseError, ResolveError>, options?: {
+    readonly transformIntent?: (intent: Intent) => Intent;
+    readonly transformPlan?: (plan: Plan) => Effect.Effect<Plan, TransformError, TransformRequirements>;
+}) => Effect.Effect<Plan<never, never>, ParseError | ResolveError | TransformError, Scope.Scope | TransformRequirements>;
+/**
+ * Run the canonical install command workflow.
+ *
+ * Executes phases in order: parse -> resolveSource -> discover ->
+ * finalizeIntent -> buildPlan -> previewOrApplyPlan.
+ */
+export declare const runInstallCommandWorkflow: <Args, Parsed, Req, Ref, Intent, ParseError, ResolveError, TransformError = never, TransformRequirements = never>(args: Args, actions: InstallExtensionCommandWorkflowActions<Args, Parsed, Req, Ref, Intent, ParseError, ResolveError>, options: {
+    readonly execution: PlanExecution;
+    readonly transformIntent?: (intent: Intent) => Intent;
+    readonly transformPlan?: (plan: Plan) => Effect.Effect<Plan, TransformError, TransformRequirements>;
+}) => Effect.Effect<OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | ParseError | ResolveError | TransformError | import("@agentxm/workspace-operations").CandidateFingerprintFailed | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-state").WorkspaceTransitionAcquireFailure | import("@agentxm/workspace-state").LockfileValidationError, import("@agentxm/workspace-state").WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/Path").Path | LifecycleResolutionProgress | import("@agentxm/workspace-operations").ResolvePlanInteraction | Exclude<TransformRequirements, Scope.Scope>>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/src/workflows/install-command/workflow.js

@@ -0,0 +1,41 @@
+/**
+ * Shared install command workflow orchestration.
+ *
+ * Defines the `InstallExtensionCommandWorkflowActions` interface and
+ * `runInstallCommandWorkflow` function shared by all install command handlers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { previewOrApplyPlan } from "@agentxm/workspace-operations";
+import { LifecycleResolutionProgress } from "../../resolution-progress.js";
+// -----------------------------------------------------------------------------
+// Install Command Workflow
+// -----------------------------------------------------------------------------
+/**
+ * Run the canonical install command workflow.
+ *
+ * Executes phases in order: parse -> resolveSource -> discover ->
+ * finalizeIntent -> buildPlan -> previewOrApplyPlan.
+ */
+export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(function* () {
+    const parsed = yield* actions.parseArgs(args);
+    const sourceRequests = yield* actions.resolveSourceRequests(parsed);
+    const refs = yield* actions.discoverRefs(sourceRequests);
+    const finalizedIntent = yield* actions.finalizeIntent(parsed, refs);
+    const intent = options?.transformIntent?.(finalizedIntent) ?? finalizedIntent;
+    const plan = yield* actions.buildPlan(intent);
+    return options?.transformPlan === undefined ? plan : yield* options.transformPlan(plan);
+});
+/**
+ * Run the canonical install command workflow.
+ *
+ * Executes phases in order: parse -> resolveSource -> discover ->
+ * finalizeIntent -> buildPlan -> previewOrApplyPlan.
+ */
+export const runInstallCommandWorkflow = (args, actions, options) => Effect.gen(function* () {
+    const progress = yield* LifecycleResolutionProgress;
+    const plan = yield* progress.withSourceResolution(buildInstallCommandPlan(args, actions, options));
+    return yield* previewOrApplyPlan(plan, { execution: options.execution });
+}).pipe(Effect.scoped, Effect.map((resolution) => resolution));
+//# sourceMappingURL=workflow.js.map

package/dist/src/workflows/uninstall-command/workflow.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared uninstall command workflow orchestration.
+ *
+ * Defines the `UninstallExtensionCommandWorkflowActions` interface and
+ * `runUninstallCommandWorkflow` function shared by all uninstall command handlers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type { Plan } from "@agentxm/workspace-operations";
+import type { StepFailure } from "@agentxm/workspace-operations";
+import type { OperationResolution } from "@agentxm/workspace-operations";
+import type { PlanExecution } from "@agentxm/workspace-operations";
+/**
+ * Type-specific actions for uninstall command workflows.
+ *
+ * Each extension type provides its own implementation of these actions.
+ * The generic type parameters allow full type safety per extension type.
+ *
+ * @typeParam Args - Raw command arguments from the active CLI parser
+ * @typeParam Parsed - Parsed/validated arguments
+ * @typeParam Intent - Command-specific uninstall intent
+ * @typeParam E - Failures the phases surface
+ */
+export interface UninstallExtensionCommandWorkflowActions<Args, Parsed, Intent, E> {
+    readonly parseArgs: (args: Args) => Effect.Effect<Parsed, E>;
+    readonly finalizeIntent: (parsed: Parsed) => Effect.Effect<Intent, E>;
+    readonly buildUninstallPlan: (intent: Intent, flags: UninstallWorkflowFlags) => Effect.Effect<Plan, E>;
+}
+export interface UninstallWorkflowFlags {
+    readonly execution: PlanExecution;
+    /** Optional delayed gate; candidate freshness is checked again after it completes. */
+    readonly beforeApply?: () => Effect.Effect<void, StepFailure>;
+}
+/**
+ * Run the canonical uninstall command workflow.
+ *
+ * Executes phases in order: parse -> finalizeIntent -> buildUninstallPlan ->
+ * previewOrApplyPlan.
+ */
+export declare const runUninstallCommandWorkflow: <Args, Parsed, Intent, E>(args: Args, actions: UninstallExtensionCommandWorkflowActions<Args, Parsed, Intent, E>, flags: UninstallWorkflowFlags) => Effect.Effect<OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").CandidateFingerprintFailed | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-state").WorkspaceTransitionAcquireFailure | import("@agentxm/workspace-state").LockfileValidationError | E, import("@agentxm/workspace-state").WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("@agentxm/workspace-operations").ResolvePlanInteraction>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/src/workflows/uninstall-command/workflow.js

@@ -0,0 +1,29 @@
+/**
+ * Shared uninstall command workflow orchestration.
+ *
+ * Defines the `UninstallExtensionCommandWorkflowActions` interface and
+ * `runUninstallCommandWorkflow` function shared by all uninstall command handlers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { previewOrApplyPlan } from "@agentxm/workspace-operations";
+// -----------------------------------------------------------------------------
+// Uninstall Command Workflow
+// -----------------------------------------------------------------------------
+/**
+ * Run the canonical uninstall command workflow.
+ *
+ * Executes phases in order: parse -> finalizeIntent -> buildUninstallPlan ->
+ * previewOrApplyPlan.
+ */
+export const runUninstallCommandWorkflow = (args, actions, flags) => Effect.gen(function* () {
+    const parsed = yield* actions.parseArgs(args);
+    const intent = yield* actions.finalizeIntent(parsed);
+    const plan = yield* actions.buildUninstallPlan(intent, flags);
+    return yield* previewOrApplyPlan(plan, {
+        execution: flags.execution,
+        ...(flags.beforeApply === undefined ? {} : { beforeApply: flags.beforeApply }),
+    });
+}).pipe(Effect.map((resolution) => resolution));
+//# sourceMappingURL=workflow.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@agentxm/extension-lifecycle",
+  "version": "0.28.4-bootstrap.0",
+  "description": "AXM extension-lifecycle feature: install, update, uninstall, enable, and disable policy across root and type-specific command forms for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
+  "type": "module",
+  "license": "FSL-1.1-MIT",
+  "homepage": "https://axm.sh",
+  "bugs": {
+    "url": "https://github.com/agentxm/axm/issues"
+  },
+  "author": "AgentXM <hello@agentxm.ai> (https://agentxm.ai)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git",
+    "directory": "packages/extension-lifecycle"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./live": {
+      "types": "./dist/src/live.d.ts",
+      "default": "./dist/src/live.js"
+    }
+  },
+  "files": [
+    "dist/src/",
+    "!**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112",
+    "semver": "^7.8.5",
+    "@agentxm/registry-client": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-sources": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-model": "^0.28.4-bootstrap.0",
+    "@agentxm/workspace-state": "^0.28.4-bootstrap.0",
+    "@agentxm/registry-protocol": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-workspace": "^0.28.4-bootstrap.0",
+    "@agentxm/workspace-operations": "^0.28.4-bootstrap.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/bun": "^1.3.14",
+    "@types/semver": "^7.5.8",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10",
+    "yaml": "^2.9.0"
+  }
+}