@agentxm/workspace-configuration 0.28.12 → 0.28.13

package/dist/src/mcp-import/import-mcp-servers.js

@@ -0,0 +1,117 @@
+/**
+ * Adopting the MCP servers a workspace already had.
+ *
+ * People arrive with MCP servers configured directly in their coding agents.
+ * Import records each one the workspace can represent losslessly as an inline
+ * settings entry and marks the native entry as AXM-managed, so the next
+ * reconciliation recognises it instead of treating it as someone else's file.
+ * A server whose definitions disagree across agents is a conflict, not a
+ * choice AXM makes on the person's behalf.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as DateTime from "effect/DateTime";
+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 { OperationJournal, ResolvePlanInteraction, operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { ConfiguredAgentOutcomesProvider, WorkspaceMutations } from "@agentxm/workspace-state";
+import { FootprintRecorder, WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+import { WorkspaceConfigurationFailed, configurationFailedToStepFailure, workspaceChangeFailedToStepFailure, } from "../errors.js";
+import { applyMcpImport, collectMcpImportSources } from "./apply.js";
+import { preflightMcpImports } from "./preflight.js";
+const plural = (count, singular) => `${String(count)} ${singular}${count === 1 ? "" : "s"}`;
+const settingsDisplayPath = (scope) => scope === "project" ? "axm.json" : ".axm/workspace/axm.json";
+/**
+ * Discover and classify every unmanaged MCP server the configured agents and
+ * the workspace itself declare. Nothing is written; the candidate names the
+ * servers that can be adopted, the ones that conflict, and the ones skipped.
+ */
+export const prepareImportMcpServers = () => Effect.gen(function* () {
+    const workspace = yield* WorkspaceMutations;
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const now = yield* DateTime.now;
+    const configured = yield* workspace.getConfiguredMcpServerEntries();
+    const discovery = yield* collectMcpImportSources(workspace, fileSystem, path);
+    const normalized = preflightMcpImports({
+        configuredNames: new Set(Object.keys(configured)),
+        now,
+        sources: discovery.sources,
+    });
+    return {
+        _tag: "ImportMcpServers",
+        preflight: {
+            ...normalized,
+            skipped: [...normalized.skipped, ...discovery.skipped].sort((left, right) => left.name.localeCompare(right.name) || left.reason.localeCompare(right.reason)),
+        },
+        scope: workspace.scope,
+    };
+});
+const importArtifact = (candidate, baseDir, path) => {
+    const adoptions = candidate.preflight.candidates.flatMap((entry) => entry.adoptions);
+    const files = [...new Set(adoptions.map((adoption) => adoption.filePath))].sort();
+    return {
+        path: settingsDisplayPath(candidate.scope),
+        scope: candidate.scope,
+        change: "updated",
+        fileCount: 1 + files.length,
+        targets: [
+            { path: settingsDisplayPath(candidate.scope), change: "updated" },
+            ...files.map((filePath) => ({
+                path: path.relative(baseDir, filePath),
+                change: "updated",
+            })),
+        ],
+    };
+};
+/**
+ * Preview or apply the inline adoption. Every adopted entry is recorded and
+ * every native entry marked in one transaction, and the transaction validates
+ * the readback before it settles: a half-adopted server would look managed
+ * without being managed.
+ */
+export const previewOrApplyImportMcpServers = (candidate, execution) => Effect.gen(function* () {
+    const workspace = yield* WorkspaceMutations;
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const artifact = importArtifact(candidate, workspace.baseDir, path);
+    const conflictSteps = candidate.preflight.conflicts.map((conflict) => ({
+        label: conflict.name,
+        readiness: "error",
+        errorMessage: conflict.reason,
+    }));
+    const importSteps = candidate.preflight.candidates.length === 0
+        ? []
+        : [
+            {
+                label: `Import ${plural(candidate.preflight.candidates.length, "MCP server")}`,
+                readiness: "ready",
+                message: `Candidates: ${candidate.preflight.candidates.map((entry) => entry.name).join(", ")}`,
+                artifact,
+                run: applyMcpImport(candidate.preflight.candidates, workspace, fileSystem).pipe(Effect.mapError((failure) => failure instanceof WorkspaceConfigurationFailed
+                    ? configurationFailedToStepFailure(failure)
+                    : workspaceChangeFailedToStepFailure(failure)), Effect.as({
+                    result: "success",
+                    message: `Imported ${plural(candidate.preflight.candidates.length, "MCP server")}`,
+                    artifact,
+                })),
+            },
+        ];
+    const plan = {
+        _tag: "Plan",
+        name: "Import MCP servers",
+        description: Option.some(`Adopt ${plural(candidate.preflight.candidates.length, "unmanaged MCP server")}`),
+        presentation: operationPresentation({ imperative: "import", past: "Imported", gerund: "Importing" }, "mcp-server"),
+        jobs: [{ concurrency: 1, steps: [...conflictSteps, ...importSteps] }],
+    };
+    const prepared = yield* prepareExecutionCandidate(plan);
+    return yield* resolveExecutionCandidate(prepared, execution);
+});
+/** The inline MCP import use case. */
+export const ImportMcpServers = {
+    prepare: prepareImportMcpServers,
+    previewOrApply: previewOrApplyImportMcpServers,
+};
+//# sourceMappingURL=import-mcp-servers.js.map

package/dist/src/{mcp-import-preflight.d.ts → mcp-import/preflight.d.ts}

@@ -38,4 +38,4 @@ export declare const preflightMcpImports: (args: {
     readonly now: DateTime.Utc;
     readonly sources: ReadonlyArray<McpImportSource>;
 }) => McpImportPreflight;
-//# sourceMappingURL=mcp-import-preflight.d.ts.map
+//# sourceMappingURL=preflight.d.ts.map

package/dist/src/{mcp-import-preflight.js → mcp-import/preflight.js}

@@ -1,5 +1,5 @@
 import * as DateTime from "effect/DateTime";
-import { isAxmManagedMcpEntry } from "@agentxm/workspace-state";
+import { isAxmManagedMcpEntry } from "@agentxm/agent-integration";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const stringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
 const stringRecord = (value) => {
@@ -266,4 +266,4 @@ export const preflightMcpImports = (args) => {
         conflicts: uniqueConflicts,
     };
 };
-//# sourceMappingURL=mcp-import-preflight.js.map
+//# sourceMappingURL=preflight.js.map

package/dist/src/membership/agent-lifecycle.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether the vendor still maintains a coding agent, and what a person must
+ * be told before AXM configures one it has stopped maintaining.
+ *
+ * The catalog records the lifecycle; membership policy decides what it means:
+ * a retired agent is never configured by detection alone, and configuring one
+ * explicitly reports why the vendor stopped maintaining it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type AgentId, type AgentLifecycle } from "@agentxm/extension-model/unstable/agent-capabilities";
+/** Narrows a raw id to a catalog agent id. */
+export declare const isCatalogAgentId: (id: string) => id is AgentId;
+/** Lifecycle for a catalog agent; non-catalog ids (e.g. `universal`) are active. */
+export declare const agentLifecycle: (id: string) => AgentLifecycle;
+/** Whether an agent must only be configured through an explicit user choice. */
+export declare const isRetiredAgent: (id: string) => boolean;
+/** Warning text for configuring an agent its vendor no longer maintains. */
+export declare const lifecycleWarning: (id: string) => string | undefined;
+//# sourceMappingURL=agent-lifecycle.d.ts.map

package/dist/src/membership/agent-lifecycle.js

@@ -0,0 +1,33 @@
+/**
+ * Whether the vendor still maintains a coding agent, and what a person must
+ * be told before AXM configures one it has stopped maintaining.
+ *
+ * The catalog records the lifecycle; membership policy decides what it means:
+ * a retired agent is never configured by detection alone, and configuring one
+ * explicitly reports why the vendor stopped maintaining it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { AGENTS_BY_ID, AGENT_IDS, } from "@agentxm/extension-model/unstable/agent-capabilities";
+const catalogAgentIds = new Set(AGENT_IDS);
+/** Narrows a raw id to a catalog agent id. */
+export const isCatalogAgentId = (id) => catalogAgentIds.has(id);
+const ACTIVE = { state: "active" };
+/** Lifecycle for a catalog agent; non-catalog ids (e.g. `universal`) are active. */
+export const agentLifecycle = (id) => isCatalogAgentId(id) ? AGENTS_BY_ID[id].lifecycle : ACTIVE;
+/** Whether an agent must only be configured through an explicit user choice. */
+export const isRetiredAgent = (id) => agentLifecycle(id).state === "retired";
+/** Warning text for configuring an agent its vendor no longer maintains. */
+export const lifecycleWarning = (id) => {
+    if (!isCatalogAgentId(id))
+        return undefined;
+    const name = AGENTS_BY_ID[id].name;
+    const lifecycle = agentLifecycle(id);
+    if (lifecycle.state === "active")
+        return undefined;
+    const since = lifecycle.since === null ? "" : ` since ${lifecycle.since}`;
+    const successor = lifecycle.supersededBy === null ? "" : ` Superseded by ${lifecycle.supersededBy}.`;
+    const note = lifecycle.note === null ? "" : ` ${lifecycle.note}`;
+    return `${name} is ${lifecycle.state}${since}.${successor}${note}`;
+};
+//# sourceMappingURL=agent-lifecycle.js.map

package/dist/src/membership/atomic-membership.d.ts

@@ -0,0 +1,41 @@
+/**
+ * One workspace transaction for a configured-agent membership change.
+ *
+ * Membership is a set: a request that records `cursor` and then fails to
+ * realize its outputs must leave the set as it found it. Every step of the
+ * change therefore runs inside a single transaction, and the transaction only
+ * settles once the workspace actually reports the transition the request
+ * asked for. Both the post-transaction check and the failure vocabulary
+ * belong here — an application that supplied either could make the same
+ * membership change mean two different things.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import { type PlannedJobStep } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+/** What the workspace must report once the transition has settled. */
+export type MembershipTransition = {
+    readonly kind: "add";
+    readonly agentIds: ReadonlyArray<string>;
+} | {
+    readonly kind: "remove";
+    readonly agentIds: ReadonlyArray<string>;
+};
+interface AtomicMembershipStepsArgs<Requirements, Output> {
+    readonly steps: ReadonlyArray<PlannedJobStep<Requirements, Output>>;
+    /** The membership change the settled workspace is checked against. */
+    readonly transition: MembershipTransition;
+}
+/** The transaction scope and platform every atomic membership step joins. */
+export type AtomicMembershipRequirements<Requirements> = Requirements | FileSystem.FileSystem | Path.Path | WorkspaceTransactionScope;
+/**
+ * Keep plan-level preview and per-step results while applying every membership
+ * and artifact step through one workspace transaction.
+ */
+export declare const makeAtomicMembershipSteps: <Requirements, Output>(args: AtomicMembershipStepsArgs<Requirements, Output>) => Effect.Effect<ReadonlyArray<PlannedJobStep<AtomicMembershipRequirements<Requirements>, Output>>, never, WorkspaceMutations>;
+export {};
+//# sourceMappingURL=atomic-membership.d.ts.map

package/dist/src/membership/atomic-membership.js

@@ -0,0 +1,125 @@
+/**
+ * One workspace transaction for a configured-agent membership change.
+ *
+ * Membership is a set: a request that records `cursor` and then fails to
+ * realize its outputs must leave the set as it found it. Every step of the
+ * change therefore runs inside a single transaction, and the transaction only
+ * settles once the workspace actually reports the transition the request
+ * asked for. Both the post-transaction check and the failure vocabulary
+ * belong here — an application that supplied either could make the same
+ * membership change mean two different things.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import { StepFailure, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
+import { WorkspaceConfigurationFailed, configurationFailedToStepFailure, workspaceChangeFailedToStepFailure, } from "../errors.js";
+const failedResult = (error, message = error.detail) => ({
+    result: "error",
+    message,
+    error,
+});
+const blockedResult = (message) => failedResult(new StepFailure({
+    category: "conflict",
+    detail: message,
+}), message);
+const rollbackResults = (executable, attempt, transactionError) => {
+    const actualFailureIndex = attempt.failedIndex ?? Math.max(0, attempt.results.length - 1);
+    const failedLabel = executable[actualFailureIndex]?.label ?? "atomic agent membership validation";
+    return executable.map((_, index) => {
+        if (index < actualFailureIndex) {
+            return blockedResult(`blocked: rolled back after ${failedLabel} failed`);
+        }
+        if (index > actualFailureIndex) {
+            return blockedResult(`blocked by ${failedLabel} failure`);
+        }
+        const attempted = attempt.results[index];
+        return attempted?.result === "error"
+            ? attempted
+            : failedResult(transactionError, transactionError.detail);
+    });
+};
+/**
+ * Read the settled membership back and refuse the transaction when it does
+ * not show the requested transition. A transition that wrote nothing and one
+ * that wrote half are the same answer to the caller: the change did not
+ * happen, and the transaction restores what it found.
+ */
+const verifyTransition = (workspace, transition) => Effect.gen(function* () {
+    const configured = new Set(yield* workspace
+        .getConfiguredAgents()
+        .pipe(Effect.mapError(workspaceChangeFailedToStepFailure)));
+    const unmet = transition.kind === "add"
+        ? transition.agentIds.filter((agentId) => !configured.has(agentId))
+        : transition.agentIds.filter((agentId) => configured.has(agentId));
+    if (unmet.length === 0)
+        return;
+    return yield* configurationFailedToStepFailure(new WorkspaceConfigurationFailed({
+        category: "internal",
+        detail: transition.kind === "add"
+            ? `Agent membership transition did not configure: ${unmet.join(", ")}`
+            : `Agent membership transition did not remove: ${unmet.join(", ")}`,
+    }));
+});
+/**
+ * Keep plan-level preview and per-step results while applying every membership
+ * and artifact step through one workspace transaction.
+ */
+export const makeAtomicMembershipSteps = (args) => Effect.gen(function* () {
+    const workspace = yield* WorkspaceMutations;
+    if (args.steps.some((step) => step.readiness === "error")) {
+        return args.steps.map((step) => step);
+    }
+    const executable = args.steps.filter((step) => step.readiness !== "error");
+    const attemptRef = yield* Ref.make({ results: [] });
+    const transition = runWorkspaceTransaction({
+        transition: Effect.gen(function* () {
+            const results = [];
+            for (const [index, step] of executable.entries()) {
+                const result = yield* step.run.pipe(Effect.catch((error) => Effect.succeed(failedResult(error))));
+                results.push(result);
+                yield* Ref.set(attemptRef, {
+                    results: [...results],
+                    ...(result.result === "error" ? { failedIndex: index } : {}),
+                });
+                if (result.result === "error") {
+                    return yield* result.error;
+                }
+            }
+            return results;
+        }),
+        validate: () => verifyTransition(workspace, args.transition),
+    }).pipe(Effect.catch((transactionError) => Ref.get(attemptRef).pipe(Effect.map((attempt) => rollbackResults(executable, attempt, transactionError._tag === "StepFailure"
+        ? transactionError
+        : new StepFailure({
+            category: "internal",
+            detail: "The agent membership transition did not complete",
+            cause: transactionError,
+        }))))));
+    const sharedTransition = yield* Effect.cached(transition);
+    let resultIndex = 0;
+    // Every step now runs the shared transaction, so the transaction scope and
+    // platform join its requirements; the plan carries them to the boundary.
+    return args.steps.map((step) => {
+        if (step.readiness === "error")
+            return step;
+        const index = resultIndex;
+        resultIndex += 1;
+        return {
+            ...step,
+            run: sharedTransition.pipe(Effect.flatMap((results) => {
+                const result = results[index];
+                return result === undefined
+                    ? new StepFailure({
+                        category: "internal",
+                        detail: `Atomic agent membership transition omitted step ${index + 1}`,
+                    })
+                    : Effect.succeed(result);
+            })),
+        };
+    });
+});
+//# sourceMappingURL=atomic-membership.js.map

package/dist/src/membership/configure-agents.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Configured-agent membership: which coding agents this workspace configures,
+ * and the change a request makes to that set.
+ *
+ * Membership is a set of decisions, not a list of writes. Adding names the
+ * agents a request actually configures — the ids it gave plus what detection
+ * found, minus the ones already configured and the ones whose vendor retired
+ * them unless the request named them itself. Removing names the agents that
+ * leave and the projection state the workspace must be reconciled to once
+ * they have. Either change settles atomically: the recorded set and the agent
+ * outputs realized for it move together or not at all.
+ *
+ * Realizing installed extensions for a new membership, and cleaning up the
+ * outputs a departing agent owned, are reconciliation work. The application
+ * plans those steps through the reconciliation feature and hands them to
+ * `previewOrApply` as ordinary plan steps, so this feature never depends on a
+ * peer feature and the whole change still settles as one closure.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { detectAgentsForScope } from "@agentxm/agent-integration";
+import type { PerAgentType } from "@agentxm/extension-model/unstable/extensions/common";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import { OperationJournal, ResolvePlanInteraction, type OperationResolution, type PlanExecution, type PlannedJobStep } 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";
+/** Every failure a membership request settles into before it is planned. */
+export type ConfigureAgentsFailure = WorkspaceConfigurationFailed | WorkspaceStateReadFailure | Effect.Error<ReturnType<typeof detectAgentsForScope>>;
+/** Every failure resolving a prepared membership change can surface. */
+export type MembershipExecutionFailure = WorkspaceConfigurationExecutionFailure;
+/**
+ * A request that changes nothing still has an answer: what it named and why
+ * the workspace already satisfies it.
+ */
+export interface ConfiguredAgentsUnchanged {
+    readonly _tag: "Unchanged";
+    readonly reason: "already-configured" | "no-active-detected" | "already-absent";
+    readonly message: string;
+    /** Retired agents detection offered and did not configure, if any. */
+    readonly retiredDetected: ReadonlyArray<RetiredAgentNotice>;
+}
+/** A retired agent detection found, and why a person should know about it. */
+export interface RetiredAgentNotice {
+    readonly agentId: string;
+    /** The vendor-lifecycle sentence, and that detection did not configure it. */
+    readonly detail: string;
+}
+export interface AddConfiguredAgentsRequest {
+    /** Agent ids the person named explicitly. */
+    readonly ids: ReadonlyArray<string>;
+    /** Also configure the agents detection finds for this workspace's scope. */
+    readonly detected: boolean;
+    /** The person accepted the vendor-lifecycle warnings this change carries. */
+    readonly acceptWarnings?: boolean;
+}
+export interface AddConfiguredAgentsCandidate {
+    readonly _tag: "AddConfiguredAgents";
+    /** The agents this change configures, in the order they were decided. */
+    readonly agentIds: ReadonlyArray<string>;
+    /** The membership the workspace holds once the change settles. */
+    readonly configuredAgents: ReadonlyArray<string>;
+    /**
+     * Retired agents detection offered. They are not configured by detection
+     * alone; naming one explicitly configures it and warns.
+     */
+    readonly retiredDetected: ReadonlyArray<RetiredAgentNotice>;
+    /** One sentence per configured agent whose vendor no longer maintains it. */
+    readonly lifecycleWarnings: ReadonlyArray<string>;
+    readonly acceptWarnings: boolean;
+    readonly scope: WorkspaceScope;
+}
+/**
+ * Settle which agents an add request configures.
+ *
+ * Explicitly named ids are validated first, so a typo is refused before
+ * detection runs. Detection contributes what it found minus the agents whose
+ * vendor retired them: a retired agent is a deliberate choice, never a
+ * consequence of having it installed.
+ */
+export declare const prepareAddConfiguredAgents: (request: AddConfiguredAgentsRequest) => Effect.Effect<AddConfiguredAgentsCandidate | ConfiguredAgentsUnchanged, ConfigureAgentsFailure, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+/**
+ * Steps the application planned through the reconciliation feature, applied
+ * inside this change's closure so membership and realized outputs settle
+ * together.
+ */
+export interface MembershipReconciliation<Requirements, Output> {
+    readonly steps: ReadonlyArray<PlannedJobStep<Requirements, Output>>;
+}
+/**
+ * The plan pipeline a membership change resolves through, plus the workspace
+ * transition its steps settle inside. `Requirements` carries whatever the
+ * reconciliation steps the application supplied still need.
+ */
+export type MembershipExecutionRequirements<Requirements> = Requirements | ConfiguredAgentOutcomesProvider | FileSystem.FileSystem | FootprintRecorder | OperationJournal | Path.Path | ResolvePlanInteraction | WorkspaceMutations | WorkspaceTransactionScope;
+/**
+ * Preview or apply a settled add. The membership writes and the supplied
+ * reconciliation steps run inside one workspace transaction, and the
+ * transaction only settles once the workspace reports the arriving agents as
+ * configured.
+ */
+export declare const previewOrApplyAddConfiguredAgents: <MaterializeRequirements = never, Output = void>(candidate: AddConfiguredAgentsCandidate, execution: PlanExecution, reconciliation?: MembershipReconciliation<MaterializeRequirements, Output>) => Effect.Effect<OperationResolution<Output>, MembershipExecutionFailure, MembershipExecutionRequirements<MaterializeRequirements>>;
+export interface RemoveConfiguredAgentsRequest {
+    readonly ids: ReadonlyArray<string>;
+}
+/** The projection state the workspace is reconciled to once the agents leave. */
+export interface DepartingAgentReconciliation {
+    readonly desiredAgentIds: ReadonlySet<string>;
+    readonly expectedNames: Readonly<Record<PerAgentType, ReadonlySet<string>>>;
+}
+export interface RemoveConfiguredAgentsCandidate {
+    readonly _tag: "RemoveConfiguredAgents";
+    readonly agentIds: ReadonlyArray<string>;
+    /** The membership the workspace holds once the change settles. */
+    readonly configuredAgents: ReadonlyArray<string>;
+    readonly reconciliation: DepartingAgentReconciliation;
+    /** The workspace root removed artifacts are reported relative to. */
+    readonly baseDir: string;
+    readonly scope: WorkspaceScope;
+}
+/**
+ * Settle which agents a remove request takes out of membership, and the
+ * reconciliation state their outputs are cleaned up against.
+ *
+ * Removing every named agent when none of them is configured is a reported
+ * no-op; removing a mixture is a refusal, because the request described a
+ * workspace that does not exist. Cleaning up owned projections needs a
+ * complete desired graph — without one, AXM cannot tell its own output from
+ * a person's file, so it refuses rather than guess.
+ */
+export declare const prepareRemoveConfiguredAgents: (request: RemoveConfiguredAgentsRequest) => Effect.Effect<RemoveConfiguredAgentsCandidate | ConfiguredAgentsUnchanged, ConfigureAgentsFailure, WorkspaceMutations>;
+/**
+ * Preview or apply a settled removal. The cleanup steps the application
+ * planned run before the membership writes and inside the same transaction,
+ * so a cleanup that cannot complete leaves the agent configured.
+ */
+export declare const previewOrApplyRemoveConfiguredAgents: <CleanupRequirements = never, Output = void>(candidate: RemoveConfiguredAgentsCandidate, execution: PlanExecution, reconciliation?: MembershipReconciliation<CleanupRequirements, Output>) => Effect.Effect<OperationResolution<Output>, MembershipExecutionFailure, MembershipExecutionRequirements<CleanupRequirements>>;
+declare const ConfiguredAgentRowSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly configured: Schema.Boolean;
+    readonly detected: Schema.Boolean;
+    /** Instruction-projection health for a configured agent; `-` when not configured. */
+    readonly instructions: Schema.String;
+    /** Whether the vendor still maintains the agent: active, deprecated, retired. */
+    readonly lifecycle: Schema.String;
+}>;
+export type ConfiguredAgentRow = typeof ConfiguredAgentRowSchema.Type;
+export declare const ConfiguredAgentInventorySchema: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly configured: Schema.Boolean;
+        readonly detected: Schema.Boolean;
+        /** Instruction-projection health for a configured agent; `-` when not configured. */
+        readonly instructions: Schema.String;
+        /** Whether the vendor still maintains the agent: active, deprecated, retired. */
+        readonly lifecycle: Schema.String;
+    }>>;
+    readonly configured: Schema.$Array<Schema.String>;
+    readonly detected: Schema.$Array<Schema.String>;
+    readonly available: Schema.$Array<Schema.String>;
+    readonly count: Schema.Number;
+}>;
+export type ConfiguredAgentInventory = typeof ConfiguredAgentInventorySchema.Type;
+export interface ListConfiguredAgentsRequest {
+    /** Report only the agents detection found. */
+    readonly detected?: boolean;
+    /** Report every supported agent id, configured or not. */
+    readonly available?: boolean;
+}
+/**
+ * Report configured, detected, and available coding agents.
+ *
+ * The default view answers "what is in play here": the agents this workspace
+ * configures and the ones present on the machine. `universal` is materialized
+ * for every workspace and is never reported as a membership choice.
+ */
+export declare const listConfiguredAgents: (request?: ListConfiguredAgentsRequest) => Effect.Effect<ConfiguredAgentInventory, ConfigureAgentsFailure, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+/** The configured-agent membership use case. */
+export declare const ConfigureAgents: {
+    readonly add: {
+        readonly prepare: (request: AddConfiguredAgentsRequest) => Effect.Effect<AddConfiguredAgentsCandidate | ConfiguredAgentsUnchanged, ConfigureAgentsFailure, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+        readonly previewOrApply: <MaterializeRequirements = never, Output = void>(candidate: AddConfiguredAgentsCandidate, execution: PlanExecution, reconciliation?: MembershipReconciliation<MaterializeRequirements, Output>) => Effect.Effect<OperationResolution<Output>, MembershipExecutionFailure, MembershipExecutionRequirements<MaterializeRequirements>>;
+    };
+    readonly remove: {
+        readonly prepare: (request: RemoveConfiguredAgentsRequest) => Effect.Effect<RemoveConfiguredAgentsCandidate | ConfiguredAgentsUnchanged, ConfigureAgentsFailure, WorkspaceMutations>;
+        readonly previewOrApply: <CleanupRequirements = never, Output = void>(candidate: RemoveConfiguredAgentsCandidate, execution: PlanExecution, reconciliation?: MembershipReconciliation<CleanupRequirements, Output>) => Effect.Effect<OperationResolution<Output>, MembershipExecutionFailure, MembershipExecutionRequirements<CleanupRequirements>>;
+    };
+    readonly list: (request?: ListConfiguredAgentsRequest) => Effect.Effect<ConfiguredAgentInventory, ConfigureAgentsFailure, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+};
+export {};
+//# sourceMappingURL=configure-agents.d.ts.map