@iowarp/clio-coder 0.3.0

package/dist/chunk-XNISANGE.js

@@ -0,0 +1,1395 @@
+import {
+  createDelayedManualCodeInput,
+  promptOAuthSelection
+} from "./chunk-KKKPTZLM.js";
+import {
+  column,
+  terminalColumns,
+  truncate,
+  twoColumnRow,
+  wrapPlain
+} from "./chunk-ME6DNWIU.js";
+import {
+  fingerprintNativeRuntime
+} from "./chunk-262G75JS.js";
+import {
+  initializeClioHome
+} from "./chunk-TFSSEXL6.js";
+import {
+  credentialWriteFailed,
+  printPlaintextCredentialWarning
+} from "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import {
+  buildProviderSupportEntry,
+  configuredTargetsForRuntime,
+  credentialsPresent,
+  describeRuntimeModels,
+  getCatalogModelForRuntime,
+  getRuntimeRegistry,
+  isOrchestratorEligibleRuntime,
+  listKnownModelsForRuntime,
+  listProviderSupportEntries,
+  probeCapabilitiesForModel,
+  registerBuiltinRuntimes,
+  supportGroupLabel
+} from "./chunk-TKHQ4DGZ.js";
+import {
+  readSettings,
+  settingsPath,
+  updateSettings
+} from "./chunk-JWHCJDCI.js";
+import {
+  openAuthStorage,
+  registerClioOAuthProviders,
+  resolveAuthTarget,
+  resolveRuntimeAuthTarget,
+  targetRequiresAuth
+} from "./chunk-5LDRNKX2.js";
+
+// src/cli/configure.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+// src/cli/configure-layout.ts
+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/validate-model.ts
+function validateModelChoice(input2) {
+  const { runtimeId, modelId, knownModels, force } = input2;
+  if (knownModels.length === 0) return { ok: true };
+  if (knownModels.includes(modelId)) return { ok: true };
+  if (force) {
+    return {
+      ok: true,
+      warning: `model '${modelId}' not in ${runtimeId} catalog (use without --force to reject)`
+    };
+  }
+  const sample = knownModels.slice(0, 10).join(", ");
+  return {
+    ok: false,
+    reason: `model '${modelId}' not in ${runtimeId} catalog. Known: ${sample}. Use --force to skip validation.`,
+    knownModels: knownModels.slice(0, 10)
+  };
+}
+
+// src/cli/configure.ts
+var HELP = `clio-coder configure
+
+Configure model targets for chat and fleet-agent dispatch.
+
+Usage:
+  clio-coder configure                   interactive wizard
+  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>
+
+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
+  --api-key-env <VAR>              read API key from this env var at call time
+  --api-key <literal>              store API key in credentials.yaml
+  --force                          allow a model outside the runtime catalog
+  --gateway                        mark the target as a gateway
+  --lifecycle <user-managed|clio-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
+`;
+var DEFAULT_PORTS = {
+  llamacpp: 8080,
+  "llamacpp-anthropic": 8080,
+  "llamacpp-completion": 8080,
+  "llamacpp-embed": 8080,
+  "llamacpp-rerank": 8080,
+  "lmstudio-native": 1234,
+  "ollama-native": 11434,
+  vllm: 8e3,
+  sglang: 3e4,
+  "lemonade-anthropic": 8e3,
+  lemonade: 8e3,
+  "anthropic-compat": 8e3,
+  "openai-compat": 8e3
+};
+function parseSetupArgs(argv) {
+  const out = {
+    positional: [],
+    help: false,
+    list: false,
+    all: 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 "--list":
+        out.list = true;
+        break;
+      case "--all":
+        out.all = 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":
+      case "--worker-model":
+        out.workerModel = need();
+        break;
+      case "--agent-profile":
+      case "--worker-profile":
+        out.workerProfile = need();
+        break;
+      case "--agent-profile-model":
+      case "--worker-profile-model":
+        out.workerProfileModel = 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-managed") {
+          throw new Error("--lifecycle must be user-managed or clio-managed");
+        }
+        out.lifecycle = v;
+        break;
+      }
+      case "--set-orchestrator":
+        out.setOrchestrator = true;
+        break;
+      case "--set-background":
+        out.setBackground = true;
+        break;
+      case "--set-fleet-default":
+      case "--set-worker-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);
+}
+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);
+  const withScheme = hasScheme ? trimmed : `http://${trimmed}`;
+  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";
+}
+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" : "needs-key" : 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 deriveTargetId(runtimeId, existing) {
+  const base = runtimeId;
+  const taken = new Set(existing.map((e) => e.id));
+  if (!taken.has(base)) return base;
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${base}-${i}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return `${base}-${Date.now()}`;
+}
+async function buildProbeContext(runtime, target) {
+  const probeCtx = {
+    credentialsPresent: credentialsPresent(),
+    httpTimeoutMs: 5e3
+  };
+  if (!runtime || !target || !targetRequiresAuth(target, runtime)) return probeCtx;
+  try {
+    const resolution = await openAuthStorage().resolveForTarget(resolveAuthTarget(target, runtime), {
+      includeFallback: false
+    });
+    if (resolution.apiKey) probeCtx.authToken = resolution.apiKey;
+  } catch {
+  }
+  return probeCtx;
+}
+function runtimeKnownModelsFor(runtimeId) {
+  return listKnownModelsForRuntime(runtimeId);
+}
+function catalogContextWindowFor(runtime, modelId) {
+  const catalogModel = getCatalogModelForRuntime(runtime.id, modelId);
+  if (typeof catalogModel?.contextWindow === "number" && catalogModel.contextWindow > 0) {
+    return catalogModel.contextWindow;
+  }
+  if (runtimeKnownModelsFor(runtime.id).includes(modelId) && runtime.defaultCapabilities.contextWindow > 0) {
+    return runtime.defaultCapabilities.contextWindow;
+  }
+  return null;
+}
+function validateResolvedModel(runtimeId, modelId, force) {
+  if (!modelId) return true;
+  const validation = validateModelChoice({
+    runtimeId,
+    modelId,
+    knownModels: runtimeKnownModelsFor(runtimeId),
+    force
+  });
+  if (!validation.ok) {
+    process.stderr.write(`error: ${validation.reason}
+`);
+    return false;
+  }
+  if (validation.warning) process.stderr.write(`warning: ${validation.warning}
+`);
+  return true;
+}
+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) {
+  if (typeof runtime.probe !== "function") return null;
+  try {
+    return await runtime.probe(target, await buildProbeContext(runtime, target));
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runtimeProbeModels(runtime, target) {
+  if (typeof runtime.probeModels !== "function") return [];
+  try {
+    return await runtime.probeModels(target, await buildProbeContext(runtime, target));
+  } 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.orchestrator.target = descriptor.id;
+  settings.orchestrator.model = model ?? descriptor.defaultModel ?? null;
+}
+function setWorkerDefaultPointer(settings, descriptor, model) {
+  settings.workers.default.target = descriptor.id;
+  settings.workers.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.background.target = descriptor.id;
+  settings.background.model = model ?? descriptor.defaultModel ?? null;
+}
+function assertOrchestratorReplacementEligible(settings, descriptor) {
+  if (settings.orchestrator.target !== descriptor.id && settings.background.target !== descriptor.id) return;
+  const role = settings.orchestrator.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.workers.profiles[trimmed] = {
+    target: descriptor.id,
+    model: model ?? descriptor.defaultModel ?? null,
+    thinkingLevel: "off"
+  };
+}
+function warnUndiscoveredContextWindow(descriptor, probe) {
+  if (!probe?.ok) return;
+  if (typeof descriptor.capabilities?.contextWindow === "number" && descriptor.capabilities.contextWindow > 0) return;
+  const discovered = probeCapabilitiesForModel(
+    {
+      target: descriptor,
+      probeCapabilities: probe.discoveredCapabilities ?? null,
+      probeModelCapabilities: probe.modelCapabilities ?? null,
+      probeModelId: probe.capabilityModelId ?? null
+    },
+    descriptor.defaultModel
+  );
+  if (typeof discovered?.contextWindow === "number" && discovered.contextWindow > 0) 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 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) {
+    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 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.orchestrator.target === descriptor.id) process.stdout.write("  orchestrator target\n");
+  if (settings.background.target === descriptor.id) process.stdout.write("  background memory target\n");
+  if (settings.workers.default.target === descriptor.id) process.stdout.write("  fleet default\n");
+  for (const [name, profile] of Object.entries(settings.workers.profiles)) {
+    if (profile.target === descriptor.id) process.stdout.write(`  fleet profile ${name}
+`);
+  }
+  process.stdout.write(`
+settings written to ${settingsPath()}
+`);
+}
+function buildDescriptor(runtime, id, parts) {
+  const descriptor = { id, runtime: runtime.id };
+  if (parts.url) descriptor.url = parts.url;
+  const wireModels = parts.wireModels?.filter((value, index, all) => value.trim().length > 0 && all.indexOf(value) === index) ?? [];
+  if (parts.model) descriptor.defaultModel = parts.model;
+  else {
+    const firstWireModel = wireModels[0];
+    if (firstWireModel) descriptor.defaultModel = firstWireModel;
+  }
+  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 (wireModels.length > 0) descriptor.wireModels = wireModels;
+  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;
+  return descriptor;
+}
+function describeAuthStatus(runtime) {
+  const status = openAuthStorage().statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  if (!status.available) return "none stored";
+  if (status.source === "environment") return `environment${status.detail ? ` (${status.detail})` : ""}`;
+  if (status.source === "stored-api-key") return "stored api key";
+  if (status.source === "stored-oauth") return "stored oauth";
+  return status.source;
+}
+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();
+  }
+}
+async function resolveSupportedWireModels(runtime, target, existing) {
+  const known = listKnownModelsForRuntime(runtime.id);
+  if (known.length > 0) return known;
+  const discovered = runtime.kind === "http" ? await runtimeProbeModels(runtime, target) : [];
+  if (discovered.length > 0) return discovered;
+  return existing?.wireModels ? [...existing.wireModels] : [];
+}
+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 pi-ai 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.workerProfile !== void 0 && args.workerProfile.trim().length === 0) {
+    printError("--agent-profile must be non-empty");
+    return 2;
+  }
+  if (args.workerProfile !== void 0 && args.workerModel !== void 0) {
+    printError(
+      "--fleet-model and --agent-profile conflict; use --agent-profile-model for the profile, or drop --agent-profile to set the fleet default"
+    );
+    return 2;
+  }
+  const settings = readSettings();
+  const auth = openAuthStorage();
+  const support = buildProviderSupportEntry(runtime);
+  const existing = settings.targets.find((e) => e.id === args.id);
+  if (existing && 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 === "openai-compat" || runtime.id === "anthropic-compat")) {
+    const fingerprint = await fingerprintNativeRuntime(url);
+    if (fingerprint) {
+      process.stdout.write(
+        `note: detected ${fingerprint.displayName} at ${url}; consider \`clio-coder targets convert ${args.id} --runtime ${fingerprint.runtimeId}\` for proper resident-model lifecycle
+`
+      );
+    }
+  }
+  const authStatus = auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  const apiKeyEnv = args.apiKeyEnv ?? existing?.auth?.apiKeyEnvVar;
+  const apiKeyRef = runtime.auth === "api-key" && (args.apiKey || existing?.auth?.apiKeyRef || authStatus.source === "stored-api-key") ? runtime.id : void 0;
+  const oauthProfile = runtime.auth === "oauth" ? existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id : void 0;
+  const seed = buildDescriptor(runtime, args.id, {
+    ...url !== void 0 ? { url } : {},
+    ...args.model !== void 0 ? { model: args.model } : existing?.defaultModel ? { model: existing.defaultModel } : support.defaultModel ? { model: support.defaultModel } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    gateway: args.gateway || existing?.gateway === true,
+    ...args.lifecycle !== void 0 ? { lifecycle: args.lifecycle } : existing?.lifecycle !== void 0 ? { lifecycle: existing.lifecycle } : {},
+    ...args.contextWindow !== void 0 ? { contextWindow: args.contextWindow } : {},
+    ...args.maxTokens !== void 0 ? { maxTokens: args.maxTokens } : {},
+    ...args.reasoning !== void 0 ? { reasoning: args.reasoning } : {}
+  });
+  const wireModels = await resolveSupportedWireModels(runtime, seed, existing);
+  const model = args.model ?? existing?.defaultModel ?? support.defaultModel ?? (support.modelSource === "catalog" ? void 0 : wireModels[0]);
+  if (model === void 0 && support.modelSource === "catalog") {
+    refuseCatalogSeededModel(runtime, support);
+    return 2;
+  }
+  if (!validateResolvedModel(runtime.id, model, args.force)) return 2;
+  if (!validateContextWindowOverride(runtime, model, args.contextWindow, args.force)) return 2;
+  const descriptor = buildDescriptor(runtime, args.id, {
+    ...url !== void 0 ? { url } : {},
+    ...model ? { model } : {},
+    ...wireModels.length > 0 ? { wireModels } : {},
+    ...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 } : {}
+  });
+  const setOrchestrator = args.setOrchestrator || args.orchestratorModel !== void 0;
+  const setBackground = args.setBackground || args.backgroundModel !== void 0;
+  if ((setOrchestrator || setBackground) && !isOrchestratorEligibleRuntime(runtime)) {
+    printError(
+      `cannot use target '${descriptor.id}' as a chat or background target because runtime '${runtime.id}' is not an HTTP/native runtime`
+    );
+    return 1;
+  }
+  try {
+    assertOrchestratorReplacementEligible(settings, descriptor);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (args.apiKey) {
+    auth.setApiKey(runtime.id, args.apiKey);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${descriptor.id}' not saved`))
+      return 1;
+    printPlaintextCredentialWarning();
+  }
+  const setWorkerDefault = args.setWorkerDefault || args.workerProfile === void 0 && args.workerModel !== void 0;
+  const applyConfiguration = (target) => {
+    applyTarget(target, descriptor);
+    if (setOrchestrator)
+      setOrchestratorPointer(target, descriptor, args.orchestratorModel ?? descriptor.defaultModel ?? null);
+    if (setBackground) setBackgroundPointer(target, descriptor, args.backgroundModel ?? descriptor.defaultModel ?? null);
+    if (setWorkerDefault)
+      setWorkerDefaultPointer(target, descriptor, args.workerModel ?? descriptor.defaultModel ?? null);
+    if (args.workerProfile !== void 0) {
+      setWorkerProfilePointer(
+        target,
+        args.workerProfile,
+        descriptor,
+        args.workerProfileModel ?? descriptor.defaultModel ?? null
+      );
+    }
+  };
+  applyConfiguration(settings);
+  updateSettings(applyConfiguration);
+  const probe = await runtimeProbe(runtime, descriptor);
+  printSummary(settings, descriptor, probe);
+  if (runtime.auth === "oauth" && !auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false }).available) {
+    process.stdout.write(
+      `note: authenticate ${runtime.id} with \`clio-coder auth login ${runtime.id}\` before using this target
+`
+    );
+  }
+  printOk(`target ${args.id} saved`);
+  return 0;
+}
+async function ask(rl, label, defaultValue) {
+  const suffix = defaultValue && defaultValue.length > 0 ? ` [${defaultValue}]` : "";
+  try {
+    const answer = (await rl.question(`${label}${suffix}: `)).trim();
+    if (answer.length === 0) return defaultValue ?? "";
+    if (answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") return null;
+    return answer;
+  } catch {
+    return null;
+  }
+}
+async function askYesNo(rl, label, defaultValue) {
+  const marker = defaultValue ? "Y/n" : "y/N";
+  for (; ; ) {
+    const answer = await ask(rl, `${label} [${marker}]`);
+    if (answer === null) return defaultValue;
+    if (answer.length === 0) return defaultValue;
+    const lc = answer.toLowerCase();
+    if (lc === "y" || lc === "yes") return true;
+    if (lc === "n" || lc === "no") return false;
+    process.stderr.write(`invalid response: ${answer}
+`);
+  }
+}
+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}
+`);
+  }
+}
+var LOCAL_APP_RUNTIME_IDS = /* @__PURE__ */ new Set(["ollama-native", "lmstudio-native"]);
+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();
+  }
+}
+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 allEntries = listProviderSupportEntries(registry.list());
+  const category = await pickCategory(rl);
+  if (category === null) return null;
+  if (category === "all") return pickRuntime(rl);
+  const filtered = runtimesForCategory(allEntries, 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 runInteractive(rl, preselectedRuntime, defaults) {
+  let runtime = preselectedRuntime ?? await pickRuntimeViaCategory(rl);
+  if (!runtime) {
+    printError("configuration cancelled");
+    return 0;
+  }
+  const auth = openAuthStorage();
+  const settings = readSettings();
+  let support = buildProviderSupportEntry(runtime);
+  const initialRuntimeId = runtime.id;
+  const existingForRuntime = configuredTargetsForRuntime(settings, initialRuntimeId);
+  const existing = (defaults.id ? settings.targets.find((entry) => entry.id === defaults.id && entry.runtime === initialRuntimeId) : null) ?? existingForRuntime[0] ?? null;
+  if (existingForRuntime.length > 0) {
+    process.stdout.write(`
+Existing targets for ${runtime.id}:
+`);
+    for (const target of existingForRuntime) {
+      process.stdout.write(`  - ${target.id}${target.defaultModel ? ` (${target.defaultModel})` : ""}
+`);
+    }
+  }
+  process.stdout.write(`
+Selected runtime: ${runtime.id} (${support.summary})
+`);
+  process.stdout.write(`Credentials: ${describeAuthStatus(runtime)}
+`);
+  if (support.modelHints.length > 0) {
+    process.stdout.write(`Known models: ${describeRuntimeModels(support, 4)}
+`);
+  }
+  const suggestedId = defaults.id ?? existing?.id ?? deriveTargetId(runtime.id, settings.targets);
+  const idInput = await ask(rl, "Target id", suggestedId);
+  if (idInput === null || idInput.length === 0) {
+    printError("target id is required");
+    return 2;
+  }
+  const targetId = idInput;
+  let url = existing?.url;
+  if (support.supportsCustomUrl) {
+    const urlDefault = defaults.url ?? existing?.url ?? defaultUrlFor(runtime.id);
+    const urlInput = await ask(
+      rl,
+      support.group === "local-http" ? "Target URL" : "Base URL override (blank for runtime default)",
+      urlDefault
+    );
+    if (urlInput === null) return 0;
+    if (urlInput.length > 0) url = normalizeUrl(urlInput, runtime.id);
+  } else if (defaults.url) {
+    url = normalizeUrl(defaults.url, runtime.id);
+  }
+  if (url) {
+    const steered = await maybeSteerToNativeRuntime(rl, runtime, url);
+    if (steered.id !== runtime.id) {
+      runtime = steered;
+      support = buildProviderSupportEntry(runtime);
+    }
+  }
+  let apiKeyEnv;
+  let apiKeyLiteral;
+  let apiKeyRef = existing?.auth?.apiKeyRef;
+  let oauthProfile = runtime.auth === "oauth" ? existing?.auth?.oauthProfile ?? runtime.oauthProviderId ?? runtime.id : void 0;
+  const authStatus = auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false });
+  if (runtime.auth === "api-key") {
+    const needsCredential = targetRequiresAuth({ id: targetId, runtime: runtime.id }, runtime);
+    const defaultSource = authStatus.source === "stored-api-key" ? "keep" : authStatus.source === "environment" || existing?.auth?.apiKeyEnvVar || needsCredential ? "env" : "skip";
+    process.stdout.write(
+      "\nCredential source: env reads a key from an environment variable, stored writes one to\ncredentials.yaml, keep leaves the current one alone, skip uses no key at all.\n"
+    );
+    const choice = await ask(rl, "Credential source [env|stored|keep|skip]", defaultSource);
+    if (choice === null) return 0;
+    const normalized = choice.trim().toLowerCase();
+    if (normalized === "stored") {
+      const literal = await ask(rl, "API key literal (stored in credentials.yaml, mode 0600)");
+      if (literal !== null && literal.length > 0) {
+        apiKeyLiteral = literal;
+        apiKeyRef = runtime.id;
+      }
+    } else if (normalized === "env") {
+      const envDefault = defaults.apiKeyEnv ?? existing?.auth?.apiKeyEnvVar ?? runtime.credentialsEnvVar ?? "";
+      const envAnswer = await ask(rl, "Env var name (blank for no key)", envDefault);
+      if (envAnswer === null) return 0;
+      if (envAnswer.length > 0) apiKeyEnv = envAnswer;
+      apiKeyRef = void 0;
+    } else if (normalized === "keep") {
+      apiKeyEnv = existing?.auth?.apiKeyEnvVar ?? (authStatus.source === "environment" ? runtime.credentialsEnvVar : void 0);
+      apiKeyRef = existing?.auth?.apiKeyRef ?? (authStatus.source === "stored-api-key" ? runtime.id : void 0);
+    } else {
+      apiKeyEnv = void 0;
+      apiKeyRef = void 0;
+    }
+  }
+  if (runtime.auth === "oauth") {
+    const connectNow = authStatus.available ? await askYesNo(rl, `Reconnect ${runtime.displayName}?`, false) : await askYesNo(rl, `Connect ${runtime.displayName} now?`, true);
+    if (connectNow) {
+      const connected = await loginOAuthRuntime(rl, runtime);
+      if (!connected) return 1;
+    }
+    oauthProfile = runtime.oauthProviderId ?? runtime.id;
+  }
+  let model = defaults.model;
+  let wireModels = existing?.wireModels ? [...existing.wireModels] : [];
+  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 } : {}
+  });
+  if (runtime.kind === "http") {
+    wireModels = await resolveSupportedWireModels(runtime, tentative, existing ?? void 0);
+  }
+  const catalogOrdered = support.modelSource === "catalog";
+  model = model ?? existing?.defaultModel ?? support.defaultModel ?? (catalogOrdered ? void 0 : wireModels[0]);
+  if (wireModels.length > 0) {
+    process.stdout.write("\nSelectable models:\n");
+    for (const [index, wireModel] of wireModels.entries()) {
+      process.stdout.write(`  ${index + 1}. ${wireModel}${wireModel === model ? "  [default]" : ""}
+`);
+    }
+    if (!model && catalogOrdered) {
+      process.stdout.write(`  listed in pi-ai 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.id, model, defaults.force)) break;
+    }
+  } else {
+    for (; ; ) {
+      if (model && validateResolvedModel(runtime.id, model, defaults.force)) break;
+      const manual = await ask(rl, "Default model id (blank to leave empty)", model ?? "");
+      if (manual === null) return 0;
+      model = manual.length > 0 ? manual : void 0;
+      if (!model) break;
+    }
+  }
+  let contextWindowChoice = defaults.contextWindow;
+  let reasoningChoice = defaults.reasoning;
+  if (PROTOCOL_COMPAT_RUNTIME_IDS.has(runtime.id)) {
+    if (contextWindowChoice === void 0) {
+      const cwDefault = existing?.capabilities?.contextWindow ?? runtime.defaultCapabilities.contextWindow;
+      const cwAnswer = await ask(
+        rl,
+        "Context window in tokens (blank for runtime default)",
+        cwDefault > 0 ? String(cwDefault) : ""
+      );
+      if (cwAnswer === null) return 0;
+      if (cwAnswer.length > 0) {
+        const parsed = Number(cwAnswer);
+        if (Number.isInteger(parsed) && parsed > 0) contextWindowChoice = parsed;
+        else process.stderr.write(`ignoring invalid context window: ${cwAnswer}
+`);
+      }
+    }
+    if (reasoningChoice === void 0) {
+      const reasoningDefault = existing?.capabilities?.reasoning ?? runtime.defaultCapabilities.reasoning === true;
+      reasoningChoice = await askYesNo(rl, "Does this model support reasoning / thinking?", reasoningDefault);
+    }
+  }
+  if (!validateContextWindowOverride(runtime, model, contextWindowChoice, defaults.force)) return 2;
+  const gatewayDefault = defaults.gateway || existing?.gateway === true;
+  const gatewayAnswer = gatewayDefault ? true : await askYesNo(rl, "Mark as gateway?", false);
+  const descriptor = buildDescriptor(runtime, targetId, {
+    ...url !== void 0 ? { url } : {},
+    ...model !== void 0 ? { model } : {},
+    ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+    ...apiKeyRef !== void 0 ? { apiKeyRef } : {},
+    ...oauthProfile !== void 0 ? { oauthProfile } : {},
+    ...wireModels.length > 0 ? { wireModels } : {},
+    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 } : {}
+  });
+  try {
+    assertOrchestratorReplacementEligible(settings, descriptor);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (apiKeyLiteral) {
+    auth.setApiKey(runtime.id, apiKeyLiteral);
+    if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored; target '${descriptor.id}' not saved`))
+      return 1;
+    printPlaintextCredentialWarning();
+  }
+  const probe = await runtimeProbe(runtime, descriptor);
+  if (probe) {
+    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.orchestrator.target);
+  const setWorkerDefault = defaults.setWorkerDefault ? true : await askYesNo(rl, "use as fleet default?", !settings.workers.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.orchestrator.target === targetId ? settings.orchestrator.model ?? model : model
+  ) : void 0;
+  if (orchestratorModel === null) return 0;
+  const workerModel = setWorkerDefault ? defaults.workerModel ?? await askModelChoice(
+    rl,
+    "Fleet model",
+    wireModels,
+    settings.workers.default.target === targetId ? settings.workers.default.model ?? model : model
+  ) : void 0;
+  if (workerModel === null) return 0;
+  const backgroundModel = setBackground ? defaults.backgroundModel ?? await askModelChoice(
+    rl,
+    "Background memory model",
+    wireModels,
+    settings.background.target === targetId ? settings.background.model ?? model : model
+  ) : void 0;
+  if (backgroundModel === null) return 0;
+  const applyWizardChoice = (target) => {
+    applyTarget(target, descriptor);
+    if (setOrchestrator) setOrchestratorPointer(target, descriptor, orchestratorModel);
+    if (setBackground) setBackgroundPointer(target, descriptor, backgroundModel);
+    if (setWorkerDefault) setWorkerDefaultPointer(target, descriptor, workerModel);
+  };
+  applyWizardChoice(settings);
+  updateSettings(applyWizardChoice);
+  printSummary(settings, descriptor, probe);
+  printOk(`target ${targetId} saved`);
+  return 0;
+}
+function runTargetRemove(id) {
+  if (!readSettings().targets.some((e) => e.id === id)) {
+    printError(`no target with id ${id}`);
+    return 1;
+  }
+  updateSettings((settings) => {
+    settings.targets = settings.targets.filter((e) => e.id !== id);
+    if (settings.orchestrator.target === id) {
+      settings.orchestrator.target = null;
+      settings.orchestrator.model = null;
+    }
+    if (settings.background.target === id) {
+      settings.background.target = null;
+      settings.background.model = null;
+    }
+    if (settings.workers.default.target === id) {
+      settings.workers.default.target = null;
+      settings.workers.default.model = null;
+    }
+    for (const [name, profile] of Object.entries(settings.workers.profiles)) {
+      if (profile.target === id) delete settings.workers.profiles[name];
+    }
+    settings.scope = settings.scope.filter((entry) => {
+      const [head] = entry.split("/");
+      return head !== 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.orchestrator.target === oldId) settings.orchestrator.target = newId;
+    if (settings.background.target === oldId) settings.background.target = newId;
+    if (settings.workers.default.target === oldId) settings.workers.default.target = newId;
+    for (const profile of Object.values(settings.workers.profiles)) {
+      if (profile.target === oldId) profile.target = newId;
+    }
+    settings.scope = settings.scope.map((entry) => {
+      const [head, ...rest] = entry.split("/");
+      if (head !== oldId) return entry;
+      return rest.length === 0 ? newId : `${newId}/${rest.join("/")}`;
+    });
+  });
+  printOk(`renamed ${oldId} to ${newId}`);
+  return 0;
+}
+async function runConfigureCommand(argv) {
+  let args;
+  try {
+    args = parseSetupArgs(argv);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  initializeClioHome();
+  ensureRegistryPopulated();
+  if (args.list) {
+    printRuntimeList(args.all);
+    return 0;
+  }
+  if (args.remove) return runTargetRemove(args.remove);
+  if (args.renameOld && args.renameNew) return runTargetRename(args.renameOld, args.renameNew);
+  if (args.positional.length > 0) {
+    printError(
+      "`clio-coder configure` accepts flags, not positional runtimes. Use `clio-coder auth login <runtime>` first when authentication is needed, then `clio-coder configure --runtime <runtimeId> ...`."
+    );
+    return 2;
+  }
+  const runtimeId = args.runtime;
+  let runtime = null;
+  if (runtimeId) {
+    runtime = getRuntimeRegistry().get(runtimeId);
+    if (!runtime) {
+      printError(`unknown runtime id: ${runtimeId}`);
+      process.stdout.write("run `clio-coder configure --list` to see registered runtimes\n");
+      return 2;
+    }
+  }
+  const hasTargetSetupFlag = args.id !== void 0 || args.url !== void 0 || args.model !== void 0 || args.workerProfile !== void 0 || args.workerProfileModel !== void 0 || args.apiKey !== void 0 || args.apiKeyEnv !== void 0 || args.gateway || args.lifecycle !== void 0 || args.setOrchestrator || args.setWorkerDefault || args.contextWindow !== void 0 || args.maxTokens !== void 0 || args.reasoning !== void 0;
+  const nonInteractive = runtime !== null && hasTargetSetupFlag;
+  if (nonInteractive && runtime) return runNonInteractive(runtime, args);
+  if ((runtimeId !== void 0 || hasTargetSetupFlag) && !input.isTTY) {
+    printError(
+      runtime === null ? "--runtime is required when configuring a target non-interactively" : "--id is required when passing flags non-interactively"
+    );
+    return 2;
+  }
+  const rl = createInterface({ input, output });
+  try {
+    return await runInteractive(rl, runtime, args);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  } finally {
+    rl.close();
+  }
+}
+
+export {
+  runTargetRemove,
+  runTargetRename,
+  runConfigureCommand
+};
+//# sourceMappingURL=chunk-XNISANGE.js.map