@agentxm/workspace-configuration 0.28.12 → 0.28.14-preview.1789139351.5cd4595aa

package/dist/src/errors.d.ts

@@ -8,6 +8,16 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
+import { StepFailure, type ApprovalRecoveryMissing, type CandidateFingerprintFailed, type PlanInteractionFailed } from "@agentxm/workspace-operations";
+import type { InvalidAgentId, LockfileValidationError, WorkspaceSettingsReadFailure, WorkspaceStateMutationFailure } from "@agentxm/workspace-state";
+import type { WorkspaceRestorationIncomplete, WorkspaceTransactionFailure, WorkspaceTransitionAcquireFailure } from "@agentxm/workspace-transactions";
+/**
+ * Every failure resolving a prepared change through the plan pipeline can
+ * surface: the workspace reads the candidate revalidates against, the
+ * approval and interaction refusals, and the transition the apply could not
+ * acquire. Step failures are carried inside the resolution, not raised.
+ */
+export type WorkspaceConfigurationExecutionFailure = ApprovalRecoveryMissing | CandidateFingerprintFailed | LockfileValidationError | PlanInteractionFailed | WorkspaceSettingsReadFailure | WorkspaceTransitionAcquireFailure;
 declare const WorkspaceConfigurationFailed_base: Schema.Class<WorkspaceConfigurationFailed, Schema.TaggedStruct<"WorkspaceConfigurationFailed", {
     readonly category: Schema.Literals<readonly ["conflict", "internal", "usage", "validation"]>;
     readonly detail: Schema.String;
@@ -26,5 +36,24 @@ declare const WorkspaceConfigurationFailed_base: Schema.Class<WorkspaceConfigura
  */
 export declare class WorkspaceConfigurationFailed extends WorkspaceConfigurationFailed_base {
 }
+/**
+ * Serialize a workspace-configuration failure into the plan-step vocabulary.
+ * The producer already chose the category and the sentence, so both carry
+ * over unchanged and the boundary renders the same words whether the failure
+ * surfaced from a step or from `prepare`.
+ */
+export declare const configurationFailedToStepFailure: (failure: WorkspaceConfigurationFailed) => StepFailure;
+/**
+ * Every failure a workspace change this feature plans can surface: the
+ * workspace's own read and write failures, the transaction machinery's, and
+ * a step that already speaks the serialized vocabulary.
+ */
+export type WorkspaceChangeFailure = InvalidAgentId | StepFailure | WorkspaceRestorationIncomplete | WorkspaceStateMutationFailure | WorkspaceTransactionFailure;
+/**
+ * Serialize a workspace change failure into the plan-step vocabulary. Read
+ * and transaction failures keep the sentences the capability already chose,
+ * so a failure reads the same wherever it was produced.
+ */
+export declare const workspaceChangeFailedToStepFailure: (failure: WorkspaceChangeFailure) => StepFailure;
 export {};
 //# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -8,6 +8,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
+import { StepFailure, restorationIncompleteToStepFailure, workspaceStateReadFailureToStepFailure, workspaceTransactionFailureToStepFailure, } from "@agentxm/workspace-operations";
 const CarriedSuggestedActionSchema = Schema.Struct({
     description: Schema.String,
     cmd: Schema.optional(Schema.String),
@@ -26,4 +27,71 @@ export class WorkspaceConfigurationFailed extends Schema.TaggedError()("Workspac
     cause: Schema.optional(Schema.Unknown),
 }) {
 }
+/**
+ * Serialize a workspace-configuration failure into the plan-step vocabulary.
+ * The producer already chose the category and the sentence, so both carry
+ * over unchanged and the boundary renders the same words whether the failure
+ * surfaced from a step or from `prepare`.
+ */
+export const configurationFailedToStepFailure = (failure) => new StepFailure({
+    category: failure.category,
+    detail: failure.detail,
+    ...(failure.suggestions === undefined ? {} : { suggestions: failure.suggestions }),
+    ...(failure.cause === undefined ? {} : { cause: failure.cause }),
+});
+/**
+ * Serialize a workspace change failure into the plan-step vocabulary. Read
+ * and transaction failures keep the sentences the capability already chose,
+ * so a failure reads the same wherever it was produced.
+ */
+export const workspaceChangeFailedToStepFailure = (failure) => {
+    switch (failure._tag) {
+        case "StepFailure":
+            return failure;
+        case "SettingsDecodeError":
+        case "SettingsIoError":
+        case "SettingsParseError":
+        case "LockfileDecodeError":
+        case "LockfileIoError":
+        case "LockfileParseError":
+        case "LockfileVersionUnsupported":
+        case "WorkspaceRootEscape":
+            return workspaceStateReadFailureToStepFailure(failure);
+        case "TransitionLockError":
+        case "TransitionLockUnavailable":
+        case "WorkspaceDirectoryError":
+        case "WorkspaceSnapshotError":
+        case "WorkspaceTransitionCompromised":
+            return workspaceTransactionFailureToStepFailure(failure);
+        case "WorkspaceRestorationIncomplete":
+            return restorationIncompleteToStepFailure(failure);
+        case "InvalidAgentId":
+            return new StepFailure({
+                category: "validation",
+                detail: `Unknown agent ID: ${failure.agentId}`,
+                suggestions: [
+                    { description: "Inspect supported agent IDs.", cmd: "axm agents list --available" },
+                ],
+                cause: failure.cause,
+            });
+        case "SettingsWriteError":
+            return new StepFailure({
+                category: "internal",
+                detail: `Workspace settings at ${failure.path} could not be written`,
+                cause: failure.cause,
+            });
+        case "LockfileWriteError":
+            return new StepFailure({
+                category: "internal",
+                detail: `Workspace lockfile at ${failure.path} could not be written`,
+                cause: failure.cause,
+            });
+        case "LockfileValidationError":
+            return new StepFailure({
+                category: "validation",
+                detail: `Workspace lockfile at ${failure.path} could not be validated`,
+                cause: failure.cause,
+            });
+    }
+};
 //# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -1,18 +1,23 @@
 /**
- * Workspace-configuration feature: workspace initialization and setup flows,
- * configured-agent membership policy, instruction-management policy over the
- * kernel's instruction semantics, and inline workspace MCP capability policy.
+ * Workspace-configuration feature: setting up a workspace, deciding which
+ * coding agents it configures, managing instruction-file propagation, and
+ * defining MCP servers inline in the workspace's own settings.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-export { WorkspaceConfigurationFailed } from "./errors.js";
-export { bootstrapWorkspace, initializeProjectWorkspace, ensureUserWorkspaceInitialized, ensureProjectWorkspaceInitialized, type SetupAgentCandidate, } from "./initialization.js";
-export type { InstructionSourceChoice, SetupAgentScan, SetupPlanRow, WorkspaceInitializationInteractionService, } from "./initialization-interaction.js";
-export { WorkspaceInitializationCancelled, WorkspaceInitializationInteraction, } from "./initialization-interaction.js";
-export { activeInstructionsConfig, disableInstructionManagement, instructionReconciliationReadiness, instructionStateIsCurrent, observeInstructions, reconcileInstructionTransition, removeInstructionTargetsFor, type InstructionReadinessFailure, } from "./instruction-reconciliation.js";
-export { dedupe, makeAtomicMembershipSteps, validateAgentIds } from "./membership.js";
-export { makeInlineMcpDefinition, matchesInlineMcpEntry, parseInlineMcpEnv, parseInlineMcpHeaders, splitCommand, validateInlineMcpRemoteUrl, } from "./inline-mcp.js";
-export { preflightMcpImports, type InlineMcpDefinition, type McpImportAdoption, type McpImportCandidate, type McpImportFinding, type McpImportPreflight, type McpImportSource, } from "./mcp-import-preflight.js";
-export { applyMcpImport, collectMcpImportSources, removeConvertedMcpConfig } from "./mcp-import.js";
+export { WorkspaceConfigurationFailed, configurationFailedToStepFailure } from "./errors.js";
+export { bootstrapWorkspace, initializeProjectWorkspace, ensureUserWorkspaceInitialized, ensureProjectWorkspaceInitialized, type SetupAgentCandidate, } from "./setup/initialization.js";
+export type { InstructionSourceChoice, SetupAgentScan, SetupPlanRow, WorkspaceInitializationInteractionService, } from "./setup/initialization-interaction.js";
+export { WorkspaceInitializationCancelled, WorkspaceInitializationInteraction, } from "./setup/initialization-interaction.js";
+export { SetupOutcomeSchema, SetupWorkspace, prepareSetupWorkspace, previewOrApplySetupWorkspace, previewAgentDefault, reportSetupWorkspace, type BundledSkillReport, type SetupApprovalRequired, type SetupArtifactTarget, type SetupOutcome, type SetupPlanStep, type SetupReportFailure, type SetupReportRequest, type SetupTransition, type SetupWorkspaceCandidate, type SetupWorkspaceFailure, type SetupWorkspaceRequest, } from "./setup/setup-workspace.js";
+export { agentLifecycle, isCatalogAgentId, isRetiredAgent, lifecycleWarning, } from "./membership/agent-lifecycle.js";
+export { dedupe, validateAgentIds } from "./membership/validate-agent-ids.js";
+export { ConfigureAgents, ConfiguredAgentInventorySchema, listConfiguredAgents, prepareAddConfiguredAgents, prepareRemoveConfiguredAgents, previewOrApplyAddConfiguredAgents, previewOrApplyRemoveConfiguredAgents, type AddConfiguredAgentsCandidate, type AddConfiguredAgentsRequest, type ConfigureAgentsFailure, type ConfiguredAgentInventory, type ConfiguredAgentRow, type ConfiguredAgentsUnchanged, type DepartingAgentReconciliation, type ListConfiguredAgentsRequest, type MembershipExecutionRequirements, type MembershipReconciliation, type RemoveConfiguredAgentsCandidate, type RemoveConfiguredAgentsRequest, } from "./membership/configure-agents.js";
+export { InstructionsStatusSchema, ManageInstructions, instructionsStatus, prepareManageInstructions, previewOrApplyManageInstructions, type InstructionsStatus, type InstructionsUnchanged, type ManageInstructionsCandidate, type ManageInstructionsRequest, type ManageInstructionsRequirements, } from "./instructions/manage-instructions.js";
+export { makeInlineMcpDefinition, matchesInlineMcpEntry, parseInlineMcpEnv, parseInlineMcpHeaders, splitCommand, validateInlineMcpRemoteUrl, } from "./inline-mcp/definition.js";
+export { AddInlineMcpServer, prepareAddInlineMcpServer, previewOrApplyAddInlineMcpServer, type AddInlineMcpServerCandidate, type AddInlineMcpServerRequest, type AddInlineMcpServerRequirements, type InlineMcpServerUnchanged, } from "./inline-mcp/add-inline-mcp-server.js";
+export { preflightMcpImports, type InlineMcpDefinition, type McpImportAdoption, type McpImportCandidate, type McpImportFinding, type McpImportPreflight, type McpImportSource, } from "./mcp-import/preflight.js";
+export { applyMcpImport, collectMcpImportSources } from "./mcp-import/apply.js";
+export { ImportMcpServers, prepareImportMcpServers, previewOrApplyImportMcpServers, type ImportMcpServersCandidate, type ImportMcpServersRequirements, } from "./mcp-import/import-mcp-servers.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -1,17 +1,34 @@
 /**
- * Workspace-configuration feature: workspace initialization and setup flows,
- * configured-agent membership policy, instruction-management policy over the
- * kernel's instruction semantics, and inline workspace MCP capability policy.
+ * Workspace-configuration feature: setting up a workspace, deciding which
+ * coding agents it configures, managing instruction-file propagation, and
+ * defining MCP servers inline in the workspace's own settings.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-export { WorkspaceConfigurationFailed } from "./errors.js";
-export { bootstrapWorkspace, initializeProjectWorkspace, ensureUserWorkspaceInitialized, ensureProjectWorkspaceInitialized, } from "./initialization.js";
-export { WorkspaceInitializationCancelled, WorkspaceInitializationInteraction, } from "./initialization-interaction.js";
-export { activeInstructionsConfig, disableInstructionManagement, instructionReconciliationReadiness, instructionStateIsCurrent, observeInstructions, reconcileInstructionTransition, removeInstructionTargetsFor, } from "./instruction-reconciliation.js";
-export { dedupe, makeAtomicMembershipSteps, validateAgentIds } from "./membership.js";
-export { makeInlineMcpDefinition, matchesInlineMcpEntry, parseInlineMcpEnv, parseInlineMcpHeaders, splitCommand, validateInlineMcpRemoteUrl, } from "./inline-mcp.js";
-export { preflightMcpImports, } from "./mcp-import-preflight.js";
-export { applyMcpImport, collectMcpImportSources, removeConvertedMcpConfig } from "./mcp-import.js";
+export { WorkspaceConfigurationFailed, configurationFailedToStepFailure } from "./errors.js";
+// -----------------------------------------------------------------------------
+// Setup
+// -----------------------------------------------------------------------------
+export { bootstrapWorkspace, initializeProjectWorkspace, ensureUserWorkspaceInitialized, ensureProjectWorkspaceInitialized, } from "./setup/initialization.js";
+export { WorkspaceInitializationCancelled, WorkspaceInitializationInteraction, } from "./setup/initialization-interaction.js";
+export { SetupOutcomeSchema, SetupWorkspace, prepareSetupWorkspace, previewOrApplySetupWorkspace, previewAgentDefault, reportSetupWorkspace, } from "./setup/setup-workspace.js";
+// -----------------------------------------------------------------------------
+// Configured-agent membership
+// -----------------------------------------------------------------------------
+export { agentLifecycle, isCatalogAgentId, isRetiredAgent, lifecycleWarning, } from "./membership/agent-lifecycle.js";
+export { dedupe, validateAgentIds } from "./membership/validate-agent-ids.js";
+export { ConfigureAgents, ConfiguredAgentInventorySchema, listConfiguredAgents, prepareAddConfiguredAgents, prepareRemoveConfiguredAgents, previewOrApplyAddConfiguredAgents, previewOrApplyRemoveConfiguredAgents, } from "./membership/configure-agents.js";
+// -----------------------------------------------------------------------------
+// Instruction-file management
+// -----------------------------------------------------------------------------
+export { InstructionsStatusSchema, ManageInstructions, instructionsStatus, prepareManageInstructions, previewOrApplyManageInstructions, } from "./instructions/manage-instructions.js";
+// -----------------------------------------------------------------------------
+// Inline MCP servers
+// -----------------------------------------------------------------------------
+export { makeInlineMcpDefinition, matchesInlineMcpEntry, parseInlineMcpEnv, parseInlineMcpHeaders, splitCommand, validateInlineMcpRemoteUrl, } from "./inline-mcp/definition.js";
+export { AddInlineMcpServer, prepareAddInlineMcpServer, previewOrApplyAddInlineMcpServer, } from "./inline-mcp/add-inline-mcp-server.js";
+export { preflightMcpImports, } from "./mcp-import/preflight.js";
+export { applyMcpImport, collectMcpImportSources } from "./mcp-import/apply.js";
+export { ImportMcpServers, prepareImportMcpServers, previewOrApplyImportMcpServers, } from "./mcp-import/import-mcp-servers.js";
 //# sourceMappingURL=index.js.map

package/dist/src/inline-mcp/add-inline-mcp-server.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Inline MCP servers: an MCP server this workspace defines in its own
+ * settings rather than acquiring as a package.
+ *
+ * An inline entry is authored, not resolved: the workspace is the authority
+ * for what it says, so adding one records the definition and projects it to
+ * every configured agent, and never records an accepted resolution. Repeating
+ * an add that already matches the recorded entry changes nothing.
+ *
+ * @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 { NativeWriteAuthority } from "@agentxm/agent-integration";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import { OperationJournal, ResolvePlanInteraction, type OperationResolution, type PlanExecution } from "@agentxm/workspace-operations";
+import { ConfiguredAgentOutcomesProvider, WorkspaceMutations, type WorkspaceStateReadFailure } from "@agentxm/workspace-state";
+import { FootprintRecorder, WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+import { WorkspaceConfigurationFailed, type WorkspaceConfigurationExecutionFailure } from "../errors.js";
+import type { InlineMcpDefinition } from "../mcp-import/preflight.js";
+export interface AddInlineMcpServerRequest {
+    readonly name: string;
+    /** Inline stdio command line, such as `npx -y linear-mcp-server`. */
+    readonly command?: string;
+    /** Inline remote streamable-HTTP URL. */
+    readonly url?: string;
+    /** `NAME` or `NAME=VALUE` inputs; a bare name becomes an environment reference. */
+    readonly env: ReadonlyArray<string>;
+    /** `Name:Value` headers for a remote server. */
+    readonly headers: ReadonlyArray<string>;
+}
+export interface AddInlineMcpServerCandidate {
+    readonly _tag: "AddInlineMcpServer";
+    readonly name: string;
+    readonly definition: InlineMcpDefinition;
+    readonly env: Readonly<Record<string, string>>;
+    /** Whether the settings file already carries an entry under this name. */
+    readonly replacesExistingEntry: boolean;
+    readonly scope: WorkspaceScope;
+}
+/** The recorded entry already says exactly what the request asked for. */
+export interface InlineMcpServerUnchanged {
+    readonly _tag: "Unchanged";
+    readonly name: string;
+    readonly message: string;
+}
+/**
+ * Settle an inline add: exactly one transport, validated inputs, and a
+ * definition the workspace can record. A request whose recorded entry already
+ * matches is reported as unchanged.
+ */
+export declare const prepareAddInlineMcpServer: (request: AddInlineMcpServerRequest) => Effect.Effect<AddInlineMcpServerCandidate | InlineMcpServerUnchanged, WorkspaceConfigurationFailed | WorkspaceStateReadFailure, WorkspaceMutations>;
+/** Every service an inline MCP change and its plan resolution need. */
+export type AddInlineMcpServerRequirements = ConfiguredAgentOutcomesProvider | FileSystem.FileSystem | FootprintRecorder | NativeWriteAuthority | OperationJournal | Path.Path | ResolvePlanInteraction | WorkspaceMutations | WorkspaceTransactionScope;
+/** Preview or apply a settled inline add: record the entry, then project it. */
+export declare const previewOrApplyAddInlineMcpServer: (candidate: AddInlineMcpServerCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution<void>, WorkspaceConfigurationExecutionFailure, AddInlineMcpServerRequirements>;
+/** The inline MCP capability use case. */
+export declare const AddInlineMcpServer: {
+    readonly prepare: (request: AddInlineMcpServerRequest) => Effect.Effect<AddInlineMcpServerCandidate | InlineMcpServerUnchanged, WorkspaceConfigurationFailed | WorkspaceStateReadFailure, WorkspaceMutations>;
+    readonly previewOrApply: (candidate: AddInlineMcpServerCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution<void>, WorkspaceConfigurationExecutionFailure, AddInlineMcpServerRequirements>;
+};
+//# sourceMappingURL=add-inline-mcp-server.d.ts.map

package/dist/src/inline-mcp/add-inline-mcp-server.js

@@ -0,0 +1,253 @@
+/**
+ * Inline MCP servers: an MCP server this workspace defines in its own
+ * settings rather than acquiring as a package.
+ *
+ * An inline entry is authored, not resolved: the workspace is the authority
+ * for what it says, so adding one records the definition and projects it to
+ * every configured agent, and never records an accepted resolution. Repeating
+ * an add that already matches the recorded entry changes nothing.
+ *
+ * @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 { NativeWriteAuthority, syncInlineMcpServerToAgents, } from "@agentxm/agent-integration";
+import { OperationJournal, ResolvePlanInteraction, StepFailure, operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { ConfiguredAgentOutcomesProvider, WorkspaceMutations, } from "@agentxm/workspace-state";
+import { FootprintRecorder, WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+import { WorkspaceConfigurationFailed, workspaceChangeFailedToStepFailure, } from "../errors.js";
+import { makeInlineMcpDefinition, matchesInlineMcpEntry, parseInlineMcpEnv, parseInlineMcpHeaders, validateInlineMcpRemoteUrl, } from "./definition.js";
+const plural = (count, singular) => `${String(count)} ${singular}${count === 1 ? "" : "s"}`;
+const settingsDisplayPath = (scope) => scope === "project" ? "axm.json" : ".axm/workspace/axm.json";
+/**
+ * Serialize a native-format failure. Every member of the family names the
+ * fact that stopped it, so the sentence carries over rather than being
+ * replaced by a generic one the person cannot act on.
+ */
+const nativeFailureToStepFailure = (failure) => {
+    switch (failure._tag) {
+        case "McpEntryUnmanaged":
+            return new StepFailure({
+                category: "conflict",
+                detail: `MCP server ${failure.serverName} in ${failure.configPath} is not AXM-managed`,
+                cause: failure,
+            });
+        case "McpOwnershipMarkerInvalid":
+            return new StepFailure({
+                category: "conflict",
+                detail: `MCP server ${failure.serverName} carries ${failure.state} AXM ownership markers`,
+                cause: failure,
+            });
+        case "McpSharedTargetConflict":
+            return new StepFailure({ category: "conflict", detail: failure.reason, cause: failure });
+        case "NativeWriteRefused":
+            return new StepFailure({
+                category: "conflict",
+                detail: `Native MCP configuration at ${failure.path} could not be protected`,
+                cause: failure,
+            });
+        case "TransientBackupFailed":
+            return new StepFailure({
+                category: "internal",
+                detail: "A native MCP configuration backup could not be taken",
+                cause: failure,
+            });
+        case "WriteBackupRetained":
+            return new StepFailure({
+                category: "internal",
+                detail: `${nativeFailureToStepFailure(failure.failure).detail}; the original content is preserved at ${failure.backupPath}`,
+                cause: failure,
+            });
+        default:
+            return new StepFailure({ category: "conflict", detail: failure.detail, cause: failure });
+    }
+};
+/**
+ * Settle an inline add: exactly one transport, validated inputs, and a
+ * definition the workspace can record. A request whose recorded entry already
+ * matches is reported as unchanged.
+ */
+export const prepareAddInlineMcpServer = (request) => Effect.gen(function* () {
+    if (request.command === undefined && request.url === undefined) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: `mcps add only configures inline MCP servers. Use axm mcps install ${request.name} for package or source locators.`,
+            suggestions: [
+                {
+                    description: "Install the MCP server package",
+                    cmd: `axm mcps install ${request.name}`,
+                },
+            ],
+        });
+    }
+    if (request.command !== undefined && request.url !== undefined) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: "Use exactly one of --command or --url.",
+        });
+    }
+    const workspace = yield* WorkspaceMutations;
+    const env = yield* parseInlineMcpEnv(request.env);
+    const headers = yield* parseInlineMcpHeaders(request.headers);
+    if (request.url !== undefined)
+        yield* validateInlineMcpRemoteUrl(request.url);
+    const definition = yield* makeInlineMcpDefinition({
+        command: request.command,
+        url: request.url,
+    }, headers);
+    const configured = yield* workspace.getConfiguredMcpServerEntries();
+    const existing = configured[request.name];
+    if (matchesInlineMcpEntry({ existing, definition, env })) {
+        return {
+            _tag: "Unchanged",
+            name: request.name,
+            message: `MCP server ${request.name} is already configured`,
+        };
+    }
+    return {
+        _tag: "AddInlineMcpServer",
+        name: request.name,
+        definition,
+        env,
+        replacesExistingEntry: existing !== undefined,
+        scope: workspace.scope,
+    };
+});
+const configArtifact = (scope, change) => ({
+    path: settingsDisplayPath(scope),
+    scope,
+    change,
+    targets: [{ path: settingsDisplayPath(scope), change }],
+});
+const recordStep = (candidate) => ({
+    label: `Configure ${candidate.name}`,
+    readiness: "ready",
+    run: Effect.gen(function* () {
+        const workspace = yield* WorkspaceMutations;
+        yield* workspace
+            .setMcpServerEntry(candidate.name, {
+            kind: "inline",
+            ...(candidate.definition.type === "stdio"
+                ? { command: candidate.definition.command, args: candidate.definition.args }
+                : { url: candidate.definition.url, headers: candidate.definition.headers }),
+            env: candidate.env,
+            enabled: true,
+        })
+            .pipe(Effect.mapError(workspaceChangeFailedToStepFailure));
+        return {
+            result: "success",
+            message: `Configured ${candidate.name}`,
+            artifact: configArtifact(candidate.scope, candidate.replacesExistingEntry ? "updated" : "created"),
+        };
+    }),
+});
+/**
+ * Project the recorded entry into every configured agent's native MCP
+ * configuration. An agent that refuses the write is reported as a warning
+ * rather than failing the change: the workspace's own record is authoritative
+ * and the next reconciliation retries the projection.
+ */
+const projectStep = (candidate) => ({
+    label: `Sync ${candidate.name} to configured agents`,
+    readiness: "ready",
+    run: Effect.gen(function* () {
+        const workspace = yield* WorkspaceMutations;
+        const entries = yield* workspace
+            .getConfiguredMcpServerEntries()
+            .pipe(Effect.mapError(workspaceChangeFailedToStepFailure));
+        const entry = entries[candidate.name];
+        if (entry === undefined) {
+            return {
+                result: "success",
+                message: `${candidate.name} is not configured`,
+            };
+        }
+        const agentIds = yield* workspace
+            .getConfiguredAgents()
+            .pipe(Effect.mapError(workspaceChangeFailedToStepFailure));
+        const outcomes = yield* syncInlineMcpServerToAgents(agentIds, {
+            workspaceRoot: workspace.baseDir,
+            serverName: candidate.name,
+            entry,
+            scope: workspace.scope,
+        }).pipe(Effect.mapError(nativeFailureToStepFailure));
+        const warningDetails = outcomes.flatMap((outcome, index) => {
+            const agentId = agentIds[index] ?? "unknown";
+            return outcome._tag === "success"
+                ? (outcome.warnings ?? []).map((warning) => `${agentId}: ${warning}`)
+                : [`${agentId}: ${outcome.reason}`];
+        });
+        const successfulAgentIds = outcomes.flatMap((outcome, index) => {
+            const agentId = agentIds[index];
+            return outcome._tag === "success" && agentId !== undefined ? [agentId] : [];
+        });
+        const groupedTargets = new Map();
+        outcomes.forEach((outcome, index) => {
+            const agentId = agentIds[index];
+            if (outcome._tag !== "success" || agentId === undefined)
+                return;
+            (outcome.targets ?? []).forEach((target) => {
+                const grouped = groupedTargets.get(target.path);
+                if (grouped === undefined) {
+                    groupedTargets.set(target.path, {
+                        path: target.path,
+                        change: target.change,
+                        agentIds: [agentId],
+                    });
+                    return;
+                }
+                grouped.agentIds.push(agentId);
+                if (grouped.change !== "created" && target.change === "created") {
+                    grouped.change = "created";
+                }
+            });
+        });
+        const syncTargets = [...groupedTargets.values()].map((target) => ({
+            path: target.path,
+            change: target.change,
+            agentIds: target.agentIds,
+        }));
+        const artifact = successfulAgentIds.length === 0
+            ? undefined
+            : {
+                path: syncTargets.length === 1
+                    ? (syncTargets[0]?.path ?? ".mcp.json")
+                    : "agent MCP configs",
+                scope: candidate.scope,
+                agents: successfulAgentIds,
+                change: syncTargets.some((target) => target.change === "created")
+                    ? "created"
+                    : "updated",
+                fileCount: syncTargets.length,
+                targets: syncTargets,
+            };
+        return {
+            result: "success",
+            message: warningDetails.length === 0
+                ? `Synced ${candidate.name} to ${plural(successfulAgentIds.length, "agent")}`
+                : `Synced ${candidate.name} to ${plural(successfulAgentIds.length, "agent")} with ${plural(warningDetails.length, "warning")}`,
+            ...(warningDetails.length > 0 ? { warnings: warningDetails } : {}),
+            ...(artifact === undefined ? {} : { artifact }),
+        };
+    }),
+});
+/** Preview or apply a settled inline add: record the entry, then project it. */
+export const previewOrApplyAddInlineMcpServer = (candidate, execution) => Effect.gen(function* () {
+    const plan = {
+        _tag: "Plan",
+        name: "Add MCP server",
+        description: Option.some(`Configure ${candidate.name} and sync agent MCP configs`),
+        presentation: operationPresentation({ imperative: "configure", past: "Configured", gerund: "Configuring" }, "mcp-server"),
+        jobs: [{ concurrency: 1, steps: [recordStep(candidate), projectStep(candidate)] }],
+    };
+    const prepared = yield* prepareExecutionCandidate(plan);
+    return yield* resolveExecutionCandidate(prepared, execution);
+});
+/** The inline MCP capability use case. */
+export const AddInlineMcpServer = {
+    prepare: prepareAddInlineMcpServer,
+    previewOrApply: previewOrApplyAddInlineMcpServer,
+};
+//# sourceMappingURL=add-inline-mcp-server.js.map

package/dist/src/{inline-mcp.d.ts → inline-mcp/definition.d.ts}

@@ -8,8 +8,8 @@
  */
 import * as Effect from "effect/Effect";
 import type { McpServerEntry } from "@agentxm/workspace-state";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-import type { InlineMcpDefinition } from "./mcp-import-preflight.js";
+import { WorkspaceConfigurationFailed } from "../errors.js";
+import type { InlineMcpDefinition } from "../mcp-import/preflight.js";
 export declare const splitCommand: (value: string) => ReadonlyArray<string>;
 export declare const parseInlineMcpEnv: (values: ReadonlyArray<string>) => Effect.Effect<Readonly<Record<string, string>>, WorkspaceConfigurationFailed>;
 export declare const parseInlineMcpHeaders: (values: ReadonlyArray<string>) => Effect.Effect<Readonly<Record<string, string>>, WorkspaceConfigurationFailed>;
@@ -24,4 +24,4 @@ export declare const makeInlineMcpDefinition: (args: {
     readonly command: string | undefined;
     readonly url: string | undefined;
 }, headers: Readonly<Record<string, string>>) => Effect.Effect<InlineMcpDefinition, WorkspaceConfigurationFailed>;
-//# sourceMappingURL=inline-mcp.d.ts.map
+//# sourceMappingURL=definition.d.ts.map

package/dist/src/{inline-mcp.js → inline-mcp/definition.js}

@@ -7,7 +7,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Effect from "effect/Effect";
-import { WorkspaceConfigurationFailed } from "./errors.js";
+import { WorkspaceConfigurationFailed } from "../errors.js";
 export const splitCommand = (value) => value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => {
     if ((part.startsWith('"') && part.endsWith('"')) ||
         (part.startsWith("'") && part.endsWith("'"))) {
@@ -128,4 +128,4 @@ export const makeInlineMcpDefinition = (args, headers) => Effect.gen(function* (
         detail: "Provide --command or --url for inline MCP servers.",
     });
 });
-//# sourceMappingURL=inline-mcp.js.map
+//# sourceMappingURL=definition.js.map