@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/chunk-7E7I3WLS.js

@@ -0,0 +1,3762 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createLifecyclePresenter,
+  shortenPath
+} from "./chunk-SKHCAU7K.js";
+import {
+  createDelayedManualCodeInput,
+  promptOAuthSelection
+} from "./chunk-2STGEDFV.js";
+import {
+  column,
+  terminalColumns,
+  truncate,
+  twoColumnRow,
+  wrapPlain
+} from "./chunk-2IR2NMPA.js";
+import {
+  fingerprintNativeRuntime
+} from "./chunk-NEKRRTYW.js";
+import {
+  INHERITED_PROJECT_CONTEXT,
+  acceptInteropAgents,
+  declineInteropAgents,
+  detectInteropAgents,
+  interopProposals,
+  renderProposalEntry,
+  resolveOnPath
+} from "./chunk-INY6HTFL.js";
+import {
+  initializeClioHome
+} from "./chunk-I7XBWTYH.js";
+import {
+  credentialWriteFailed,
+  printPlaintextCredentialWarning
+} from "./chunk-PUVDKJ2Y.js";
+import {
+  printError,
+  printOk
+} from "./chunk-VPKWYKEY.js";
+import {
+  source_default
+} from "./chunk-5TSRNF4G.js";
+import {
+  isOrchestratorEligibleRuntime,
+  probeCapabilitiesForModel,
+  readTargetModelSnapshot,
+  recordTargetModelSnapshot
+} from "./chunk-XPWWI35G.js";
+import {
+  credentialsPresent
+} from "./chunk-2JH2WHGE.js";
+import {
+  bindAgentProfileInSettings,
+  readSettings,
+  removeTargetFromSettings,
+  settingsPath,
+  updateSettings
+} from "./chunk-GHS5EBTQ.js";
+import {
+  getVersionInfo
+} from "./chunk-XPLRXC72.js";
+import {
+  greetLmStudio,
+  registerBuiltinRuntimes
+} from "./chunk-VW6DOEDG.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-UXCU4E3T.js";
+import {
+  buildProviderSupportEntry,
+  configuredTargetsForRuntime,
+  describeRuntimeModels,
+  listKnownModelsForRuntime,
+  listProviderSupportEntries,
+  supportGroupLabel
+} from "./chunk-LLDJM5XK.js";
+import {
+  authStoragePath,
+  openAuthStorage,
+  registerClioOAuthProviders,
+  resolveAuthTarget,
+  resolveRuntimeAuthTarget,
+  targetRequiresAuth
+} from "./chunk-ID64D7PE.js";
+import {
+  getRuntimeRegistry
+} from "./chunk-NUGM5KR6.js";
+import {
+  getCatalogModelForRuntime
+} from "./chunk-5OIVVPHF.js";
+import {
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/configure.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { stdin as input, stdout as output2 } from "node:process";
+import { createInterface as createInterface2 } from "node:readline/promises";
+
+// src/cli/ask.ts
+init_esm_shims();
+async function ask(rl, label, defaultValue) {
+  const suffix = defaultValue && defaultValue.length > 0 ? ` [${defaultValue}]` : "";
+  try {
+    const answer = (await rl.question(`${label}${suffix}: `)).trim();
+    if (answer.length === 0) return defaultValue ?? "";
+    if (answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") return null;
+    return answer;
+  } catch {
+    return null;
+  }
+}
+async function askYesNo(rl, label, defaultValue) {
+  const marker = defaultValue ? "Y/n" : "y/N";
+  for (; ; ) {
+    const answer = await ask(rl, `${label} [${marker}]`);
+    if (answer === null) return defaultValue;
+    if (answer.length === 0) return defaultValue;
+    const lc = answer.toLowerCase();
+    if (lc === "y" || lc === "yes") return true;
+    if (lc === "n" || lc === "no") return false;
+    process.stderr.write(`invalid response: ${answer}
+`);
+  }
+}
+
+// src/cli/configure-interop.ts
+init_esm_shims();
+import { stdout as output } from "node:process";
+
+// src/cli/configure-target.ts
+init_esm_shims();
+
+// src/cli/validate-model.ts
+init_esm_shims();
+var SAMPLE_SIZE = 10;
+function sample(models) {
+  const shown = models.slice(0, SAMPLE_SIZE).join(", ");
+  return models.length > SAMPLE_SIZE ? `${shown}, \u2026` : shown;
+}
+function describeLiveTarget(live) {
+  return live.url ? `target '${live.targetId}' at ${live.url}` : `target '${live.targetId}'`;
+}
+function formatUnadvertisedModelReason(modelId, live) {
+  const resident = live.resident.length > 0 ? live.resident.join(", ") : "none";
+  return `${describeLiveTarget(live)} does not advertise model '${modelId}'. Advertised (${live.models.length}): ${sample(live.models)}. Resident instances: ${resident}. Pass one of the advertised ids with --model, or --force to save a model the target cannot serve.`;
+}
+function validateModelChoice(input2) {
+  const { runtimeId, modelId, knownModels, live, force } = input2;
+  if (live !== void 0) return validateAgainstLive(modelId, live, force);
+  if (knownModels.length === 0) return validateAgainstLive(modelId, live, force);
+  if (knownModels.includes(modelId)) return { ok: true };
+  if (force) {
+    return {
+      ok: true,
+      warning: `model '${modelId}' not in ${runtimeId} catalog (use without --force to reject)`
+    };
+  }
+  return {
+    ok: false,
+    reason: `model '${modelId}' not in ${runtimeId} catalog. Known: ${sample(knownModels)}. Use --force to skip validation.`,
+    knownModels: knownModels.slice(0, SAMPLE_SIZE)
+  };
+}
+function validateAgainstLive(modelId, live, force) {
+  if (!live || live.models.length === 0) return { ok: true };
+  if (live.models.includes(modelId)) return { ok: true };
+  const reason = formatUnadvertisedModelReason(modelId, live);
+  if (force) return { ok: true, warning: `${reason.replace(/ Pass one of.*$/u, "")} Saved anyway because of --force.` };
+  return { ok: false, reason, knownModels: live.models.slice(0, SAMPLE_SIZE) };
+}
+
+// src/cli/configure-target.ts
+var DEFAULT_PORTS = {
+  llamacpp: 8080,
+  "llamacpp-anthropic": 8080,
+  "llamacpp-completion": 8080,
+  "llamacpp-embed": 8080,
+  "llamacpp-rerank": 8080,
+  "lmstudio-native": 1234,
+  lmstudio: 1234,
+  "ollama-native": 11434,
+  vllm: 8e3,
+  sglang: 3e4,
+  "lemonade-anthropic": 8e3,
+  lemonade: 8e3,
+  "anthropic-compat": 8e3,
+  "openai-compat": 8e3,
+  litellm: 4e3
+};
+function trimTrailing(url) {
+  return url.endsWith("/") && url.length > 1 ? url.slice(0, -1) : url;
+}
+function normalizeUrl(input2, runtimeId) {
+  const trimmed = input2.trim();
+  if (trimmed.length === 0) return defaultUrlFor(runtimeId);
+  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed);
+  let withScheme = hasScheme ? trimmed : `http://${trimmed}`;
+  if (runtimeId === "lmstudio") withScheme = withScheme.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:");
+  try {
+    const parsed = new URL(withScheme);
+    if (!hasScheme && !parsed.port && DEFAULT_PORTS[runtimeId]) {
+      parsed.port = String(DEFAULT_PORTS[runtimeId]);
+    }
+    return trimTrailing(parsed.toString());
+  } catch {
+    return trimTrailing(withScheme);
+  }
+}
+function defaultUrlFor(runtimeId) {
+  const port = DEFAULT_PORTS[runtimeId];
+  return port ? `http://127.0.0.1:${port}` : "http://127.0.0.1:8080";
+}
+function deriveTargetId(runtimeId, existing) {
+  const base = runtimeId;
+  const taken = new Set(existing.map((e) => e.id));
+  if (!taken.has(base)) return base;
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${base}-${i}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return `${base}-${Date.now()}`;
+}
+async function buildProbeContext(runtime, target) {
+  const probeCtx = {
+    credentialsPresent: credentialsPresent(),
+    httpTimeoutMs: 5e3
+  };
+  if (!runtime || !target || !targetRequiresAuth(target, runtime)) return probeCtx;
+  try {
+    const resolution = await openAuthStorage().resolveForTarget(resolveAuthTarget(target, runtime), {
+      includeFallback: false
+    });
+    if (resolution.apiKey) probeCtx.authToken = resolution.apiKey;
+  } catch {
+  }
+  return probeCtx;
+}
+function runtimeKnownModelsFor(runtimeId) {
+  return listKnownModelsForRuntime(runtimeId);
+}
+function catalogContextWindowFor(runtime, modelId) {
+  const catalogModel = getCatalogModelForRuntime(runtime.id, modelId);
+  if (typeof catalogModel?.contextWindow === "number" && catalogModel.contextWindow > 0) {
+    return catalogModel.contextWindow;
+  }
+  if (runtimeKnownModelsFor(runtime.id).includes(modelId) && runtime.defaultCapabilities.contextWindow > 0) {
+    return runtime.defaultCapabilities.contextWindow;
+  }
+  return null;
+}
+function validateResolvedModel(runtime, target, modelId, force, inventory) {
+  if (!modelId) return true;
+  const knownModels = runtimeKnownModelsFor(runtime.id);
+  const live = inventory.source === "probe" ? liveInventoryFor(target, inventory) : void 0;
+  const validation = validateModelChoice({ runtimeId: runtime.id, modelId, knownModels, live, force });
+  if (!validation.ok) {
+    process.stderr.write(`error: ${validation.reason}
+`);
+    return false;
+  }
+  if (validation.warning) process.stderr.write(`warning: ${validation.warning}
+`);
+  if (knownModels.length === 0 && live === void 0 && runtime.kind === "http") {
+    process.stderr.write(
+      `warning: could not verify model '${modelId}': ${target.url ?? `target '${target.id}'`} returned no model list; it is saved as written
+`
+    );
+  }
+  return true;
+}
+function modelChoiceRefusal(runtime, target, modelId, inventory) {
+  const live = inventory.source === "probe" ? liveInventoryFor(target, inventory) : void 0;
+  const validation = validateModelChoice({
+    runtimeId: runtime.id,
+    modelId,
+    knownModels: runtimeKnownModelsFor(runtime.id),
+    live,
+    force: false
+  });
+  return validation.ok ? null : validation.reason;
+}
+function validateContextWindowOverride(runtime, modelId, contextWindow, force) {
+  if (contextWindow === void 0 || !modelId) return true;
+  const catalogMax = catalogContextWindowFor(runtime, modelId);
+  if (catalogMax === null || contextWindow <= catalogMax) return true;
+  const message = `--context-window ${contextWindow} exceeds catalog max ${catalogMax} for model '${modelId}'`;
+  if (!force) {
+    process.stderr.write(`error: ${message}. Use --force to override.
+`);
+    return false;
+  }
+  process.stderr.write(`warning: ${message}
+`);
+  return true;
+}
+async function runtimeProbe(runtime, target, authToken) {
+  if (typeof runtime.probe !== "function") return null;
+  try {
+    const context = await buildProbeContext(runtime, target);
+    return await runtime.probe(target, authToken === void 0 ? context : { ...context, authToken });
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runtimeProbeModels(runtime, target, authToken) {
+  if (typeof runtime.probeModels !== "function") return [];
+  try {
+    const context = await buildProbeContext(runtime, target);
+    return await runtime.probeModels(target, authToken === void 0 ? context : { ...context, authToken });
+  } catch {
+    return [];
+  }
+}
+function applyTarget(settings, descriptor) {
+  const idx = settings.targets.findIndex((e) => e.id === descriptor.id);
+  if (idx >= 0) settings.targets[idx] = descriptor;
+  else settings.targets.push(descriptor);
+}
+function setOrchestratorPointer(settings, descriptor, model) {
+  const runtime = getRuntimeRegistry().get(descriptor.runtime);
+  if (!runtime) {
+    throw new Error(
+      `cannot use target '${descriptor.id}' as orchestrator target because runtime '${descriptor.runtime}' is not registered`
+    );
+  }
+  if (!isOrchestratorEligibleRuntime(runtime)) {
+    throw new Error(
+      `cannot use target '${descriptor.id}' as orchestrator target because runtime '${runtime.id}' is not an HTTP/native runtime`
+    );
+  }
+  settings.chat.target = descriptor.id;
+  settings.chat.model = model ?? descriptor.defaultModel ?? null;
+}
+function setWorkerDefaultPointer(settings, descriptor, model) {
+  settings.fleet.default.target = descriptor.id;
+  settings.fleet.default.model = model ?? descriptor.defaultModel ?? null;
+}
+function setBackgroundPointer(settings, descriptor, model) {
+  const runtime = getRuntimeRegistry().get(descriptor.runtime);
+  if (!runtime || !isOrchestratorEligibleRuntime(runtime)) {
+    throw new Error(
+      `cannot use target '${descriptor.id}' as background target because runtime '${descriptor.runtime}' is not an HTTP/native runtime`
+    );
+  }
+  settings.context.memory.target = descriptor.id;
+  settings.context.memory.model = model ?? descriptor.defaultModel ?? null;
+}
+function assertOrchestratorReplacementEligible(settings, descriptor) {
+  if (settings.chat.target !== descriptor.id && settings.context.memory.target !== descriptor.id) return;
+  const role = settings.chat.target === descriptor.id ? "orchestrator" : "background";
+  const runtime = getRuntimeRegistry().get(descriptor.runtime);
+  if (!runtime) {
+    throw new Error(
+      `cannot update ${role} target '${descriptor.id}' because runtime '${descriptor.runtime}' is not registered`
+    );
+  }
+  if (!isOrchestratorEligibleRuntime(runtime)) {
+    throw new Error(`cannot update ${role} target '${descriptor.id}' to non-HTTP/native runtime '${runtime.id}'`);
+  }
+}
+function setWorkerProfilePointer(settings, name, descriptor, model) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) throw new Error("fleet profile name must be non-empty");
+  settings.fleet.profiles[trimmed] = {
+    target: descriptor.id,
+    model: model ?? descriptor.defaultModel ?? null,
+    thinkingLevel: "off"
+  };
+}
+function contextWindowUndiscovered(descriptor, probe) {
+  if (!probe?.ok) return false;
+  if (typeof descriptor.capabilities?.contextWindow === "number" && descriptor.capabilities.contextWindow > 0) {
+    return false;
+  }
+  const discovered = probeCapabilitiesForModel(
+    {
+      target: descriptor,
+      probeCapabilities: probe.discoveredCapabilities ?? null,
+      probeModelCapabilities: probe.modelCapabilities ?? null,
+      probeModelId: probe.capabilityModelId ?? null
+    },
+    descriptor.defaultModel
+  );
+  return !(typeof discovered?.contextWindow === "number" && discovered.contextWindow > 0);
+}
+function warnUndiscoveredContextWindow(descriptor, probe) {
+  if (!contextWindowUndiscovered(descriptor, probe)) return;
+  process.stdout.write(
+    "  warning: the target reported no context window; Clio will use the runtime default as a guess. Set one with --context-window.\n"
+  );
+}
+function modelSupportsThinking(runtime, descriptor, probe) {
+  const discovered = probe ? probeCapabilitiesForModel(
+    {
+      target: descriptor,
+      probeCapabilities: probe.discoveredCapabilities ?? null,
+      probeModelCapabilities: probe.modelCapabilities ?? null,
+      probeModelId: probe.capabilityModelId ?? null
+    },
+    descriptor.defaultModel
+  ) : null;
+  if (typeof discovered?.reasoning === "boolean") return discovered.reasoning;
+  if (typeof descriptor.capabilities?.reasoning === "boolean") return descriptor.capabilities.reasoning;
+  return runtime.defaultCapabilities.reasoning === true;
+}
+function probeReadings(probe) {
+  const readings = [];
+  if (probe.models && probe.models.length > 0) readings.push(`${probe.models.length} models`);
+  if (probe.serverVersion) readings.push(probe.serverVersion);
+  if (probe.discoveredCapabilities && Object.keys(probe.discoveredCapabilities).length > 0) {
+    readings.push("capabilities");
+  }
+  return readings;
+}
+function probeLines(descriptor, probe) {
+  const latency = probe.latencyMs !== void 0 ? ` (${probe.latencyMs}ms)` : "";
+  if (!probe.ok) {
+    if (descriptor.runtime === "antigravity-code") {
+      const next = probe.failureKind === "missing" ? "install the official Antigravity CLI and put `agy` on PATH" : probe.failureKind === "authentication" ? "run `agy` yourself and complete sign-in; Clio never reads or manages that session" : probe.failureKind === "unsupported-feature" ? "update `agy`; this integration requires its structured JSON model catalog" : "run `agy` directly to inspect setup, then re-run `clio-coder targets --probe`";
+      return [`probe failed${latency}: ${probe.error ?? "unknown"}`, `  ${next}`];
+    }
+    const where = descriptor.url ? ` ${descriptor.url}` : "";
+    return [
+      `probe failed${latency}:${where} ${probe.error ?? "unknown"}`,
+      `  check the server is running and reachable, then re-run: clio-coder configure --id ${descriptor.id} --url <url>`
+    ];
+  }
+  const readings = probeReadings(probe);
+  if (readings.length > 0) return [`probe ok${latency} ${readings.join(", ")}`];
+  return [
+    `probe reachable${latency}, but the target answered no model list and no version`,
+    "  Clio cannot verify the model id or the context window from here and will send both as written.",
+    "  re-read them once the server serves them with: clio-coder targets --probe"
+  ];
+}
+function buildDescriptor(runtime, id, parts) {
+  const descriptor = { id, runtime: runtime.id };
+  if (parts.url) descriptor.url = parts.url;
+  if (parts.model) descriptor.defaultModel = parts.model;
+  const auth = {};
+  if (parts.apiKeyEnv) auth.apiKeyEnvVar = parts.apiKeyEnv;
+  if (parts.apiKeyRef) auth.apiKeyRef = parts.apiKeyRef;
+  if (parts.oauthProfile) auth.oauthProfile = parts.oauthProfile;
+  if (Object.keys(auth).length > 0) descriptor.auth = auth;
+  if (parts.gateway) descriptor.gateway = true;
+  if (parts.lifecycle) descriptor.lifecycle = parts.lifecycle;
+  const caps = {};
+  if (parts.contextWindow !== void 0) caps.contextWindow = parts.contextWindow;
+  if (parts.maxTokens !== void 0) caps.maxTokens = parts.maxTokens;
+  if (parts.reasoning !== void 0) caps.reasoning = parts.reasoning;
+  if (Object.keys(caps).length > 0) descriptor.capabilities = caps;
+  if (parts.lmstudio) descriptor.lmstudio = parts.lmstudio;
+  if (parts.litellm) descriptor.litellm = parts.litellm;
+  return descriptor;
+}
+function describeAuthStatus(runtime) {
+  const status = openAuthStorage().statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  if (!status.available) return "none stored";
+  if (status.source === "environment") return `environment${status.detail ? ` (${status.detail})` : ""}`;
+  if (status.source === "stored-api-key") return "stored api key";
+  if (status.source === "stored-oauth") return "stored oauth";
+  return status.source;
+}
+function advertisedModelIds(inventory) {
+  const ids = [...inventory.models];
+  for (const id of Object.keys(inventory.modelStates ?? {})) if (!ids.includes(id)) ids.push(id);
+  return ids;
+}
+function residentModelIds(modelStates) {
+  return Object.entries(modelStates ?? {}).filter(([, status]) => status.state === "loaded" || status.state === "loading").map(([id]) => id);
+}
+function liveInventoryFor(target, inventory) {
+  return {
+    targetId: target.id,
+    url: target.url,
+    models: advertisedModelIds(inventory),
+    resident: residentModelIds(inventory.modelStates)
+  };
+}
+async function resolveSupportedWireModels(runtime, target, existing, authToken) {
+  const known = listKnownModelsForRuntime(runtime.id);
+  const liveAuthoritative = runtime.externalAgentLoop?.modelCatalog === "live-authoritative";
+  if (known.length > 0 && !liveAuthoritative) return { models: known, source: "catalog" };
+  let probeError;
+  if (runtime.kind === "http" || liveAuthoritative) {
+    const probe = await runtimeProbe(runtime, target, authToken);
+    if (probe?.ok && probe.models && probe.models.length > 0) {
+      recordTargetModelSnapshot(target, probe.models, probe.modelLabels ? { modelLabels: probe.modelLabels } : {});
+      return {
+        models: [...probe.models],
+        source: "probe",
+        modelStates: probe.modelStates,
+        ...probe.modelLabels ? { labels: probe.modelLabels } : {}
+      };
+    }
+    probeError = probe?.error;
+    const discovered = await runtimeProbeModels(runtime, target, authToken);
+    if (discovered.length > 0) {
+      recordTargetModelSnapshot(target, discovered);
+      return { models: discovered, source: "probe" };
+    }
+  }
+  const cached = readTargetModelSnapshot(target);
+  if (cached && cached.models.length > 0) {
+    return {
+      models: [...cached.models],
+      source: "cache",
+      ...cached.modelLabels ? { labels: cached.modelLabels } : {},
+      ...probeError ? { probeError } : {}
+    };
+  }
+  if (known.length > 0) return { models: known, source: "catalog", ...probeError ? { probeError } : {} };
+  if (existing?.wireModels && existing.wireModels.length > 0) {
+    recordTargetModelSnapshot(target, existing.wireModels);
+    return { models: [...existing.wireModels], source: "legacy" };
+  }
+  return { models: [], source: "none", ...probeError ? { probeError } : {} };
+}
+function inventoryGap(runtime, target) {
+  if (runtime.externalAgentLoop?.modelCatalog === "live-authoritative") {
+    return "Antigravity returned no live model catalog; run `agy` yourself, complete sign-in, then probe again";
+  }
+  if (runtime.kind !== "http") return `${runtime.id} does not list its models; type the id the provider documents`;
+  return `${target.url ?? runtime.id} answered no model list; type the id the server serves`;
+}
+var LOCAL_APP_RUNTIME_IDS = /* @__PURE__ */ new Set(["ollama-native", "lmstudio"]);
+var PROTOCOL_COMPAT_RUNTIME_IDS = /* @__PURE__ */ new Set(["openai-compat", "anthropic-compat"]);
+function runtimesForCategory(entries, category) {
+  switch (category) {
+    case "local-app":
+      return entries.filter((entry) => LOCAL_APP_RUNTIME_IDS.has(entry.runtimeId));
+    case "local-http":
+      return entries.filter((entry) => entry.group === "local-http" && !LOCAL_APP_RUNTIME_IDS.has(entry.runtimeId));
+    case "chatgpt":
+      return entries.filter((entry) => entry.runtimeId === "openai-codex");
+    case "cloud-api": {
+      const byLabel = (a, b) => a.label.localeCompare(b.label) || a.runtimeId.localeCompare(b.runtimeId);
+      const named = entries.filter((entry) => entry.group === "cloud-api").slice().sort(byLabel);
+      const compat = entries.filter((entry) => PROTOCOL_COMPAT_RUNTIME_IDS.has(entry.runtimeId)).map((entry) => ({ ...entry, group: "cloud-api" })).sort(byLabel);
+      return [...named, ...compat];
+    }
+    case "all":
+      return entries.slice();
+  }
+}
+function railPrefix(plain) {
+  return plain ? "  " : `${source_default.cyan("\u2502")}  `;
+}
+
+// src/cli/select.ts
+init_esm_shims();
+import { emitKeypressEvents } from "node:readline";
+function canSelect(input2 = process.stdin, output3 = process.stdout) {
+  return Boolean(input2.isTTY && output3.isTTY && typeof input2.setRawMode === "function" && process.env.TERM !== "dumb");
+}
+var ESC = "\x1B";
+var CURSOR_HIDE = `${ESC}[?25l`;
+var CURSOR_SHOW = `${ESC}[?25h`;
+var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;?]*[A-Za-z]`, "gu");
+function printedWidth(text) {
+  return text.replace(ANSI_PATTERN, "").length;
+}
+function headingLines(heading) {
+  if (heading === void 0) return [];
+  return typeof heading === "string" ? [heading] : [...heading];
+}
+async function readKeys(input2, output3, hideCursor, onStart, onKey, onEnd) {
+  const wasRaw = input2.isRaw === true;
+  emitKeypressEvents(input2);
+  input2.setRawMode(true);
+  input2.resume();
+  if (hideCursor) output3.write(CURSOR_HIDE);
+  onStart();
+  try {
+    return await new Promise((resolve) => {
+      const finish2 = (result) => {
+        input2.off("keypress", handleKey);
+        input2.off("end", handleEnd);
+        input2.off("close", handleEnd);
+        resolve(result);
+      };
+      function handleEnd() {
+        finish2(onEnd());
+      }
+      function handleKey(str, key) {
+        onKey(str, key ?? {}, finish2);
+      }
+      input2.on("keypress", handleKey);
+      input2.once("end", handleEnd);
+      input2.once("close", handleEnd);
+    });
+  } finally {
+    if (hideCursor) output3.write(CURSOR_SHOW);
+    if (!wasRaw) input2.setRawMode(false);
+    input2.pause();
+  }
+}
+function makeFrame(output3) {
+  let drawn = 0;
+  return {
+    draw(lines) {
+      if (drawn > 0) output3.write(`${ESC}[${drawn}A${ESC}[0J`);
+      output3.write(`${lines.join("\n")}
+`);
+      drawn = lines.length;
+    },
+    erase() {
+      if (drawn > 0) output3.write(`${ESC}[${drawn}A${ESC}[0J`);
+      drawn = 0;
+    },
+    drawn: () => drawn
+  };
+}
+function choiceRows(spec, index, windowStart, viewport) {
+  const { choices, rail, railWidth, output: output3, markerWidth, marker } = spec;
+  const room = terminalColumns(output3) - railWidth;
+  const hasHints = choices.some((choice) => choice.hint !== void 0);
+  const labelWidth = Math.min(30, Math.max(...choices.map((choice) => choice.label.length)));
+  const hintRoom = room - markerWidth - labelWidth - 2;
+  const end = Math.min(choices.length, windowStart + viewport);
+  const lines = [];
+  if (windowStart > 0) lines.push(`${rail}${source_default.dim(`  \u2191 ${windowStart} more`)}`);
+  for (let position = windowStart; position < end; position++) {
+    const choice = choices[position];
+    if (choice === void 0) continue;
+    const active = position === index;
+    const aligned = hasHints && hintRoom >= 12;
+    const label = aligned ? column(choice.label, labelWidth) : truncate(choice.label, room - markerWidth);
+    const hint = aligned && choice.hint !== void 0 ? truncate(choice.hint, hintRoom) : "";
+    const styledLabel = active ? source_default.cyan.bold(label) : label;
+    lines.push(`${rail}${marker(position)}${styledLabel}${hint.length > 0 ? `  ${source_default.dim(hint)}` : ""}`.trimEnd());
+  }
+  if (end < choices.length) lines.push(`${rail}${source_default.dim(`  \u2193 ${choices.length - end} more`)}`);
+  return lines;
+}
+function viewportFor(output3, overhead, total, requested) {
+  if (requested !== void 0) return Math.max(1, Math.min(total, requested));
+  const rows = typeof output3.rows === "number" && output3.rows > 0 ? output3.rows : 24;
+  return Math.max(3, Math.min(total, rows - overhead));
+}
+async function promptSelect(options) {
+  const input2 = options.input ?? process.stdin;
+  const output3 = options.output ?? process.stdout;
+  const choices = options.choices;
+  if (choices.length === 0) return { kind: "back" };
+  const rail = options.railPrefix ?? "";
+  const railWidth = 3;
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output3);
+  let index = Math.min(Math.max(options.initialIndex ?? 0, 0), choices.length - 1);
+  let windowStart = 0;
+  const render = () => {
+    const viewport = viewportFor(output3, head.length + 5, choices.length, options.maxVisible);
+    if (index < windowStart) windowStart = index;
+    else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
+    windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    lines.push(
+      ...choiceRows(
+        {
+          choices,
+          rail,
+          railWidth,
+          output: output3,
+          markerWidth: 2,
+          marker: (position) => `${position === index ? source_default.cyan("\u276F") : " "} `
+        },
+        index,
+        windowStart,
+        viewport
+      )
+    );
+    lines.push(rail.trimEnd());
+    const legend = ["\u2191/\u2193 move", "enter select"];
+    if (options.backLabel !== void 0 && options.backLabel !== "quit") legend.push(`esc ${options.backLabel}`);
+    legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+  };
+  const result = await readKeys(
+    input2,
+    output3,
+    true,
+    render,
+    (_str, key, finish2) => {
+      if (key.ctrl && (key.name === "c" || key.name === "d")) {
+        finish2({ kind: "quit" });
+        return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          index = (index - 1 + choices.length) % choices.length;
+          render();
+          return;
+        case "down":
+        case "j":
+        case "tab":
+          index = (index + 1) % choices.length;
+          render();
+          return;
+        case "pageup":
+          index = Math.max(0, index - 5);
+          render();
+          return;
+        case "pagedown":
+          index = Math.min(choices.length - 1, index + 5);
+          render();
+          return;
+        case "home":
+          index = 0;
+          render();
+          return;
+        case "end":
+          index = choices.length - 1;
+          render();
+          return;
+        case "return":
+        case "enter":
+        case "space": {
+          const choice = choices[index];
+          finish2(choice === void 0 ? { kind: "back" } : { kind: "selected", value: choice.value });
+          return;
+        }
+        case "escape":
+        case "left":
+        case "backspace":
+          finish2({ kind: "back" });
+          return;
+        case "q":
+          finish2({ kind: "quit" });
+          return;
+        default: {
+          const digit = Number.parseInt(key.name ?? "", 10);
+          if (Number.isInteger(digit) && digit >= 1 && digit <= choices.length) {
+            index = digit - 1;
+            render();
+            const choice = choices[index];
+            if (choice !== void 0) finish2({ kind: "selected", value: choice.value });
+          }
+        }
+      }
+    },
+    () => ({ kind: "quit" })
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+async function promptMultiSelect(options) {
+  const input2 = options.input ?? process.stdin;
+  const output3 = options.output ?? process.stdout;
+  const choices = options.choices;
+  if (choices.length === 0) return { kind: "selected", values: [] };
+  const rail = options.railPrefix ?? "";
+  const railWidth = 3;
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output3);
+  const checked = choices.map((choice) => choice.checked === true);
+  let index = 0;
+  let windowStart = 0;
+  const render = () => {
+    const viewport = viewportFor(output3, head.length + 5, choices.length, options.maxVisible);
+    if (index < windowStart) windowStart = index;
+    else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
+    windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    lines.push(
+      ...choiceRows(
+        {
+          choices,
+          rail,
+          railWidth,
+          output: output3,
+          markerWidth: 4,
+          marker: (position) => {
+            const cursor = position === index ? source_default.cyan("\u276F") : " ";
+            const box = checked[position] === true ? source_default.green("\u25C9") : source_default.dim("\u25CB");
+            return `${cursor} ${box} `;
+          }
+        },
+        index,
+        windowStart,
+        viewport
+      )
+    );
+    lines.push(rail.trimEnd());
+    const legend = ["\u2191/\u2193 move", "space toggle", `enter ${options.confirmLabel ?? "confirm"}`];
+    if (options.backLabel !== void 0) legend.push(`esc ${options.backLabel}`);
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+  };
+  const result = await readKeys(
+    input2,
+    output3,
+    true,
+    render,
+    (_str, key, finish2) => {
+      if (key.ctrl && (key.name === "c" || key.name === "d")) {
+        finish2({ kind: "quit" });
+        return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          index = (index - 1 + choices.length) % choices.length;
+          render();
+          return;
+        case "down":
+        case "j":
+        case "tab":
+          index = (index + 1) % choices.length;
+          render();
+          return;
+        case "home":
+          index = 0;
+          render();
+          return;
+        case "end":
+          index = choices.length - 1;
+          render();
+          return;
+        case "space":
+          checked[index] = checked[index] !== true;
+          render();
+          return;
+        case "a":
+          {
+            const turnOn = checked.some((value) => !value);
+            checked.fill(turnOn);
+          }
+          render();
+          return;
+        case "return":
+        case "enter":
+          finish2({
+            kind: "selected",
+            values: choices.filter((_choice, position) => checked[position] === true).map((choice) => choice.value)
+          });
+          return;
+        case "escape":
+        case "left":
+          finish2({ kind: "back" });
+          return;
+        default: {
+          const digit = Number.parseInt(key.name ?? "", 10);
+          if (Number.isInteger(digit) && digit >= 1 && digit <= choices.length) {
+            index = digit - 1;
+            checked[index] = checked[index] !== true;
+            render();
+          }
+        }
+      }
+    },
+    () => ({ kind: "quit" })
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+function typedText(str, key) {
+  if (key.ctrl === true || key.meta === true) return null;
+  if (typeof str !== "string" || str.length === 0) return null;
+  if (/[\u0000-\u001F\u007F]/u.test(str)) return null;
+  return str;
+}
+async function promptText(options) {
+  const input2 = options.input ?? process.stdin;
+  const output3 = options.output ?? process.stdout;
+  const rail = options.railPrefix ?? "";
+  const railWidth = printedWidth(rail);
+  const head = headingLines(options.heading);
+  const frame = makeFrame(output3);
+  let value = options.initial ?? "";
+  let caret = value.length;
+  let error = null;
+  let below = 0;
+  let parked = false;
+  const render = () => {
+    if (parked) {
+      output3.write(`\r${below > 0 ? `${ESC}[${below}B` : ""}`);
+      parked = false;
+    }
+    const room = Math.max(8, terminalColumns(output3) - railWidth - 2);
+    const shown = options.mask === true ? "\u2022".repeat(value.length) : value;
+    const lines = [];
+    for (const line of head) lines.push(`${rail}${line}`.trimEnd());
+    if (head.length > 0) lines.push(rail.trimEnd());
+    const fieldIndex = lines.length;
+    lines.push(`${rail}${source_default.cyan("\u276F")} ${truncate(shown, room)}`);
+    if (error !== null) lines.push(`${rail}${source_default.yellow(truncate(error, room))}`);
+    else if (options.hint !== void 0) lines.push(`${rail}${source_default.dim(truncate(options.hint, room))}`);
+    lines.push(rail.trimEnd());
+    const legend = ["enter accept"];
+    if (options.backLabel !== void 0) legend.push(`esc ${options.backLabel}`);
+    legend.push("ctrl-c quit");
+    lines.push(`${rail}${source_default.dim(legend.join(" \xB7 "))}`);
+    frame.draw(lines);
+    below = lines.length - fieldIndex;
+    const columnOffset = railWidth + 2 + Math.min(caret, room);
+    output3.write(`${ESC}[${below}A\r${columnOffset > 0 ? `${ESC}[${columnOffset}C` : ""}`);
+    parked = true;
+  };
+  const unpark = () => {
+    if (!parked) return;
+    output3.write(`\r${below > 0 ? `${ESC}[${below}B` : ""}`);
+    parked = false;
+  };
+  const result = await readKeys(
+    input2,
+    output3,
+    false,
+    render,
+    (str, key, finish2) => {
+      if (key.ctrl === true) {
+        switch (key.name) {
+          case "c":
+          case "d":
+            unpark();
+            finish2({ kind: "quit" });
+            return;
+          case "a":
+            caret = 0;
+            render();
+            return;
+          case "e":
+            caret = value.length;
+            render();
+            return;
+          case "u":
+            value = value.slice(caret);
+            caret = 0;
+            render();
+            return;
+          case "k":
+            value = value.slice(0, caret);
+            render();
+            return;
+          case "w": {
+            const head_ = value.slice(0, caret).replace(/\S+\s*$/u, "");
+            value = head_ + value.slice(caret);
+            caret = head_.length;
+            render();
+            return;
+          }
+          default:
+            return;
+        }
+      }
+      switch (key.name) {
+        case "escape":
+          unpark();
+          finish2({ kind: "back" });
+          return;
+        case "return":
+        case "enter": {
+          const answer = value.trim();
+          const reason = options.validate?.(answer) ?? null;
+          if (reason !== null) {
+            error = reason;
+            render();
+            return;
+          }
+          unpark();
+          finish2({ kind: "value", value: answer });
+          return;
+        }
+        case "backspace":
+          if (caret > 0) {
+            value = value.slice(0, caret - 1) + value.slice(caret);
+            caret -= 1;
+            error = null;
+            render();
+          }
+          return;
+        case "delete":
+          if (caret < value.length) {
+            value = value.slice(0, caret) + value.slice(caret + 1);
+            error = null;
+            render();
+          }
+          return;
+        case "left":
+          caret = Math.max(0, caret - 1);
+          render();
+          return;
+        case "right":
+          caret = Math.min(value.length, caret + 1);
+          render();
+          return;
+        case "home":
+          caret = 0;
+          render();
+          return;
+        case "end":
+          caret = value.length;
+          render();
+          return;
+        default: {
+          const typed = typedText(str, key);
+          if (typed === null) return;
+          value = value.slice(0, caret) + typed + value.slice(caret);
+          caret += typed.length;
+          error = null;
+          render();
+        }
+      }
+    },
+    () => {
+      unpark();
+      return { kind: "quit" };
+    }
+  );
+  if (options.clearOnExit) frame.erase();
+  return result;
+}
+
+// src/cli/configure-interop.ts
+function describe(proposal) {
+  const lines = [
+    "",
+    `${proposal.label} is installed and not configured as a delegation agent.`,
+    "",
+    renderProposalEntry(proposal),
+    "",
+    `projectContext stays ${INHERITED_PROJECT_CONTEXT}: this agent receives your task text, never the project projection.`,
+    `toolGovernance is clio-coder-policy: its tool calls are gated by Clio safety.`
+  ];
+  if (proposal.needsNetworkInstall) {
+    lines.push(`The ACP adapter is not installed locally; npx fetches it the first time you delegate.`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function proposalHint(proposal) {
+  const command = [proposal.entry.command, ...proposal.entry.args ?? []].join(" ");
+  return proposal.needsNetworkInstall ? `${command} (npx fetches the adapter on first use)` : command;
+}
+async function reviewInteropAgents(io) {
+  const report = await detectInteropAgents({ cwd: process.cwd(), probeVersion: true });
+  const proposals = interopProposals(report, readSettings());
+  if (proposals.length === 0) {
+    if (!io.quiet) output.write("No new coding agents to connect.\n");
+    return { code: 0, wired: [], back: false };
+  }
+  const streams = io.streams;
+  const interactive = streams !== void 0 && canSelect(streams.in, streams.out);
+  if (!interactive && io.rl === null) {
+    for (const proposal of proposals) output.write(describe(proposal));
+    output.write("\nRun `clio-coder configure --interop` on a terminal to connect any of these.\n");
+    return { code: 0, wired: [], back: false };
+  }
+  const accepted = [];
+  const declined = [];
+  if (interactive && streams) {
+    const presenter = io.presenter ?? createLifecyclePresenter({ stream: streams.out });
+    const rail = io.rail ?? railPrefix(presenter.isPlain());
+    presenter.note(
+      `Clio found ${proposals.length === 1 ? "one coding agent" : `${proposals.length} coding agents`} it can delegate to. A peer receives your task text and never the project projection, and its tool calls are gated by Clio safety.`
+    );
+    const result = await promptMultiSelect({
+      heading: ["", source_default.bold("Delegate to any of these?")],
+      choices: proposals.map((proposal) => ({
+        value: proposal.kind,
+        label: proposal.label,
+        hint: proposalHint(proposal)
+      })),
+      railPrefix: rail,
+      backLabel: "back",
+      confirmLabel: "confirm",
+      clearOnExit: true,
+      input: streams.in,
+      output: streams.out
+    });
+    if (result.kind === "back") return { code: 0, wired: [], back: true };
+    if (result.kind === "quit") return { code: 0, wired: [], back: false };
+    for (const proposal of proposals) {
+      (result.values.includes(proposal.kind) ? accepted : declined).push(proposal.kind);
+    }
+  } else if (io.rl !== null) {
+    for (const proposal of proposals) {
+      output.write(describe(proposal));
+      const yes = await askYesNo(io.rl, `Add ${proposal.label} as delegation agent \`${proposal.entry.id}\`?`, false);
+      (yes ? accepted : declined).push(proposal.kind);
+    }
+  }
+  const wired = [];
+  if (accepted.length > 0) {
+    const result = acceptInteropAgents(accepted, report);
+    for (const diagnostic of result.diagnostics) {
+      if (io.presenter) io.presenter.warn(diagnostic);
+      else output.write(`note: ${diagnostic}
+`);
+    }
+    for (const id of result.wired) {
+      wired.push(id);
+      if (!io.presenter) printOk(`delegation agent ${id} added; use \`/delegate ${id} <task>\``);
+    }
+  }
+  if (declined.length > 0) {
+    declineInteropAgents(declined, report);
+    const line = `Declined ${declined.join(", ")}; Clio stays quiet about them until their version or path changes.`;
+    if (io.presenter) io.presenter.note(line);
+    else output.write(`${line}
+`);
+  }
+  return { code: 0, wired, back: false };
+}
+async function runInteropReview(io) {
+  return (await reviewInteropAgents(io)).code;
+}
+
+// src/cli/configure-layout.ts
+init_esm_shims();
+function maxLength(values) {
+  return values.reduce((widest, value) => Math.max(widest, value.length), 0);
+}
+var CONFIGURE_CATEGORY_CHOICES = [
+  {
+    category: "local-app",
+    label: "Local app",
+    summary: "Ollama or LM Studio (recommended for new users)",
+    aliases: ["local"]
+  },
+  {
+    category: "local-http",
+    label: "Local HTTP server",
+    summary: "llama.cpp / vLLM / SGLang / OpenAI/Anthropic-compatible",
+    aliases: ["http"]
+  },
+  {
+    category: "chatgpt",
+    label: "ChatGPT plan",
+    summary: "Plus or Pro via Codex OAuth",
+    aliases: ["codex"]
+  },
+  {
+    category: "cloud-api",
+    label: "Cloud API key",
+    summary: "Anthropic, OpenAI, OpenRouter, Groq, Google, DeepSeek, Mistral, Bedrock, or any OpenAI/Anthropic-compatible endpoint (e.g. Inception)",
+    aliases: ["cloud"]
+  },
+  {
+    category: "all",
+    label: "All runtimes",
+    summary: "advanced (full list)",
+    aliases: ["a"]
+  }
+];
+function formatCategoryMenu(width) {
+  const leftWidth = maxLength(CONFIGURE_CATEGORY_CHOICES.map((choice, index) => `${index + 1}. ${choice.label}`)) + 2;
+  const lines = [];
+  for (const [index, choice] of CONFIGURE_CATEGORY_CHOICES.entries()) {
+    lines.push(...twoColumnRow(`${index + 1}. ${choice.label}`, choice.summary, { indent: 2, leftWidth, width }));
+  }
+  return lines;
+}
+function matchCategoryChoice(answer) {
+  const lc = answer.trim().toLowerCase();
+  if (lc.length === 0) return null;
+  for (const [index, choice] of CONFIGURE_CATEGORY_CHOICES.entries()) {
+    if (lc === String(index + 1) || lc === choice.category || choice.aliases.includes(lc)) {
+      return choice.category;
+    }
+  }
+  return null;
+}
+function formatRuntimeMenu(items, width) {
+  if (items.length === 0) return [];
+  const leftWidth = maxLength(items.map((item, index) => `${String(index + 1).padStart(2)}. ${item.runtimeId}`)) + 1;
+  const lines = [];
+  let lastGroup = null;
+  const grouped = new Set(items.map((item) => item.group)).size > 1;
+  for (const [index, item] of items.entries()) {
+    if (grouped && item.group !== lastGroup) {
+      lastGroup = item.group;
+      lines.push(`  ${item.group}:`);
+    }
+    lines.push(
+      ...twoColumnRow(`${String(index + 1).padStart(2)}. ${item.runtimeId}`, item.summary, {
+        indent: 4,
+        leftWidth,
+        width
+      })
+    );
+  }
+  return lines;
+}
+var LIST_INDENT = 2;
+var LIST_GAP = 1;
+var LIST_MIN_MODELS = 16;
+function formatRuntimeList(rows, width) {
+  if (rows.length === 0) return [];
+  const targetCells = rows.map((row) => `targets=${row.targets}`);
+  const idWidth = maxLength(rows.map((row) => row.runtimeId));
+  const labelWidth = maxLength(rows.map((row) => row.label));
+  const authWidth = maxLength(rows.map((row) => row.auth));
+  const targetsWidth = maxLength(targetCells);
+  const alignedWidth = LIST_INDENT + idWidth + LIST_GAP + labelWidth + LIST_GAP + authWidth + LIST_GAP + targetsWidth;
+  const inline = width >= alignedWidth + LIST_GAP + LIST_MIN_MODELS;
+  const pad = " ".repeat(LIST_INDENT);
+  const detailPad = " ".repeat(LIST_INDENT + 2);
+  const lines = [];
+  let lastGroup = null;
+  for (const [index, row] of rows.entries()) {
+    if (row.group !== lastGroup) {
+      if (lastGroup !== null) lines.push("");
+      lastGroup = row.group;
+      lines.push(`${row.group}:`);
+    }
+    const targetCell = targetCells[index] ?? "";
+    const models = `models=${row.models}`;
+    if (inline) {
+      const id = column(row.runtimeId, idWidth);
+      const label = column(row.label, labelWidth);
+      const auth = column(row.auth, authWidth);
+      lines.push(truncate(`${pad}${id} ${label} ${auth} ${column(targetCell, targetsWidth)} ${models}`, width));
+      continue;
+    }
+    lines.push(truncate(`${pad}${column(row.runtimeId, idWidth)} ${column(row.auth, authWidth)} ${targetCell}`, width));
+    lines.push(truncate(`${detailPad}${row.label} \xB7 ${models}`, width));
+  }
+  return lines;
+}
+
+// src/cli/configure-oauth.ts
+init_esm_shims();
+async function loginOAuthRuntime(rl, runtime) {
+  const auth = openAuthStorage();
+  if (runtime.authNotice) process.stdout.write(`note: ${runtime.authNotice}
+`);
+  const manualCodeInput = createDelayedManualCodeInput(
+    rl,
+    "Paste verification code if browser callback does not complete automatically: "
+  );
+  try {
+    await auth.login(runtime.oauthProviderId ?? runtime.id, {
+      onAuth: ({ url, instructions }) => {
+        process.stdout.write(`
+Open: ${url}
+`);
+        if (instructions) process.stdout.write(`${instructions}
+`);
+        process.stdout.write("Waiting for the browser callback. A manual code prompt will appear if needed.\n");
+      },
+      onDeviceCode: ({ verificationUri, userCode }) => {
+        process.stdout.write(`
+Open: ${verificationUri}
+`);
+        process.stdout.write(`Enter code: ${userCode}
+`);
+      },
+      onPrompt: async (prompt) => {
+        const answer = await rl.question(`${prompt.message}${prompt.allowEmpty ? " " : ": "}`);
+        return prompt.allowEmpty ? answer : answer.trim();
+      },
+      onSelect: (prompt) => promptOAuthSelection(rl, prompt),
+      onManualCodeInput: manualCodeInput.onManualCodeInput,
+      onProgress: (message) => {
+        process.stderr.write(`${message}
+`);
+      }
+    });
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored`)) return false;
+    printOk(`authenticated ${runtime.id}`);
+    return true;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return false;
+  } finally {
+    manualCodeInput.cancel();
+  }
+}
+
+// src/cli/configure-onboarding.ts
+init_esm_shims();
+import { createInterface } from "node:readline/promises";
+function canRunOnboarding(streams) {
+  return canSelect(streams.in, streams.out);
+}
+var LABEL_WIDTH = 11;
+function railWriter(out) {
+  let lines = 0;
+  const stream = {
+    write(chunk) {
+      const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+      for (const char of text) if (char === "\n") lines += 1;
+      return out.write(chunk);
+    },
+    isTTY: out.isTTY,
+    columns: out.columns
+  };
+  return {
+    stream,
+    mark: () => lines,
+    rewindTo(mark) {
+      const back = lines - mark;
+      if (back > 0) out.write(`\x1B[${back}A\x1B[0J`);
+      lines = mark;
+    }
+  };
+}
+function supportFor(runtime) {
+  return buildProviderSupportEntry(runtime);
+}
+function allEntries() {
+  return listProviderSupportEntries(getRuntimeRegistry().list());
+}
+function draftDescriptor(answers, runtime, withModel) {
+  const apiKeyRef = answers.credential === "stored" || answers.credential === "keep" ? runtime.id : void 0;
+  return buildDescriptor(runtime, answers.targetId ?? runtime.id, {
+    ...answers.url !== void 0 ? { url: answers.url } : {},
+    ...withModel && answers.model !== void 0 ? { model: answers.model } : {},
+    ...answers.apiKeyEnv !== void 0 ? { apiKeyEnv: answers.apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...runtime.auth === "oauth" ? { oauthProfile: runtime.oauthProviderId ?? runtime.id } : {}
+  });
+}
+var CATEGORY_STEP = {
+  id: "category",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const current = CONFIGURE_CATEGORY_CHOICES.findIndex((choice2) => choice2.category === answers.category);
+    const result = await promptSelect({
+      heading: ["", source_default.bold("How will you connect Clio to a model?")],
+      choices: CONFIGURE_CATEGORY_CHOICES.map((choice2) => ({
+        value: choice2.category,
+        label: choice2.label,
+        hint: choice2.summary
+      })),
+      initialIndex: current >= 0 ? current : 0,
+      railPrefix: wizard.rail,
+      backLabel: "cancel",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    if (answers.category !== result.value) {
+      answers.runtime = void 0;
+      answers.detected = void 0;
+    }
+    answers.category = result.value;
+    const choice = CONFIGURE_CATEGORY_CHOICES.find((entry) => entry.category === result.value);
+    wizard.answer("Connection", choice?.label ?? result.value);
+    return "next";
+  }
+};
+var RUNTIME_STEP = {
+  id: "runtime",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const registry = getRuntimeRegistry();
+    const chatEntries = allEntries().filter((entry) => {
+      const runtime2 = registry.get(entry.runtimeId);
+      return runtime2 !== null && isOrchestratorEligibleRuntime(runtime2);
+    });
+    const entries = answers.category ? runtimesForCategory(chatEntries, answers.category) : chatEntries;
+    const usable = entries.length > 0 ? entries : chatEntries;
+    const previous = usable.findIndex((entry) => entry.runtimeId === answers.runtime?.id);
+    const featured = usable.findIndex((entry) => entry.featured);
+    const result = await promptSelect({
+      heading: ["", source_default.bold("Which runtime?")],
+      choices: usable.map((entry) => ({ value: entry.runtimeId, label: entry.runtimeId, hint: entry.summary })),
+      initialIndex: previous >= 0 ? previous : featured >= 0 ? featured : 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    const runtime = registry.get(result.value);
+    if (!runtime) return "back";
+    if (answers.runtime?.id !== runtime.id) {
+      answers.targetId = void 0;
+      answers.url = void 0;
+      answers.detected = void 0;
+      answers.credential = void 0;
+      answers.apiKeyEnv = void 0;
+      answers.apiKeyLiteral = void 0;
+      answers.model = void 0;
+      answers.inventory = void 0;
+      answers.inventoryKey = void 0;
+    }
+    answers.runtime = runtime;
+    wizard.answer("Runtime", `${runtime.id}  ${source_default.dim(supportFor(runtime).summary)}`);
+    return "next";
+  }
+};
+var TARGET_ID_STEP = {
+  id: "target-id",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const runtime = answers.runtime;
+    if (!runtime) return "back";
+    const result = await promptText({
+      heading: ["", source_default.bold("Target id")],
+      initial: answers.targetId ?? deriveTargetId(runtime.id, readSettings().targets),
+      hint: "the name you will use for this target in `clio-coder targets`",
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      validate: (value) => {
+        if (value.length === 0) return "a target id is required";
+        if (/\s/u.test(value)) return "a target id cannot contain spaces";
+        return null;
+      },
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    if (answers.targetId !== result.value) answers.inventoryKey = void 0;
+    answers.targetId = result.value;
+    wizard.answer("Target id", result.value);
+    return "next";
+  }
+};
+var URL_STEP = {
+  id: "url",
+  applies: (answers) => answers.runtime !== void 0 && supportFor(answers.runtime).supportsCustomUrl,
+  run: async (wizard, answers) => {
+    const runtime = answers.runtime;
+    if (!runtime) return "back";
+    const local = supportFor(runtime).group === "local-http";
+    const result = await promptText({
+      heading: ["", source_default.bold(local ? "Where is the server?" : "Base URL")],
+      initial: answers.url ?? defaultUrlFor(runtime.id),
+      hint: "host:port is enough; Clio fills in the scheme and the port it knows",
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      validate: (value) => value.length === 0 ? "a URL is required for this runtime" : null,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    const url = normalizeUrl(result.value, runtime.id);
+    if (answers.url !== url) {
+      answers.inventoryKey = void 0;
+      answers.detected = void 0;
+    }
+    answers.url = url;
+    wizard.answer("URL", url);
+    await reportReachability(wizard, answers, runtime, url);
+    return "next";
+  }
+};
+async function reportReachability(wizard, answers, runtime, url) {
+  const draft = draftDescriptor(answers, runtime, false);
+  const probe = await runtimeProbe(runtime, draft, answers.apiKeyLiteral);
+  if (probe !== null) {
+    if (probe.ok) {
+      const readings = probeReadings(probe);
+      wizard.presenter.step(`reachable, ${readings.length > 0 ? readings.join(", ") : "no model list offered"}`);
+    } else if (probe.authFailed) {
+      wizard.presenter.warn("rejected the key");
+    } else {
+      wizard.presenter.warn(`not reachable, you can fix this later: ${probe.error ?? "no reply"}`);
+    }
+  }
+  if (probe?.ok && runtime.id === "lmstudio") {
+    const greeting = await greetLmStudio(draft, { credentialsPresent: /* @__PURE__ */ new Set(), httpTimeoutMs: 750 });
+    if (!greeting.ok) wizard.presenter.warn(`${url} answered, but not with the LM Studio greeting`);
+  }
+  if (PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id)) {
+    const fingerprint = await fingerprintNativeRuntime(url);
+    if (fingerprint && getRuntimeRegistry().get(fingerprint.runtimeId)) {
+      answers.detected = { runtimeId: fingerprint.runtimeId, displayName: fingerprint.displayName };
+    }
+  }
+}
+var DETECTED_RUNTIME_STEP = {
+  id: "detected-runtime",
+  applies: (answers) => answers.detected !== void 0 && answers.runtime !== void 0,
+  run: async (wizard, answers) => {
+    const detected = answers.detected;
+    const runtime = answers.runtime;
+    if (!detected || !runtime) return "next";
+    const native = getRuntimeRegistry().get(detected.runtimeId);
+    if (!native) return "next";
+    const result = await promptSelect({
+      heading: ["", source_default.bold(`That URL is serving ${detected.displayName}.`)],
+      choices: [
+        {
+          value: true,
+          label: `Use ${native.id}`,
+          hint: "its own runtime, with resident-model lifecycle and its real capabilities"
+        },
+        { value: false, label: `Keep ${runtime.id}`, hint: "the generic protocol runtime you picked" }
+      ],
+      initialIndex: 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    if (result.value) {
+      answers.runtime = native;
+      answers.inventoryKey = void 0;
+      wizard.answer("Detected", `${detected.displayName}, using runtime ${native.id}`);
+    } else {
+      wizard.answer("Detected", `${detected.displayName}, keeping runtime ${runtime.id}`);
+    }
+    return "next";
+  }
+};
+function defaultCredentialSource(runtime, targetId) {
+  const status = openAuthStorage().statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  if (status.source === "stored-api-key") return "keep";
+  if (status.source === "environment") return "env";
+  return targetRequiresAuth({ id: targetId, runtime: runtime.id }, runtime) ? "env" : "skip";
+}
+async function connectOAuth(wizard, runtime) {
+  const rl = createInterface({ input: wizard.streams.in, output: wizard.streams.out });
+  try {
+    return await loginOAuthRuntime(rl, runtime);
+  } finally {
+    rl.close();
+  }
+}
+var CREDENTIAL_STEP = {
+  id: "credential",
+  applies: (answers) => answers.runtime?.auth === "api-key" || answers.runtime?.auth === "oauth",
+  run: async (wizard, answers) => {
+    const runtime = answers.runtime;
+    if (!runtime) return "back";
+    const stored = describeAuthStatus(runtime);
+    if (runtime.auth === "oauth") {
+      const result2 = await promptSelect({
+        heading: ["", source_default.bold(`Sign in to ${runtime.displayName}`), source_default.dim(`credential: ${stored}`)],
+        choices: [
+          { value: "oauth-connect", label: "Connect now", hint: "opens your browser and waits for the callback" },
+          {
+            value: "oauth-skip",
+            label: "Later",
+            hint: `run \`clio-coder auth login ${runtime.id}\` before the first turn`
+          }
+        ],
+        initialIndex: answers.credential === "oauth-skip" ? 1 : 0,
+        railPrefix: wizard.rail,
+        backLabel: "back",
+        clearOnExit: true,
+        input: wizard.input,
+        output: wizard.output
+      });
+      if (result2.kind === "quit") return "quit";
+      if (result2.kind === "back") return "back";
+      answers.credential = result2.value;
+      if (result2.value === "oauth-connect") {
+        const connected = await connectOAuth(wizard, runtime);
+        if (!connected) {
+          wizard.presenter.warn(`sign-in did not complete; run \`clio-coder auth login ${runtime.id}\` when ready`);
+          wizard.answer("Credential", "not connected yet");
+          return "next";
+        }
+        wizard.answer("Credential", `connected to ${runtime.id}`);
+        return "next";
+      }
+      wizard.answer("Credential", "not connected yet");
+      return "next";
+    }
+    const hasStored = stored !== "none stored";
+    const choices = [
+      {
+        value: "env",
+        label: "Environment variable",
+        hint: "read at call time; nothing is written to disk"
+      },
+      {
+        value: "stored",
+        label: "Store the key",
+        hint: "written to credentials.yaml, mode 0600, not encrypted"
+      },
+      ...hasStored ? [{ value: "keep", label: "Keep what is there", hint: stored }] : [],
+      { value: "skip", label: "No key", hint: "this target needs no credential" }
+    ];
+    const current = answers.credential ?? defaultCredentialSource(runtime, answers.targetId ?? runtime.id);
+    const initial = Math.max(
+      0,
+      choices.findIndex((choice) => choice.value === current)
+    );
+    const result = await promptSelect({
+      heading: ["", source_default.bold("How should Clio get the API key?"), source_default.dim(`currently: ${stored}`)],
+      choices,
+      initialIndex: initial,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    answers.credential = result.value;
+    if (result.value !== "env") answers.apiKeyEnv = void 0;
+    if (result.value !== "stored") answers.apiKeyLiteral = void 0;
+    if (result.value === "keep") wizard.answer("Credential", stored);
+    if (result.value === "skip") wizard.answer("Credential", "none");
+    return "next";
+  }
+};
+var CREDENTIAL_VALUE_STEP = {
+  id: "credential-value",
+  applies: (answers) => answers.credential === "env" || answers.credential === "stored",
+  run: async (wizard, answers) => {
+    const runtime = answers.runtime;
+    if (!runtime) return "back";
+    const wantsEnv = answers.credential === "env";
+    const result = await promptText({
+      heading: ["", source_default.bold(wantsEnv ? "Which environment variable?" : "Paste the API key")],
+      initial: wantsEnv ? answers.apiKeyEnv ?? runtime.credentialsEnvVar ?? "" : "",
+      hint: wantsEnv ? "Clio reads it every time it calls the provider, so the key never lands on disk" : `stored at ${shortenPath(authStoragePath())}`,
+      ...wantsEnv ? {} : { mask: true },
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    if (wantsEnv) {
+      answers.apiKeyEnv = result.value.length > 0 ? result.value : void 0;
+      answers.inventoryKey = void 0;
+      wizard.answer("Credential", result.value.length > 0 ? `$${result.value}` : "none");
+      return "next";
+    }
+    answers.apiKeyLiteral = result.value.length > 0 ? result.value : void 0;
+    answers.inventoryKey = void 0;
+    wizard.answer("Credential", result.value.length > 0 ? "stored in credentials.yaml" : "none");
+    return "next";
+  }
+};
+async function modelInventory(answers, runtime) {
+  const key = [
+    runtime.id,
+    answers.targetId,
+    answers.url,
+    answers.apiKeyEnv,
+    answers.apiKeyLiteral ? "literal" : ""
+  ].join("|");
+  if (answers.inventoryKey === key && answers.inventory) return answers.inventory;
+  const inventory = await resolveSupportedWireModels(
+    runtime,
+    draftDescriptor(answers, runtime, false),
+    void 0,
+    answers.apiKeyLiteral
+  );
+  answers.inventory = inventory;
+  answers.inventoryKey = key;
+  return inventory;
+}
+var MODEL_STEP = {
+  id: "model",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const runtime = answers.runtime;
+    if (!runtime) return "back";
+    const support = supportFor(runtime);
+    const inventory = await modelInventory(answers, runtime);
+    const catalogOrdered = support.modelSource === "catalog";
+    const preferred = answers.model ?? (inventory.source === "probe" ? inventory.models[0] : support.defaultModel) ?? (catalogOrdered ? void 0 : inventory.models[0]) ?? void 0;
+    if (inventory.models.length === 0) {
+      wizard.presenter.warn(inventoryGap(runtime, { url: answers.url }));
+      const result2 = await promptText({
+        heading: ["", source_default.bold("Which model?")],
+        initial: preferred ?? "",
+        hint: "the wire id the provider documents; Clio sends it as written",
+        railPrefix: wizard.rail,
+        backLabel: "back",
+        clearOnExit: true,
+        validate: (value) => value.length === 0 ? "a model id is required" : null,
+        input: wizard.input,
+        output: wizard.output
+      });
+      if (result2.kind === "quit") return "quit";
+      if (result2.kind === "back") return "back";
+      answers.model = result2.value;
+      wizard.answer("Model", result2.value);
+      await readModelCapabilities(answers, runtime);
+      return "next";
+    }
+    const selected = inventory.models.indexOf(preferred ?? "");
+    const result = await promptSelect({
+      heading: [
+        "",
+        source_default.bold("Which model?"),
+        source_default.dim(
+          inventory.source === "probe" ? "read live from the target just now" : inventory.source === "cache" ? "cached model snapshot; not verified in this run" : "model hints; not a live account catalog"
+        )
+      ],
+      choices: inventory.models.map((model) => {
+        const state = inventory.modelStates?.[model]?.state;
+        const hint = model === preferred ? "default" : state !== void 0 && state !== "unknown" ? state : void 0;
+        const label = inventory.labels?.[model];
+        return {
+          value: model,
+          label: label && label !== model ? `${model} \u2014 ${label}` : model,
+          ...hint === void 0 ? {} : { hint }
+        };
+      }),
+      initialIndex: selected >= 0 ? selected : 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    const refusal = modelChoiceRefusal(
+      runtime,
+      { id: answers.targetId ?? runtime.id, url: answers.url },
+      result.value,
+      inventory
+    );
+    if (refusal !== null) {
+      wizard.presenter.warn(refusal);
+      return "back";
+    }
+    answers.model = result.value;
+    wizard.answer("Model", result.value);
+    await readModelCapabilities(answers, runtime);
+    return "next";
+  }
+};
+async function readModelCapabilities(answers, runtime) {
+  const descriptor = draftDescriptor(answers, runtime, true);
+  const probe = await runtimeProbe(runtime, descriptor);
+  answers.probe = probe;
+  if (probe?.ok && probe.models) {
+    recordTargetModelSnapshot(descriptor, probe.models, probe.modelLabels ? { modelLabels: probe.modelLabels } : {});
+  }
+}
+var THINKING_HINTS = {
+  off: "never ask this model to think before answering",
+  minimal: "a sentence of reasoning",
+  low: "short reasoning, the usual choice",
+  medium: "more reasoning on hard turns",
+  high: "long reasoning, slower and more expensive",
+  xhigh: "longer still, where the model offers it",
+  max: "everything the model will spend"
+};
+var THINKING_STEP = {
+  id: "thinking",
+  applies: (answers) => {
+    const runtime = answers.runtime;
+    if (!runtime || answers.model === void 0) return false;
+    if (PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id)) return true;
+    return modelSupportsThinking(runtime, draftDescriptor(answers, runtime, true), answers.probe ?? null);
+  },
+  run: async (wizard, answers) => {
+    const current = THINKING_LEVELS.indexOf(answers.thinking ?? "low");
+    const result = await promptSelect({
+      heading: ["", source_default.bold("How hard should it think?"), source_default.dim("changeable any time in `clio-coder configure`")],
+      choices: THINKING_LEVELS.map((level) => ({ value: level, label: level, hint: THINKING_HINTS[level] })),
+      initialIndex: current >= 0 ? current : 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind === "quit") return "quit";
+    if (result.kind === "back") return "back";
+    answers.thinking = result.value;
+    wizard.answer("Thinking", result.value);
+    return "next";
+  }
+};
+var ANTIGRAVITY_COLLEAGUE_STEP = {
+  id: "antigravity-colleague",
+  applies: (answers) => answers.runtime !== void 0 && isOrchestratorEligibleRuntime(answers.runtime) && resolveOnPath(["agy"]).presence === "present" && !readSettings().targets.some((target) => target.runtime === "antigravity-code"),
+  run: async (wizard, answers) => {
+    const runtime = getRuntimeRegistry().get("antigravity-code");
+    if (!runtime) return "next";
+    const choice = await promptSelect({
+      heading: [
+        "",
+        source_default.bold("Add your local Antigravity research colleague?"),
+        source_default.dim("optional, experimental, dispatch-only; Clio does not authenticate or inspect its session")
+      ],
+      choices: [
+        { value: false, label: "Not now", hint: "your primary Clio target is unchanged" },
+        { value: true, label: "Add read-only colleague", hint: "probe the non-generating model catalog" }
+      ],
+      initialIndex: answers.antigravity ? 1 : 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (choice.kind === "quit") return "quit";
+    if (choice.kind === "back") return "back";
+    if (!choice.value) {
+      answers.antigravity = void 0;
+      wizard.answer("Colleague", "not added");
+      return "next";
+    }
+    const targetId = deriveTargetId(runtime.id, readSettings().targets);
+    const descriptor = buildDescriptor(runtime, targetId, {});
+    const inventory = await resolveSupportedWireModels(runtime, descriptor);
+    if (inventory.source !== "probe" || inventory.models.length === 0) {
+      answers.antigravity = void 0;
+      wizard.presenter.warn(
+        inventory.probeError ?? "Antigravity did not return a live catalog. Run `agy` yourself, complete sign-in, then add it from Configure \u2192 Targets."
+      );
+      wizard.answer("Colleague", "not added; sign in with agy first");
+      return "next";
+    }
+    const picked = await promptSelect({
+      heading: ["", source_default.bold("Antigravity research model"), source_default.dim("live account catalog")],
+      choices: inventory.models.map((model) => ({
+        value: model,
+        label: inventory.labels?.[model] ? `${model} \u2014 ${inventory.labels[model]}` : model
+      })),
+      initialIndex: 0,
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (picked.kind === "quit") return "quit";
+    if (picked.kind === "back") return "back";
+    answers.antigravity = { targetId, model: picked.value };
+    wizard.answer("Colleague", `${targetId}/${picked.value} \u2192 world-knowledge`);
+    return "next";
+  }
+};
+var PEERS_STEP = {
+  id: "peers",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const outcome = await reviewInteropAgents({
+      rl: null,
+      streams: wizard.streams,
+      presenter: wizard.presenter,
+      rail: wizard.rail,
+      quiet: true
+    });
+    if (outcome.back) return "back";
+    answers.wiredPeers = outcome.wired;
+    return "next";
+  }
+};
+var STEPS = [
+  CATEGORY_STEP,
+  RUNTIME_STEP,
+  TARGET_ID_STEP,
+  CREDENTIAL_STEP,
+  CREDENTIAL_VALUE_STEP,
+  URL_STEP,
+  DETECTED_RUNTIME_STEP,
+  MODEL_STEP,
+  THINKING_STEP,
+  ANTIGRAVITY_COLLEAGUE_STEP,
+  PEERS_STEP
+];
+function persist(answers, descriptor, chatEligible) {
+  updateSettings((settings) => {
+    applyTarget(settings, descriptor);
+    if (chatEligible) setOrchestratorPointer(settings, descriptor, answers.model ?? null);
+    setWorkerDefaultPointer(settings, descriptor, answers.model ?? null);
+    if (answers.thinking !== void 0) {
+      settings.chat.thinkingLevel = answers.thinking;
+      settings.fleet.default.thinkingLevel = answers.thinking;
+    }
+    if (answers.antigravity !== void 0) {
+      const antigravityRuntime = getRuntimeRegistry().get("antigravity-code");
+      if (!antigravityRuntime) throw new Error("Antigravity runtime disappeared before settings were written");
+      const external = buildDescriptor(antigravityRuntime, answers.antigravity.targetId, {
+        model: answers.antigravity.model
+      });
+      applyTarget(settings, external);
+      setWorkerProfilePointer(settings, "world-knowledge-external", external, answers.antigravity.model);
+      bindAgentProfileInSettings(settings, "world-knowledge", "world-knowledge-external");
+    }
+  });
+}
+async function runOnboardingWizard(streams) {
+  const writer = railWriter(streams.out);
+  const presenter = createLifecyclePresenter({ stream: writer.stream });
+  const rail = railPrefix(presenter.isPlain());
+  const columns = streams.out.columns ?? 80;
+  const wizard = {
+    streams,
+    presenter,
+    rail,
+    input: streams.in,
+    output: streams.out,
+    answer: (label, value) => {
+      presenter.fields([[label.padEnd(LABEL_WIDTH), truncate(value, Math.max(12, columns - LABEL_WIDTH - 6))]]);
+    }
+  };
+  presenter.header("Welcome to Clio Coder", "configure");
+  presenter.note("Pick the model you want Clio to talk to; escape goes back a step and changes nothing.");
+  presenter.note(`Result: ${shortenPath(settingsPath())}`);
+  const answers = {};
+  const marks = new Array(STEPS.length).fill(writer.mark());
+  let cursor = 0;
+  let direction = 1;
+  while (cursor < STEPS.length) {
+    const step = STEPS[cursor];
+    if (step === void 0) break;
+    if (!step.applies(answers)) {
+      cursor += direction;
+      if (cursor < 0) return cancel(presenter);
+      continue;
+    }
+    marks[cursor] = writer.mark();
+    const outcome = await step.run(wizard, answers);
+    if (outcome === "quit") return cancel(presenter);
+    if (outcome === "back") {
+      direction = -1;
+      cursor -= 1;
+      while (cursor >= 0 && !(STEPS[cursor]?.applies(answers) ?? false)) cursor -= 1;
+      if (cursor < 0) return cancel(presenter);
+      writer.rewindTo(marks[cursor] ?? writer.mark());
+      continue;
+    }
+    direction = 1;
+    cursor += 1;
+  }
+  return finish(wizard, answers);
+}
+function cancel(presenter) {
+  presenter.done("Cancelled, nothing written");
+  printError("configuration cancelled");
+  return 130;
+}
+function finish(wizard, answers) {
+  const runtime = answers.runtime;
+  const targetId = answers.targetId;
+  if (!runtime || targetId === void 0) return cancel(wizard.presenter);
+  const presenter = wizard.presenter;
+  if (answers.apiKeyLiteral !== void 0) {
+    const auth = openAuthStorage();
+    auth.setApiKey(runtime.id, answers.apiKeyLiteral);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${targetId}' not saved`)) {
+      presenter.done("Nothing written");
+      return 1;
+    }
+    printPlaintextCredentialWarning();
+  }
+  const reasoning = PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id) && answers.thinking !== void 0 ? answers.thinking !== "off" : void 0;
+  const descriptor = buildDescriptor(runtime, targetId, {
+    ...answers.url !== void 0 ? { url: answers.url } : {},
+    ...answers.model !== void 0 ? { model: answers.model } : {},
+    ...answers.apiKeyEnv !== void 0 ? { apiKeyEnv: answers.apiKeyEnv } : {},
+    ...answers.credential === "stored" || answers.credential === "keep" ? { apiKeyRef: runtime.id } : {},
+    ...runtime.auth === "oauth" ? { oauthProfile: runtime.oauthProviderId ?? runtime.id } : {},
+    ...reasoning === void 0 ? {} : { reasoning }
+  });
+  const chatEligible = isOrchestratorEligibleRuntime(runtime);
+  try {
+    persist(answers, descriptor, chatEligible);
+  } catch (error) {
+    presenter.fail("settings were not written", error instanceof Error ? error.message : String(error));
+    presenter.done("Nothing written");
+    return 1;
+  }
+  presenter.completedStep(`target ${targetId} saved, runtime ${runtime.id}`);
+  if (chatEligible)
+    presenter.completedStep(`chat runs on ${targetId}${answers.model ? `, model ${answers.model}` : ""}`);
+  else presenter.completedStep(`${runtime.id} cannot answer chat; ${targetId} is registered for dispatch only`);
+  presenter.completedStep(`fleet default is ${targetId}`);
+  if (answers.thinking !== void 0) presenter.completedStep(`thinking level ${answers.thinking}`);
+  for (const peer of answers.wiredPeers ?? []) {
+    presenter.completedStep(`delegation agent ${peer} added; use \`/delegate ${peer} <task>\``);
+  }
+  if (answers.antigravity !== void 0) {
+    presenter.completedStep(
+      `world-knowledge bound read-only to ${answers.antigravity.targetId}/${answers.antigravity.model}`
+    );
+  }
+  presenter.completedStep(`settings written to ${shortenPath(settingsPath())}`);
+  if (contextWindowUndiscovered(descriptor, answers.probe ?? null)) {
+    presenter.warn(
+      `${targetId} reported no context window, so Clio will use the runtime default as a guess. Set the real one with \`clio-coder configure --id ${targetId} --runtime ${runtime.id} --context-window <N>\`.`
+    );
+  }
+  presenter.commandAdvice("Start Clio:", "clio-coder");
+  presenter.commandAdvice("Change any of this later:", "clio-coder configure");
+  presenter.done("Done");
+  return 0;
+}
+
+// src/cli/configure.ts
+var HELP = `clio-coder configure
+
+Configure model targets and runtime settings for chat and fleet dispatch.
+
+Usage:
+  clio-coder configure                   interactive configuration wizard
+  clio-coder configure --section <name>  open one section directly:
+                                         targets, models, chat, fleet,
+                                         permissions, panes, skills, diagnostics
+                                         Without a terminal this prints the
+                                         section's values and exits.
+  clio-coder configure --json            emit the effective settings as JSON
+  clio-coder configure --interop         review detected coding agents as delegation peers
+  clio-coder configure --list            list target runtimes (user-facing only)
+  clio-coder configure --list --all      list every registered runtime including aliases
+  clio-coder configure --id <targetId> [flags] --runtime <runtimeId>
+  clio-coder configure --help, -h        show this message
+
+In the interactive menus: arrow keys move, enter opens, escape goes back, q
+quits. Where the terminal cannot support that, the same menus are numbered and
+answered by typing a number, b for back, or q to quit.
+
+Non-interactive flags:
+  --id <targetId>                  target id to register (required when non-interactive)
+  --runtime <runtimeId>            runtime to use when registering non-interactively
+  --url <host>                     target base URL (http(s):// or ws://)
+  --model <wireModelId>            default model id for this target
+  --orchestrator-model <id>        model to use when setting chat default
+  --background-model <id>          model to use for proactive task memory
+  --fleet-model <id>               model to use when setting fleet default
+                                   (mutually exclusive with --agent-profile)
+  --agent-profile <name>           save this target as a named fleet profile
+  --agent-profile-model <id>       model to use for --agent-profile
+  --bind-agent <agentId>           bind this --agent-profile to an agent
+  --api-key-env <VAR>              read API key from this env var at call time
+  --api-key <literal>              store API key in credentials.yaml
+  --force                          save a model outside the runtime catalog, or one the
+                                   target does not advertise, without refusing
+  --gateway                        mark the target as a gateway
+  --lifecycle <user-managed|clio-coder-managed>
+                                  resident model lifecycle policy
+  --set-orchestrator               use this target for chat
+  --set-background                 use this target for proactive task memory
+  --set-fleet-default              use this target for the fleet default
+  --context-window <N>             capability override
+  --max-tokens <N>                 output token capability override
+  --reasoning <true|false>         capability override
+`;
+function parseSetupArgs(argv) {
+  const out = {
+    positional: [],
+    help: false,
+    list: false,
+    all: false,
+    interop: false,
+    json: false,
+    force: false,
+    gateway: false,
+    setOrchestrator: false,
+    setBackground: false,
+    setWorkerDefault: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const need = () => {
+      const v = argv[i + 1];
+      if (v === void 0) throw new Error(`${a} requires a value`);
+      i += 1;
+      return v;
+    };
+    switch (a) {
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      case "--json":
+        out.json = true;
+        break;
+      case "--section":
+        out.section = need();
+        break;
+      case "--list":
+        out.list = true;
+        break;
+      case "--all":
+        out.all = true;
+        break;
+      case "--interop":
+        out.interop = true;
+        break;
+      case "--remove":
+        out.remove = need();
+        break;
+      case "--rename":
+        out.renameOld = need();
+        out.renameNew = need();
+        break;
+      case "--id":
+        out.id = need();
+        break;
+      case "--runtime":
+        out.runtime = need();
+        break;
+      case "--url":
+        out.url = need();
+        break;
+      case "--model":
+        out.model = need();
+        break;
+      case "--orchestrator-model":
+        out.orchestratorModel = need();
+        break;
+      case "--background-model":
+        out.backgroundModel = need();
+        break;
+      case "--fleet-model":
+        out.workerModel = need();
+        break;
+      case "--agent-profile":
+        out.workerProfile = need();
+        break;
+      case "--agent-profile-model":
+        out.workerProfileModel = need();
+        break;
+      case "--bind-agent":
+        out.bindAgent = need();
+        break;
+      case "--api-key-env":
+        out.apiKeyEnv = need();
+        break;
+      case "--api-key":
+        out.apiKey = need();
+        break;
+      case "--force":
+        out.force = true;
+        break;
+      case "--gateway":
+        out.gateway = true;
+        break;
+      case "--lifecycle": {
+        const v = need();
+        if (v !== "user-managed" && v !== "clio-coder-managed") {
+          throw new Error("--lifecycle must be user-managed or clio-coder-managed");
+        }
+        out.lifecycle = v;
+        break;
+      }
+      case "--set-orchestrator":
+        out.setOrchestrator = true;
+        break;
+      case "--set-background":
+        out.setBackground = true;
+        break;
+      case "--set-fleet-default":
+        out.setWorkerDefault = true;
+        break;
+      case "--context-window": {
+        const n = Number(need());
+        if (!Number.isFinite(n) || n <= 0) throw new Error("--context-window must be a positive number");
+        out.contextWindow = Math.floor(n);
+        break;
+      }
+      case "--max-tokens": {
+        const n = Number(need());
+        if (!Number.isFinite(n) || n <= 0) throw new Error("--max-tokens must be a positive number");
+        out.maxTokens = Math.floor(n);
+        break;
+      }
+      case "--reasoning": {
+        const v = need().toLowerCase();
+        if (v !== "true" && v !== "false") throw new Error("--reasoning must be true or false");
+        out.reasoning = v === "true";
+        break;
+      }
+      default:
+        if (a.startsWith("-")) throw new Error(`unknown flag: ${a}`);
+        out.positional.push(a);
+    }
+  }
+  return out;
+}
+function ensureRegistryPopulated() {
+  registerClioOAuthProviders();
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+}
+var RUNTIME_LIST_CAPTION = "every registered runtime. run `clio-coder auth list` for the ones clio authenticates itself; the rest authenticate through their own tool (claude-cli, aws-sdk) or need no credential.";
+function printRuntimeList(includeHidden) {
+  const settings = readSettings();
+  const auth = openAuthStorage();
+  const rows = [];
+  for (const entry of listProviderSupportEntries(getRuntimeRegistry().list(), { includeHidden })) {
+    const runtime = getRuntimeRegistry().get(entry.runtimeId);
+    const status = runtime && entry.connectable ? auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false }) : null;
+    const authLabel = runtime?.auth === "oauth" ? status?.available ? "connected" : "login" : runtime?.auth === "api-key" ? status?.available ? "credential" : targetRequiresAuth({ id: entry.runtimeId, runtime: entry.runtimeId }, runtime) ? "needs-key" : "key-optional" : runtime?.auth ?? "none";
+    rows.push({
+      group: supportGroupLabel(entry.group),
+      runtimeId: entry.runtimeId,
+      label: entry.label,
+      auth: authLabel,
+      targets: configuredTargetsForRuntime(settings, entry.runtimeId).length,
+      models: describeRuntimeModels(entry, 2)
+    });
+  }
+  const width = terminalColumns();
+  for (const line of formatRuntimeList(rows, width)) {
+    process.stdout.write(`${line}
+`);
+  }
+  for (const line of wrapPlain(RUNTIME_LIST_CAPTION, width)) {
+    process.stdout.write(`${line}
+`);
+  }
+}
+function printSummary(settings, descriptor, probe) {
+  process.stdout.write(`
+saved target ${descriptor.id} (runtime=${descriptor.runtime})
+`);
+  if (descriptor.url) process.stdout.write(`  url        ${descriptor.url}
+`);
+  if (descriptor.defaultModel) process.stdout.write(`  model      ${descriptor.defaultModel}
+`);
+  if (descriptor.auth?.apiKeyEnvVar) process.stdout.write(`  apiKeyEnv  ${descriptor.auth.apiKeyEnvVar}
+`);
+  if (descriptor.gateway) process.stdout.write("  gateway    true\n");
+  if (descriptor.lifecycle) process.stdout.write(`  lifecycle  ${descriptor.lifecycle}
+`);
+  if (probe) {
+    for (const line of probeLines(descriptor, probe)) process.stdout.write(`  ${line}
+`);
+  }
+  warnUndiscoveredContextWindow(descriptor, probe);
+  if (settings.chat.target === descriptor.id) process.stdout.write("  orchestrator target\n");
+  if (settings.context.memory.target === descriptor.id) process.stdout.write("  background memory target\n");
+  if (settings.fleet.default.target === descriptor.id) process.stdout.write("  fleet default\n");
+  for (const [name, profile] of Object.entries(settings.fleet.profiles)) {
+    if (profile.target === descriptor.id) process.stdout.write(`  fleet profile ${name}
+`);
+  }
+  process.stdout.write(`
+settings written to ${settingsPath()}
+`);
+}
+function resolveModelChoice(answer, wireModels, defaultValue) {
+  if (answer.length === 0) return defaultValue;
+  const numeric = Number(answer);
+  if (Number.isInteger(numeric) && numeric >= 1 && numeric <= wireModels.length) {
+    return wireModels[numeric - 1];
+  }
+  return answer;
+}
+async function askModelChoice(rl, label, wireModels, defaultValue) {
+  const answer = await ask(rl, `${label} (number or id)`, defaultValue ?? "");
+  if (answer === null) return null;
+  return resolveModelChoice(answer, wireModels, defaultValue) ?? "";
+}
+function refuseCatalogSeededModel(runtime, support) {
+  printError(
+    `--model is required for ${runtime.id}: its ${support.modelHints.length} model ids come from the provider catalog in name order, which recommends none of them`
+  );
+  process.stderr.write(
+    `  run \`clio-coder configure --runtime ${runtime.id}\` with no other flags to choose from the full list
+`
+  );
+}
+async function runNonInteractive(runtime, args) {
+  if (!args.id) {
+    printError("--id is required when passing flags non-interactively");
+    return 2;
+  }
+  if (args.workerProfileModel !== void 0 && args.workerProfile === void 0) {
+    printError("--agent-profile-model requires --agent-profile");
+    return 2;
+  }
+  if (args.bindAgent !== void 0 && args.workerProfile === void 0) {
+    printError("--bind-agent requires --agent-profile");
+    return 2;
+  }
+  if (args.workerProfile !== void 0 && args.workerProfile.trim().length === 0) {
+    printError("--agent-profile must be non-empty");
+    return 2;
+  }
+  if (args.workerProfile !== void 0 && args.workerModel !== void 0) {
+    printError(
+      "--fleet-model and --agent-profile conflict; use --agent-profile-model for the profile, or drop --agent-profile to set the fleet default"
+    );
+    return 2;
+  }
+  const settings = readSettings();
+  const auth = openAuthStorage();
+  const support = buildProviderSupportEntry(runtime);
+  const existing = settings.targets.find((e) => e.id === args.id);
+  if (existing && (getRuntimeRegistry().get(existing.runtime)?.id ?? existing.runtime) !== runtime.id) {
+    printError(`target ${args.id} already exists with runtime ${existing.runtime}`);
+    return 2;
+  }
+  let url = args.url ? normalizeUrl(args.url, runtime.id) : existing?.url;
+  if (!url && support.supportsCustomUrl) {
+    url = defaultUrlFor(runtime.id);
+  }
+  if (url && runtime.id === "lmstudio") {
+    const greeting = await greetLmStudio(
+      { id: args.id, runtime: runtime.id, url },
+      { credentialsPresent: /* @__PURE__ */ new Set(), httpTimeoutMs: 750 }
+    );
+    if (!greeting.ok) {
+      printError(`refusing to save LM Studio target '${args.id}': ${url} did not return the LM Studio greeting`);
+      return 2;
+    }
+  }
+  if (url && (runtime.id === "openai-compat" || runtime.id === "anthropic-compat")) {
+    const fingerprint = await fingerprintNativeRuntime(url);
+    if (fingerprint) {
+      process.stdout.write(
+        `note: detected ${fingerprint.displayName} at ${url}; consider \`clio-coder targets convert ${args.id} --runtime ${fingerprint.runtimeId}\` for proper resident-model lifecycle
+`
+      );
+    }
+  }
+  const authStatus = auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  const apiKeyEnv = args.apiKeyEnv ?? existing?.auth?.apiKeyEnvVar;
+  const apiKeyRef = runtime.auth === "api-key" && (args.apiKey || existing?.auth?.apiKeyRef || authStatus.source === "stored-api-key") ? runtime.id : void 0;
+  const oauthProfile = runtime.auth === "oauth" ? existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id : void 0;
+  const seed = buildDescriptor(runtime, args.id, {
+    ...url !== void 0 ? { url } : {},
+    ...args.model !== void 0 ? { model: args.model } : existing?.defaultModel ? { model: existing.defaultModel } : support.defaultModel ? { model: support.defaultModel } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    gateway: args.gateway || existing?.gateway === true,
+    ...args.lifecycle !== void 0 ? { lifecycle: args.lifecycle } : existing?.lifecycle !== void 0 ? { lifecycle: existing.lifecycle } : {},
+    ...args.contextWindow !== void 0 ? { contextWindow: args.contextWindow } : {},
+    ...args.maxTokens !== void 0 ? { maxTokens: args.maxTokens } : {},
+    ...args.reasoning !== void 0 ? { reasoning: args.reasoning } : {},
+    ...existing?.lmstudio ? { lmstudio: existing.lmstudio } : {},
+    ...existing?.litellm ? { litellm: existing.litellm } : {}
+  });
+  const inventory = await resolveSupportedWireModels(runtime, seed, existing, args.apiKey);
+  const wireModels = inventory.models;
+  const model = args.model ?? existing?.defaultModel ?? (inventory.source === "probe" ? wireModels[0] : support.defaultModel) ?? (support.modelSource === "catalog" ? void 0 : wireModels[0]);
+  if (model === void 0 && support.modelSource === "catalog") {
+    refuseCatalogSeededModel(runtime, support);
+    return 2;
+  }
+  if (!validateResolvedModel(runtime, seed, model, args.force, inventory)) return 2;
+  if (!validateContextWindowOverride(runtime, model, args.contextWindow, args.force)) return 2;
+  const descriptor = buildDescriptor(runtime, args.id, {
+    ...url !== void 0 ? { url } : {},
+    ...model ? { model } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    gateway: args.gateway || existing?.gateway === true,
+    ...args.lifecycle !== void 0 ? { lifecycle: args.lifecycle } : existing?.lifecycle !== void 0 ? { lifecycle: existing.lifecycle } : {},
+    ...args.contextWindow !== void 0 ? { contextWindow: args.contextWindow } : {},
+    ...args.maxTokens !== void 0 ? { maxTokens: args.maxTokens } : {},
+    ...args.reasoning !== void 0 ? { reasoning: args.reasoning } : {},
+    ...existing?.lmstudio ? { lmstudio: existing.lmstudio } : {},
+    ...existing?.litellm ? { litellm: existing.litellm } : {}
+  });
+  const setOrchestrator = args.setOrchestrator || args.orchestratorModel !== void 0;
+  const setBackground = args.setBackground || args.backgroundModel !== void 0;
+  if ((setOrchestrator || setBackground) && !isOrchestratorEligibleRuntime(runtime)) {
+    printError(
+      `cannot use target '${descriptor.id}' as a chat or background target because runtime '${runtime.id}' is not an HTTP/native runtime`
+    );
+    return 1;
+  }
+  try {
+    assertOrchestratorReplacementEligible(settings, descriptor);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (args.apiKey) {
+    auth.setApiKey(runtime.id, args.apiKey);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${descriptor.id}' not saved`))
+      return 1;
+    printPlaintextCredentialWarning();
+  }
+  const setWorkerDefault = args.setWorkerDefault || args.workerProfile === void 0 && args.workerModel !== void 0;
+  const applyConfiguration = (target) => {
+    applyTarget(target, descriptor);
+    if (setOrchestrator)
+      setOrchestratorPointer(target, descriptor, args.orchestratorModel ?? descriptor.defaultModel ?? null);
+    if (setBackground) setBackgroundPointer(target, descriptor, args.backgroundModel ?? descriptor.defaultModel ?? null);
+    if (setWorkerDefault)
+      setWorkerDefaultPointer(target, descriptor, args.workerModel ?? descriptor.defaultModel ?? null);
+    if (args.workerProfile !== void 0) {
+      setWorkerProfilePointer(
+        target,
+        args.workerProfile,
+        descriptor,
+        args.workerProfileModel ?? descriptor.defaultModel ?? null
+      );
+      if (args.bindAgent !== void 0) bindAgentProfileInSettings(target, args.bindAgent, args.workerProfile);
+    }
+  };
+  applyConfiguration(settings);
+  updateSettings(applyConfiguration);
+  const probe = await runtimeProbe(runtime, descriptor);
+  if (probe?.ok && probe.models) {
+    recordTargetModelSnapshot(descriptor, probe.models, probe.modelLabels ? { modelLabels: probe.modelLabels } : {});
+  }
+  printSummary(settings, descriptor, probe);
+  if (runtime.auth === "oauth" && !auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false }).available) {
+    process.stdout.write(
+      `note: authenticate ${runtime.id} with \`clio-coder auth login ${runtime.id}\` before using this target
+`
+    );
+  }
+  printOk(`target ${args.id} saved`);
+  return 0;
+}
+async function pickRuntime(rl) {
+  const registry = getRuntimeRegistry();
+  const entries = listProviderSupportEntries(registry.list());
+  return pickRuntimeFromEntries(rl, entries, "\nSupported runtimes:");
+}
+async function pickRuntimeFromEntries(rl, entries, heading) {
+  const registry = getRuntimeRegistry();
+  if (entries.length === 0) {
+    process.stderr.write("no runtimes available in this category\n");
+    return null;
+  }
+  process.stdout.write(`${heading}
+`);
+  const menu = formatRuntimeMenu(
+    entries.map((entry) => ({
+      group: supportGroupLabel(entry.group),
+      runtimeId: entry.runtimeId,
+      summary: entry.summary
+    })),
+    terminalColumns()
+  );
+  for (const line of menu) process.stdout.write(`${line}
+`);
+  const allowedIds = new Set(entries.map((entry) => entry.runtimeId));
+  const defaultRuntimeId = entries.find((entry) => entry.featured)?.runtimeId ?? "";
+  for (; ; ) {
+    const answer = await ask(rl, "\nSelection (number or runtime id)", defaultRuntimeId);
+    if (answer === null) return null;
+    if (answer.length === 0) {
+      process.stderr.write(`pick a number from 1 to ${entries.length}, or type a runtime id
+`);
+      continue;
+    }
+    const numeric = Number(answer);
+    if (Number.isInteger(numeric) && numeric >= 1 && numeric <= entries.length) {
+      const picked = entries[numeric - 1];
+      if (picked) {
+        const runtime = registry.get(picked.runtimeId);
+        if (runtime) return runtime;
+      }
+    }
+    if (allowedIds.has(answer)) {
+      const match = registry.get(answer);
+      if (match) return match;
+    }
+    process.stderr.write(`unknown runtime id for this category: ${answer}
+`);
+  }
+}
+async function pickCategory(rl) {
+  process.stdout.write("\nHow will you connect Clio to a model?\n\n");
+  for (const line of formatCategoryMenu(terminalColumns())) process.stdout.write(`${line}
+`);
+  for (; ; ) {
+    const answer = await ask(rl, "\nSelection", "1");
+    if (answer === null) return null;
+    if (answer.length === 0) continue;
+    const category = matchCategoryChoice(answer);
+    if (category) return category;
+    process.stderr.write(`invalid choice: ${answer}
+`);
+  }
+}
+async function pickRuntimeViaCategory(rl) {
+  const registry = getRuntimeRegistry();
+  const allEntries2 = listProviderSupportEntries(registry.list());
+  const category = await pickCategory(rl);
+  if (category === null) return null;
+  if (category === "all") return pickRuntime(rl);
+  const filtered = runtimesForCategory(allEntries2, category);
+  if (filtered.length === 0) {
+    process.stderr.write("no runtimes available for that category; falling back to full list\n");
+    return pickRuntime(rl);
+  }
+  if (category === "chatgpt") {
+    const only = filtered[0];
+    if (only) {
+      const runtime = registry.get(only.runtimeId);
+      if (runtime) {
+        process.stdout.write(`
+Using ${runtime.id} (${only.summary}).
+`);
+        return runtime;
+      }
+    }
+    return pickRuntime(rl);
+  }
+  if (filtered.length === 1) {
+    const only = filtered[0];
+    if (only) {
+      const runtime = registry.get(only.runtimeId);
+      if (runtime) {
+        process.stdout.write(`
+Using ${runtime.id} (${only.summary}).
+`);
+        return runtime;
+      }
+    }
+  }
+  const heading = category === "local-app" ? "\nLocal apps:" : category === "local-http" ? "\nLocal HTTP servers:" : "\nCloud APIs:";
+  return pickRuntimeFromEntries(rl, filtered, heading);
+}
+async function maybeSteerToNativeRuntime(rl, currentRuntime, url) {
+  if (currentRuntime.id !== "openai-compat" && currentRuntime.id !== "anthropic-compat") return currentRuntime;
+  const fingerprint = await fingerprintNativeRuntime(url);
+  if (!fingerprint) return currentRuntime;
+  const native = getRuntimeRegistry().get(fingerprint.runtimeId);
+  if (!native) return currentRuntime;
+  process.stdout.write(`
+Detected ${fingerprint.displayName} at ${url}.
+`);
+  const switchIt = await askYesNo(rl, `Use ${fingerprint.runtimeId} runtime instead of ${currentRuntime.id}?`, true);
+  if (!switchIt) return currentRuntime;
+  process.stdout.write(`Using ${fingerprint.runtimeId} runtime.
+`);
+  return native;
+}
+async function runTargetSetupInteractive(rl, runtime, defaults) {
+  const auth = openAuthStorage();
+  const settings = readSettings();
+  let support = buildProviderSupportEntry(runtime);
+  const initialRuntimeId = runtime.id;
+  const existingForRuntime = configuredTargetsForRuntime(settings, initialRuntimeId);
+  const existing = (defaults.id ? settings.targets.find((entry) => entry.id === defaults.id && entry.runtime === initialRuntimeId) : null) ?? existingForRuntime[0] ?? null;
+  if (existingForRuntime.length > 0) {
+    process.stdout.write(`
+Existing targets for ${runtime.id}:
+`);
+    for (const target of existingForRuntime) {
+      process.stdout.write(`  - ${target.id}${target.defaultModel ? ` (${target.defaultModel})` : ""}
+`);
+    }
+  }
+  process.stdout.write(`
+Selected runtime: ${runtime.id} (${support.summary})
+`);
+  process.stdout.write(`Credentials: ${describeAuthStatus(runtime)}
+`);
+  if (support.modelHints.length > 0) {
+    process.stdout.write(`Known models: ${describeRuntimeModels(support, 4)}
+`);
+  }
+  const suggestedId = defaults.id ?? existing?.id ?? deriveTargetId(runtime.id, settings.targets);
+  const idInput = await ask(rl, "Target id", suggestedId);
+  if (idInput === null || idInput.length === 0) {
+    printError("target id is required");
+    return 2;
+  }
+  const targetId = idInput;
+  let url = existing?.url;
+  if (support.supportsCustomUrl) {
+    const urlDefault = defaults.url ?? existing?.url ?? defaultUrlFor(runtime.id);
+    const urlInput = await ask(
+      rl,
+      support.group === "local-http" ? "Target URL" : "Base URL override (blank for runtime default)",
+      urlDefault
+    );
+    if (urlInput === null) return 0;
+    if (urlInput.length > 0) url = normalizeUrl(urlInput, runtime.id);
+  } else if (defaults.url) {
+    url = normalizeUrl(defaults.url, runtime.id);
+  }
+  if (url) {
+    const steered = await maybeSteerToNativeRuntime(rl, runtime, url);
+    if (steered.id !== runtime.id) {
+      runtime = steered;
+      support = buildProviderSupportEntry(runtime);
+    }
+    if (runtime.id === "lmstudio") {
+      const greeting = await greetLmStudio(
+        { id: targetId, runtime: runtime.id, url },
+        { credentialsPresent: /* @__PURE__ */ new Set(), httpTimeoutMs: 750 }
+      );
+      if (!greeting.ok) {
+        printError(`refusing to save LM Studio target '${targetId}': ${url} did not return the LM Studio greeting`);
+        return 2;
+      }
+    }
+  }
+  let apiKeyEnv;
+  let apiKeyLiteral;
+  let apiKeyRef = existing?.auth?.apiKeyRef;
+  let oauthProfile = runtime.auth === "oauth" ? existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id : void 0;
+  const authStatus = auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  if (runtime.auth === "api-key") {
+    const needsCredential = targetRequiresAuth({ id: targetId, runtime: runtime.id }, runtime);
+    const defaultSource = authStatus.source === "stored-api-key" ? "keep" : authStatus.source === "environment" || existing?.auth?.apiKeyEnvVar || needsCredential ? "env" : "skip";
+    process.stdout.write(
+      "\nCredential source: env reads a key from an environment variable, stored writes one to\ncredentials.yaml, keep leaves the current one alone, skip uses no key at all.\n"
+    );
+    const choice = await ask(rl, "Credential source [env|stored|keep|skip]", defaultSource);
+    if (choice === null) return 0;
+    const normalized = choice.trim().toLowerCase();
+    if (normalized === "stored") {
+      const literal = await ask(rl, "API key literal (stored in credentials.yaml, mode 0600)");
+      if (literal !== null && literal.length > 0) {
+        apiKeyLiteral = literal;
+        apiKeyRef = runtime.id;
+      }
+    } else if (normalized === "env") {
+      const envDefault = defaults.apiKeyEnv ?? existing?.auth?.apiKeyEnvVar ?? runtime.credentialsEnvVar ?? "";
+      const envAnswer = await ask(rl, "Env var name (blank for no key)", envDefault);
+      if (envAnswer === null) return 0;
+      if (envAnswer.length > 0) apiKeyEnv = envAnswer;
+      apiKeyRef = void 0;
+    } else if (normalized === "keep") {
+      apiKeyEnv = existing?.auth?.apiKeyEnvVar ?? (authStatus.source === "environment" ? runtime.credentialsEnvVar : void 0);
+      apiKeyRef = existing?.auth?.apiKeyRef ?? (authStatus.source === "stored-api-key" ? runtime.id : void 0);
+    } else {
+      apiKeyEnv = void 0;
+      apiKeyRef = void 0;
+    }
+  }
+  if (runtime.auth === "oauth") {
+    const connectNow = authStatus.available ? await askYesNo(rl, `Reconnect ${runtime.displayName}?`, false) : await askYesNo(rl, `Connect ${runtime.displayName} now?`, true);
+    if (connectNow) {
+      const connected = await loginOAuthRuntime(rl, runtime);
+      if (!connected) return 1;
+    }
+    oauthProfile = runtime.oauthProviderId ?? runtime.id;
+  }
+  let model = defaults.model;
+  let inventory = { models: [], source: "none" };
+  const tentative = buildDescriptor(runtime, targetId, {
+    ...url !== void 0 ? { url } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    gateway: defaults.gateway,
+    ...defaults.lifecycle !== void 0 ? { lifecycle: defaults.lifecycle } : existing?.lifecycle !== void 0 ? { lifecycle: existing.lifecycle } : {},
+    ...defaults.contextWindow !== void 0 ? { contextWindow: defaults.contextWindow } : {},
+    ...defaults.maxTokens !== void 0 ? { maxTokens: defaults.maxTokens } : {},
+    ...defaults.reasoning !== void 0 ? { reasoning: defaults.reasoning } : {},
+    ...existing?.lmstudio ? { lmstudio: existing.lmstudio } : {},
+    ...existing?.litellm ? { litellm: existing.litellm } : {}
+  });
+  if (runtime.kind === "http" || runtime.externalAgentLoop?.modelCatalog === "live-authoritative") {
+    inventory = await resolveSupportedWireModels(runtime, tentative, existing ?? void 0);
+  }
+  const wireModels = inventory.models;
+  const catalogOrdered = support.modelSource === "catalog";
+  model = model ?? existing?.defaultModel ?? (inventory.source === "probe" ? wireModels[0] : support.defaultModel) ?? (catalogOrdered ? void 0 : wireModels[0]);
+  if (wireModels.length > 0) {
+    process.stdout.write("\nSelectable models:\n");
+    for (const [index, wireModel] of wireModels.entries()) {
+      const label = inventory.labels?.[wireModel];
+      process.stdout.write(
+        `  ${index + 1}. ${wireModel}${label && label !== wireModel ? ` \u2014 ${label}` : ""}${wireModel === model ? "  [default]" : ""}
+`
+      );
+    }
+    if (inventory.source === "cache") process.stdout.write("  cached model snapshot (not verified in this run)\n");
+    if (inventory.probeError) process.stdout.write(`  live probe unavailable: ${inventory.probeError}
+`);
+    if (!model && catalogOrdered) {
+      process.stdout.write(`  listed in provider catalog order, which recommends none of them; pick one.
+`);
+    }
+    for (; ; ) {
+      const pickedModel = await askModelChoice(rl, "Default target model", wireModels, model);
+      if (pickedModel === null) return 0;
+      if (pickedModel.length > 0) model = pickedModel;
+      if (!model) {
+        process.stdout.write("  a model is required: enter a number from the list or a model id.\n");
+        continue;
+      }
+      if (validateResolvedModel(runtime, tentative, model, defaults.force, inventory)) break;
+    }
+  } else {
+    for (; ; ) {
+      if (model && validateResolvedModel(runtime, tentative, model, defaults.force, inventory)) break;
+      const manual = await ask(rl, "Default model id (blank to leave empty)", model ?? "");
+      if (manual === null) return 0;
+      model = manual.length > 0 ? manual : void 0;
+      if (!model) break;
+    }
+  }
+  let contextWindowChoice = defaults.contextWindow;
+  let reasoningChoice = defaults.reasoning;
+  if (PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id)) {
+    if (contextWindowChoice === void 0) {
+      const cwDefault = existing?.capabilities?.contextWindow ?? runtime.defaultCapabilities.contextWindow;
+      const cwAnswer = await ask(
+        rl,
+        "Context window in tokens (blank for runtime default)",
+        cwDefault > 0 ? String(cwDefault) : ""
+      );
+      if (cwAnswer === null) return 0;
+      if (cwAnswer.length > 0) {
+        const parsed = Number(cwAnswer);
+        if (Number.isInteger(parsed) && parsed > 0) contextWindowChoice = parsed;
+        else process.stderr.write(`ignoring invalid context window: ${cwAnswer}
+`);
+      }
+    }
+    if (reasoningChoice === void 0) {
+      const reasoningDefault = existing?.capabilities?.reasoning ?? runtime.defaultCapabilities.reasoning === true;
+      reasoningChoice = await askYesNo(rl, "Does this model support reasoning / thinking?", reasoningDefault);
+    }
+  }
+  if (!validateContextWindowOverride(runtime, model, contextWindowChoice, defaults.force)) return 2;
+  const gatewayDefault = defaults.gateway || existing?.gateway === true;
+  const gatewayAnswer = gatewayDefault ? true : await askYesNo(rl, "Mark as gateway?", false);
+  const descriptor = buildDescriptor(runtime, targetId, {
+    ...url !== void 0 ? { url } : {},
+    ...model !== void 0 ? { model } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    gateway: gatewayAnswer,
+    ...defaults.lifecycle !== void 0 ? { lifecycle: defaults.lifecycle } : existing?.lifecycle !== void 0 ? { lifecycle: existing.lifecycle } : {},
+    ...contextWindowChoice !== void 0 ? { contextWindow: contextWindowChoice } : {},
+    ...defaults.maxTokens !== void 0 ? { maxTokens: defaults.maxTokens } : {},
+    ...reasoningChoice !== void 0 ? { reasoning: reasoningChoice } : {},
+    ...existing?.lmstudio ? { lmstudio: existing.lmstudio } : {},
+    ...existing?.litellm ? { litellm: existing.litellm } : {}
+  });
+  try {
+    assertOrchestratorReplacementEligible(settings, descriptor);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (apiKeyLiteral) {
+    auth.setApiKey(runtime.id, apiKeyLiteral);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${descriptor.id}' not saved`))
+      return 1;
+    printPlaintextCredentialWarning();
+  }
+  const probe = await runtimeProbe(runtime, descriptor);
+  if (probe?.ok && probe.models) recordTargetModelSnapshot(descriptor, probe.models);
+  if (probe) {
+    process.stdout.write("\n");
+    for (const line of probeLines(descriptor, probe)) process.stdout.write(`${line}
+`);
+    if (!probe.ok) {
+      const keepAnyway = await askYesNo(rl, "save this target anyway, without a reply from it?", true);
+      if (!keepAnyway) {
+        printError("aborted; settings not changed");
+        return 0;
+      }
+    }
+  }
+  const setOrchestrator = !isOrchestratorEligibleRuntime(runtime) ? false : defaults.setOrchestrator ? true : await askYesNo(rl, "use as orchestrator (chat) target?", !settings.chat.target);
+  const setWorkerDefault = defaults.setWorkerDefault ? true : await askYesNo(rl, "use as fleet default?", !settings.fleet.default.target);
+  const setBackground = !isOrchestratorEligibleRuntime(runtime) ? false : defaults.setBackground ? true : await askYesNo(rl, "use as background memory target?", false);
+  const orchestratorModel = setOrchestrator ? defaults.orchestratorModel ?? await askModelChoice(
+    rl,
+    "Orchestrator model",
+    wireModels,
+    settings.chat.target === targetId ? settings.chat.model ?? model : model
+  ) : void 0;
+  if (orchestratorModel === null) return 0;
+  const workerModel = setWorkerDefault ? defaults.workerModel ?? await askModelChoice(
+    rl,
+    "Fleet model",
+    wireModels,
+    settings.fleet.default.target === targetId ? settings.fleet.default.model ?? model : model
+  ) : void 0;
+  if (workerModel === null) return 0;
+  const backgroundModel = setBackground ? defaults.backgroundModel ?? await askModelChoice(
+    rl,
+    "Background memory model",
+    wireModels,
+    settings.context.memory.target === targetId ? settings.context.memory.model ?? model : model
+  ) : void 0;
+  if (backgroundModel === null) return 0;
+  const applyWizardChoice = (target) => {
+    applyTarget(target, descriptor);
+    if (setOrchestrator) setOrchestratorPointer(target, descriptor, orchestratorModel);
+    if (setBackground) setBackgroundPointer(target, descriptor, backgroundModel);
+    if (setWorkerDefault) setWorkerDefaultPointer(target, descriptor, workerModel);
+  };
+  applyWizardChoice(settings);
+  updateSettings(applyWizardChoice);
+  printSummary(settings, descriptor, probe);
+  printOk(`target ${targetId} saved`);
+  await runInteropReview({ rl });
+  return 0;
+}
+function runTargetRemove(id) {
+  if (!readSettings().targets.some((e) => e.id === id)) {
+    printError(`no target with id ${id}`);
+    return 1;
+  }
+  updateSettings((settings) => {
+    removeTargetFromSettings(settings, id);
+  });
+  printOk(`removed target ${id}`);
+  return 0;
+}
+function runTargetRename(oldId, newId) {
+  if (oldId === newId) {
+    printError("old and new id are identical");
+    return 2;
+  }
+  const current = readSettings();
+  if (current.targets.some((e) => e.id === newId)) {
+    printError(`target id already exists: ${newId}`);
+    return 2;
+  }
+  if (!current.targets.some((e) => e.id === oldId)) {
+    printError(`no target with id ${oldId}`);
+    return 1;
+  }
+  updateSettings((settings) => {
+    const target = settings.targets.find((e) => e.id === oldId);
+    if (!target) return;
+    target.id = newId;
+    if (settings.chat.target === oldId) settings.chat.target = newId;
+    if (settings.context.memory.target === oldId) settings.context.memory.target = newId;
+    if (settings.fleet.default.target === oldId) settings.fleet.default.target = newId;
+    for (const profile of Object.values(settings.fleet.profiles)) {
+      if (profile.target === oldId) profile.target = newId;
+    }
+    settings.chat.modelPicker.cycleSet = settings.chat.modelPicker.cycleSet.map((entry) => {
+      const [head, ...rest] = entry.split("/");
+      if (head !== oldId) return entry;
+      return rest.length === 0 ? newId : `${newId}/${rest.join("/")}`;
+    });
+  });
+  printOk(`renamed ${oldId} to ${newId}`);
+  return 0;
+}
+var NONE = "(none)";
+var onOff = (value) => value ? "enabled" : "disabled";
+var listOr = (values, fallback = NONE) => values.length > 0 ? values.join(", ") : fallback;
+async function askInteger(io, label, current, apply, min = 0) {
+  const answer = await ask(io.rl, label, String(current));
+  if (answer === null) return;
+  const parsed = Number(answer);
+  if (!Number.isFinite(parsed) || parsed < min) {
+    io.out.write(`  ${label} must be a number of at least ${min}; left at ${current}
+`);
+    return;
+  }
+  const value = Math.floor(parsed);
+  apply(value);
+  io.ok(`${label} set to ${value}`);
+}
+async function askChoice(io, label, allowed, current, apply) {
+  const answer = await ask(io.rl, `${label} [${allowed.join("|")}]`, current);
+  if (answer === null) return;
+  const value = answer.trim().toLowerCase();
+  if (!allowed.includes(value)) {
+    io.out.write(`  ${label} must be one of ${allowed.join(", ")}; left at ${current}
+`);
+    return;
+  }
+  apply(value);
+  io.ok(`${label} set to ${value}`);
+}
+var SECTIONS = [
+  {
+    id: "targets",
+    title: "Targets & Auth",
+    summary: "providers, endpoints, credentials, models",
+    aliases: ["auth", "target", "providers"],
+    fields: () => {
+      const settings = readSettings();
+      const rows = [
+        ["Chat target", `${settings.chat.target ?? NONE} (model: ${settings.chat.model ?? "target default"})`],
+        [
+          "Fleet target",
+          `${settings.fleet.default.target ?? NONE} (model: ${settings.fleet.default.model ?? "target default"})`
+        ]
+      ];
+      if (settings.targets.length === 0) rows.push(["Registered", "(no targets registered)"]);
+      else
+        for (const target of settings.targets) {
+          rows.push([
+            `  ${target.id}`,
+            `${target.runtime}, model ${target.defaultModel ?? "unset"}${settings.chat.target === target.id ? " [chat]" : ""}${settings.fleet.default.target === target.id ? " [fleet]" : ""}`
+          ]);
+        }
+      return rows;
+    },
+    actions: [
+      {
+        label: "Add a target",
+        hint: "register a provider endpoint",
+        run: async (io) => {
+          const runtime = await pickRuntimeViaCategory(io.rl);
+          if (runtime) await runTargetSetupInteractive(io.rl, runtime, emptyArgs());
+        }
+      },
+      {
+        label: "Set the chat target",
+        hint: "which target answers in chat",
+        run: async (io) => {
+          await assignTarget(io, "chat");
+        }
+      },
+      {
+        label: "Set the fleet default target",
+        hint: "which target dispatched workers use",
+        run: async (io) => {
+          await assignTarget(io, "fleet");
+        }
+      },
+      {
+        label: "Remove a target",
+        run: async (io) => {
+          const settings = readSettings();
+          const ids = settings.targets.map((target) => target.id);
+          if (ids.length === 0) {
+            io.out.write("  No targets to remove.\n");
+            return;
+          }
+          io.out.write(`  Registered: ${ids.join(", ")}
+`);
+          const chosen = await ask(io.rl, "Target id to remove");
+          if (chosen === null || !ids.includes(chosen)) return;
+          if (await askYesNo(io.rl, `Remove target '${chosen}'?`, false)) {
+            runTargetRemove(chosen);
+          }
+        }
+      }
+    ]
+  },
+  {
+    id: "models",
+    title: "Models & Thinking",
+    summary: "default model, thinking level, favorites",
+    aliases: ["model", "thinking"],
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Chat model", settings.chat.model ?? "(target default)"],
+        ["Chat thinking", settings.chat.thinkingLevel],
+        ["Fleet thinking", settings.fleet.default.thinkingLevel],
+        ["Favorites", listOr(settings.chat.modelPicker.favorites)],
+        ["Cycle set (Alt+J/K)", listOr(settings.chat.modelPicker.cycleSet)]
+      ];
+    },
+    actions: [
+      {
+        label: "Chat thinking level",
+        hint: THINKING_LEVELS.join(" | "),
+        run: async (io) => {
+          await askChoice(io, "Chat thinking level", THINKING_LEVELS, readSettings().chat.thinkingLevel, (value) => {
+            updateSettings((draft) => {
+              draft.chat.thinkingLevel = value;
+            });
+          });
+        }
+      },
+      {
+        label: "Fleet thinking level",
+        hint: THINKING_LEVELS.join(" | "),
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Fleet thinking level",
+            THINKING_LEVELS,
+            readSettings().fleet.default.thinkingLevel,
+            (value) => {
+              updateSettings((draft) => {
+                draft.fleet.default.thinkingLevel = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Chat default model",
+        hint: "blank clears the override",
+        run: async (io) => {
+          const model = await ask(
+            io.rl,
+            "Chat default model (blank for the target default)",
+            readSettings().chat.model ?? ""
+          );
+          if (model === null) return;
+          updateSettings((draft) => {
+            draft.chat.model = model.length > 0 ? model : null;
+          });
+          io.ok(model.length > 0 ? `Chat default model set to ${model}` : "Chat default model cleared");
+        }
+      },
+      {
+        label: "Model favorites",
+        hint: "comma-separated",
+        run: async (io) => {
+          await askList(io, "Model favorites", readSettings().chat.modelPicker.favorites, (values) => {
+            updateSettings((draft) => {
+              draft.chat.modelPicker.favorites = values;
+            });
+          });
+        }
+      },
+      {
+        label: "Cycle set",
+        hint: "comma-separated, Alt+J/K walks it",
+        run: async (io) => {
+          await askList(io, "Cycle set", readSettings().chat.modelPicker.cycleSet, (values) => {
+            updateSettings((draft) => {
+              draft.chat.modelPicker.cycleSet = values;
+            });
+          });
+        }
+      }
+    ]
+  },
+  {
+    id: "chat",
+    title: "Chat Defaults",
+    summary: "streaming, progress, compaction",
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Smooth streaming", settings.interface.smoothStreaming],
+        ["Terminal progress", onOff(settings.interface.terminalProgress)],
+        [
+          "Max output tokens",
+          settings.chat.maxOutputTokens > 0 ? String(settings.chat.maxOutputTokens) : "(runtime default)"
+        ],
+        ["Prompt prewarm", onOff(settings.chat.prewarm)],
+        [
+          "Auto-compaction",
+          settings.context.compaction.auto ? `enabled at ${Math.round(settings.context.compaction.threshold * 100)}%` : "disabled"
+        ],
+        [
+          "Working-set eviction",
+          settings.context.workingSet.enabled ? `enabled (${settings.context.workingSet.policy})` : "disabled"
+        ]
+      ];
+    },
+    actions: [
+      {
+        label: "Smooth streaming",
+        hint: "off | auto | on",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Smooth streaming",
+            ["off", "auto", "on"],
+            readSettings().interface.smoothStreaming,
+            (value) => {
+              updateSettings((draft) => {
+                draft.interface.smoothStreaming = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Terminal progress indicator",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.interface.terminalProgress = !draft.interface.terminalProgress;
+            next = draft.interface.terminalProgress;
+          });
+          io.ok(`Terminal progress ${onOff(next)}`);
+        }
+      },
+      {
+        label: "Max output tokens",
+        hint: "0 for the runtime default",
+        run: async (io) => {
+          await askInteger(io, "Max output tokens", readSettings().chat.maxOutputTokens, (value) => {
+            updateSettings((draft) => {
+              draft.chat.maxOutputTokens = value;
+            });
+          });
+        }
+      },
+      {
+        label: "Prompt prewarm",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.chat.prewarm = !draft.chat.prewarm;
+            next = draft.chat.prewarm;
+          });
+          io.ok(`Prompt prewarm ${onOff(next)}`);
+        }
+      },
+      {
+        label: "Auto-compaction",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.context.compaction.auto = !draft.context.compaction.auto;
+            next = draft.context.compaction.auto;
+          });
+          io.ok(`Auto-compaction ${onOff(next)}`);
+        }
+      }
+    ]
+  },
+  {
+    id: "fleet",
+    title: "Fleet",
+    summary: "concurrency, retries, worker timeouts",
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Concurrency limit", String(settings.fleet.concurrency)],
+        ["Max retries", String(settings.fleet.retry.maxRetries)],
+        ["Tool calls per run", String(settings.fleet.limits.toolCallsPerRun)],
+        ["Run timeout", `${settings.fleet.limits.internalRunTimeoutMs / 1e3}s`],
+        ["Worker profiles", listOr(Object.keys(settings.fleet.profiles))],
+        [
+          "Subagent pins",
+          listOr(Object.entries(settings.fleet.agentProfiles).map(([agent, profile]) => `${agent} -> ${profile}`))
+        ],
+        ["Remote nodes", listOr(settings.fleet.nodes.map((node) => node.id))]
+      ];
+    },
+    actions: [
+      {
+        label: "Concurrency limit",
+        hint: "auto, or a positive integer",
+        run: async (io) => {
+          const current = String(readSettings().fleet.concurrency);
+          const answer = await ask(io.rl, "Concurrency limit [auto or a number]", current);
+          if (answer === null) return;
+          if (answer.trim().toLowerCase() === "auto") {
+            updateSettings((draft) => {
+              draft.fleet.concurrency = "auto";
+            });
+            io.ok("Concurrency limit set to auto");
+            return;
+          }
+          const parsed = Number(answer);
+          if (!Number.isFinite(parsed) || parsed < 1) {
+            io.out.write(`  Concurrency limit must be auto or at least 1; left at ${current}
+`);
+            return;
+          }
+          updateSettings((draft) => {
+            draft.fleet.concurrency = Math.floor(parsed);
+          });
+          io.ok(`Concurrency limit set to ${Math.floor(parsed)}`);
+        }
+      },
+      {
+        label: "Max retries",
+        run: async (io) => {
+          await askInteger(io, "Max retries", readSettings().fleet.retry.maxRetries, (value) => {
+            updateSettings((draft) => {
+              draft.fleet.retry.maxRetries = value;
+            });
+          });
+        }
+      },
+      {
+        label: "Tool calls per run",
+        run: async (io) => {
+          await askInteger(
+            io,
+            "Tool calls per run",
+            readSettings().fleet.limits.toolCallsPerRun,
+            (value) => {
+              updateSettings((draft) => {
+                draft.fleet.limits.toolCallsPerRun = value;
+              });
+            },
+            1
+          );
+        }
+      },
+      {
+        label: "Run timeout",
+        hint: "seconds",
+        run: async (io) => {
+          const current = readSettings().fleet.limits.internalRunTimeoutMs / 1e3;
+          const answer = await ask(io.rl, "Run timeout in seconds", String(current));
+          if (answer === null) return;
+          const parsed = Number(answer);
+          if (!Number.isFinite(parsed) || parsed < 1) {
+            io.out.write(`  Run timeout must be at least 1 second; left at ${current}s
+`);
+            return;
+          }
+          updateSettings((draft) => {
+            draft.fleet.limits.internalRunTimeoutMs = Math.floor(parsed * 1e3);
+          });
+          io.ok(`Run timeout set to ${Math.floor(parsed)}s`);
+        }
+      }
+    ]
+  },
+  {
+    id: "permissions",
+    title: "Permissions & Autonomy",
+    summary: "autonomy level, worker permissions, cost limits",
+    aliases: ["autonomy", "safety"],
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Autonomy level", settings.safety.autonomy],
+        ["Worker permissions", settings.fleet.permissions.mode],
+        ["Session cost limit", `$${settings.safety.limits.sessionCostUsd} USD`],
+        ["Turn tool budget", String(settings.safety.limits.chatToolCallsPerTurn)],
+        ["Review watchdog", onOff(settings.safety.review.enabled)]
+      ];
+    },
+    actions: [
+      {
+        label: "Autonomy level",
+        hint: "interactive | assisted | auto-edit | full",
+        run: async (io) => {
+          io.out.write(
+            "  interactive prompts for everything, assisted auto-reads and confirms writes,\n  auto-edit confirms only bash, full runs unattended.\n"
+          );
+          await askChoice(
+            io,
+            "Autonomy level",
+            ["interactive", "assisted", "auto-edit", "full"],
+            readSettings().safety.autonomy,
+            (value) => {
+              updateSettings((draft) => {
+                draft.safety.autonomy = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Worker permission mode",
+        hint: "deny | fail | escalate",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Worker permission mode",
+            ["deny", "fail", "escalate"],
+            readSettings().fleet.permissions.mode,
+            (value) => {
+              updateSettings((draft) => {
+                draft.fleet.permissions.mode = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Session cost limit",
+        hint: "USD",
+        run: async (io) => {
+          const current = readSettings().safety.limits.sessionCostUsd;
+          const answer = await ask(io.rl, "Session cost limit in USD", String(current));
+          if (answer === null) return;
+          const parsed = Number(answer);
+          if (!Number.isFinite(parsed) || parsed <= 0) {
+            io.out.write(`  Session cost limit must be greater than 0; left at $${current}
+`);
+            return;
+          }
+          updateSettings((draft) => {
+            draft.safety.limits.sessionCostUsd = parsed;
+          });
+          io.ok(`Session cost limit set to $${parsed} USD`);
+        }
+      },
+      {
+        label: "Turn tool budget",
+        run: async (io) => {
+          await askInteger(
+            io,
+            "Turn tool budget",
+            readSettings().safety.limits.chatToolCallsPerTurn,
+            (value) => {
+              updateSettings((draft) => {
+                draft.safety.limits.chatToolCallsPerTurn = value;
+              });
+            },
+            1
+          );
+        }
+      },
+      {
+        label: "Turn-end review watchdog",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.safety.review.enabled = !draft.safety.review.enabled;
+            next = draft.safety.review.enabled;
+          });
+          io.ok(`Review watchdog ${onOff(next)}`);
+        }
+      }
+    ]
+  },
+  {
+    id: "panes",
+    title: "Panes & Layout",
+    summary: "terminal panes, startup layout, display mode",
+    aliases: ["layout", "interface", "pane"],
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Panes capability", settings.interface.panes.enabled],
+        ["Startup layout", settings.interface.panes.layout],
+        ["TUI mode", settings.interface.mode],
+        ["Output detail", settings.interface.outputDetail],
+        ["Desktop notifications", onOff(settings.interface.desktopNotifications)],
+        ["Git commit attribution", onOff(settings.integrations.git.commitAttribution)]
+      ];
+    },
+    actions: [
+      {
+        label: "Panes capability",
+        hint: "off | auto | embedded",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Panes capability",
+            ["off", "auto", "embedded"],
+            readSettings().interface.panes.enabled,
+            (value) => {
+              updateSettings((draft) => {
+                draft.interface.panes.enabled = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Startup layout",
+        hint: "off | workers | cockpit",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Startup layout",
+            ["off", "workers", "cockpit"],
+            readSettings().interface.panes.layout,
+            (value) => {
+              updateSettings((draft) => {
+                draft.interface.panes.layout = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "TUI mode",
+        hint: "regular | fullscreen",
+        run: async (io) => {
+          await askChoice(io, "TUI mode", ["regular", "fullscreen"], readSettings().interface.mode, (value) => {
+            updateSettings((draft) => {
+              draft.interface.mode = value;
+            });
+          });
+        }
+      },
+      {
+        label: "Output detail",
+        hint: "minimal | default | verbose",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Output detail",
+            ["minimal", "default", "verbose"],
+            readSettings().interface.outputDetail,
+            (value) => {
+              updateSettings((draft) => {
+                draft.interface.outputDetail = value;
+              });
+            }
+          );
+        }
+      },
+      {
+        label: "Desktop notifications",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.interface.desktopNotifications = !draft.interface.desktopNotifications;
+            next = draft.interface.desktopNotifications;
+          });
+          io.ok(`Desktop notifications ${onOff(next)}`);
+        }
+      },
+      {
+        label: "Git commit attribution",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.integrations.git.commitAttribution = !draft.integrations.git.commitAttribution;
+            next = draft.integrations.git.commitAttribution;
+          });
+          io.ok(`Git commit attribution ${onOff(next)}`);
+        }
+      }
+    ]
+  },
+  {
+    id: "skills",
+    title: "Skills & Extensions",
+    summary: "project imports, ACP peers, plugins",
+    aliases: ["extensions", "skill", "interop"],
+    fields: () => {
+      const settings = readSettings();
+      const rows = [
+        ["Trust project imports", settings.integrations.projectResources.trustProjectImports ? "trusted" : "untrusted"],
+        ["External ACP agents", String(settings.integrations.externalAgents.entries.length)]
+      ];
+      for (const agent of settings.integrations.externalAgents.entries) {
+        rows.push([`  ${agent.id}`, `${agent.command} (governance: ${agent.toolGovernance ?? "default"})`]);
+      }
+      rows.push(
+        ["Runtime plugins", listOr(settings.integrations.runtimePlugins)],
+        ["Library remote sync", onOff(settings.integrations.library.sync)]
+      );
+      return rows;
+    },
+    actions: [
+      {
+        label: "Trust project imports",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.integrations.projectResources.trustProjectImports = !draft.integrations.projectResources.trustProjectImports;
+            next = draft.integrations.projectResources.trustProjectImports;
+          });
+          io.ok(`Project imports ${next ? "trusted" : "untrusted"}`);
+        }
+      },
+      {
+        label: "Review external ACP agents",
+        hint: "runs the interop review",
+        run: async (io) => {
+          await runInteropReview({ rl: io.rl, streams: io.streams });
+        }
+      },
+      {
+        label: "Library remote sync",
+        hint: "toggle",
+        run: async (io) => {
+          let next = false;
+          updateSettings((draft) => {
+            draft.integrations.library.sync = !draft.integrations.library.sync;
+            next = draft.integrations.library.sync;
+          });
+          io.ok(`Library remote sync ${onOff(next)}`);
+        }
+      }
+    ]
+  },
+  {
+    id: "diagnostics",
+    title: "Diagnostics",
+    summary: "version, directories, doctor, raw settings",
+    aliases: ["doctor", "diag"],
+    fields: () => {
+      const dirs = resolveClioDirs();
+      const info = getVersionInfo();
+      return [
+        ["Clio Coder", info.clio],
+        ["Node.js", info.node],
+        ["Platform", info.platform],
+        ["Config dir", shortenPath(dirs.config)],
+        ["Data dir", shortenPath(dirs.data)],
+        ["State dir", shortenPath(dirs.state)],
+        ["Cache dir", shortenPath(dirs.cache)]
+      ];
+    },
+    actions: [
+      {
+        label: "Run doctor",
+        hint: "read-only health check",
+        run: async () => {
+          const { runDoctorCommand } = await import("./doctor-WNNVO6FY.js");
+          await runDoctorCommand([]);
+        }
+      },
+      {
+        label: "Show raw settings.yaml",
+        run: async (io) => {
+          const file = settingsPath();
+          if (!existsSync(file)) {
+            io.out.write("  settings.yaml does not exist yet.\n");
+            return;
+          }
+          io.out.write(`
+--- ${shortenPath(file)} ---
+${readFileSync(file, "utf8")}--- end ---
+`);
+        }
+      }
+    ]
+  }
+];
+function emptyArgs() {
+  return {
+    positional: [],
+    help: false,
+    list: false,
+    all: false,
+    interop: false,
+    json: false,
+    force: false,
+    gateway: false,
+    setOrchestrator: false,
+    setBackground: false,
+    setWorkerDefault: false
+  };
+}
+async function askList(io, label, current, apply) {
+  const answer = await ask(io.rl, `${label} (comma-separated, blank clears)`, current.join(", "));
+  if (answer === null) return;
+  const values = answer.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  apply(values);
+  io.ok(values.length === 0 ? `${label} cleared` : `${label} set to ${values.join(", ")}`);
+}
+async function assignTarget(io, role) {
+  const settings = readSettings();
+  const ids = settings.targets.map((target2) => target2.id);
+  if (ids.length === 0) {
+    io.out.write("  No targets registered yet. Add one first.\n");
+    return;
+  }
+  io.out.write(`  Registered: ${ids.join(", ")}
+`);
+  const currentTarget = role === "chat" ? settings.chat.target : settings.fleet.default.target;
+  const chosen = await ask(io.rl, `${role === "chat" ? "Chat" : "Fleet"} target id`, currentTarget ?? ids[0] ?? "");
+  if (chosen === null) return;
+  if (!ids.includes(chosen)) {
+    io.out.write(`  ${chosen} is not a registered target; nothing changed.
+`);
+    return;
+  }
+  const target = settings.targets.find((entry) => entry.id === chosen);
+  const model = await ask(io.rl, "Model (blank for the target default)", target?.defaultModel ?? "");
+  if (model === null) return;
+  updateSettings((draft) => {
+    if (role === "chat") {
+      draft.chat.target = chosen;
+      draft.chat.model = model.length > 0 ? model : null;
+    } else {
+      draft.fleet.default.target = chosen;
+      draft.fleet.default.model = model.length > 0 ? model : null;
+    }
+  });
+  io.ok(`${role === "chat" ? "Chat" : "Fleet"} target set to ${chosen}`);
+}
+async function pickEntry(rl, io, entries, backLabel, plain) {
+  const out = io.out;
+  if (canSelect(io.in, out)) {
+    const result = await promptSelect({
+      choices: entries.map((entry, index2) => ({
+        value: index2,
+        label: entry.label,
+        ...entry.hint === void 0 ? {} : { hint: entry.hint }
+      })),
+      railPrefix: railPrefix(plain),
+      backLabel,
+      input: io.in,
+      output: out
+    });
+    if (result.kind === "selected") return { kind: "index", index: result.value };
+    return result.kind === "quit" ? { kind: "quit" } : { kind: "back" };
+  }
+  const rail = railPrefix(plain);
+  entries.forEach((entry, index2) => {
+    out.write(`${rail}${index2 + 1}. ${entry.label}${entry.hint === void 0 ? "" : `  (${entry.hint})`}
+`);
+  });
+  out.write(`${rail}b. ${backLabel}
+${rail}q. Quit
+`);
+  const answer = await ask(rl, "\nSelection", "b");
+  if (answer === null) return { kind: "quit" };
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "b" || trimmed === "back" || trimmed.length === 0) return { kind: "back" };
+  if (trimmed === "q" || trimmed === "quit") return { kind: "quit" };
+  const index = Number.parseInt(trimmed, 10) - 1;
+  if (Number.isInteger(index) && index >= 0 && index < entries.length) return { kind: "index", index };
+  out.write(`${rail}Not one of the choices: ${answer}
+`);
+  return { kind: "back" };
+}
+function renderSection(spec, out) {
+  const presenter = createLifecyclePresenter({ stream: out });
+  presenter.header(spec.title, "configure");
+  presenter.note(`Source: ${shortenPath(settingsPath())}`);
+  presenter.fields(spec.fields());
+  return presenter;
+}
+async function runSection(rl, streams, spec, backLabel) {
+  for (; ; ) {
+    const presenter = renderSection(spec, streams.out);
+    const io = {
+      rl,
+      out: streams.out,
+      streams,
+      ok: (text) => {
+        presenter.completedStep(text);
+      }
+    };
+    presenter.blank();
+    const choice = await pickEntry(rl, streams, spec.actions, backLabel, presenter.isPlain());
+    if (choice.kind !== "index") return choice.kind;
+    const action = spec.actions[choice.index];
+    if (action !== void 0) await action.run(io);
+  }
+}
+async function runConfigSectionsMenu(rl, streams) {
+  for (; ; ) {
+    const presenter = createLifecyclePresenter({ stream: streams.out });
+    presenter.header("Clio Coder Configuration", "configure");
+    presenter.note(`Source: ${shortenPath(settingsPath())}`);
+    presenter.blank();
+    const choice = await pickEntry(
+      rl,
+      streams,
+      SECTIONS.map((section) => ({ label: section.title, hint: section.summary })),
+      "quit",
+      presenter.isPlain()
+    );
+    if (choice.kind !== "index") return 0;
+    const spec = SECTIONS[choice.index];
+    if (spec === void 0) continue;
+    if (await runSection(rl, streams, spec, "back") === "quit") return 0;
+  }
+}
+function findSection(name) {
+  const wanted = name.trim().toLowerCase();
+  return SECTIONS.find((section) => section.id === wanted || (section.aliases ?? []).includes(wanted));
+}
+var SECTION_IDS = SECTIONS.map((section) => section.id);
+async function runInteractive(rl, preselectedRuntime, defaults, streams) {
+  if (preselectedRuntime) {
+    return await runTargetSetupInteractive(rl, preselectedRuntime, defaults);
+  }
+  if (defaults.section !== void 0) {
+    const spec = findSection(defaults.section);
+    if (spec === void 0) {
+      printError(`unknown section: ${defaults.section}. Sections: ${SECTION_IDS.join(", ")}`);
+      return 2;
+    }
+    if (streams.in.isTTY !== true) {
+      renderSection(spec, streams.out).done("Done");
+      return 0;
+    }
+    await runSection(rl, streams, spec, "quit");
+    return 0;
+  }
+  if (readSettings().targets.length === 0) {
+    if (canRunOnboarding(streams)) {
+      rl.close();
+      return await runOnboardingWizard(streams);
+    }
+    const runtime = await pickRuntimeViaCategory(rl);
+    if (!runtime) {
+      printError("configuration cancelled");
+      return 130;
+    }
+    return await runTargetSetupInteractive(rl, runtime, defaults);
+  }
+  return await runConfigSectionsMenu(rl, streams);
+}
+async function runConfigureCommand(argv, inStream = input, outStream = output2) {
+  let args;
+  try {
+    args = parseSetupArgs(argv);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  initializeClioHome();
+  ensureRegistryPopulated();
+  if (args.json) {
+    const settings = readSettings();
+    outStream.write(`${JSON.stringify(settings, null, 2)}
+`);
+    return 0;
+  }
+  if (args.list) {
+    printRuntimeList(args.all);
+    return 0;
+  }
+  if (args.interop) {
+    if (!input.isTTY) return runInteropReview({ rl: null });
+    const rl2 = createInterface2({ input, output: output2 });
+    try {
+      return await runInteropReview({ rl: rl2, streams: { in: input, out: output2 } });
+    } finally {
+      rl2.close();
+    }
+  }
+  if (args.remove) return runTargetRemove(args.remove);
+  if (args.renameOld && args.renameNew) return runTargetRename(args.renameOld, args.renameNew);
+  if (args.positional.length > 0) {
+    printError(
+      "`clio-coder configure` accepts flags, not positional runtimes. Use `clio-coder auth login <runtime>` first when authentication is needed, then `clio-coder configure --runtime <runtimeId> ...`."
+    );
+    return 2;
+  }
+  const runtimeId = args.runtime;
+  let runtime = null;
+  if (runtimeId) {
+    runtime = getRuntimeRegistry().get(runtimeId);
+    if (!runtime) {
+      printError(`unknown runtime id: ${runtimeId}`);
+      process.stdout.write("run `clio-coder configure --list` to see registered runtimes\n");
+      return 2;
+    }
+    if (runtimeId === "lmstudio-native" && runtime.id === "lmstudio") {
+      process.stderr.write("warning: runtime 'lmstudio-native' is deprecated; using 'lmstudio'\n");
+    }
+  }
+  const hasTargetSetupFlag = args.id !== void 0 || args.url !== void 0 || args.model !== void 0 || args.workerProfile !== void 0 || args.workerProfileModel !== void 0 || args.apiKey !== void 0 || args.apiKeyEnv !== void 0 || args.gateway || args.lifecycle !== void 0 || args.setOrchestrator || args.setWorkerDefault || args.contextWindow !== void 0 || args.maxTokens !== void 0 || args.reasoning !== void 0;
+  const nonInteractive = runtime !== null && hasTargetSetupFlag;
+  if (nonInteractive && runtime) return runNonInteractive(runtime, args);
+  if ((runtimeId !== void 0 || hasTargetSetupFlag) && !input.isTTY) {
+    printError(
+      runtime === null ? "--runtime is required when configuring a target non-interactively" : "--id is required when passing flags non-interactively"
+    );
+    return 2;
+  }
+  const rl = createInterface2({ input: inStream, output: outStream });
+  try {
+    return await runInteractive(rl, runtime, args, { in: inStream, out: outStream });
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  } finally {
+    rl.close();
+  }
+}
+
+export {
+  runTargetRemove,
+  runTargetRename,
+  runConfigureCommand
+};
+//# sourceMappingURL=chunk-7E7I3WLS.js.map