onto-mcp 0.4.12 → 0.4.13

package/dist/core-runtime/llm/sealed-dispatch-capability.js

@@ -0,0 +1,359 @@
+import crypto from "node:crypto";
+import { VERSION as ANTHROPIC_SDK_VERSION } from "@anthropic-ai/sdk/version";
+import { VERSION as OPENAI_SDK_VERSION } from "openai/version";
+import { normalizeLlmModelSwitcher, } from "./model-switcher.js";
+import { resolveDispatchFallbackAdapterCapabilities, } from "./dispatch-fallback-adapter-capabilities.js";
+import { StructuredDispatchError, } from "./structured-dispatch-error.js";
+export class SemanticMapDispatchAccounting {
+    #entries = [];
+    record(entry) {
+        if (!Number.isSafeInteger(entry.actual_adapter_request_count) ||
+            entry.actual_adapter_request_count < 0) {
+            throw new Error("semantic-map dispatch accounting requires a non-negative adapter request count.");
+        }
+        const existing = this.#entries.find((candidate) => candidate.logical_dispatch_id === entry.logical_dispatch_id);
+        if (existing) {
+            if (existing.observation_id !== entry.observation_id ||
+                existing.execution_source !== entry.execution_source ||
+                existing.operation !== entry.operation ||
+                existing.descriptor_id !== entry.descriptor_id ||
+                existing.capability_instance_id !== entry.capability_instance_id) {
+                throw new Error(`semantic-map dispatch accounting logical_dispatch_id ${entry.logical_dispatch_id} changed identity.`);
+            }
+            existing.actual_adapter_request_count += entry.actual_adapter_request_count;
+            existing.disposition = entry.disposition;
+            existing.failure_class = entry.failure_class;
+            return;
+        }
+        this.#entries.push(structuredClone(entry));
+    }
+    entries() {
+        return this.#entries.map((entry) => structuredClone(entry));
+    }
+}
+const OFFICIAL_BASE_URLS = {
+    openai: "https://api.openai.com/v1",
+    anthropic: "https://api.anthropic.com",
+};
+const ROUTE_AFFECTING_ENV = {
+    openai: [
+        "OPENAI_ADMIN_KEY",
+        "OPENAI_API_VERSION",
+        "OPENAI_BASE_URL",
+        "OPENAI_CUSTOM_HEADERS",
+        "OPENAI_ENDPOINT",
+        "OPENAI_LOG",
+        "OPENAI_ORG_ID",
+        "OPENAI_PROJECT_ID",
+        "OPENAI_WEBHOOK_SECRET",
+    ],
+    anthropic: [
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_CONFIG_DIR",
+        "ANTHROPIC_CUSTOM_HEADERS",
+        "ANTHROPIC_ENVIRONMENT_ID",
+        "ANTHROPIC_ENVIRONMENT_KEY",
+        "ANTHROPIC_FEDERATION_RULE_ID",
+        "ANTHROPIC_IDENTITY_TOKEN",
+        "ANTHROPIC_IDENTITY_TOKEN_FILE",
+        "ANTHROPIC_LOG",
+        "ANTHROPIC_ORGANIZATION_ID",
+        "ANTHROPIC_PROFILE",
+        "ANTHROPIC_SCOPE",
+        "ANTHROPIC_SERVICE_ACCOUNT_ID",
+        "ANTHROPIC_SESSION_ID",
+        "ANTHROPIC_WEBHOOK_SIGNING_KEY",
+        "ANTHROPIC_WORKSPACE_ID",
+        "ANTHROPIC_WORK_ID",
+    ],
+};
+const ACCEPTED_REASONING_EFFORTS = {
+    openai: new Set(["none", "minimal", "low", "medium", "high", "xhigh"]),
+    anthropic: new Set(["low", "medium", "high", "xhigh", "max"]),
+};
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const object = value;
+    return `{${Object.keys(object)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`)
+        .join(",")}}`;
+}
+export function dispatchDescriptorProjection(preimage) {
+    return {
+        ...preimage,
+        descriptor_id: crypto.createHash("sha256").update(canonicalJson(preimage)).digest("hex"),
+    };
+}
+function assertSealedEnvironment(provider) {
+    const present = ROUTE_AFFECTING_ENV[provider].filter((name) => process.env[name] !== undefined);
+    if (present.length > 0) {
+        throw new Error(`dispatch fallback sealed ${provider} route rejects route-affecting ambient environment: ${present.join(", ")}.`);
+    }
+}
+function readCapturedCredential(envName) {
+    const credential = process.env[envName];
+    if (typeof credential !== "string" || credential.trim().length === 0) {
+        throw new Error(`dispatch fallback credential environment ${envName} is missing or empty.`);
+    }
+    return credential;
+}
+function errorMetadata(error) {
+    const record = error !== null && typeof error === "object"
+        ? error
+        : {};
+    const nestedCode = record.error?.code ?? record.error?.type;
+    return {
+        status: typeof record.status === "number" ? record.status : null,
+        code: typeof record.code === "string"
+            ? record.code
+            : typeof nestedCode === "string" ? nestedCode : null,
+        name: typeof record.constructor?.name === "string" &&
+            record.constructor.name !== "Error"
+            ? record.constructor.name
+            : typeof record.name === "string"
+                ? record.name
+                : "UnknownError",
+    };
+}
+function structuredEvidence(args) {
+    const common = {
+        descriptor_id: args.descriptorId,
+        capability_instance_id: args.capabilityInstanceId,
+        logical_dispatch_id: args.logicalDispatchId,
+        actual_adapter_request_count: args.adapterRequestCount,
+    };
+    const metadata = errorMetadata(args.error);
+    if (metadata.status === 429) {
+        return { ...common, failure_class: "rate_limit", failure_code: "http_429", source: "sdk_http_status" };
+    }
+    if (metadata.code === "rate_limit_error" || metadata.code === "rate_limit_exceeded") {
+        return { ...common, failure_class: "rate_limit", failure_code: "provider_rate_limit_code", source: "sdk_error_code" };
+    }
+    if (metadata.status === 401 || metadata.status === 403) {
+        return {
+            ...common,
+            failure_class: "auth",
+            failure_code: metadata.status === 401 ? "http_401" : "http_403",
+            source: "sdk_http_status",
+        };
+    }
+    if (metadata.code === "authentication_error" || metadata.code === "invalid_api_key") {
+        return { ...common, failure_class: "auth", failure_code: "provider_auth_code", source: "sdk_error_code" };
+    }
+    if (metadata.status !== null && metadata.status >= 500) {
+        return { ...common, failure_class: "transport", failure_code: "http_5xx", source: "sdk_http_status" };
+    }
+    if (metadata.name.includes("Timeout")) {
+        return { ...common, failure_class: "transport", failure_code: "timeout", source: "sdk_exception_type" };
+    }
+    if (metadata.name.includes("Connection")) {
+        return { ...common, failure_class: "transport", failure_code: "connection_failure", source: "sdk_exception_type" };
+    }
+    if (metadata.status !== null && metadata.status >= 400 && metadata.status < 500) {
+        return { ...common, failure_class: null, failure_code: "provider_request_rejected", source: "sdk_http_status" };
+    }
+    if (metadata.code !== null) {
+        return { ...common, failure_class: null, failure_code: "adapter_unknown", source: "sdk_error_code" };
+    }
+    return { ...common, failure_class: null, failure_code: "adapter_unknown", source: "sdk_exception_type" };
+}
+function noOpLogger() {
+    const noOp = () => undefined;
+    return { debug: noOp, info: noOp, warn: noOp, error: noOp };
+}
+export async function createSealedDispatchCapability(args) {
+    const selection = normalizeLlmModelSwitcher(args.llm);
+    if (!selection || selection.execution_route !== "direct_model_call" || selection.auth !== "api_key") {
+        throw new Error("dispatch fallback requires an explicit api_key direct-model selection.");
+    }
+    if (selection.model_provider !== "openai" && selection.model_provider !== "anthropic") {
+        throw new Error(`dispatch fallback has no sealed official SDK route for ${selection.model_provider}.`);
+    }
+    if (selection.base_url !== undefined) {
+        throw new Error("dispatch fallback rejects custom base_url; only the official SDK endpoint is supported.");
+    }
+    if (!selection.model_id || !selection.api_key_env || !selection.reasoning_effort) {
+        throw new Error("dispatch fallback requires model, api_key_env, and effort in settings.");
+    }
+    if (!ACCEPTED_REASONING_EFFORTS[selection.model_provider].has(selection.reasoning_effort)) {
+        throw new Error(`dispatch fallback rejects unsupported effort '${selection.reasoning_effort}'.`);
+    }
+    assertSealedEnvironment(selection.model_provider);
+    const credential = readCapturedCredential(selection.api_key_env);
+    const modelId = selection.model_id;
+    const reasoningEffort = selection.reasoning_effort;
+    const sealedSelection = Object.freeze({ ...selection });
+    const isOpenAI = selection.model_provider === "openai";
+    const protocolVersion = isOpenAI
+        ? "openai_responses_v1"
+        : "anthropic_messages_v1";
+    const adapterPackageVersion = isOpenAI ? OPENAI_SDK_VERSION : ANTHROPIC_SDK_VERSION;
+    const resolvedCapabilities = resolveDispatchFallbackAdapterCapabilities({
+        executionAdapter: selection.execution_adapter,
+        adapterPackageVersion,
+        protocolVersion,
+    });
+    if (!resolvedCapabilities) {
+        throw new Error(`dispatch fallback adapter capability is not registered for ${selection.execution_adapter}@${adapterPackageVersion}/${protocolVersion}.`);
+    }
+    const capabilities = Object.freeze({ ...resolvedCapabilities });
+    const capabilityInstanceId = crypto.randomUUID();
+    const descriptor = Object.freeze(dispatchDescriptorProjection({
+        model_provider: selection.model_provider,
+        model_id: selection.model_id,
+        execution_adapter: selection.execution_adapter,
+        protocol_version: protocolVersion,
+        adapter_package_version: adapterPackageVersion,
+        auth: selection.auth,
+        endpoint_kind: "official_sdk",
+        service_tier: selection.service_tier ?? null,
+        reasoning_effort: selection.reasoning_effort,
+        dispatch_role: args.operation,
+    }));
+    let totalAdapterRequests = 0;
+    const sealedFetch = globalThis.fetch.bind(globalThis);
+    const countedFetch = async (input, init) => {
+        totalAdapterRequests += 1;
+        return sealedFetch(input, init);
+    };
+    const openAIClient = isOpenAI
+        ? new (await import("openai")).default({
+            apiKey: credential,
+            adminAPIKey: null,
+            organization: null,
+            project: null,
+            webhookSecret: null,
+            baseURL: OFFICIAL_BASE_URLS.openai,
+            maxRetries: 0,
+            fetch: countedFetch,
+            logLevel: "off",
+            logger: noOpLogger(),
+        })
+        : null;
+    const anthropicClient = !isOpenAI
+        ? new (await import("@anthropic-ai/sdk")).default({
+            apiKey: credential,
+            authToken: null,
+            credentials: null,
+            config: null,
+            profile: null,
+            webhookKey: null,
+            baseURL: OFFICIAL_BASE_URLS.anthropic,
+            maxRetries: 0,
+            fetch: countedFetch,
+            logLevel: "off",
+            logger: noOpLogger(),
+        })
+        : null;
+    return {
+        selection: sealedSelection,
+        public_descriptor: descriptor,
+        capabilities,
+        capability_instance_id: capabilityInstanceId,
+        async invokeOnce(input) {
+            if (!Number.isSafeInteger(input.max_tokens) || input.max_tokens < 1) {
+                throw new Error("sealed dispatch max_tokens must be a positive safe integer.");
+            }
+            const logicalDispatchId = input.logical_dispatch_id ?? crypto.randomUUID();
+            const requestCountBefore = totalAdapterRequests;
+            try {
+                let result;
+                if (openAIClient) {
+                    const response = await openAIClient.responses.create({
+                        model: modelId,
+                        instructions: input.system_prompt,
+                        input: input.user_prompt,
+                        max_output_tokens: input.max_tokens,
+                        store: false,
+                        reasoning: { effort: reasoningEffort },
+                    });
+                    if (response.status !== "completed") {
+                        throw new StructuredDispatchError({
+                            descriptor_id: descriptor.descriptor_id,
+                            capability_instance_id: capabilityInstanceId,
+                            logical_dispatch_id: logicalDispatchId,
+                            actual_adapter_request_count: totalAdapterRequests - requestCountBefore,
+                            failure_class: null,
+                            failure_code: "adapter_contract_violation",
+                            source: "sdk_exception_type",
+                        });
+                    }
+                    result = {
+                        text: response.output_text ?? "",
+                        input_tokens: response.usage?.input_tokens ?? 0,
+                        output_tokens: response.usage?.output_tokens ?? 0,
+                        model_id: modelId,
+                        effective_base_url: OFFICIAL_BASE_URLS.openai,
+                        declared_billing_mode: "per_token",
+                    };
+                }
+                else {
+                    const response = await anthropicClient.messages.create({
+                        model: modelId,
+                        max_tokens: input.max_tokens,
+                        system: input.system_prompt,
+                        messages: [{ role: "user", content: input.user_prompt }],
+                        thinking: { type: "adaptive" },
+                        output_config: { effort: reasoningEffort },
+                    });
+                    result = {
+                        text: response.content
+                            .filter((block) => block.type === "text")
+                            .map((block) => block.text)
+                            .join("\n"),
+                        input_tokens: response.usage.input_tokens,
+                        output_tokens: response.usage.output_tokens,
+                        model_id: modelId,
+                        effective_base_url: OFFICIAL_BASE_URLS.anthropic,
+                        declared_billing_mode: "per_token",
+                    };
+                }
+                const actualAdapterRequestCount = totalAdapterRequests - requestCountBefore;
+                if (actualAdapterRequestCount !== 1) {
+                    throw new StructuredDispatchError({
+                        descriptor_id: descriptor.descriptor_id,
+                        capability_instance_id: capabilityInstanceId,
+                        logical_dispatch_id: logicalDispatchId,
+                        actual_adapter_request_count: actualAdapterRequestCount,
+                        failure_class: null,
+                        failure_code: "adapter_contract_violation",
+                        source: "sdk_exception_type",
+                    });
+                }
+                return {
+                    result,
+                    logical_dispatch_id: logicalDispatchId,
+                    actual_adapter_request_count: actualAdapterRequestCount,
+                };
+            }
+            catch (error) {
+                if (error instanceof StructuredDispatchError)
+                    throw error;
+                const count = totalAdapterRequests - requestCountBefore;
+                if (count !== 1) {
+                    throw new StructuredDispatchError({
+                        descriptor_id: descriptor.descriptor_id,
+                        capability_instance_id: capabilityInstanceId,
+                        logical_dispatch_id: logicalDispatchId,
+                        actual_adapter_request_count: count,
+                        failure_class: null,
+                        failure_code: "adapter_contract_violation",
+                        source: "sdk_exception_type",
+                    });
+                }
+                throw new StructuredDispatchError(structuredEvidence({
+                    error,
+                    descriptorId: descriptor.descriptor_id,
+                    capabilityInstanceId,
+                    logicalDispatchId,
+                    adapterRequestCount: count,
+                }));
+            }
+        },
+    };
+}

package/dist/core-runtime/llm/structured-dispatch-error.js

@@ -0,0 +1,15 @@
+export class StructuredDispatchError extends Error {
+    evidence;
+    constructor(evidence) {
+        super(`sealed dispatch failed: ${evidence.failure_code} ` +
+            `(descriptor=${evidence.descriptor_id}, logical_dispatch=${evidence.logical_dispatch_id})`);
+        this.name = "StructuredDispatchError";
+        this.evidence = evidence;
+    }
+}
+export function readStructuredDispatchFailureEvidence(error) {
+    return error instanceof StructuredDispatchError ? error.evidence : null;
+}
+export function readStructuredDispatchFailureClass(error) {
+    return readStructuredDispatchFailureEvidence(error)?.failure_class ?? null;
+}

package/dist/core-runtime/onboard/claude-profile-scan.js

@@ -0,0 +1,65 @@
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Markers that identify a directory as a Claude Code config dir.
+ *
+ * `settings.json` and `.credentials.json` are documented to live under
+ * `CLAUDE_CONFIG_DIR` (code.claude.com/docs/en/settings: "Credentials are
+ * stored in ~/.claude/.credentials.json, or under $CLAUDE_CONFIG_DIR if that
+ * variable is set"). `.claude.json` (user/local MCP + state) and `projects/`
+ * appear inside relocated profile dirs in practice. Requiring any one of these
+ * excludes sibling dirs like `.claude-sessions` that match the name glob but
+ * are not config roots.
+ */
+const CLAUDE_CONFIG_MARKERS = [
+    "settings.json",
+    ".credentials.json",
+    ".claude.json",
+    "projects",
+];
+function isDirectory(target) {
+    try {
+        return fsSync.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `dir` is a directory carrying at least one Claude config marker. */
+export function looksLikeClaudeConfigDir(dir) {
+    if (!isDirectory(dir))
+        return false;
+    return CLAUDE_CONFIG_MARKERS.some((marker) => fsSync.existsSync(path.join(dir, marker)));
+}
+/**
+ * Discover Claude Code config directories the user keeps under their home:
+ * the default `~/.claude` plus `~/.claude-*` variants that carry a config
+ * marker, plus any ambient `CLAUDE_CONFIG_DIR` (honored even if it lives
+ * outside the home glob). Returns absolute paths, deduped and deterministically
+ * sorted (default `~/.claude` first, then numeric-aware order).
+ */
+export function discoverClaudeProfiles(options = {}) {
+    const home = options.homeDir ?? os.homedir();
+    const found = new Set();
+    // Ambient CLAUDE_CONFIG_DIR is authoritative for "the active profile" and may
+    // point outside the home glob, so include it whenever it resolves to a dir.
+    const env = options.configDirEnv?.trim();
+    if (env && isDirectory(env))
+        found.add(path.resolve(env));
+    let entries = [];
+    try {
+        entries = fsSync.readdirSync(home);
+    }
+    catch {
+        entries = [];
+    }
+    for (const name of entries) {
+        if (name !== ".claude" && !name.startsWith(".claude-"))
+            continue;
+        const dir = path.join(home, name);
+        if (looksLikeClaudeConfigDir(dir))
+            found.add(path.resolve(dir));
+    }
+    return [...found].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}

package/dist/core-runtime/onboard/cli-host.js

@@ -42,6 +42,7 @@ export function createCliHost(spec, runner = defaultCommandRunner) {
     const withNote = (summary) => spec.targetNote ? `${summary} (${spec.targetNote})` : summary;
     return {
         id: spec.id,
+        ...(spec.key ? { key: spec.key } : {}),
         displayName: spec.displayName,
         detect,
         plan(entry) {
@@ -121,13 +122,15 @@ export function createCliHost(spec, runner = defaultCommandRunner) {
  *
  * Config-dir resolution: explicit `configDir` wins; otherwise an ambient
  * `CLAUDE_CONFIG_DIR` is honored (and shown in the plan); otherwise the claude
- * default (`~/.claude`) applies.
+ * default (`~/.claude`) applies. `key`/`displayName` distinguish per-profile
+ * targets when `--all-claude-profiles` registers several at once.
  */
 export function createClaudeCodeHost(options = {}) {
     const effectiveDir = options.configDir ?? process.env.CLAUDE_CONFIG_DIR;
     const spec = {
         id: "claude-code",
-        displayName: "Claude Code",
+        ...(options.key ? { key: options.key } : {}),
+        displayName: options.displayName ?? "Claude Code",
         cli: "claude",
         addArgs: (entry) => [
             "mcp",

package/dist/core-runtime/onboard/configure-provider.js

@@ -23,6 +23,11 @@ const REVIEW_ACTOR_SEATS = {
     lens: "worker",
     synthesize: "worker",
 };
+// The PROVIDER-MANAGED subset of reconstruct actors — the two required seats
+// this command (re)writes. Deliberately NARROWER than the full actor key set
+// (settings-chain RECONSTRUCT_ACTOR_KEYS): optional per-role override seats
+// (e.g. semantic_map_synthesize) are user-owned and must SURVIVE a provider
+// switch — applyActorBlocks spreads the existing actors underneath.
 const RECONSTRUCT_ACTORS = ["semantic_author", "confirmation_provider"];
 /**
  * Build a minimal actor LLM block from caller input. Only keys the caller
@@ -43,6 +48,8 @@ export function buildLlmBlock(input) {
         block.service_tier = input.serviceTier;
     if (input.apiKeyEnv !== undefined)
         block.api_key_env = input.apiKeyEnv;
+    if (input.timeoutMs !== undefined)
+        block.timeout_ms = input.timeoutMs;
     return block;
 }
 /**
@@ -114,7 +121,14 @@ function applyActorBlocks(existing, blocks) {
         const reconstructExecution = isPlainObject(reconstruct.execution)
             ? { ...reconstruct.execution }
             : {};
-        reconstructExecution.actors = blocks.reconstruct;
+        // Overwrite ONLY the provider-managed seats; preserve user-owned actor
+        // keys (e.g. the optional semantic_map_synthesize override seat) so a
+        // provider switch or bootstrap re-run cannot silently delete them
+        // (INV-MODEL-1 role-aware design §5.1-9).
+        const existingActors = isPlainObject(reconstructExecution.actors)
+            ? reconstructExecution.actors
+            : {};
+        reconstructExecution.actors = { ...existingActors, ...blocks.reconstruct };
         reconstruct.execution = reconstructExecution;
         next.reconstruct = reconstruct;
     }
@@ -233,6 +247,9 @@ const USAGE = [
     "  --effort <e>          Reasoning effort",
     "  --service-tier <t>    Service tier",
     "  --base-url <u>        Base URL override",
+    "  --timeout-ms <ms>     Per-actor CLI-worker call timeout (positive integer ms).",
+    "                        Bounds the codex/claude direct-call worker; not the",
+    "                        api_key SDK route. See llm.timeout_ms.",
     "  --project             Write the project seat (.onto/settings.json) instead",
     "                        of the user seat (~/.onto/settings.json)",
     "  --help, -h            Show this help",
@@ -246,6 +263,7 @@ export function parseConfigureProviderArgs(argv) {
         effort: undefined,
         serviceTier: undefined,
         baseUrl: undefined,
+        timeoutMsRaw: undefined,
         target: "user",
         projectRoot: undefined,
         settingsPath: undefined,
@@ -276,6 +294,9 @@ export function parseConfigureProviderArgs(argv) {
             case "--base-url":
                 parsed.baseUrl = argv[++i];
                 break;
+            case "--timeout-ms":
+                parsed.timeoutMsRaw = argv[++i];
+                break;
             case "--project":
                 parsed.target = "project";
                 break;
@@ -323,6 +344,16 @@ export async function runConfigureProvider(argv) {
         console.error(USAGE);
         return 1;
     }
+    let timeoutMs;
+    if (parsed.timeoutMsRaw !== undefined) {
+        const n = Number(parsed.timeoutMsRaw);
+        if (!Number.isInteger(n) || n < 1) {
+            console.error("[onto configure-provider] --timeout-ms must be a positive integer " +
+                `(ms); got "${parsed.timeoutMsRaw}".`);
+            return 1;
+        }
+        timeoutMs = n;
+    }
     const input = {
         provider: parsed.provider,
         model: parsed.model,
@@ -333,6 +364,7 @@ export async function runConfigureProvider(argv) {
             ? { serviceTier: parsed.serviceTier }
             : {}),
         ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
     };
     const targetSpec = {
         target: parsed.target,

package/dist/core-runtime/onboard/host-target.js

@@ -1,12 +1,37 @@
+import os from "node:os";
+import path from "node:path";
 import { createClaudeCodeHost, createCodexHost } from "./cli-host.js";
 import { claudeDesktopConfigPath, createJsonConfigHost, cursorConfigPath, } from "./json-config-host.js";
+/** Render an absolute path with the home prefix collapsed to `~` for display. */
+function shortenHome(target) {
+    const home = os.homedir();
+    const rel = path.relative(home, target);
+    if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+        return path.join("~", rel);
+    }
+    return target;
+}
+/** Build one Claude Code target per discovered profile config dir. */
+function claudeProfileTargets(profiles) {
+    return profiles.map((dir) => createClaudeCodeHost({
+        configDir: dir,
+        key: `claude-code:${dir}`,
+        displayName: `Claude Code (${shortenHome(dir)})`,
+    }));
+}
 /**
- * The four supported hosts in display order. CLI-backed hosts (Claude Code,
- * Codex) come first; JSON-config hosts (Claude Desktop, Cursor) follow.
+ * The supported hosts in display order. CLI-backed hosts (Claude Code, Codex)
+ * come first; JSON-config hosts (Claude Desktop, Cursor) follow. When
+ * `claudeProfiles` is supplied, Claude Code expands into one target per profile.
  */
 export function getDefaultHostTargets(options = {}) {
+    const claudeTargets = options.claudeProfiles && options.claudeProfiles.length > 0
+        ? claudeProfileTargets(options.claudeProfiles)
+        : [
+            createClaudeCodeHost(options.claudeConfigDir ? { configDir: options.claudeConfigDir } : {}),
+        ];
     return [
-        createClaudeCodeHost(options.claudeConfigDir ? { configDir: options.claudeConfigDir } : {}),
+        ...claudeTargets,
         createCodexHost(),
         createJsonConfigHost({
             id: "claude-desktop",