@agentxm/workspace-configuration 0.28.4-bootstrap.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Typed failures for workspace-configuration flows. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim. The CLI's interaction
+ * implementation also maps prompt-guard failures into this family, so setup
+ * prompts surface through the same conversion.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+declare const WorkspaceConfigurationFailed_base: Schema.Class<WorkspaceConfigurationFailed, Schema.TaggedStruct<"WorkspaceConfigurationFailed", {
+    readonly category: Schema.Literals<readonly ["conflict", "internal", "usage", "validation"]>;
+    readonly detail: Schema.String;
+    readonly suggestions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly cmd: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly recover: Schema.optional<Schema.String>;
+    readonly cmd: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A workspace-configuration flow could not proceed. `category` and `detail`
+ * carry the boundary rendering 1:1.
+ */
+export declare class WorkspaceConfigurationFailed extends WorkspaceConfigurationFailed_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,29 @@
+/**
+ * Typed failures for workspace-configuration flows. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim. The CLI's interaction
+ * implementation also maps prompt-guard failures into this family, so setup
+ * prompts surface through the same conversion.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+const CarriedSuggestedActionSchema = Schema.Struct({
+    description: Schema.String,
+    cmd: Schema.optional(Schema.String),
+    url: Schema.optional(Schema.String),
+});
+/**
+ * A workspace-configuration flow could not proceed. `category` and `detail`
+ * carry the boundary rendering 1:1.
+ */
+export class WorkspaceConfigurationFailed extends Schema.TaggedError()("WorkspaceConfigurationFailed", {
+    category: Schema.Literals(["conflict", "internal", "usage", "validation"]),
+    detail: Schema.String,
+    suggestions: Schema.optional(Schema.Array(CarriedSuggestedActionSchema)),
+    recover: Schema.optional(Schema.String),
+    cmd: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @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";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @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";
+//# sourceMappingURL=index.js.map

package/dist/src/initialization-interaction.d.ts

@@ -0,0 +1,112 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/Context";
+import type { AgentDescriptor } from "@agentxm/extension-model/unstable/agents/types";
+import type { WorkspaceConfigurationFailed } from "./errors.js";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import type { SetupScopeSupportCategory } from "@agentxm/workspace-state";
+declare const WorkspaceInitializationCancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "WorkspaceInitializationCancelled";
+} & Readonly<A>;
+/**
+ * Typed cancellation of workspace initialization. The CLI implementation maps
+ * a prompt cancellation into this kernel-owned error; the runtime envelope
+ * treats it as a cancelled (successful) exit.
+ */
+export declare class WorkspaceInitializationCancelled extends WorkspaceInitializationCancelled_base<{
+    readonly message: string;
+}> {
+}
+export interface InstructionSourceChoice {
+    readonly fileName: string;
+    readonly exists: boolean;
+    readonly lines: number;
+}
+/** One row of the setup plan presented before confirmation. */
+export interface SetupPlanRow {
+    readonly target: string;
+    readonly action: string;
+    readonly detail: string;
+}
+/** Agent-detection summary presented before agent selection. */
+export interface SetupAgentScan {
+    readonly detectedCount: number;
+    readonly retiredAgents: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+    }>;
+}
+export interface WorkspaceInitializationInteractionService {
+    readonly selectAgents: (options: {
+        readonly allAgents: ReadonlyArray<AgentDescriptor>;
+        readonly detectedIds: ReadonlyArray<string>;
+        readonly projectDetectedIds: ReadonlyArray<string>;
+        readonly userDetectedIds: ReadonlyArray<string>;
+        readonly suggestedIds: ReadonlyArray<string>;
+        readonly configuredIds: ReadonlyArray<string>;
+    }) => Effect.Effect<ReadonlyArray<string>, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly confirmInstructionSync: (options: {
+        readonly enabled: boolean;
+    }) => Effect.Effect<boolean, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly selectInstructionSource: (options: {
+        readonly defaultFileName: string;
+        readonly choices: ReadonlyArray<InstructionSourceChoice>;
+    }) => Effect.Effect<string, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly confirmSetupPlan: () => Effect.Effect<boolean, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    /** Present the agent scan summary. The implementation owns all wording. */
+    readonly presentAgentScan: (scan: SetupAgentScan) => Effect.Effect<void>;
+    /** Present the setup plan rows before confirmation. */
+    readonly presentSetupPlan: (rows: ReadonlyArray<SetupPlanRow>) => Effect.Effect<void>;
+    /** Present per-category scope-support outcomes for the selected agents. */
+    readonly presentScopeSupport: (scope: WorkspaceScope, categories: ReadonlyArray<SetupScopeSupportCategory>) => Effect.Effect<void>;
+}
+declare const WorkspaceInitializationInteraction_base: ServiceMap.ServiceClass<WorkspaceInitializationInteraction, "@agentxm/workspace-configuration/initialization-interaction/WorkspaceInitializationInteraction", WorkspaceInitializationInteractionService>;
+export declare class WorkspaceInitializationInteraction extends WorkspaceInitializationInteraction_base {
+}
+export interface WorkspaceInitializationInteractionTestState {
+    readonly selectAgentsCalls: Array<{
+        readonly allAgents: ReadonlyArray<AgentDescriptor>;
+        readonly detectedIds: ReadonlyArray<string>;
+        readonly projectDetectedIds: ReadonlyArray<string>;
+        readonly userDetectedIds: ReadonlyArray<string>;
+        readonly suggestedIds: ReadonlyArray<string>;
+        readonly configuredIds: ReadonlyArray<string>;
+    }>;
+    readonly confirmInstructionSyncCalls: Array<{
+        readonly enabled: boolean;
+    }>;
+    readonly selectInstructionSourceCalls: Array<{
+        readonly defaultFileName: string;
+        readonly choices: ReadonlyArray<InstructionSourceChoice>;
+    }>;
+    readonly confirmSetupPlanCalls: Array<null>;
+    readonly presentAgentScanCalls: Array<SetupAgentScan>;
+    readonly presentSetupPlanCalls: Array<ReadonlyArray<SetupPlanRow>>;
+    readonly presentScopeSupportCalls: Array<{
+        readonly scope: WorkspaceScope;
+        readonly categories: ReadonlyArray<SetupScopeSupportCategory>;
+    }>;
+}
+export declare const WorkspaceInitializationInteractionTest: (overrides?: {
+    readonly selectAgents?: (options: {
+        readonly allAgents: ReadonlyArray<AgentDescriptor>;
+        readonly detectedIds: ReadonlyArray<string>;
+        readonly projectDetectedIds: ReadonlyArray<string>;
+        readonly userDetectedIds: ReadonlyArray<string>;
+        readonly suggestedIds: ReadonlyArray<string>;
+        readonly configuredIds: ReadonlyArray<string>;
+    }) => Effect.Effect<ReadonlyArray<string>, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly confirmInstructionSync?: (options: {
+        readonly enabled: boolean;
+    }) => Effect.Effect<boolean, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly selectInstructionSource?: (options: {
+        readonly defaultFileName: string;
+        readonly choices: ReadonlyArray<InstructionSourceChoice>;
+    }) => Effect.Effect<string, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+    readonly confirmSetupPlan?: () => Effect.Effect<boolean, WorkspaceInitializationCancelled | WorkspaceConfigurationFailed>;
+}) => {
+    layer: Layer.Layer<WorkspaceInitializationInteraction, never, never>;
+    state: WorkspaceInitializationInteractionTestState;
+};
+export {};
+//# sourceMappingURL=initialization-interaction.d.ts.map

package/dist/src/initialization-interaction.js

@@ -0,0 +1,62 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/Context";
+/**
+ * Typed cancellation of workspace initialization. The CLI implementation maps
+ * a prompt cancellation into this kernel-owned error; the runtime envelope
+ * treats it as a cancelled (successful) exit.
+ */
+export class WorkspaceInitializationCancelled extends Data.TaggedError("WorkspaceInitializationCancelled") {
+}
+export class WorkspaceInitializationInteraction extends ServiceMap.Service()("@agentxm/workspace-configuration/initialization-interaction/WorkspaceInitializationInteraction") {
+}
+export const WorkspaceInitializationInteractionTest = (overrides) => {
+    const state = {
+        selectAgentsCalls: [],
+        confirmInstructionSyncCalls: [],
+        selectInstructionSourceCalls: [],
+        confirmSetupPlanCalls: [],
+        presentAgentScanCalls: [],
+        presentSetupPlanCalls: [],
+        presentScopeSupportCalls: [],
+    };
+    const layer = Layer.succeed(WorkspaceInitializationInteraction, {
+        selectAgents: (options) => Effect.gen(function* () {
+            state.selectAgentsCalls.push(options);
+            return yield* overrides?.selectAgents?.(options) ??
+                Effect.succeed([
+                    ...new Set([
+                        ...options.configuredIds,
+                        ...options.projectDetectedIds,
+                        ...options.suggestedIds,
+                    ]),
+                ]);
+        }),
+        confirmInstructionSync: (options) => Effect.gen(function* () {
+            state.confirmInstructionSyncCalls.push(options);
+            return yield* overrides?.confirmInstructionSync?.(options) ??
+                Effect.succeed(options.enabled);
+        }),
+        selectInstructionSource: (options) => Effect.gen(function* () {
+            state.selectInstructionSourceCalls.push(options);
+            return yield* overrides?.selectInstructionSource?.(options) ??
+                Effect.succeed(options.defaultFileName);
+        }),
+        confirmSetupPlan: () => Effect.gen(function* () {
+            state.confirmSetupPlanCalls.push(null);
+            return yield* overrides?.confirmSetupPlan?.() ?? Effect.succeed(true);
+        }),
+        presentAgentScan: (scan) => Effect.sync(() => {
+            state.presentAgentScanCalls.push(scan);
+        }),
+        presentSetupPlan: (rows) => Effect.sync(() => {
+            state.presentSetupPlanCalls.push(rows);
+        }),
+        presentScopeSupport: (scope, categories) => Effect.sync(() => {
+            state.presentScopeSupportCalls.push({ scope, categories });
+        }),
+    });
+    return { layer, state };
+};
+//# sourceMappingURL=initialization-interaction.js.map

package/dist/src/initialization.d.ts

@@ -0,0 +1,199 @@
+/**
+ * WorkspaceMutations initialization logic.
+ *
+ * Handles initial setup of project and user-scope workspaces: agent detection,
+ * interactive agent selection, and settings/lockfile creation.
+ *
+ * @internal
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import { type ConfigurableAgentId } from "@agentxm/extension-model/unstable/agents/types";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+import { type Settings } from "@agentxm/workspace-state";
+import type { WorkspaceMutationsOptions } from "@agentxm/workspace-state";
+import { type WorkspaceLocation } from "@agentxm/workspace-state";
+export interface SetupAgentCandidate {
+    readonly id: ConfigurableAgentId;
+    readonly name: string;
+    readonly projectDetected: boolean;
+    readonly userDetected: boolean;
+    readonly state: "selected" | "suggested" | "available" | "retired";
+    readonly selectionReason?: "explicit" | "project-detected" | "user-detected" | "catalog-suggestion";
+}
+export declare const initializeProjectWorkspace: (localDir: string, options: WorkspaceMutationsOptions) => Effect.Effect<{
+    settings: {
+        readonly [x: string]: unknown;
+        readonly $schema?: string;
+        readonly owner?: string & import("effect/Brand").Brand<"Handle">;
+        readonly publish?: {
+            readonly defaultVisibility?: "public" | "private" | undefined;
+        };
+        readonly minimumReleaseAge?: string;
+        readonly minimumReleaseAgeExclude?: readonly {
+            readonly owner: string & import("effect/Brand").Brand<"Handle">;
+            readonly type: "knowledge" | "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "pack" | "*";
+            readonly name: "*" | (string & import("effect/Brand").Brand<"ExtensionName">);
+        }[];
+        readonly agents?: readonly ("claude-code" | "codex" | "cursor" | "github-copilot-cli" | "opencode" | "adal" | "aider-desk" | "amp" | "antigravity" | "antigravity-cli" | "augment" | "cline" | "codearts-agent" | "codebuddy" | "codemaker" | "codestudio" | "command-code" | "continue" | "cortex" | "crush" | "deepagents" | "devin" | "dexto" | "droid" | "firebender" | "forgecode" | "gemini-cli" | "goose" | "grok-cli" | "hermes" | "ibm-bob" | "iflow-cli" | "junie" | "lingma" | "kilo" | "kimi-cli" | "kiro-cli" | "kode" | "mcpjam" | "minimax-code" | "mistral-vibe" | "mux" | "neovate" | "openclaw" | "openhands" | "ona" | "pi" | "pochi" | "qoder" | "qoder-cn" | "qwen-code" | "replit" | "roo" | "rovodev" | "tabnine-cli" | "trae-cn" | "trae" | "warp" | "windsurf" | "zencoder" | "zed" | "zenflow")[];
+        readonly instructionFiles?: false | {
+            readonly fileName?: string;
+            readonly gitignoreAliases?: boolean;
+        };
+        readonly sources?: readonly ({
+            readonly name: string;
+            readonly type: "github";
+            readonly url: URL;
+        } | {
+            readonly name: string;
+            readonly type: "gitlab";
+            readonly url: URL;
+        } | {
+            readonly name: string;
+            readonly type: "bitbucket";
+            readonly url: URL;
+        } | {
+            readonly name: string;
+            readonly type: "azurerepos";
+            readonly url: URL;
+        } | {
+            readonly name: string;
+            readonly type: "registry";
+            readonly location: URL;
+        })[];
+        readonly skills?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+                readonly origin?: "bundled";
+            };
+        };
+        readonly skillsConfig?: {
+            readonly dir?: string;
+        };
+        readonly rules?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+            };
+        };
+        readonly rulesConfig?: {
+            readonly dir?: string;
+        };
+        readonly hooks?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+            };
+        };
+        readonly hooksConfig?: {
+            readonly dir?: string;
+        };
+        readonly knowledge?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+                readonly instructionEntry?: boolean;
+            };
+        };
+        readonly knowledgeConfig?: {
+            readonly dir?: string;
+            readonly instructions?: boolean;
+        };
+        readonly subagents?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+            };
+        };
+        readonly subagentsConfig?: {
+            readonly dir?: string;
+        };
+        readonly packs?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+            };
+        };
+        readonly packsConfig?: {
+            readonly dir?: string;
+        };
+        readonly mcpServers?: {
+            readonly [x: string]: {
+                readonly source: string;
+                readonly enabled: boolean;
+                readonly env: {
+                    readonly [x: string]: string;
+                };
+                readonly url?: string | undefined;
+                readonly agents?: readonly ("claude-code" | "codex" | "cursor" | "github-copilot-cli" | "opencode" | "adal" | "aider-desk" | "amp" | "antigravity" | "antigravity-cli" | "augment" | "cline" | "codearts-agent" | "codebuddy" | "codemaker" | "codestudio" | "command-code" | "continue" | "cortex" | "crush" | "deepagents" | "devin" | "dexto" | "droid" | "firebender" | "forgecode" | "gemini-cli" | "goose" | "grok-cli" | "hermes" | "ibm-bob" | "iflow-cli" | "junie" | "lingma" | "kilo" | "kimi-cli" | "kiro-cli" | "kode" | "mcpjam" | "minimax-code" | "mistral-vibe" | "mux" | "neovate" | "openclaw" | "openhands" | "ona" | "pi" | "pochi" | "qoder" | "qoder-cn" | "qwen-code" | "replit" | "roo" | "rovodev" | "tabnine-cli" | "trae-cn" | "trae" | "warp" | "windsurf" | "zencoder" | "zed" | "zenflow")[] | undefined;
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly command?: string | undefined;
+                readonly args?: readonly string[] | undefined;
+                readonly kind?: "sourced" | undefined;
+            } | {
+                readonly enabled: boolean;
+                readonly env: {
+                    readonly [x: string]: string;
+                };
+                readonly kind: "inline";
+                readonly url?: string | undefined;
+                readonly agents?: readonly ("claude-code" | "codex" | "cursor" | "github-copilot-cli" | "opencode" | "adal" | "aider-desk" | "amp" | "antigravity" | "antigravity-cli" | "augment" | "cline" | "codearts-agent" | "codebuddy" | "codemaker" | "codestudio" | "command-code" | "continue" | "cortex" | "crush" | "deepagents" | "devin" | "dexto" | "droid" | "firebender" | "forgecode" | "gemini-cli" | "goose" | "grok-cli" | "hermes" | "ibm-bob" | "iflow-cli" | "junie" | "lingma" | "kilo" | "kimi-cli" | "kiro-cli" | "kode" | "mcpjam" | "minimax-code" | "mistral-vibe" | "mux" | "neovate" | "openclaw" | "openhands" | "ona" | "pi" | "pochi" | "qoder" | "qoder-cn" | "qwen-code" | "replit" | "roo" | "rovodev" | "tabnine-cli" | "trae-cn" | "trae" | "warp" | "windsurf" | "zencoder" | "zed" | "zenflow")[] | undefined;
+                readonly source?: undefined;
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly command?: string | undefined;
+                readonly args?: readonly string[] | undefined;
+            };
+        };
+        readonly mcpServersConfig?: {
+            readonly dir?: string;
+        };
+        readonly lint?: {
+            readonly rules?: {
+                readonly [x: string]: "off" | "info" | "warn" | "error";
+            };
+        };
+    };
+    agentCandidates: readonly SetupAgentCandidate[];
+    confirmed: boolean;
+}, WorkspaceConfigurationFailed | import("./initialization-interaction.js").WorkspaceInitializationCancelled | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/workspace-state").LockfileWriteError | import("@agentxm/extension-workspace").InstructionMaintenanceFailure, FileSystem.FileSystem | Path.Path>;
+interface WorkspaceInitializationState {
+    readonly settings: Settings;
+    readonly initialized: boolean;
+    readonly wouldInitialize: boolean;
+    readonly cancelled: boolean;
+    readonly agentCandidates: ReadonlyArray<SetupAgentCandidate>;
+}
+/**
+ * Ensure the user workspace has axm.json and axm-lock.yaml.
+ *
+ * Creates missing files with empty defaults.
+ *
+ * @param workspaceRoot - Path to the user workspace root
+ */
+export declare const ensureUserWorkspaceInitialized: (workspaceRoot: string, options: WorkspaceMutationsOptions) => Effect.Effect<WorkspaceInitializationState, WorkspaceConfigurationFailed | import("./initialization-interaction.js").WorkspaceInitializationCancelled | import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/workspace-state").LockfileWriteError, FileSystem.FileSystem | Path.Path>;
+/**
+ * Ensure project workspace is initialized, returning local settings.
+ *
+ * Reads existing local settings or runs the initialization flow when missing.
+ *
+ * @param localDir - Path to local .axm directory
+ * @param options - WorkspaceMutations options
+ * @returns Effect yielding local Settings
+ */
+export declare const ensureProjectWorkspaceInitialized: (localDir: string, options: WorkspaceMutationsOptions) => Effect.Effect<WorkspaceInitializationState, WorkspaceConfigurationFailed | import("./initialization-interaction.js").WorkspaceInitializationCancelled | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/workspace-state").LockfileWriteError | import("@agentxm/extension-workspace").InstructionMaintenanceFailure, FileSystem.FileSystem | Path.Path>;
+export declare const bootstrapWorkspace: (options: WorkspaceMutationsOptions) => Effect.Effect<{
+    location: WorkspaceLocation;
+    settings: Settings;
+    initialized: boolean;
+    wouldInitialize: boolean;
+    cancelled: boolean;
+    agentCandidates: ReadonlyArray<SetupAgentCandidate>;
+}, WorkspaceConfigurationFailed | import("./initialization-interaction.js").WorkspaceInitializationCancelled | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/workspace-state").LockfileWriteError | import("@agentxm/extension-workspace").InstructionMaintenanceFailure, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=initialization.d.ts.map