@agentxm/extension-lifecycle 0.28.4-bootstrap.0

package/dist/src/live.js

@@ -0,0 +1,18 @@
+/**
+ * Environment-backed layers of the extension-lifecycle feature: the seven
+ * per-type manager implementations behind the extension-workspace manager
+ * contracts, and the hook-backed configured-agent-outcomes provider. Only
+ * application composition roots import this module.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { HookManagerLive } from "./hooks/manager.js";
+export { HookConfiguredAgentOutcomesProviderLive } from "./hooks/configured-agent-outcomes-provider.js";
+export { RuleManagerLive } from "./rules/manager.js";
+export { SkillManagerLive } from "./skills/manager.js";
+export { SubagentManagerLive } from "./subagents/manager.js";
+export { McpServerManagerLive } from "./mcps/manager.js";
+export { PackManagerLive } from "./packs/manager.js";
+export { KnowledgeManagerLive } from "./knowledge/manager.js";
+//# sourceMappingURL=live.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * MCP server extension manager service.
+ *
+ * Implements ExtensionManager<McpServerExtensionRef>. Delegates to existing
+ * MCP server materialization functions and workspace service methods.
+ *
+ * @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 Path from "effect/Path";
+import * as Layer from "effect/Layer";
+import { McpServerManager } from "@agentxm/extension-workspace";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+export declare const McpServerManagerLive: Layer.Layer<McpServerManager, never, WorkspaceMutations | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+//# sourceMappingURL=manager.d.ts.map

package/dist/src/mcps/manager.js

@@ -0,0 +1,213 @@
+/**
+ * MCP server extension manager service.
+ *
+ * Implements ExtensionManager<McpServerExtensionRef>. Delegates to existing
+ * MCP server materialization functions and workspace service methods.
+ *
+ * @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 Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { McpConfigIoFailed, McpInstallStateMissing, McpRegistryOnlyInstall, removeMcpServerFromManifest, applyProjectionPlans, planSingletonProjection, } from "@agentxm/extension-workspace";
+import { McpServerManager } from "@agentxm/extension-workspace";
+import { configuredMcpServersToDiskRefs } from "@agentxm/extension-workspace";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { canReuseInstalledPackage } from "@agentxm/extension-workspace";
+import { materializeRegistryPackageWithTreeIntegrity } from "../registry-materialization.js";
+import { computeExtensionPathsForLayout } 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 { protectWorkspacePath } from "@agentxm/workspace-state";
+import { computeMaterializedTreeIntegrity } from "@agentxm/workspace-state";
+// Build lock entry from registry ref
+const buildMcpServerLockEntry = (ref, treeIntegrity) => ({
+    type: "registry",
+    sourceType: "registry",
+    packageFormat: "agentxm",
+    endpoint: ref.source.location,
+    extensionType: "mcp-server",
+    workspaceName: ref.server.name,
+    owner: ref.owner,
+    name: ref.name,
+    resolvedVersion: decodeVersionSync(ref.version),
+    integrity: Option.getOrElse(ref.integrity, () => ""),
+    sourceName: ref.source.name,
+    publisherBindingId: ref.publisherBindingId,
+    treeIntegrity,
+});
+// -----------------------------------------------------------------------------
+// Live Layer
+// -----------------------------------------------------------------------------
+export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const fs = yield* FileSystem.FileSystem;
+    const httpClient = yield* HttpClient.HttpClient;
+    const path = yield* Path.Path;
+    const baseDir = ws.baseDir;
+    // Build a layer to provide FileSystem + Path to inner effects
+    const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path), Layer.succeed(HttpClient.HttpClient, httpClient));
+    const provide = (effect) => Effect.provide(effect, fsPathLayer);
+    const lastTreeIntegrities = new Map();
+    const materializeInstall = Effect.fn("McpServerManager.materializeInstall")(function* ({ ref, force }) {
+        if (ref.refType !== "registry") {
+            return yield* new McpRegistryOnlyInstall({
+                serverName: ref.server.name,
+                refType: ref.refType,
+            });
+        }
+        const registryRef = ref;
+        const canonicalPath = computeExtensionPathsForLayout(path.join, ws.layout, registryRef, "mcps", registryRef.name).canonicalPath;
+        const lockedEntry = yield* ws.getLockedMcpServer(registryRef.server.name);
+        const lockedVersion = acceptedRegistryVersionForRef(lockedEntry, registryRef);
+        const useExisting = yield* provide(canReuseInstalledPackage({
+            installedPath: canonicalPath,
+            force: force === true,
+            refVersion: registryRef.version,
+            hasIntegrity: Option.isSome(registryRef.integrity),
+            ...(lockedVersion === undefined ? {} : { lockedVersion }),
+            existsFailureDetail: (target) => `Failed to check if canonical path exists: ${target}`,
+        }));
+        if (useExisting && Option.isSome(lockedEntry)) {
+            const observedTree = yield* provide(computeMaterializedTreeIntegrity(canonicalPath));
+            if (observedTree === lockedEntry.value.treeIntegrity) {
+                lastTreeIntegrities.set(registryRef.server.name, lockedEntry.value.treeIntegrity);
+                return;
+            }
+        }
+        const materialized = yield* provide(materializeRegistryPackageWithTreeIntegrity({
+            baseDir,
+            destinationPath: canonicalPath,
+            sourceLocation: registryRef.source.location,
+            owner: registryRef.owner,
+            type: "mcp-server",
+            name: registryRef.name,
+            version: registryRef.version,
+            integrity: registryRef.integrity,
+            messages: {
+                integrityMismatchDetail: `Integrity mismatch for ${registryRef.name}@${registryRef.version}`,
+            },
+        }));
+        lastTreeIntegrities.set(registryRef.server.name, materialized.treeIntegrity);
+    }, Effect.asVoid);
+    const makeMaterializeRemoval = (retainCanonical) => Effect.fn("McpServerManager.materializeRemoval")(function* ({ target }) {
+        const configuredAgents = yield* ws.getConfiguredAgents();
+        yield* applyProjectionPlans(configuredAgents.map((agentId) => planSingletonProjection({
+            unitId: "mcp-server:native-config-entry",
+            // Multiple configured agents may share one native config file.
+            targetFile: `mcp:${target.name}:configured-agents`,
+            contributor: target,
+            adapter: {
+                observe: () => Effect.succeed({
+                    unitId: "mcp-server:native-config-entry",
+                    path: `${agentId}:${target.name}`,
+                    present: true,
+                    current: false,
+                    expectedContributors: [],
+                    observedContributors: [target.name],
+                }),
+                apply: () => provide(removeMcpServerFromManifest(agentId, {
+                    workspaceRoot: baseDir,
+                    scope: ws.scope,
+                    serverName: target.name,
+                })).pipe(Effect.asVoid),
+            },
+        })));
+        if (retainCanonical)
+            return;
+        const canonical = yield* provide(acceptedCanonicalObservation({
+            workspace: ws,
+            type: "mcp-server",
+            name: target.name,
+        }));
+        const serverPath = removableAcceptedCanonicalPath(canonical);
+        if (Option.isSome(serverPath)) {
+            yield* protectWorkspacePath(serverPath.value);
+            yield* fs.remove(serverPath.value, { recursive: true, force: true }).pipe(Effect.mapError((cause) => new McpConfigIoFailed({
+                detail: `Failed to remove MCP server package: ${serverPath.value}`,
+                cause,
+            })));
+        }
+    }, Effect.asVoid);
+    const materializeUninstall = makeMaterializeRemoval(false);
+    const materializeDeactivate = makeMaterializeRemoval(true);
+    return {
+        type: "mcp-server",
+        runTransaction: ws.runTransaction,
+        isInstalled: Effect.fn("McpServerManager.isInstalled")(function* ({ target, }) {
+            return yield* isObservedInstalled(ws, "mcp-server", target.name);
+        }),
+        materializeInstall,
+        prepareSourceTransition: ({ ref }) => provide(prepareAcceptedCanonicalTransition({
+            workspace: ws,
+            type: "mcp-server",
+            name: ref.server.name,
+            ref,
+        })),
+        getConfiguredSource: Effect.fn("McpServerManager.getConfiguredSource")(function* ({ target, }) {
+            const configured = yield* ws.getConfiguredMcpServerEntries();
+            return Option.fromUndefinedOr(configured[target.name]?.source);
+        }),
+        isConfigured: Effect.fn("McpServerManager.isConfigured")(function* ({ target }) {
+            const configured = yield* ws.getConfiguredMcpServerEntries();
+            return configured[target.name] !== undefined;
+        }),
+        listMaterializable: Effect.fn("McpServerManager.listMaterializable")(function* () {
+            const configured = yield* ws.records
+                .rows("mcp-server")
+                .pipe(Effect.map(configuredRowsByName));
+            return yield* configuredMcpServersToDiskRefs({ fs, path, baseDir, scope: ws.scope, layout: ws.layout }, configured);
+        }),
+        materializeUninstall,
+        materializeDeactivate,
+        upsertSettingsEntry: ({ ref, versionRange, }) => {
+            if (ref.refType !== "registry")
+                return Effect.void.pipe(Effect.withSpan("McpServerManager.upsertSettingsEntry"));
+            const registryRef = ref;
+            return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
+                const treeIntegrity = lastTreeIntegrities.get(registryRef.server.name);
+                if (treeIntegrity === undefined) {
+                    return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
+                }
+                const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity);
+                return ws.setMcpServer({
+                    name: ref.server.name,
+                    lockEntry,
+                    versionRange,
+                });
+            }), Effect.withSpan("McpServerManager.upsertSettingsEntry"));
+        },
+        removeSettingsEntry: ({ target }) => ws
+            .removeMcpServerSettings(target.name)
+            .pipe(Effect.withSpan("McpServerManager.removeSettingsEntry")),
+        upsertLockfileEntry: ({ ref }) => {
+            if (ref.refType !== "registry")
+                return ws
+                    .removeMcpServerLock(ref.server.name)
+                    .pipe(Effect.withSpan("McpServerManager.upsertLockfileEntry"));
+            const registryRef = ref;
+            return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
+                const treeIntegrity = lastTreeIntegrities.get(registryRef.server.name);
+                if (treeIntegrity === undefined) {
+                    return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
+                }
+                const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity);
+                return ws.setMcpServerLock({
+                    name: ref.server.name,
+                    lockEntry,
+                    versionRange: Option.none(),
+                });
+            }), Effect.withSpan("McpServerManager.upsertLockfileEntry"));
+        },
+        removeLockfileEntry: ({ target }) => ws
+            .removeMcpServerLock(target.name)
+            .pipe(Effect.withSpan("McpServerManager.removeLockfileEntry")),
+    };
+}));
+//# sourceMappingURL=manager.js.map

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

@@ -0,0 +1,24 @@
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { McpServerLockEntry } from "@agentxm/workspace-state";
+import type { JobStepArtifact, JobStepArtifactTarget } from "@agentxm/workspace-operations";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+export declare const mcpConfigSurface: (scope: WorkspaceScope) => string;
+export declare const MCP_AGENT_CONFIG_SURFACE = ".mcp.json";
+export declare const mcpServerVersion: (entry: McpServerLockEntry) => string | undefined;
+export declare const mcpServerSourcePath: (scope: WorkspaceScope, entry: McpServerLockEntry) => string;
+export declare const agentConfigTarget: (change: JobStepArtifactTarget["change"], agentIds: ReadonlyArray<AgentId>) => JobStepArtifactTarget | undefined;
+export interface AgentMcpConfigOutcome {
+    readonly agentId: string;
+    readonly targets?: ReadonlyArray<JobStepArtifactTarget>;
+}
+export declare const agentConfigTargets: (outcomes: ReadonlyArray<AgentMcpConfigOutcome>) => ReadonlyArray<JobStepArtifactTarget>;
+export declare const mcpSettingsTarget: (scope: WorkspaceScope, change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
+export declare const mcpSourceTarget: (scope: WorkspaceScope, entry: McpServerLockEntry, change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
+export declare const mcpServerArtifact: (args: {
+    readonly lockEntry: McpServerLockEntry | undefined;
+    readonly scope: JobStepArtifact["scope"];
+    readonly change: JobStepArtifact["change"];
+    readonly targets: ReadonlyArray<JobStepArtifactTarget>;
+    readonly agents?: ReadonlyArray<string>;
+}) => JobStepArtifact;
+//# sourceMappingURL=artifact.d.ts.map

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

@@ -0,0 +1,74 @@
+import { ACQUIRED_EXTENSIONS_DIR } from "@agentxm/workspace-state";
+import { acquiredExtensionDisplayPathFromLockEntry } from "@agentxm/workspace-state";
+export const mcpConfigSurface = (scope) => scope === "project"
+    ? "axm.json / axm-lock.yaml"
+    : ".axm/workspace/axm.json / .axm/workspace/axm-lock.yaml";
+export const MCP_AGENT_CONFIG_SURFACE = ".mcp.json";
+export const mcpServerVersion = (entry) => entry.type === "registry" ? entry.resolvedVersion : undefined;
+export const mcpServerSourcePath = (scope, entry) => acquiredExtensionDisplayPathFromLockEntry(scope === "project" ? ACQUIRED_EXTENSIONS_DIR : ".axm/workspace/agent_extensions", entry, "mcps", entry.workspaceName);
+export const agentConfigTarget = (change, agentIds) => agentIds.length === 0
+    ? undefined
+    : {
+        path: MCP_AGENT_CONFIG_SURFACE,
+        change,
+        agentIds,
+    };
+const mergeTargetChange = (current, next) => {
+    if (current === "created" || next === "created")
+        return "created";
+    if (current === "updated" || next === "updated")
+        return "updated";
+    if (current === "removed" || next === "removed")
+        return "removed";
+    return "unchanged";
+};
+export const agentConfigTargets = (outcomes) => {
+    const grouped = new Map();
+    for (const outcome of outcomes) {
+        for (const target of outcome.targets ?? []) {
+            const existing = grouped.get(target.path);
+            if (existing === undefined) {
+                grouped.set(target.path, {
+                    path: target.path,
+                    change: target.change,
+                    agentIds: [outcome.agentId],
+                });
+                continue;
+            }
+            existing.change = mergeTargetChange(existing.change, target.change);
+            existing.agentIds.push(outcome.agentId);
+        }
+    }
+    return Array.from(grouped.values()).map((target) => ({
+        path: target.path,
+        change: target.change,
+        agentIds: target.agentIds,
+    }));
+};
+export const mcpSettingsTarget = (scope, change) => ({
+    path: scope === "project" ? "axm.json" : ".axm/workspace/axm.json",
+    change,
+});
+export const mcpSourceTarget = (scope, entry, change) => ({
+    path: mcpServerSourcePath(scope, entry),
+    change,
+});
+export const mcpServerArtifact = (args) => {
+    const version = args.lockEntry === undefined ? undefined : mcpServerVersion(args.lockEntry);
+    return {
+        path: args.lockEntry === undefined
+            ? mcpConfigSurface(args.scope)
+            : mcpServerSourcePath(args.scope, args.lockEntry),
+        scope: args.scope,
+        change: args.change,
+        ...(args.agents === undefined ? {} : { agents: args.agents }),
+        ...(version === undefined ? {} : { version }),
+        ...(args.targets.length === 0
+            ? {}
+            : {
+                fileCount: args.targets.length,
+                targets: args.targets,
+            }),
+    };
+};
+//# sourceMappingURL=artifact.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Disable MCP server executor.
+ *
+ * @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 { CodingAgentRepository } from "@agentxm/extension-workspace";
+import type { StepFailure } from "@agentxm/workspace-operations";
+import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+export type DisableMcpServerOperation = Operation<"disable-mcp-server", {
+    readonly serverName: string;
+}>;
+export declare const disableMcpServer: (op: DisableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+//# sourceMappingURL=disable.d.ts.map

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

@@ -0,0 +1,113 @@
+/**
+ * Disable MCP server executor.
+ *
+ * @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 { CodingAgentRepository, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { appendWarningsToMessage } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
+import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
+import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
+import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { ExtensionLifecycleFailed } from "../../errors.js";
+export const disableMcpServer = (op) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const ws = yield* WorkspaceMutations;
+    const agentRepo = yield* CodingAgentRepository;
+    const configured = yield* ws.getConfiguredMcpServerEntries();
+    const entry = configured[op.args.serverName];
+    if (entry === undefined) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "not_found",
+            detail: `MCP server "${op.args.serverName}" not found in settings`,
+        });
+    }
+    const agents = yield* agentRepo.getConfiguredAgents();
+    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
+        entry,
+        agentIds: agents.map((agent) => agent.id),
+        scope: ws.scope,
+    });
+    if (sharedTargetConflict !== undefined) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "conflict",
+            detail: sharedTargetConflict,
+        });
+    }
+    const outcomes = yield* ws.runTransaction({
+        transition: Effect.gen(function* () {
+            const synced = yield* Effect.forEach(agents, (agent) => Effect.gen(function* () {
+                if (isMcpServerApplicableToAgent(entry, agent.id)) {
+                    return yield* agent.removeMcpServer({
+                        workspaceRoot: ws.baseDir,
+                        scope: ws.scope,
+                        serverName: op.args.serverName,
+                        disableOnly: true,
+                    });
+                }
+                const inspection = yield* inspectAgentMcpServer({
+                    workspaceRoot: ws.baseDir,
+                    scope: ws.scope,
+                    agentId: agent.id,
+                    serverName: op.args.serverName,
+                    entry,
+                });
+                if (inspection.status === "unmanaged") {
+                    return yield* new ExtensionLifecycleFailed({
+                        category: "conflict",
+                        detail: `${agent.id} has an unmanaged MCP server named ${op.args.serverName}; AXM will not remove it while applying the target policy`,
+                    });
+                }
+                return inspection.status === "drift"
+                    ? yield* agent.removeMcpServer({
+                        workspaceRoot: ws.baseDir,
+                        scope: ws.scope,
+                        serverName: op.args.serverName,
+                    })
+                    : { _tag: "success", targets: [] };
+            }), { concurrency: "unbounded" });
+            yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({
+                agentId: agent.id,
+                outcome: synced[index] ?? {
+                    _tag: "failed",
+                    reason: "Agent sync returned no outcome",
+                },
+            })));
+            yield* ws.updateMcpServerEntry(op.args.serverName, (current) => ({
+                ...current,
+                enabled: false,
+            }));
+            return synced;
+        }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)),
+        validate: () => Effect.void,
+    });
+    const syncedAgents = agents.flatMap((agent, index) => {
+        const outcome = outcomes[index];
+        return outcome !== undefined && "targets" in outcome
+            ? [{ agentId: agent.id, targets: outcome.targets }]
+            : [];
+    });
+    const warnings = mcpSyncWarnings(op.args.serverName, agents.map((agent, index) => ({
+        agentId: agent.id,
+        outcome: outcomes[index] ?? {
+            _tag: "failed",
+            reason: "Agent sync returned no outcome",
+        },
+    })));
+    return {
+        result: "success",
+        message: appendWarningsToMessage(`Disabled ${op.args.serverName}`, warnings),
+        artifact: mcpServerArtifact({
+            lockEntry: undefined,
+            scope: ws.scope,
+            change: "updated",
+            targets: [mcpSettingsTarget(ws.scope, "updated"), ...agentConfigTargets(syncedAgents)],
+        }),
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=disable.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Enable MCP server executor.
+ *
+ * @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 { CodingAgentRepository } from "@agentxm/extension-workspace";
+import type { StepFailure } from "@agentxm/workspace-operations";
+import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+export type EnableMcpServerOperation = Operation<"enable-mcp-server", {
+    readonly serverName: string;
+}>;
+export declare const enableMcpServer: (op: EnableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+//# sourceMappingURL=enable.d.ts.map