@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-EX57VVWW.js

@@ -0,0 +1,4157 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  canSelect,
+  promptMultiSelect,
+  promptSelect,
+  promptText
+} from "./chunk-HSQQFDB3.js";
+import {
+  createDelayedManualCodeInput,
+  promptOAuthSelection
+} from "./chunk-LK2FN5JY.js";
+import {
+  createLifecyclePresenter,
+  shortenPath
+} from "./chunk-N24R6KWS.js";
+import {
+  column,
+  terminalColumns,
+  truncate,
+  twoColumnRow,
+  wrapPlain
+} from "./chunk-ZIDFQJRB.js";
+import {
+  editTextExternally,
+  resolveExternalEditor
+} from "./chunk-R2CT5YDO.js";
+import {
+  fingerprintNativeRuntime
+} from "./chunk-KW5HXKLJ.js";
+import {
+  initializeClioHome
+} from "./chunk-URCXX7WJ.js";
+import {
+  INHERITED_PROJECT_CONTEXT,
+  acceptInteropAgents,
+  declineInteropAgents,
+  interopProposals,
+  renderProposalEntry
+} from "./chunk-T2MDZES3.js";
+import {
+  detectInteropAgents,
+  resolveOnPath
+} from "./chunk-4A6YRGV4.js";
+import {
+  credentialWriteFailed,
+  printPlaintextCredentialWarning
+} from "./chunk-GGPF6LLE.js";
+import {
+  SETTING_CONTROLS,
+  applyControlValue,
+  controlInstructions,
+  formatControlValue
+} from "./chunk-VOYUCAQF.js";
+import {
+  getAtPath
+} from "./chunk-GGWI3OVM.js";
+import {
+  SETTINGS_SECTIONS,
+  resolveSettingsSection,
+  settingsGroupForPath,
+  settingsSectionForPath
+} from "./chunk-LJRBX7QR.js";
+import {
+  diffSettings
+} from "./chunk-GN7QBEEI.js";
+import {
+  describeLocalCapacity,
+  observeHostCapacityFacts,
+  resolveLocalConcurrency
+} from "./chunk-E6IPKW2E.js";
+import {
+  printError,
+  printOk
+} from "./chunk-NBXFPI7U.js";
+import {
+  source_default
+} from "./chunk-SQZHXUB3.js";
+import {
+  loadedContextWindowForModel,
+  probeCapabilitiesForModel,
+  readTargetModelSnapshot,
+  recordTargetModelSnapshot
+} from "./chunk-EYTLV3W3.js";
+import {
+  credentialsPresent
+} from "./chunk-DVTBERFY.js";
+import {
+  isOrchestratorEligibleRuntime
+} from "./chunk-6EJYVCTN.js";
+import {
+  greetLmStudio,
+  probeJson,
+  registerBuiltinRuntimes,
+  targetRootUrl
+} from "./chunk-77DCC6JZ.js";
+import {
+  buildProviderSupportEntry,
+  configuredTargetsForRuntime,
+  describeRuntimeModels,
+  listKnownModelsForRuntime,
+  listProviderSupportEntries,
+  supportGroupLabel
+} from "./chunk-SYF7FVBL.js";
+import {
+  authStoragePath,
+  openAuthStorage,
+  registerClioOAuthProviders,
+  resolveAuthTarget,
+  resolveRuntimeAuthTarget,
+  targetRequiresAuth
+} from "./chunk-Z4GLJ6J4.js";
+import {
+  closestRuntimeId,
+  getRuntimeRegistry
+} from "./chunk-2WVPJF3Z.js";
+import {
+  getCatalogModelForRuntime
+} from "./chunk-27YTM2CV.js";
+import {
+  AUTONOMY_LEVELS
+} from "./chunk-UZVYEF57.js";
+import {
+  SettingsValidationError,
+  bindAgentProfileInSettings,
+  readSettings,
+  removeTargetFromSettings,
+  settingsPath,
+  updateSavedSettingsDocument,
+  updateSettings,
+  validateSettings,
+  withSettingsLock
+} from "./chunk-56XP4FJU.js";
+import {
+  DEFAULT_SETTINGS,
+  DEFAULT_SETTINGS_YAML,
+  THINKING_LEVELS
+} from "./chunk-QZTTRSJE.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  warnLegacyNaming
+} from "./chunk-O63U2I6I.js";
+import {
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  getVersionInfo
+} from "./chunk-2VLYHHFT.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/configure.ts
+init_esm_shims();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { stdin as input, stdout as output2 } from "node:process";
+
+// src/cli/ask.ts
+init_esm_shims();
+async function ask(rl, label, defaultValue) {
+  if (rl.text) return rl.text(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) {
+  if (rl.choose && rl.interactive) return await rl.choose(label, ["yes", "no"], defaultValue ? "yes" : "no") === "yes";
+  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-controls.ts
+init_esm_shims();
+
+// src/cli/configure-prompts.ts
+init_esm_shims();
+import { createInterface } from "node:readline/promises";
+
+// 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,
+  ollama: 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()}`;
+}
+function targetApiKeyRef(targetId, targets) {
+  const taken = new Set(targets.filter((target) => target.id !== targetId).map((target) => target.auth?.apiKeyRef));
+  const base = `target:${targetId}`;
+  let ref = base;
+  for (let suffix = 2; taken.has(ref); suffix += 1) ref = `${base}-${suffix}`;
+  return ref;
+}
+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;
+  }
+  if (descriptor.defaultModel && loadedContextWindowForModel({ discoveredModelStates: probe.modelStates ?? null }, descriptor.defaultModel) !== null) {
+    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;
+  if (parts.ollama) descriptor.ollama = parts.ollama;
+  return descriptor;
+}
+function describeAuthStatus(runtime, target) {
+  const status = openAuthStorage().statusForTarget(
+    target ? resolveAuthTarget(target, runtime) : 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", "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/configure-prompts.ts
+var ConfigureNavigation = class extends Error {
+  constructor(kind) {
+    super(kind);
+    this.kind = kind;
+  }
+  kind;
+};
+var ConfigurePrompts = class {
+  constructor(input2, output3) {
+    this.input = input2;
+    this.output = output3;
+  }
+  input;
+  output;
+  get interactive() {
+    return canSelect(this.input, this.output);
+  }
+  clearScreen() {
+    if (this.interactive) this.output.write("\x1B[H\x1B[2J");
+  }
+  async question(query, options) {
+    const rl = createInterface({ input: this.input, output: this.output });
+    try {
+      return await new Promise((resolve, reject) => {
+        rl.once("close", () => reject(new ConfigureNavigation("quit")));
+        rl.once("SIGINT", () => reject(new ConfigureNavigation("quit")));
+        rl.question(query, options ?? {}).then(resolve, reject);
+      });
+    } finally {
+      rl.close();
+    }
+  }
+  async text(label, initial = "", mask = false) {
+    if (!this.interactive) {
+      const value = (await this.question(`${label}${initial ? ` [${initial}]` : ""}: `)).trim();
+      if (/^(q|quit)$/iu.test(value)) throw new ConfigureNavigation("quit");
+      return value || initial;
+    }
+    const result = await promptText({
+      heading: ["", label],
+      railPrefix: railPrefix(createLifecyclePresenter({ stream: this.output }).isPlain()),
+      initial,
+      mask,
+      backLabel: "back",
+      clearOnExit: true,
+      input: this.input,
+      output: this.output
+    });
+    if (result.kind !== "value") throw new ConfigureNavigation(result.kind);
+    return result.value;
+  }
+  async choose(label, choices, current, searchable = false) {
+    if (!this.interactive) return this.text(`${label} [${choices.join("|")}]`, current);
+    const result = await promptSelect({
+      heading: ["", label],
+      railPrefix: railPrefix(createLifecyclePresenter({ stream: this.output }).isPlain()),
+      choices: choices.map((value) => ({ value, label: value })),
+      initialIndex: Math.max(0, choices.indexOf(current)),
+      ...searchable ? { searchable: true, maxVisible: 8 } : {},
+      backLabel: "back",
+      clearOnExit: true,
+      input: this.input,
+      output: this.output
+    });
+    if (result.kind !== "selected") throw new ConfigureNavigation(result.kind);
+    return result.value;
+  }
+};
+
+// src/cli/configure-controls.ts
+function editText(control, value) {
+  if (value === null || value === void 0) return "";
+  return control.kind === "list" ? value.join(", ") : control.kind === "json" ? JSON.stringify(value) : String(value);
+}
+function saveControl(path, input2) {
+  updateSavedSettingsDocument((saved) => {
+    const before = validateSettings(saved).settings;
+    const preview = structuredClone(before);
+    applyControlValue(preview, path, input2);
+    const diff = diffSettings(before, preview);
+    const paths = /* @__PURE__ */ new Set([path, ...diff.hotReload, ...diff.nextTurn, ...diff.restartRequired]);
+    for (const changed of paths) {
+      if (changed !== path && changed.startsWith(`${path}.`)) continue;
+      let cursor = saved;
+      const keys = changed.split(".");
+      for (const key of keys.slice(0, -1)) {
+        if (!cursor[key] || typeof cursor[key] !== "object") cursor[key] = {};
+        cursor = cursor[key];
+      }
+      const leaf = keys.at(-1);
+      const value = getAtPath(preview, changed);
+      if (value === void 0) delete cursor[leaf];
+      else cursor[leaf] = value;
+    }
+    const validation = validateSettings(saved);
+    if (validation.issues.length) throw new SettingsValidationError(validation.issues);
+    return saved;
+  });
+}
+async function runSectionControls(prompts, section) {
+  const controls = SETTING_CONTROLS.filter((control) => settingsSectionForPath(control.path) === section);
+  const groups = [...new Set(controls.map((control) => settingsGroupForPath(control.path)))];
+  const title = SETTINGS_SECTIONS.find((entry) => entry.id === section)?.label ?? section;
+  let group = groups[0] ?? "";
+  for (; ; ) {
+    try {
+      prompts.clearScreen();
+      const presenter = createLifecyclePresenter({ stream: prompts.output });
+      presenter.header(`${title} \xB7 All controls`, "configure");
+      presenter.note(
+        "Choose a group, then a setting. Each edit explains its effect and is validated before saving globally."
+      );
+      group = await prompts.choose("Settings group", [...groups, "Back"], group, true);
+      if (group === "Back") return;
+      if (!groups.includes(group)) {
+        presenter.warn("Choose a group from the list.");
+        continue;
+      }
+      for (; ; ) {
+        const members = controls.filter((control2) => settingsGroupForPath(control2.path) === group);
+        const labels = members.map((control2) => `${control2.label} \xB7 ${control2.path}`);
+        let chosen;
+        try {
+          chosen = await prompts.choose(group, [...labels, "Back"], labels[0] ?? "Back", true);
+        } catch (error) {
+          if (error instanceof ConfigureNavigation && error.kind === "back") break;
+          throw error;
+        }
+        if (chosen === "Back") break;
+        const control = members[labels.indexOf(chosen)];
+        if (!control) {
+          presenter.warn("Choose a setting from the list.");
+          continue;
+        }
+        try {
+          prompts.clearScreen();
+          presenter.header(control.label, "configure");
+          for (const line of controlInstructions(control).split("\n")) presenter.note(line);
+          const current = getAtPath(readSettings(), control.path);
+          presenter.fields([
+            ["Setting", control.path],
+            ["Current", formatControlValue(current)],
+            ["Shipped default", formatControlValue(getAtPath(DEFAULT_SETTINGS, control.path))],
+            ["Save scope", "Global default; current sessions follow their reload rules"]
+          ]);
+          if (control.readOnly) {
+            await prompts.text("Press Enter to return");
+            continue;
+          }
+          const values = control.choices ?? (control.kind === "boolean" ? ["true", "false"] : void 0);
+          const value = values ? await prompts.choose("New value", values, String(current)) : await prompts.text("New value", prompts.interactive ? editText(control, current) : "");
+          const proposed = readSettings();
+          applyControlValue(proposed, control.path, value);
+          if (await prompts.choose(`Save ${control.label} globally?`, ["Save", "Cancel"], "Save") === "Save") {
+            saveControl(control.path, value);
+            presenter.completedStep(`${control.label} saved`);
+          }
+        } catch (error) {
+          if (error instanceof ConfigureNavigation) {
+            if (error.kind === "quit") throw error;
+          } else presenter.warn(`Not saved: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof ConfigureNavigation && error.kind === "back") return;
+      throw error;
+    }
+  }
+}
+
+// src/cli/configure-editor.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+async function editSettings(prompts) {
+  const file = settingsPath();
+  const original = existsSync(file) ? readFileSync(file, "utf8") : null;
+  let draft = original ?? DEFAULT_SETTINGS_YAML;
+  const editor = resolveExternalEditor();
+  for (; ; ) {
+    const result = editTextExternally(draft, editor, ".yaml");
+    if (!result.ok || result.text === void 0) throw new Error(result.error ?? "Editor did not return a draft");
+    draft = `${result.text}
+`;
+    if (draft === original) {
+      prompts.output.write("Settings unchanged.\n");
+      return false;
+    }
+    try {
+      const validated = validateSettings((0, import_yaml.parse)(draft));
+      if (validated.issues.length) throw new SettingsValidationError(validated.issues);
+    } catch (error) {
+      prompts.output.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      if (await prompts.choose("Invalid draft", ["Return to editor", "Discard draft"], "Return to editor") === "Return to editor")
+        continue;
+      return false;
+    }
+    const choice = await prompts.choose(
+      "Save validated settings?",
+      ["Save", "Return to editor", "Discard draft"],
+      "Save"
+    );
+    if (choice === "Return to editor") continue;
+    if (choice !== "Save") return false;
+    withSettingsLock(() => {
+      const current = existsSync(file) ? readFileSync(file, "utf8") : null;
+      if (current !== original)
+        throw new Error("Settings changed while the editor was open. Reopen the editor to keep those changes.");
+      safeResourceWrite(file, draft, { encoding: "utf8", mode: 420, backup: original !== null });
+    });
+    prompts.output.write(`Settings saved to ${file}${original === null ? "" : `; previous file: ${file}.bak`}
+`);
+    return true;
+  }
+}
+
+// src/cli/configure-interop.ts
+init_esm_shims();
+import { stdout as output } from "node:process";
+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 as createInterface2 } 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" ? targetApiKeyRef(answers.targetId ?? runtime.id, readSettings().targets) : answers.credential === "keep" ? answers.existing?.auth?.apiKeyRef ?? runtime.id : void 0;
+  const configured = 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: answers.existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id } : {}
+  });
+  const descriptor = { ...answers.existing, ...configured };
+  if (!withModel) delete descriptor.defaultModel;
+  if (answers.existing?.auth || configured.auth) {
+    descriptor.auth = { ...answers.existing?.auth, ...configured.auth };
+    if (runtime.auth === "api-key") {
+      if (answers.credential !== "env") delete descriptor.auth.apiKeyEnvVar;
+      if (answers.credential !== "stored" && answers.credential !== "keep") delete descriptor.auth.apiKeyRef;
+    }
+    if (Object.keys(descriptor.auth).length === 0) delete descriptor.auth;
+  }
+  return descriptor;
+}
+var CATEGORY_STEP = {
+  id: "category",
+  applies: (answers) => answers.mode !== "edit" && !answers.fixedRuntime,
+  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: (answers) => answers.mode !== "edit" && !answers.fixedRuntime,
+  run: async (wizard, answers) => {
+    const registry = getRuntimeRegistry();
+    const chatEntries = allEntries().filter((entry) => {
+      const runtime2 = registry.get(entry.runtimeId);
+      return runtime2 !== null && (answers.mode !== "first" || 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.thinking = void 0;
+      answers.contextWindow = void 0;
+      answers.probe = 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: (answers) => answers.mode !== "edit",
+  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";
+        if (readSettings().targets.some((target) => target.id === value))
+          return "that target id already exists; choose another or use Edit a target";
+        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);
+    const authenticated = await reportReachability(wizard, answers, runtime, url);
+    if (!authenticated && runtime.auth === "api-key") {
+      answers.inventoryKey = void 0;
+      if (answers.credential === "skip") answers.credential = void 0;
+      return "credential";
+    }
+    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("Authentication failed. Choose a credential for this server before selecting a model.");
+      return false;
+    } 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 };
+    }
+  }
+  return true;
+}
+var DETECTED_RUNTIME_STEP = {
+  id: "detected-runtime",
+  applies: (answers) => answers.mode !== "edit" && 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";
+  if (runtime.id === "litellm") return "stored";
+  return targetRequiresAuth({ id: targetId, runtime: runtime.id }, runtime) ? "env" : "skip";
+}
+async function connectOAuth(wizard, runtime) {
+  const rl = createInterface2({ 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, answers.existing);
+    if (runtime.auth === "oauth") {
+      const result2 = await promptSelect({
+        heading: [
+          "",
+          source_default.bold(`Sign in to ${runtime.displayName}`),
+          source_default.dim(`credential: ${stored}`),
+          "Sign-in stores credentials immediately; target settings wait for Save."
+        ],
+        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 = answers.existing?.auth?.apiKeyRef !== void 0 || 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: "only for servers that accept unauthenticated requests"
+      }
+    ];
+    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;
+    answers.inventoryKey = 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 },
+      validate: (value) => value.length > 0 ? null : `Enter ${wantsEnv ? "an environment variable" : "a key"}, or press Escape to choose No key.`,
+      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.apiKeyLiteral);
+  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) => {
+    if (answers.mode !== "first" && !PROTOCOL_COMPAT_RUNTIME_IDS.has(answers.runtime?.id ?? "")) return false;
+    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(
+          answers.mode === "first" ? "changeable any time in `clio-coder configure`" : "off disables reasoning for this target; chat and fleet thinking defaults stay unchanged"
+        )
+      ],
+      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.mode === "first" && 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 CONTEXT_STEP = {
+  id: "context-window",
+  applies: (answers) => PROTOCOL_COMPAT_RUNTIME_IDS.has(answers.runtime?.id ?? "") || answers.mode === "edit",
+  run: async (wizard, answers) => {
+    const result = await promptText({
+      heading: ["", source_default.bold("Context window in tokens")],
+      initial: answers.contextWindow === void 0 ? "" : String(answers.contextWindow),
+      hint: "optional override; blank uses detected capabilities or the runtime default",
+      validate: (value) => value === "" || Number.isSafeInteger(Number(value)) && Number(value) > 0 ? null : "enter a positive whole number, or leave blank",
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind !== "value") return result.kind;
+    answers.contextWindow = result.value ? Number(result.value) : void 0;
+    wizard.answer("Context", result.value || "detected / runtime default");
+    return "next";
+  }
+};
+var REVIEW_STEP = {
+  id: "review",
+  applies: () => true,
+  run: async (wizard, answers) => {
+    const result = await promptSelect({
+      heading: [
+        "",
+        source_default.bold("Review target"),
+        `${answers.targetId} \xB7 ${answers.runtime?.id} \xB7 ${answers.model}`,
+        answers.mode === "first" ? "Use for chat and fleet." : "Existing chat, fleet, memory, and profile defaults stay in place.",
+        "Escape returns to the previous step; settings are saved only when you choose Save."
+      ],
+      choices: [
+        { value: "save", label: "Save target" },
+        { value: "back", label: "Back" },
+        { value: "cancel", label: "Cancel setup" }
+      ],
+      railPrefix: wizard.rail,
+      backLabel: "back",
+      clearOnExit: true,
+      input: wizard.input,
+      output: wizard.output
+    });
+    if (result.kind !== "selected") return result.kind;
+    return result.value === "save" ? "next" : result.value === "back" ? "back" : "cancel";
+  }
+};
+var STEPS = [
+  CATEGORY_STEP,
+  RUNTIME_STEP,
+  TARGET_ID_STEP,
+  CREDENTIAL_STEP,
+  CREDENTIAL_VALUE_STEP,
+  URL_STEP,
+  DETECTED_RUNTIME_STEP,
+  MODEL_STEP,
+  THINKING_STEP,
+  CONTEXT_STEP,
+  ANTIGRAVITY_COLLEAGUE_STEP,
+  REVIEW_STEP
+];
+function applyAnswers(settings, answers, descriptor, chatEligible) {
+  const current = settings.targets.find((target) => target.id === descriptor.id);
+  if (answers.mode === "edit") {
+    if (JSON.stringify(current) !== JSON.stringify(answers.existing))
+      throw new Error("This target changed during setup; reopen Edit to keep those changes.");
+  } else if (current) throw new Error(`Target '${descriptor.id}' already exists; use Edit a target.`);
+  applyTarget(settings, descriptor);
+  if (answers.mode === "first" && chatEligible) setOrchestratorPointer(settings, descriptor, answers.model ?? null);
+  if (answers.mode === "first") setWorkerDefaultPointer(settings, descriptor, answers.model ?? null);
+  if (answers.mode === "first" && 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, options = {
+  mode: "first"
+}) {
+  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(
+    options.mode === "edit" ? `Edit target: ${options.target.id}` : options.mode === "first" ? "Welcome to Clio Coder" : "Add a target",
+    "configure"
+  );
+  presenter.note("Pick a model; escape goes back. Review and save when ready.");
+  presenter.note(`Result: ${shortenPath(settingsPath())}`);
+  const existing = options.mode === "edit" ? options.target : void 0;
+  const answers = {
+    mode: options.mode,
+    existing,
+    runtime: existing ? getRuntimeRegistry().get(existing.runtime) ?? void 0 : options.mode !== "edit" ? options.runtime : void 0,
+    fixedRuntime: options.mode !== "edit" && options.runtime !== void 0,
+    targetId: existing?.id,
+    url: existing?.url,
+    model: existing?.defaultModel,
+    credential: existing?.auth?.apiKeyEnvVar ? "env" : existing?.auth?.apiKeyRef ? "keep" : void 0,
+    apiKeyEnv: existing?.auth?.apiKeyEnvVar,
+    contextWindow: existing?.capabilities?.contextWindow,
+    thinking: existing?.capabilities?.reasoning === false ? "off" : void 0
+  };
+  if (existing && !answers.runtime) {
+    presenter.fail(`Unknown runtime: ${existing.runtime}`);
+    return 2;
+  }
+  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, answers);
+      continue;
+    }
+    marks[cursor] = writer.mark();
+    const outcome = await step.run(wizard, answers);
+    if (outcome === "quit" || outcome === "cancel") return cancel(presenter, answers, outcome === "quit");
+    if (outcome === "credential") {
+      direction = 1;
+      cursor = STEPS.indexOf(CREDENTIAL_STEP);
+      continue;
+    }
+    if (outcome === "back") {
+      direction = -1;
+      cursor -= 1;
+      while (cursor >= 0 && !(STEPS[cursor]?.applies(answers) ?? false)) cursor -= 1;
+      if (cursor < 0) return cancel(presenter, answers);
+      writer.rewindTo(marks[cursor] ?? writer.mark());
+      continue;
+    }
+    direction = 1;
+    cursor += 1;
+  }
+  const code = finish(wizard, answers);
+  if (code === 0 && answers.mode === "first") {
+    await reviewInteropAgents({ rl: null, streams, presenter, rail, quiet: true });
+  }
+  return code;
+}
+function cancel(presenter, answers, quit = false) {
+  presenter.done("Cancelled; target settings not saved");
+  if (answers.mode === "first") printError("configuration cancelled");
+  return answers.mode === "first" || quit ? 130 : 0;
+}
+function finish(wizard, answers) {
+  const runtime = answers.runtime;
+  const targetId = answers.targetId;
+  if (!runtime || targetId === void 0) return cancel(wizard.presenter, answers);
+  const presenter = wizard.presenter;
+  const reasoning = PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id) && answers.thinking !== void 0 ? answers.thinking !== "off" : void 0;
+  const descriptor = draftDescriptor(answers, runtime, true);
+  descriptor.capabilities = { ...descriptor.capabilities };
+  if (reasoning !== void 0) descriptor.capabilities.reasoning = reasoning;
+  if (answers.contextWindow === void 0) delete descriptor.capabilities.contextWindow;
+  else descriptor.capabilities.contextWindow = answers.contextWindow;
+  const chatEligible = isOrchestratorEligibleRuntime(runtime);
+  try {
+    const preview = readSettings();
+    applyAnswers(preview, answers, descriptor, chatEligible);
+    const validated = validateSettings(preview);
+    if (validated.issues.length) throw new SettingsValidationError(validated.issues);
+    initializeClioHome();
+    if (answers.apiKeyLiteral !== void 0 && descriptor.auth?.apiKeyRef) {
+      const auth = openAuthStorage();
+      auth.setApiKey(descriptor.auth.apiKeyRef, answers.apiKeyLiteral);
+      if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${targetId}' not saved`)) {
+        presenter.done("Nothing written");
+        return 1;
+      }
+      printPlaintextCredentialWarning();
+    }
+    updateSettings((settings) => applyAnswers(settings, answers, descriptor, chatEligible));
+  } catch (error) {
+    presenter.fail("settings were not written", error instanceof Error ? error.message : String(error));
+    presenter.done("Target settings not saved");
+    return 1;
+  }
+  presenter.completedStep(`target ${targetId} saved, runtime ${runtime.id}`);
+  if (answers.mode === "first" && chatEligible)
+    presenter.completedStep(`chat runs on ${targetId}${answers.model ? `, model ${answers.model}` : ""}`);
+  else if (!chatEligible)
+    presenter.completedStep(`${runtime.id} cannot answer chat; ${targetId} is registered for dispatch only`);
+  if (answers.mode === "first") presenter.completedStep(`fleet default is ${targetId}`);
+  else presenter.note("Use Settings \u2192 Chat, Fleet, or Context & Memory to change model defaults.");
+  if (answers.mode === "first" && answers.thinking !== void 0)
+    presenter.completedStep(`thinking level ${answers.thinking}`);
+  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-quick.ts
+init_esm_shims();
+function endpointUrl(value) {
+  const url = new URL(value.includes("://") ? value : `http://${value}`);
+  if (!["http:", "https:"].includes(url.protocol) || !url.hostname)
+    throw new Error("Use an http:// or https:// endpoint URL.");
+  if (url.username || url.password)
+    throw new Error("Enter the endpoint without credentials; Clio asks for a key when needed.");
+  return url.toString().replace(/\/$/u, "");
+}
+async function connect(url, key) {
+  const settings = readSettings();
+  const registry = getRuntimeRegistry();
+  const matches = settings.targets.filter((target2) => {
+    const runtime2 = registry.get(target2.runtime);
+    if (!target2.url || !runtime2 || !isOrchestratorEligibleRuntime(runtime2)) return false;
+    try {
+      return endpointUrl(target2.url) === url;
+    } catch {
+      return false;
+    }
+  });
+  const existing = matches.find((target2) => target2.id === settings.chat.target) ?? matches[0];
+  let runtime = existing ? registry.get(existing.runtime) : null;
+  let token = key;
+  if (existing && runtime && token === void 0) {
+    const auth = await openAuthStorage().resolveForTarget(resolveAuthTarget(existing, runtime), {
+      includeFallback: false
+    });
+    token = auth.apiKey;
+  }
+  const ctx = { credentialsPresent: /* @__PURE__ */ new Set(), httpTimeoutMs: 5e3, authToken: token ?? "" };
+  if (!runtime) {
+    const root = targetRootUrl({ id: "quick", runtime: "openai-compat", url }) ?? url;
+    const headers = token ? { Authorization: `Bearer ${token}` } : {};
+    const native = await fingerprintNativeRuntime(root, headers);
+    let id = native?.runtimeId ?? "openai-compat";
+    if (!native) {
+      const info = await probeJson({
+        url: `${root}/v1/model/info`,
+        headers,
+        timeoutMs: 1e3
+      });
+      if (info.ok && info.data?.data?.some((row) => typeof row.model_name === "string" && row.model_info !== void 0))
+        id = "litellm";
+    }
+    runtime = registry.get(id);
+  }
+  if (!runtime) throw new Error("No compatible runtime is available. Open Settings \u2192 Connections.");
+  const target = existing ? structuredClone(existing) : {
+    id: deriveTargetId(runtime.id, settings.targets),
+    runtime: runtime.id,
+    url
+  };
+  let probe = await runtime.probe?.(target, ctx) ?? {
+    ok: false,
+    error: "This connection does not support endpoint checks."
+  };
+  let models = probe.ok ? probe.models ?? await runtime.probeModels?.(target, ctx) ?? [] : [];
+  if (!existing && runtime.id === "openai-compat" && !probe.ok && /HTTP (401|403|404)/u.test(probe.error ?? "")) {
+    const anthropic = registry.get("anthropic-compat");
+    if (anthropic) {
+      const candidate = { ...target, runtime: anthropic.id };
+      const catalog = await anthropic.probeModels?.(candidate, ctx) ?? [];
+      if (catalog.length > 0) {
+        runtime = anthropic;
+        target.runtime = anthropic.id;
+        target.id = deriveTargetId(anthropic.id, settings.targets);
+        models = catalog;
+        probe = { ok: true, models };
+      }
+    }
+  }
+  models = [...new Set(models)].filter((id) => probe.modelCapabilities?.[id]?.chat !== false);
+  return { runtime, target, existing, probe, models };
+}
+async function runQuickConnect(prompts) {
+  const initial = readSettings();
+  const first = initial.targets.length === 0;
+  const current = initial.targets.find((target) => target.id === initial.chat.target);
+  let url = current?.url ?? "";
+  let key;
+  let connection;
+  let model = "";
+  let step = "url";
+  let askedKey = false;
+  let optionalKey = false;
+  let notice = "";
+  const presenter = createLifecyclePresenter({ stream: prompts.output });
+  for (; ; ) {
+    prompts.clearScreen();
+    presenter.header("Quick Connect", "configure");
+    presenter.note("Connect one model to power Clio. Change other settings whenever you need them.");
+    if (notice) {
+      presenter.warn(notice);
+      notice = "";
+    }
+    try {
+      if (step === "url") {
+        presenter.note("LM Studio: localhost:1234 \xB7 Ollama: localhost:11434");
+        const answer = await prompts.text("Endpoint URL", url);
+        if (!answer) {
+          notice = "Enter the endpoint URL shown by your model server or API provider.";
+          continue;
+        }
+        try {
+          url = endpointUrl(answer);
+        } catch (error) {
+          notice = error instanceof Error ? error.message : String(error);
+          continue;
+        }
+        key = void 0;
+        askedKey = false;
+        connection = void 0;
+      } else if (step === "key") {
+        presenter.note(`Endpoint: ${url}`);
+        if (optionalKey)
+          presenter.note("Some APIs publish models publicly but require a key for chat. Leave blank for a keyless server.");
+        key = await prompts.text("API key (saved locally when you choose Connect)", "", true) || void 0;
+        if (!key && !optionalKey) {
+          notice = "Enter a key, or press Escape to change the endpoint.";
+          continue;
+        }
+        askedKey = true;
+      }
+      if (step === "url" || step === "key") {
+        presenter.note("Checking the endpoint and reading its model list\u2026");
+        connection = await connect(url, key);
+        if (!connection.probe.ok) {
+          if (connection.probe.authFailed || /HTTP (401|403)/u.test(connection.probe.error ?? "")) {
+            optionalKey = false;
+            notice = key ? "The endpoint rejected that key. Try again, or Escape to go back." : "This endpoint needs an API key.";
+            step = "key";
+          } else {
+            notice = `Could not connect: ${connection.probe.error ?? "no reply"}. Check the URL and that the server is running.`;
+            step = "url";
+          }
+          continue;
+        }
+        if (!connection.existing && !askedKey && connection.runtime.auth === "api-key" && connection.runtime.tier !== "local-native") {
+          optionalKey = true;
+          step = "key";
+          continue;
+        }
+        if (connection.models.length === 0) {
+          notice = "The endpoint offered no chat models. Load a model and retry. Servers without model discovery can use Settings \u2192 Connections.";
+          step = "url";
+          continue;
+        }
+        const preferred = connection.existing?.id === initial.chat.target ? initial.chat.model : connection.target.defaultModel;
+        model = preferred && connection.models.includes(preferred) ? preferred : connection.models[0] ?? "";
+        step = connection.models.length === 1 ? "save" : "model";
+        continue;
+      }
+      if (!connection) {
+        step = "url";
+        continue;
+      }
+      if (step === "model") {
+        presenter.note(`Connected: ${url} (${connection.runtime.displayName})`);
+        model = await prompts.choose("Choose the model for Clio", connection.models, model, true);
+        if (!connection.models.includes(model)) {
+          notice = "Choose a model from the endpoint's live list.";
+          continue;
+        }
+        step = "save";
+        continue;
+      }
+      presenter.fields([
+        ["Endpoint", url],
+        ["Model", model],
+        ["Connection", "live model discovery passed"]
+      ]);
+      if (first) {
+        const settings = readSettings();
+        const autonomy = {
+          "read-only": "inspect and answer; no edits or commands",
+          suggest: "ask before edits, commands, and delegation",
+          "auto-edit": "edit and run recognized checks; unfamiliar commands ask",
+          "full-auto": "skip autonomy approvals; safety rules still apply"
+        }[settings.safety.autonomy];
+        presenter.fields([
+          ["Autonomy", `${settings.safety.autonomy} \xB7 ${autonomy}`],
+          [
+            "Worker approvals",
+            settings.fleet.permissions.mode === "deny" ? "deny requests needing approval; continue allowed work" : settings.fleet.permissions.mode === "fail" ? "stop a worker when approval is needed" : "ask you; unanswered requests follow the configured fallback"
+          ],
+          [
+            "Tracked spending",
+            settings.safety.limits.sessionCostUsd === 0 ? "no session ceiling" : `$${settings.safety.limits.sessionCostUsd} per session; unpriced usage is not covered`
+          ]
+        ]);
+        presenter.note("Safety rules still apply. You can adjust these in /settings \u2192 Permissions & Limits.");
+      } else presenter.note("Use this model for chat. Your other settings and role assignments stay in place.");
+      const choice = await prompts.choose("Ready to connect", ["Connect", "Back"], "Connect");
+      if (choice !== "Connect") throw new ConfigureNavigation("back");
+      const descriptor = structuredClone(connection.target);
+      if (!connection.existing) descriptor.defaultModel = model;
+      if (key) {
+        descriptor.auth = { ...descriptor.auth, apiKeyRef: targetApiKeyRef(descriptor.id, readSettings().targets) };
+        delete descriptor.auth.apiKeyEnvVar;
+      }
+      const apply = (settings) => {
+        const target = settings.targets.find((entry) => entry.id === descriptor.id);
+        if (JSON.stringify(target) !== JSON.stringify(connection?.existing))
+          throw new Error("This target changed during setup. Reopen Quick Connect to keep those changes.");
+        applyTarget(settings, descriptor);
+        setOrchestratorPointer(settings, descriptor, model);
+        if (first && !settings.fleet.default.target) setWorkerDefaultPointer(settings, descriptor, model);
+      };
+      const preview = readSettings();
+      apply(preview);
+      const validated = validateSettings(preview);
+      if (validated.issues.length) throw new SettingsValidationError(validated.issues);
+      initializeClioHome();
+      if (key && descriptor.auth?.apiKeyRef) {
+        const auth = openAuthStorage();
+        auth.setApiKey(descriptor.auth.apiKeyRef, key);
+        if (credentialWriteFailed(auth, "The key was not saved; connection settings were not changed."))
+          throw new Error("The key could not be saved. Check permissions on the credentials file and retry.");
+        printPlaintextCredentialWarning();
+      }
+      updateSettings(apply);
+      presenter.done(`Connected: ${descriptor.id} / ${model}`);
+      presenter.commandAdvice("Start Clio:", "clio-coder");
+      presenter.note(
+        'You can start working immediately. Ask Clio "What can you do without asking me?" or open /settings whenever you want to adjust the defaults.'
+      );
+      return "connected";
+    } catch (error) {
+      if (!(error instanceof ConfigureNavigation)) {
+        notice = error instanceof Error ? error.message : String(error);
+        step = "url";
+        continue;
+      }
+      if (error.kind === "quit" || step === "url") {
+        presenter.done("Quick Connect cancelled; connection settings not saved.");
+        return error.kind;
+      }
+      step = step === "save" && (connection?.models.length ?? 0) > 1 ? "model" : step === "model" || step === "save" ? askedKey ? "key" : "url" : "url";
+    }
+  }
+}
+
+// src/cli/configure.ts
+var HELP = `clio-coder configure
+
+Configure model targets and runtime settings for chat and fleet dispatch.
+
+Usage:
+  clio-coder configure                   Quick Connect, Settings, or Diagnostics
+  clio-coder configure --quick           connect an endpoint with recommended defaults
+  clio-coder configure --settings        open the complete settings menu
+  clio-coder configure --section <name>  open one section directly:
+                                         targets, chat, fleet, context, safety,
+                                         interface, integrations, advanced
+                                         (older section names remain accepted)
+                                         Without a terminal this prints the
+                                         section's values and exits.
+  clio-coder configure --json            emit the effective settings as JSON
+  clio-coder configure --edit            edit all user settings in VISUAL/EDITOR;
+                                         validate and review before saving
+  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,
+    edit: false,
+    quick: false,
+    settings: 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 "--edit":
+        out.edit = true;
+        break;
+      case "--quick":
+        out.quick = true;
+        break;
+      case "--settings":
+        out.settings = 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;
+  }
+  initializeClioHome();
+  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(
+    existing ? resolveAuthTarget(existing, runtime) : 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") ? args.apiKey ? targetApiKeyRef(args.id, settings.targets) : existing?.auth?.apiKeyRef ?? runtime.id : void 0;
+  const oauthProfile = runtime.auth === "oauth" ? existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id : void 0;
+  const seed = {
+    ...existing,
+    ...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 } : {},
+      ...existing?.ollama ? { ollama: existing.ollama } : {}
+    })
+  };
+  seed.capabilities = { ...existing?.capabilities, ...seed.capabilities };
+  if (seed.auth) seed.auth = { ...existing?.auth, ...seed.auth };
+  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 = {
+    ...existing,
+    ...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 } : {},
+      ...existing?.ollama ? { ollama: existing.ollama } : {}
+    })
+  };
+  descriptor.capabilities = { ...existing?.capabilities, ...descriptor.capabilities };
+  if (descriptor.auth) descriptor.auth = { ...existing?.auth, ...descriptor.auth };
+  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 && apiKeyRef) {
+    auth.setApiKey(apiKeyRef, 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, args.apiKey);
+  if (probe?.ok && probe.models) {
+    recordTargetModelSnapshot(descriptor, probe.models, probe.modelLabels ? { modelLabels: probe.modelLabels } : {});
+  }
+  printSummary(settings, descriptor, probe);
+  if (runtime.auth === "oauth" && !auth.statusForTarget(existing ? resolveAuthTarget(existing, runtime) : 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 : 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, existing ?? void 0)}
+`);
+  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(
+    existing ? resolveAuthTarget(existing, runtime) : resolveRuntimeAuthTarget(runtime),
+    { includeFallback: false }
+  );
+  if (runtime.auth === "api-key") {
+    const needsCredential = targetRequiresAuth({ id: targetId, runtime: runtime.id }, runtime);
+    const defaultSource = existing?.auth?.apiKeyRef || 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 rl.text("API key literal (stored in credentials.yaml, mode 0600)", "", true);
+      if (literal !== null && literal.length > 0) {
+        apiKeyLiteral = literal;
+        apiKeyRef = targetApiKeyRef(targetId, settings.targets);
+      }
+    } 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 = existing?.auth?.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 } : {},
+    ...existing?.ollama ? { ollama: existing.ollama } : {}
+  });
+  if (existing?.auth?.headers) tentative.auth = { ...tentative.auth, headers: existing.auth.headers };
+  if (runtime.kind === "http" || runtime.externalAgentLoop?.modelCatalog === "live-authoritative") {
+    inventory = await resolveSupportedWireModels(runtime, tentative, existing ?? void 0, apiKeyLiteral);
+  }
+  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 configured = 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 } : {},
+    ...existing?.ollama ? { ollama: existing.ollama } : {}
+  });
+  const descriptor = {
+    ...existing,
+    ...configured,
+    capabilities: { ...existing?.capabilities, ...configured.capabilities }
+  };
+  if (existing?.auth?.headers) descriptor.auth = { ...configured.auth, headers: existing.auth.headers };
+  else if (!configured.auth) delete descriptor.auth;
+  try {
+    assertOrchestratorReplacementEligible(settings, descriptor);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const probe = await runtimeProbe(runtime, descriptor, apiKeyLiteral);
+  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;
+  if (apiKeyLiteral && apiKeyRef) {
+    auth.setApiKey(apiKeyRef, apiKeyLiteral);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${descriptor.id}' not saved`))
+      return 1;
+    printPlaintextCredentialWarning();
+  }
+  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;
+    }
+    for (const roster of Object.values(settings.fleet.rosters)) {
+      for (const member of roster.members) if (member.target === oldId) member.target = newId;
+    }
+    const renameRef = (entry) => {
+      const [head, ...rest] = entry.split("/");
+      if (head !== oldId) return entry;
+      return rest.length === 0 ? newId : `${newId}/${rest.join("/")}`;
+    };
+    settings.chat.modelPicker.cycleSet = settings.chat.modelPicker.cycleSet.map(renameRef);
+    settings.chat.modelPicker.favorites = settings.chat.modelPicker.favorites.map(renameRef);
+  });
+  printOk(`renamed ${oldId} to ${newId}`);
+  return 0;
+}
+var NONE = "(none)";
+var onOff = (value) => value ? "enabled" : "disabled";
+function concurrencyLabel(concurrency) {
+  if (concurrency !== "auto") return String(concurrency);
+  const local = resolveLocalConcurrency("auto", observeHostCapacityFacts());
+  return `auto \xB7 ${describeLocalCapacity(local) ?? `local ${local.limit}`}`;
+}
+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.isSafeInteger(parsed) || parsed < min) {
+    io.warn(`${label} must be a whole number of at least ${min}; left at ${current}
+`);
+    return;
+  }
+  const value = parsed;
+  apply(value);
+  io.ok(`${label} set to ${value}`);
+}
+async function askChoice(io, label, allowed, current, apply) {
+  const answer = await io.rl.choose(label, allowed, current);
+  if (answer === null) return;
+  const value = answer.trim().toLowerCase();
+  if (!allowed.includes(value)) {
+    io.warn(`${label} must be one of ${allowed.join(", ")}; left at ${current}
+`);
+    return;
+  }
+  apply(value);
+  io.ok(`${label} set to ${value}`);
+}
+async function runTargetWizard(io, options) {
+  const before = readSettings().targets;
+  io.rl.clearScreen();
+  const code = await runOnboardingWizard(io.streams, options);
+  if (code === 130) throw new ConfigureNavigation("quit");
+  if (code !== 0) {
+    await io.rl.text("Press Enter to return");
+    io.warn("Target settings were not saved.");
+    return;
+  }
+  const changed = readSettings().targets.find(
+    (target) => JSON.stringify(target) !== JSON.stringify(before.find((entry) => entry.id === target.id))
+  );
+  if (changed) io.ok(`Target ${changed.id} saved`);
+}
+var DIAGNOSTICS_SECTION = {
+  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 (io) => {
+        const { runDoctorCommand } = await import("./doctor-S5KZ2GTN.js");
+        await runDoctorCommand([]);
+        await io.rl.text("Press Enter to return");
+      }
+    },
+    {
+      label: "Show raw settings.yaml",
+      run: async (io) => {
+        const file = settingsPath();
+        if (!existsSync2(file)) {
+          io.out.write("  settings.yaml does not exist yet.\n");
+          return;
+        }
+        io.out.write(`
+--- ${shortenPath(file)} ---
+${readFileSync2(file, "utf8")}--- end ---
+`);
+        await io.rl.text("Press Enter to return");
+      }
+    }
+  ]
+};
+var SECTION_CONTENT = {
+  targets: {
+    fields: () => {
+      const settings = readSettings();
+      const rows = [];
+      for (const target of settings.targets)
+        rows.push([
+          target.id,
+          `${target.runtime} \xB7 ${target.url ?? "provider default"} \xB7 ${target.defaultModel ?? "no default model"}`
+        ]);
+      return rows.length ? rows : [["Connections", "No connections yet. Choose Add a target to connect a provider."]];
+    },
+    actions: [
+      {
+        label: "Add a target",
+        hint: "register a provider endpoint",
+        run: async (io) => {
+          if (canRunOnboarding(io.streams)) {
+            await runTargetWizard(io, { mode: readSettings().targets.length === 0 ? "first" : "add" });
+            return;
+          }
+          const runtime = await pickRuntimeViaCategory(io.rl);
+          if (runtime) await runTargetSetupInteractive(io.rl, runtime, emptyArgs());
+        }
+      },
+      {
+        label: "Edit a target",
+        hint: "endpoint, credentials, model, capabilities",
+        run: async (io) => {
+          const targets = readSettings().targets;
+          if (targets.length === 0) return;
+          const id = await io.rl.choose(
+            "Target to edit",
+            targets.map((target2) => target2.id),
+            targets[0]?.id ?? ""
+          );
+          const target = targets.find((entry) => entry.id === id);
+          if (!target) return;
+          if (canRunOnboarding(io.streams)) {
+            await runTargetWizard(io, { mode: "edit", target });
+          } else {
+            const runtime = getRuntimeRegistry().get(target.runtime);
+            if (runtime) await runTargetSetupInteractive(io.rl, runtime, { ...emptyArgs(), id });
+          }
+        }
+      },
+      {
+        label: "Rename a target",
+        run: async (io) => {
+          const ids = readSettings().targets.map((target) => target.id);
+          if (ids.length === 0) return;
+          const id = await io.rl.choose("Target to rename", ids, ids[0] ?? "");
+          const name = await ask(io.rl, "New target id", id);
+          if (!name || name === id) return;
+          if (ids.includes(name)) {
+            io.warn(`Target id already exists: ${name}`);
+            return;
+          }
+          if (runTargetRename(id, name) === 0) io.ok(`Renamed ${id} to ${name}`);
+          else io.warn(`Could not rename target ${id}`);
+        }
+      },
+      {
+        label: "Remove a target",
+        run: async (io) => {
+          const settings = readSettings();
+          const ids = settings.targets.map((target) => target.id);
+          if (ids.length === 0) {
+            io.warn("No targets to remove.");
+            return;
+          }
+          io.out.write(`  Registered: ${ids.join(", ")}
+`);
+          const chosen = await io.rl.choose("Target to remove", ids, ids[0] ?? "");
+          if (chosen === null || !ids.includes(chosen)) return;
+          if (await askYesNo(io.rl, `Remove target '${chosen}'?`, false)) {
+            if (runTargetRemove(chosen) === 0) io.ok(`Removed target ${chosen}`);
+            else io.warn(`Could not remove target ${chosen}`);
+          }
+        }
+      }
+    ]
+  },
+  chat: {
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Chat target", settings.chat.target ?? NONE],
+        ["Chat model", settings.chat.model ?? "(target default)"],
+        ["Chat thinking", settings.chat.thinkingLevel],
+        ["Favorites", listOr(settings.chat.modelPicker.favorites)],
+        ["Model cycle set", listOr(settings.chat.modelPicker.cycleSet)],
+        ["Max output tokens", String(settings.chat.maxOutputTokens)],
+        ["Prompt prewarm", onOff(settings.chat.prewarm)],
+        ["Retry transient errors", onOff(settings.chat.retry.enabled)],
+        ["Max retries", String(settings.chat.retry.maxRetries)]
+      ];
+    },
+    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: "Set the chat target",
+        hint: "which target answers in chat",
+        run: async (io) => {
+          await assignTarget(io, "chat");
+        }
+      },
+      {
+        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;
+          updateSavedSettingsDocument((saved) => {
+            const document = saved;
+            document.chat = { ...document.chat, model: model.length > 0 ? model : null };
+            return document;
+          });
+          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) => {
+            saveControl("chat.modelPicker.favorites", values.join(", "));
+          });
+        }
+      },
+      {
+        label: "Cycle set",
+        hint: "comma-separated models for the scoped cycle actions",
+        run: async (io) => {
+          await askList(io, "Cycle set", readSettings().chat.modelPicker.cycleSet, (values) => {
+            updateSettings((draft) => {
+              draft.chat.modelPicker.cycleSet = values;
+            });
+          });
+        }
+      },
+      {
+        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)}`);
+        }
+      }
+    ]
+  },
+  fleet: {
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Fleet target", settings.fleet.default.target ?? NONE],
+        ["Fleet model", settings.fleet.default.model ?? "(target default)"],
+        ["Fleet thinking", settings.fleet.default.thinkingLevel],
+        ["Concurrency limit", concurrencyLabel(settings.fleet.concurrency)],
+        ["Max retries", String(settings.fleet.retry.maxRetries)],
+        ["Task worktree root", settings.fleet.worktrees.root],
+        ["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))],
+        [
+          "Agent routes",
+          listOr(Object.entries(settings.fleet.agentProfiles).map(([agent, profile]) => `${agent} -> ${profile}`))
+        ],
+        ["Remote nodes", listOr(settings.fleet.nodes.map((node) => node.id))]
+      ];
+    },
+    actions: [
+      {
+        label: "Set the fleet default target",
+        hint: "which target dispatched workers use",
+        run: async (io) => {
+          await assignTarget(io, "fleet");
+        }
+      },
+      {
+        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: "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.warn(`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.warn(`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`);
+        }
+      }
+    ]
+  },
+  context: {
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["Auto-compaction", onOff(settings.context.compaction.auto)],
+        ["Compaction threshold", String(settings.context.compaction.threshold)],
+        ["Compaction model", settings.context.compaction.model ?? "(chat model)"],
+        ["Working-set eviction", onOff(settings.context.workingSet.enabled)],
+        ["Tool result cap (bytes)", String(settings.context.toolResultMaxBytes)],
+        ["Memory target", settings.context.memory.target ?? "(rules only)"],
+        ["Memory model", settings.context.memory.model ?? "(target default)"],
+        ["Proactive memory", onOff(settings.context.memory.enabled)]
+      ];
+    },
+    actions: [
+      {
+        label: "Set the background memory target",
+        run: async (io) => assignTarget(io, "memory")
+      },
+      {
+        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)}`);
+        }
+      }
+    ]
+  },
+  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)],
+        ["External agent governance", settings.integrations.externalAgents.defaults.toolGovernance]
+      ];
+    },
+    actions: [
+      {
+        label: "Autonomy level",
+        hint: AUTONOMY_LEVELS.join(" | "),
+        run: async (io) => {
+          io.out.write(
+            "  read-only inspects; suggest asks before edits, execution, and delegation.\n  auto-edit allows workspace edits, recognized checks, and routine delegation;\n  unfamiliar commands and larger dispatch plans ask. Declared outward actions ask.\n  full-auto skips autonomy prompts. Safety rules still apply at every level.\n"
+          );
+          await askChoice(io, "Autonomy level", AUTONOMY_LEVELS, 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.warn(`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)}`);
+        }
+      }
+    ]
+  },
+  interface: {
+    fields: () => {
+      const settings = readSettings();
+      return [
+        ["TUI mode", settings.interface.mode],
+        ["Output style", settings.interface.outputDetail],
+        ["Smooth streaming", settings.interface.smoothStreaming],
+        ["Terminal progress", onOff(settings.interface.terminalProgress)],
+        ["Desktop notifications", onOff(settings.interface.desktopNotifications)],
+        ["Panes capability", settings.interface.panes.enabled],
+        ["Startup layout", settings.interface.panes.layout]
+      ];
+    },
+    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: "Panes capability",
+        hint: "off | auto (join an existing pane host)",
+        run: async (io) => {
+          await askChoice(io, "Panes capability", ["off", "auto"], 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 style",
+        hint: "compact | standard | detailed",
+        run: async (io) => {
+          await askChoice(
+            io,
+            "Output style",
+            ["compact", "standard", "detailed"],
+            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)}`);
+        }
+      }
+    ]
+  },
+  integrations: {
+    fields: () => {
+      const settings = readSettings();
+      const rows = [
+        ["Trust project imports", settings.integrations.projectResources.trustProjectImports ? "trusted" : "untrusted"],
+        ["External ACP agents", String(settings.integrations.externalAgents.entries.length)],
+        ["Runtime plugins", listOr(settings.integrations.runtimePlugins)],
+        ["Library remote sync", onOff(settings.integrations.library.sync)],
+        ["Git commit attribution", onOff(settings.integrations.git.commitAttribution)]
+      ];
+      for (const agent of settings.integrations.externalAgents.entries)
+        rows.push([agent.id, `${agent.command} (governance: ${agent.toolGovernance ?? "default"})`]);
+      return rows;
+    },
+    actions: [
+      {
+        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)}`);
+        }
+      },
+      {
+        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)}`);
+        }
+      }
+    ]
+  },
+  advanced: {
+    fields: () => {
+      return [
+        ...DIAGNOSTICS_SECTION.fields(),
+        ["Settings file", shortenPath(settingsPath())],
+        ["Reference", "clio-coder docs configuration-reference"]
+      ];
+    },
+    actions: [
+      ...DIAGNOSTICS_SECTION.actions,
+      {
+        label: "Edit all settings",
+        hint: "VISUAL / EDITOR; validate before saving",
+        run: async (io) => {
+          if (await editSettings(io.rl)) io.ok("Settings saved; previous file kept at settings.yaml.bak");
+        }
+      }
+    ]
+  }
+};
+var SECTIONS = SETTINGS_SECTIONS.map((section) => ({
+  id: section.id,
+  title: section.label,
+  summary: section.description,
+  aliases: section.aliases,
+  ...SECTION_CONTENT[section.id],
+  actions: [
+    ...SECTION_CONTENT[section.id].actions,
+    ...section.id === "targets" || section.id === "advanced" ? [] : [
+      {
+        label: "All controls in this section",
+        hint: "searchable groups, help, defaults, and validated edits",
+        run: async (io) => runSectionControls(io.rl, section.id)
+      }
+    ]
+  ]
+}));
+function emptyArgs() {
+  return {
+    positional: [],
+    help: false,
+    list: false,
+    all: false,
+    interop: false,
+    json: false,
+    edit: false,
+    quick: false,
+    settings: 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.filter((target2) => {
+    const runtime = getRuntimeRegistry().get(target2.runtime);
+    return role === "fleet" || runtime !== null && isOrchestratorEligibleRuntime(runtime);
+  }).map((target2) => target2.id);
+  if (ids.length === 0) {
+    io.warn("No eligible targets registered yet. Add one first.");
+    return;
+  }
+  io.out.write(`  Registered: ${ids.join(", ")}
+`);
+  const currentTarget = role === "chat" ? settings.chat.target : role === "fleet" ? settings.fleet.default.target : settings.context.memory.target;
+  const label = role === "chat" ? "Chat" : role === "fleet" ? "Fleet" : "Background memory";
+  const chosen = await io.rl.choose(`${label} target`, ids, currentTarget ?? ids[0] ?? "");
+  if (chosen === null) return;
+  if (!ids.includes(chosen)) {
+    io.warn(`${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 override (blank uses ${target?.defaultModel ?? "the target default"})`, "");
+  if (model === null) return;
+  updateSettings((draft) => {
+    if (role === "chat") {
+      draft.chat.target = chosen;
+      draft.chat.model = model.length > 0 ? model : null;
+    } else if (role === "fleet") {
+      draft.fleet.default.target = chosen;
+      draft.fleet.default.model = model.length > 0 ? model : null;
+    } else {
+      draft.context.memory.target = chosen;
+      draft.context.memory.model = model.length > 0 ? model : null;
+    }
+  });
+  io.ok(`${label} target set to ${chosen}`);
+}
+async function pickEntry(rl, io, entries, backLabel, plain, initialIndex = 0) {
+  const out = io.out;
+  if (canSelect(io.in, out)) {
+    const result = await promptSelect({
+      initialIndex,
+      clearOnExit: true,
+      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(spec.summary);
+  presenter.note(`Source: ${shortenPath(settingsPath())}${spec.id === "diagnostics" ? "" : " \xB7 saves globally"}`);
+  presenter.fields(spec.fields());
+  return presenter;
+}
+async function runSection(rl, streams, spec, backLabel) {
+  let selected = 0;
+  let notice;
+  for (; ; ) {
+    rl.clearScreen();
+    const presenter = renderSection(spec, streams.out);
+    if (notice) {
+      if (notice.warning) presenter.warn(notice.text);
+      else presenter.completedStep(notice.text);
+      notice = void 0;
+    }
+    const io = {
+      rl,
+      out: streams.out,
+      streams,
+      ok: (text) => {
+        notice = { text, warning: false };
+      },
+      warn: (text) => {
+        notice = { text: text.trim(), warning: true };
+      }
+    };
+    presenter.blank();
+    const choice = await pickEntry(rl, streams, spec.actions, backLabel, presenter.isPlain(), selected);
+    if (choice.kind !== "index") return choice.kind;
+    selected = choice.index;
+    const action = spec.actions[selected];
+    try {
+      if (action !== void 0) await action.run(io);
+    } catch (error) {
+      if (error instanceof ConfigureNavigation) {
+        if (error.kind === "quit") return "quit";
+      } else
+        notice = { text: `Change not saved: ${error instanceof Error ? error.message : String(error)}`, warning: true };
+    }
+  }
+}
+async function runConfigSectionsMenu(rl, streams, backLabel = "quit") {
+  let selected = 0;
+  for (; ; ) {
+    rl.clearScreen();
+    const presenter = createLifecyclePresenter({ stream: streams.out });
+    presenter.header("Clio Coder Settings", "configure");
+    presenter.note(`Source: ${shortenPath(settingsPath())}`);
+    presenter.note("Same sections as /settings. Changes here become your saved defaults.");
+    presenter.blank();
+    const choice = await pickEntry(
+      rl,
+      streams,
+      SECTIONS.map((section) => ({ label: section.title, hint: section.summary })),
+      backLabel,
+      presenter.isPlain(),
+      selected
+    );
+    if (choice.kind !== "index") return choice.kind;
+    selected = choice.index;
+    const spec = SECTIONS[selected];
+    if (spec === void 0) continue;
+    if (await runSection(rl, streams, spec, "back") === "quit") return "quit";
+  }
+}
+async function runConfigLauncher(rl, streams) {
+  let selected = 0;
+  const exitCode = () => readSettings().chat.target ? 0 : 130;
+  for (; ; ) {
+    rl.clearScreen();
+    const presenter = createLifecyclePresenter({ stream: streams.out });
+    presenter.header("Clio Coder", "configure");
+    presenter.note("Connect a model and start coding. Everything else is optional.");
+    presenter.blank();
+    const choice = await pickEntry(
+      rl,
+      streams,
+      [
+        { label: "Quick Connect", hint: "endpoint \u2192 model \u2192 ready" },
+        { label: "Settings", hint: "all configuration options" },
+        { label: "Diagnostics", hint: "check an existing installation" }
+      ],
+      "quit",
+      presenter.isPlain(),
+      selected
+    );
+    if (choice.kind !== "index") return exitCode();
+    selected = choice.index;
+    if (selected === 0) {
+      const result = await runQuickConnect(rl);
+      if (result === "connected") return 0;
+      if (result === "quit") return exitCode();
+    } else if (selected === 1) {
+      if (await runConfigSectionsMenu(rl, streams, "back") === "quit") return exitCode();
+    } else {
+      const section = findSection("diagnostics");
+      if (section && await runSection(rl, streams, section, "back") === "quit") return exitCode();
+    }
+  }
+}
+function findSection(name) {
+  const wanted = name.trim().toLowerCase();
+  if (["diagnostics", "doctor", "diag"].includes(wanted)) return DIAGNOSTICS_SECTION;
+  return SECTIONS.find((section) => section.id === resolveSettingsSection(wanted));
+}
+var SECTION_IDS = SECTIONS.map((section) => section.id);
+async function runInteractive(rl, preselectedRuntime, defaults, streams) {
+  if (defaults.quick) {
+    if (!canRunOnboarding(streams)) {
+      printError("--quick needs a terminal; use --id and --runtime for unattended setup");
+      return 2;
+    }
+    return await runQuickConnect(rl) === "connected" ? 0 : 130;
+  }
+  if (defaults.settings) {
+    await runConfigSectionsMenu(rl, streams);
+    return 0;
+  }
+  if (preselectedRuntime) {
+    if (canRunOnboarding(streams))
+      return runOnboardingWizard(streams, {
+        mode: readSettings().targets.length === 0 ? "first" : "add",
+        runtime: 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 (canRunOnboarding(streams)) return runConfigLauncher(rl, streams);
+  if (readSettings().targets.length === 0) {
+    const runtime = await pickRuntimeViaCategory(rl);
+    if (!runtime) {
+      printError("configuration cancelled");
+      return 130;
+    }
+    return await runTargetSetupInteractive(rl, runtime, defaults);
+  }
+  await runConfigSectionsMenu(rl, streams);
+  return 0;
+}
+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;
+  }
+  ensureRegistryPopulated();
+  if (args.edit) {
+    if (!inStream.isTTY || !outStream.isTTY) {
+      printError("--edit needs a terminal; use configure --json to inspect settings without one");
+      return 2;
+    }
+    try {
+      await editSettings(new ConfigurePrompts(inStream, outStream));
+      return 0;
+    } catch (error) {
+      if (error instanceof ConfigureNavigation) return 0;
+      printError(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+  }
+  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 (!inStream.isTTY) return runInteropReview({ rl: null });
+    const rl2 = new ConfigurePrompts(inStream, outStream);
+    return runInteropReview({ rl: rl2, streams: { in: inStream, out: outStream } });
+  }
+  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) {
+      const suggestion = closestRuntimeId(getRuntimeRegistry(), runtimeId);
+      printError(`unknown runtime id: ${runtimeId}${suggestion ? ` (did you mean '${suggestion}'?)` : ""}`);
+      process.stdout.write("run `clio-coder configure --list` to see registered runtimes\n");
+      return 2;
+    }
+    if (runtimeId !== runtime.id) warnLegacyNaming(runtimeId, runtime.id);
+  }
+  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.setBackground || args.backgroundModel !== void 0 || args.orchestratorModel !== void 0 || args.workerModel !== void 0 || args.bindAgent !== void 0 || 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) && !inStream.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 = new ConfigurePrompts(inStream, outStream);
+  try {
+    return await runInteractive(rl, runtime, args, { in: inStream, out: outStream });
+  } catch (err) {
+    if (err instanceof ConfigureNavigation) {
+      if (readSettings().targets.length > 0) return 0;
+      printError("configuration cancelled");
+      return 130;
+    }
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+
+export {
+  resolveSupportedWireModels,
+  runTargetRemove,
+  runTargetRename,
+  runConfigureCommand
+};
+//# sourceMappingURL=chunk-EX57VVWW.js.map