@iowarp/clio-coder 0.3.0

package/dist/targets-DZMEZAH4.js

@@ -0,0 +1,977 @@
+import "./chunk-NI4DEJMC.js";
+import {
+  ensureClioState
+} from "./chunk-7RBKDI66.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import "./chunk-HMYNFFY4.js";
+import {
+  runConfigureCommand,
+  runTargetRemove,
+  runTargetRename
+} from "./chunk-XNISANGE.js";
+import "./chunk-KKKPTZLM.js";
+import {
+  column,
+  terminalColumns,
+  truncate
+} from "./chunk-ME6DNWIU.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import {
+  ProvidersDomainModule,
+  getRuntimeRegistry,
+  isDispatchEligibleRuntime,
+  isOrchestratorEligibleRuntime,
+  registerBuiltinRuntimes
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import {
+  readSettings,
+  updateSettings
+} from "./chunk-JWHCJDCI.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/targets.ts
+import chalk from "chalk";
+var HEADER = ["id", "tier", "runtime", "auth", "url", "model", "health", "caps", "notes"];
+var HELP = `clio-coder targets
+
+List and manage configured model targets.
+
+Usage:
+  clio-coder targets [--json] [--probe] [--target <id>]
+  clio-coder targets add [configure flags]
+  clio-coder targets use <id> [--model <id>] [--orchestrator-model <id>] [--background-model <id>]
+                       [--fleet-target <id>] [--fleet-model <id>]
+  clio-coder targets fleet [--json]
+  clio-coder targets profile list [--json]
+  clio-coder targets profile set <name> <id> [--model <id>] [--thinking <level>]
+  clio-coder targets profile <name> <id> [--model <id>] [--thinking <level>]
+  clio-coder targets profile remove <name> [--force]
+  clio-coder targets profile rename <old> <new>
+  clio-coder targets profile bind <agentId> <profileName>
+  clio-coder targets profile unbind <agentId>
+  clio-coder targets profile bindings [--json]
+  clio-coder targets convert <id> --runtime <runtimeId>
+  clio-coder targets remove <id>
+  clio-coder targets rename <old> <new>
+
+Aliases:
+  --worker-target and --worker-model are accepted for --fleet-target and
+  --fleet-model, carried over from before the worker/fleet rename.
+`;
+var USE_USAGE = "clio-coder targets use <id> [--model <id>] [--orchestrator-model <id>] [--background-model <id>] [--fleet-target <id>] [--fleet-model <id>]";
+function wantsHelp(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function printUsage(usage) {
+  process.stdout.write(`usage: ${usage}
+`);
+  return 0;
+}
+var VALID_THINKING = new Set(THINKING_LEVELS);
+var PROFILE_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "set", "remove", "rename", "bind", "unbind", "bindings"]);
+function parseListArgs(args) {
+  const parsed = { json: false, probe: false, help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.json = true;
+      continue;
+    }
+    if (arg === "--probe") {
+      parsed.probe = true;
+      continue;
+    }
+    if (arg === "--target") {
+      const value = args[i + 1];
+      if (!value) throw new Error("--target requires a value");
+      parsed.target = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown targets argument: ${arg}`);
+  }
+  return parsed;
+}
+async function runTargetsCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "add") return runConfigureCommand(args.slice(1));
+  if (subcommand === "use") return runUse(args.slice(1));
+  if (subcommand === "fleet" || subcommand === "workers") return runFleet(args.slice(1));
+  if (subcommand === "profile" || subcommand === "worker") return runProfile(args.slice(1));
+  if (subcommand === "remove") return runRemove(args.slice(1));
+  if (subcommand === "rename") return runRename(args.slice(1));
+  if (subcommand === "convert") return runConvert(args.slice(1));
+  if (subcommand === "--help" || subcommand === "-h") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseListArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  ensureClioState();
+  const loaded = await loadDomains([ConfigDomainModule, ProvidersDomainModule]);
+  const providers = loaded.getContract("providers");
+  if (!providers) {
+    process.stderr.write("targets: provider domain not loaded\n");
+    await loaded.stop();
+    return 1;
+  }
+  if (parsed.probe) {
+    try {
+      await providers.probeAllLive();
+    } catch (err) {
+      process.stderr.write(`targets: live probe failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  const entries = providers.list();
+  if (parsed.target !== void 0 && !entries.some((e) => e.target.id === parsed.target)) {
+    printError(
+      `no target with id ${parsed.target}. ${entries.length} target${entries.length === 1 ? "" : "s"} configured.`
+    );
+    await loaded.stop();
+    return 2;
+  }
+  const filtered = parsed.target ? entries.filter((e) => e.target.id === parsed.target) : entries;
+  if (parsed.json) {
+    const settings = readSettings();
+    const candidateFor = (status) => {
+      const orchestratorModel = settings.orchestrator?.target === status.target.id ? settings.orchestrator?.model ?? null : null;
+      return orchestratorModel ?? status.target.defaultModel ?? null;
+    };
+    const rows = filtered.map((status) => {
+      const candidate = candidateFor(status);
+      const detectedReasoning = candidate ? providers.getDetectedReasoning(status.target.id, candidate) : null;
+      return serializeStatus(status, { detectedReasoning, candidateModelId: candidate });
+    });
+    process.stdout.write(`${JSON.stringify({ targets: rows }, null, 2)}
+`);
+  } else if (filtered.length === 0) {
+    process.stdout.write(
+      "no targets configured. run `clio-coder configure` or `clio-coder targets add` to register one.\n"
+    );
+  } else {
+    renderTable(providers, filtered);
+  }
+  await loaded.stop();
+  return 0;
+}
+function parseUseArgs(args) {
+  const id = args[0];
+  if (!id) return null;
+  const parsed = { id };
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    const need = () => {
+      const value = args[i + 1];
+      if (!value) throw new Error(`${arg} requires a value`);
+      i += 1;
+      return value;
+    };
+    if (arg === "--model") {
+      parsed.model = need();
+      continue;
+    }
+    if (arg === "--orchestrator-model") {
+      parsed.orchestratorModel = need();
+      continue;
+    }
+    if (arg === "--background-model") {
+      parsed.backgroundModel = need();
+      continue;
+    }
+    if (arg === "--fleet-model" || arg === "--worker-model") {
+      parsed.workerModel = need();
+      continue;
+    }
+    if (arg === "--fleet-target" || arg === "--worker-target") {
+      parsed.workerTarget = need();
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown targets use argument: ${arg}`);
+  }
+  return parsed;
+}
+function runUse(args) {
+  if (wantsHelp(args)) return printUsage(USE_USAGE);
+  let parsed;
+  try {
+    parsed = parseUseArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed) {
+    printError(`usage: ${USE_USAGE}`);
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  const target = settings.targets.find((entry) => entry.id === parsed.id);
+  if (!target) {
+    printError(`no target with id ${parsed.id}`);
+    return 1;
+  }
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+  const runtime = registry.get(target.runtime);
+  if (!runtime) {
+    printError(
+      `cannot use target '${target.id}' as orchestrator target because runtime '${target.runtime}' is not registered`
+    );
+    return 1;
+  }
+  if (!isOrchestratorEligibleRuntime(runtime)) {
+    printError(
+      `cannot use target '${target.id}' as orchestrator target because runtime '${runtime.id}' is not an HTTP/native runtime`
+    );
+    return 1;
+  }
+  let workerTarget = target;
+  if (parsed.workerTarget !== void 0 && parsed.workerTarget !== target.id) {
+    const resolved = resolveDispatchProfileTarget(settings, parsed.workerTarget, "fleet worker target");
+    if ("exitCode" in resolved) return resolved.exitCode;
+    workerTarget = resolved.target;
+  }
+  const sharedModel = parsed.model ?? target.defaultModel ?? null;
+  const orchestratorModel = parsed.orchestratorModel ?? sharedModel;
+  const workerModel = parsed.workerModel ?? (workerTarget === target ? sharedModel : workerTarget.defaultModel ?? null);
+  const backgroundModel = parsed.backgroundModel;
+  updateSettings((fresh) => {
+    fresh.orchestrator.target = target.id;
+    fresh.orchestrator.model = orchestratorModel;
+    fresh.workers.default.target = workerTarget.id;
+    fresh.workers.default.model = workerModel;
+    if (backgroundModel !== void 0) {
+      fresh.background.target = target.id;
+      fresh.background.model = backgroundModel;
+    }
+  });
+  const dispatchWhere = workerTarget === target ? "" : ` and ${workerTarget.id} for fleet dispatch`;
+  const chatWhere = workerTarget === target ? "for chat and fleet dispatch" : "for chat";
+  printOk(
+    `using target ${target.id} ${chatWhere}${dispatchWhere}${backgroundModel === void 0 ? "" : ", and background memory"}`
+  );
+  return 0;
+}
+function parseWorkerArgs(args) {
+  const name = args[0];
+  const targetId = args[1];
+  if (!name || !targetId) return null;
+  const parsed = { name, targetId };
+  for (let i = 2; i < args.length; i += 1) {
+    const arg = args[i];
+    const need = () => {
+      const value = args[i + 1];
+      if (!value) throw new Error(`${arg} requires a value`);
+      i += 1;
+      return value;
+    };
+    if (arg === "--model") {
+      parsed.model = need();
+      continue;
+    }
+    if (arg === "--thinking") {
+      const value = need();
+      if (!VALID_THINKING.has(value)) {
+        throw new Error("--thinking must be one of: off|minimal|low|medium|high|xhigh|max");
+      }
+      parsed.thinkingLevel = value;
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown targets profile argument: ${arg}`);
+  }
+  return parsed;
+}
+function requireTrimmed(value, label) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0) throw new Error(`${label} must be non-empty`);
+  return trimmed;
+}
+function parseProfileRemoveArgs(args) {
+  const name = args[0];
+  if (!name) return null;
+  const parsed = { name: name.trim(), force: false };
+  if (parsed.name.length === 0) throw new Error("profile name must be non-empty");
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--force") {
+      parsed.force = true;
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown targets profile remove argument: ${arg}`);
+  }
+  return parsed;
+}
+function parseProfileRenameArgs(args) {
+  if (args.length !== 2) return null;
+  const oldName = requireTrimmed(args[0], "old profile name");
+  const newName = requireTrimmed(args[1], "new profile name");
+  return { oldName, newName };
+}
+function parseProfileBindArgs(args) {
+  if (args.length !== 2) return null;
+  return {
+    agentId: requireTrimmed(args[0], "agent id"),
+    profileName: requireTrimmed(args[1], "profile name")
+  };
+}
+function resolveDispatchProfileTarget(settings, targetId, role = "fleet profile target") {
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) {
+    printError(`no target with id ${targetId}`);
+    return { exitCode: 2 };
+  }
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+  const runtime = registry.get(target.runtime);
+  if (!runtime) {
+    printError(`cannot use target '${target.id}' as ${role} because runtime '${target.runtime}' is not registered`);
+    return { exitCode: 1 };
+  }
+  if (!isDispatchEligibleRuntime(runtime)) {
+    printError(
+      `cannot use target '${target.id}' as ${role} because runtime '${runtime.id}' is not a fleet-dispatch target`
+    );
+    return { exitCode: 1 };
+  }
+  return { target };
+}
+function runProfileSet(args, usage = "clio-coder targets profile <name> <id> [--model <id>] [--thinking <level>]") {
+  if (wantsHelp(args)) return printUsage(usage);
+  let parsed;
+  try {
+    parsed = parseWorkerArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed) {
+    printError(`usage: ${usage}`);
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  const resolved = resolveDispatchProfileTarget(settings, parsed.targetId);
+  if ("exitCode" in resolved) return resolved.exitCode;
+  const { target } = resolved;
+  const existing = settings.workers.profiles[parsed.name];
+  const profileName = parsed.name;
+  const profile = {
+    target: target.id,
+    model: parsed.model ?? target.defaultModel ?? null,
+    thinkingLevel: parsed.thinkingLevel ?? existing?.thinkingLevel ?? "off"
+  };
+  updateSettings((fresh) => {
+    fresh.workers.profiles[profileName] = profile;
+  });
+  printOk(`fleet profile ${parsed.name} -> ${target.id}`);
+  return 0;
+}
+function runProfileRemove(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets profile remove <name> [--force]");
+  let parsed;
+  try {
+    parsed = parseProfileRemoveArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed) {
+    printError("usage: clio-coder targets profile remove <name> [--force]");
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  if (!settings.workers.profiles[parsed.name]) {
+    printError(`no fleet profile named ${parsed.name}`);
+    return 1;
+  }
+  const boundAgents = Object.entries(settings.workers.agentBindings).filter(([, profileName]) => profileName === parsed.name).map(([agentId]) => agentId);
+  if (boundAgents.length > 0 && !parsed.force) {
+    printError(
+      `fleet profile ${parsed.name} is bound to ${boundAgents.length} agent${boundAgents.length === 1 ? "" : "s"}; use --force to remove profile and bindings`,
+      boundAgents.join(", ")
+    );
+    return 1;
+  }
+  let removedBindings = 0;
+  updateSettings((fresh) => {
+    delete fresh.workers.profiles[parsed.name];
+    for (const [agentId, profileName] of Object.entries(fresh.workers.agentBindings)) {
+      if (profileName !== parsed.name) continue;
+      delete fresh.workers.agentBindings[agentId];
+      removedBindings += 1;
+    }
+  });
+  printOk(
+    `removed fleet profile ${parsed.name} (${removedBindings} binding${removedBindings === 1 ? "" : "s"} removed)`
+  );
+  return 0;
+}
+function runProfileRename(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets profile rename <old> <new>");
+  let parsed;
+  try {
+    parsed = parseProfileRenameArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed) {
+    printError("usage: clio-coder targets profile rename <old> <new>");
+    return 2;
+  }
+  if (parsed.oldName === parsed.newName) {
+    printError("old and new profile names are identical");
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  if (!settings.workers.profiles[parsed.oldName]) {
+    printError(`no fleet profile named ${parsed.oldName}`);
+    return 1;
+  }
+  if (settings.workers.profiles[parsed.newName]) {
+    printError(`fleet profile already exists: ${parsed.newName}`);
+    return 2;
+  }
+  let updatedBindings = 0;
+  updateSettings((fresh) => {
+    const profile = fresh.workers.profiles[parsed.oldName];
+    if (!profile) return;
+    fresh.workers.profiles[parsed.newName] = profile;
+    delete fresh.workers.profiles[parsed.oldName];
+    for (const [agentId, profileName] of Object.entries(fresh.workers.agentBindings)) {
+      if (profileName !== parsed.oldName) continue;
+      fresh.workers.agentBindings[agentId] = parsed.newName;
+      updatedBindings += 1;
+    }
+  });
+  printOk(
+    `renamed fleet profile ${parsed.oldName} to ${parsed.newName} (${updatedBindings} binding${updatedBindings === 1 ? "" : "s"} updated)`
+  );
+  return 0;
+}
+function runProfileBind(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets profile bind <agentId> <profileName>");
+  let parsed;
+  try {
+    parsed = parseProfileBindArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (!parsed) {
+    printError("usage: clio-coder targets profile bind <agentId> <profileName>");
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  if (settings.delegation.agents.some((agent) => agent.id === parsed.agentId)) {
+    printError(
+      `cannot bind ACP delegation agent '${parsed.agentId}' to a fleet profile; ACP agents use their own runner and ignore native target routing`
+    );
+    return 1;
+  }
+  if (!settings.workers.profiles[parsed.profileName]) {
+    process.stderr.write(
+      `${chalk.yellow("warning:")} fleet profile '${parsed.profileName}' is not configured; binding will resolve after the profile exists
+`
+    );
+  }
+  updateSettings((fresh) => {
+    fresh.workers.agentBindings[parsed.agentId] = parsed.profileName;
+  });
+  printOk(`bound agent ${parsed.agentId} -> fleet profile ${parsed.profileName}`);
+  return 0;
+}
+function runProfileUnbind(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets profile unbind <agentId>");
+  let parsed;
+  try {
+    if (args.length !== 1) throw new Error("usage: clio-coder targets profile unbind <agentId>");
+    parsed = requireTrimmed(args[0], "agent id");
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  if (!settings.workers.agentBindings[parsed]) {
+    printError(`agent ${parsed} is not bound to a fleet profile`);
+    return 1;
+  }
+  updateSettings((fresh) => {
+    delete fresh.workers.agentBindings[parsed];
+  });
+  printOk(`unbound agent ${parsed}`);
+  return 0;
+}
+function runProfileBindings(args) {
+  let json = false;
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write("usage: clio-coder targets profile bindings [--json]\n");
+      return 0;
+    }
+    printError(`unknown targets profile bindings argument: ${arg}`);
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  const rows = Object.entries(settings.workers.agentBindings).sort(([a], [b]) => a.localeCompare(b)).map(([agentId, profileName]) => {
+    const profile = settings.workers.profiles[profileName];
+    return {
+      agentId,
+      profile: profileName,
+      target: profile?.target ?? null,
+      model: profile?.model ?? null,
+      warning: profile ? null : "missing profile"
+    };
+  });
+  if (json) {
+    process.stdout.write(`${JSON.stringify(rows, null, 2)}
+`);
+    return 0;
+  }
+  if (rows.length === 0) {
+    process.stdout.write(
+      "no agent profile bindings configured. run `clio-coder targets profile bind <agentId> <profile>` to add one.\n"
+    );
+    return 0;
+  }
+  process.stdout.write(
+    `${column("agent", 18)}${column("profile", 20)}${column("target", 16)}${column("model", 30)}warning
+`
+  );
+  for (const row of rows) {
+    process.stdout.write(
+      `${column(row.agentId, 18)}${column(row.profile, 20)}${column(row.target ?? "-", 16)}${column(row.model ?? "-", 30)}${row.warning ?? "-"}
+`
+    );
+  }
+  return 0;
+}
+function runProfile(args) {
+  const subcommand = args[0];
+  if (subcommand && PROFILE_SUBCOMMANDS.has(subcommand)) {
+    switch (subcommand) {
+      case "list":
+        return runFleet(args.slice(1), "clio-coder targets profile list [--json]");
+      case "set":
+        return runProfileSet(
+          args.slice(1),
+          "clio-coder targets profile set <name> <id> [--model <id>] [--thinking <level>]"
+        );
+      case "remove":
+        return runProfileRemove(args.slice(1));
+      case "rename":
+        return runProfileRename(args.slice(1));
+      case "bind":
+        return runProfileBind(args.slice(1));
+      case "unbind":
+        return runProfileUnbind(args.slice(1));
+      case "bindings":
+        return runProfileBindings(args.slice(1));
+    }
+  }
+  return runProfileSet(args);
+}
+function runFleet(args, usage = "clio-coder targets fleet [--json]") {
+  let json = false;
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write(`usage: ${usage}
+`);
+      return 0;
+    }
+    printError(`unknown targets fleet argument: ${arg}`);
+    return 2;
+  }
+  ensureClioState();
+  const settings = readSettings();
+  const byId = new Map(settings.targets.map((target) => [target.id, target]));
+  const rows = Object.entries(settings.workers.profiles).map(([name, profile]) => {
+    const target = profile.target ? byId.get(profile.target) : void 0;
+    return {
+      name,
+      target: profile.target,
+      runtime: target?.runtime ?? null,
+      model: profile.model,
+      thinkingLevel: profile.thinkingLevel
+    };
+  });
+  if (json) {
+    process.stdout.write(`${JSON.stringify(rows, null, 2)}
+`);
+    return 0;
+  }
+  if (rows.length === 0) {
+    process.stdout.write("no fleet profiles configured. run `clio-coder targets profile <name> <id>` to add one.\n");
+    return 0;
+  }
+  process.stdout.write(
+    `${column("profile", 18)}${column("target", 16)}${column("runtime", 20)}${column("model", 30)}thinking
+`
+  );
+  for (const row of rows) {
+    process.stdout.write(
+      `${column(row.name, 18)}${column(row.target ?? "-", 16)}${column(row.runtime ?? "-", 20)}${column(row.model ?? "-", 30)}${row.thinkingLevel}
+`
+    );
+  }
+  return 0;
+}
+function runRemove(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets remove <id>");
+  if (args.length !== 1 || !args[0]) {
+    printError("usage: clio-coder targets remove <id>");
+    return 2;
+  }
+  ensureClioState();
+  return runTargetRemove(args[0]);
+}
+function runRename(args) {
+  if (wantsHelp(args)) return printUsage("clio-coder targets rename <old> <new>");
+  if (args.length !== 2 || !args[0] || !args[1]) {
+    printError("usage: clio-coder targets rename <old> <new>");
+    return 2;
+  }
+  ensureClioState();
+  return runTargetRename(args[0], args[1]);
+}
+var CONVERT_USAGE = "clio-coder targets convert <id> --runtime <runtimeId>";
+function runConvert(args) {
+  if (wantsHelp(args)) return printUsage(CONVERT_USAGE);
+  const id = args[0];
+  if (!id || id.startsWith("-")) {
+    printError(`usage: ${CONVERT_USAGE}`);
+    return 2;
+  }
+  let runtimeId;
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--runtime") {
+      const value = args[i + 1];
+      if (!value) {
+        printError("--runtime requires a value");
+        return 2;
+      }
+      runtimeId = value;
+      i += 1;
+      continue;
+    }
+    printError(`unknown convert argument: ${arg}`);
+    return 2;
+  }
+  if (!runtimeId) {
+    printError("--runtime is required");
+    return 2;
+  }
+  ensureClioState();
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+  const runtime = registry.get(runtimeId);
+  if (!runtime) {
+    printError(`unknown runtime id: ${runtimeId} (run \`clio-coder configure --list\` to see registered runtimes)`);
+    return 2;
+  }
+  const settings = readSettings();
+  const target = settings.targets.find((entry) => entry.id === id);
+  if (!target) {
+    printError(`no target with id ${id}`);
+    return 1;
+  }
+  if (target.runtime === runtimeId) {
+    printOk(`target ${id} already uses runtime ${runtimeId}`);
+    return 0;
+  }
+  if (settings.orchestrator.target === id && !isOrchestratorEligibleRuntime(runtime)) {
+    printError(`cannot convert orchestrator target '${id}' to non-HTTP/native runtime '${runtime.id}'`);
+    return 1;
+  }
+  const previousRuntime = target.runtime;
+  updateSettings((fresh) => {
+    const entry = fresh.targets.find((candidate) => candidate.id === id);
+    if (entry) entry.runtime = runtimeId;
+  });
+  printOk(`converted target ${id}: ${previousRuntime} -> ${runtimeId}`);
+  return 0;
+}
+var TABLE_COLUMNS = [
+  "id",
+  "tier",
+  "runtime",
+  "auth",
+  "url",
+  "model",
+  "health",
+  "caps",
+  "notes"
+];
+var TABLE_GAP = 1;
+var TABLE_SHRINK_ORDER = [
+  ["notes", 16],
+  ["url", 12],
+  ["model", 12],
+  ["notes", 0],
+  ["auth", 6],
+  ["runtime", 6],
+  ["tier", 4]
+];
+var TABLE_GROW_ORDER = [
+  ["url", Number.POSITIVE_INFINITY],
+  ["model", Number.POSITIVE_INFINITY],
+  ["notes", 16],
+  ["auth", Number.POSITIVE_INFINITY],
+  ["runtime", Number.POSITIVE_INFINITY],
+  ["tier", Number.POSITIVE_INFINITY],
+  ["notes", Number.POSITIVE_INFINITY]
+];
+function tableWidths(rows, width) {
+  const natural = {};
+  for (const [index, key] of TABLE_COLUMNS.entries()) {
+    natural[key] = rows.reduce((widest, row) => Math.max(widest, row[key].length), (HEADER[index] ?? key).length);
+  }
+  const widths = { ...natural };
+  for (const [key, floor] of TABLE_SHRINK_ORDER) widths[key] = Math.min(widths[key], floor);
+  const total = () => TABLE_COLUMNS.reduce((sum, key) => sum + widths[key], 0) + TABLE_GAP * (TABLE_COLUMNS.length - 1);
+  let surplus = width - total();
+  for (const [key, ceiling] of TABLE_GROW_ORDER) {
+    if (surplus <= 0) break;
+    const take = Math.min(surplus, Math.max(0, Math.min(natural[key], ceiling) - widths[key]));
+    widths[key] += take;
+    surplus -= take;
+  }
+  return widths;
+}
+function formatTargetTable(rows, width, paintHealth = (cell) => cell) {
+  const widths = tableWidths(rows, width);
+  const line = (cells) => cells.join(" ".repeat(TABLE_GAP)).trimEnd();
+  return {
+    header: truncate(line(TABLE_COLUMNS.map((key, index) => column(HEADER[index] ?? key, widths[key]))), width),
+    rows: rows.map((row) => {
+      const cells = TABLE_COLUMNS.map((key) => column(row[key], widths[key]));
+      const plain = line(cells);
+      if (plain.length > width) return truncate(plain, width);
+      return line(cells.map((cell, index) => TABLE_COLUMNS[index] === "health" ? paintHealth(cell, row) : cell));
+    })
+  };
+}
+function renderTable(providers, entries) {
+  const sorted = [...entries].sort(compareStatusByTier);
+  const table = formatTargetTable(
+    sorted.map((status) => targetTableRow(providers, status)),
+    terminalColumns(),
+    // The cell is padded before it is painted, so the ansi bytes land outside
+    // the width arithmetic instead of having to be guessed at with slack.
+    (cell, row) => healthColor(row.health)(cell)
+  );
+  let currentTier = null;
+  for (const [index, status] of sorted.entries()) {
+    const tier = statusTier(status);
+    if (tier !== currentTier) {
+      currentTier = tier;
+      process.stdout.write(`${chalk.bold(tierLabel(tier))}
+`);
+      process.stdout.write(`${chalk.bold(table.header)}
+`);
+    }
+    process.stdout.write(`${table.rows[index] ?? ""}
+`);
+  }
+}
+function targetTableRow(providers, status) {
+  return {
+    id: status.target.id,
+    tier: statusTier(status),
+    runtime: status.runtime ? status.runtime.id : status.target.runtime,
+    auth: formatAuth(providers, status),
+    url: formatUrl(status),
+    model: status.target.defaultModel ?? "-",
+    health: status.health.status,
+    caps: capabilityBadges(status.capabilities),
+    notes: formatNotes(status)
+  };
+}
+function healthColor(status) {
+  switch (status) {
+    case "healthy":
+      return chalk.green;
+    case "degraded":
+      return chalk.yellow;
+    case "down":
+      return chalk.red;
+    default:
+      return chalk.dim;
+  }
+}
+function formatUrl(status) {
+  if (status.target.url) return status.target.url;
+  return "(built-in)";
+}
+function formatAuth(providers, status) {
+  if (!status.runtime) return "-";
+  if (status.runtime.auth !== "api-key" && status.runtime.auth !== "oauth") return status.runtime.auth;
+  const auth = providers.auth.statusForTarget(status.target, status.runtime);
+  if (!auth.available) return "disconnected";
+  if (auth.source === "environment") return auth.detail ? `env:${auth.detail}` : "environment";
+  return auth.source.replace("stored-", "");
+}
+function capabilityBadges(caps) {
+  const badge = (on, letter) => on ? letter : "-";
+  return [
+    badge(caps.chat, "C"),
+    badge(caps.tools, "T"),
+    badge(caps.reasoning, "R"),
+    badge(caps.vision, "V"),
+    badge(caps.embeddings, "E"),
+    badge(caps.rerank, "K"),
+    badge(caps.fim, "F")
+  ].join("");
+}
+function residentModelsSummary(states) {
+  if (!states) return null;
+  const entries = Object.entries(states);
+  if (entries.length === 0) return null;
+  const resident = entries.filter(([, status]) => status.state === "loaded" || status.state === "loading").map(([id, status]) => status.state === "loading" ? `${id} (loading)` : id);
+  return resident.length > 0 ? `resident: ${resident.join(", ")}` : "resident: none";
+}
+function formatContextWindow(status) {
+  const window = status.capabilities.contextWindow;
+  return status.contextWindowProvenance === "runtime-default" ? `ctx ${window} (unverified runtime default)` : `ctx ${window}`;
+}
+function formatNotes(status) {
+  const parts = [];
+  if (status.target.gateway) parts.push("gateway");
+  if (status.runtime?.auth === "oauth") parts.push("oauth");
+  if (status.runtime?.auth === "claude-cli") parts.push("claude-cli");
+  if (status.capabilities.contextWindow > 0) parts.push(formatContextWindow(status));
+  if (!status.available && status.reason) parts.push(status.reason);
+  const residency = residentModelsSummary(status.discoveredModelStates);
+  if (residency) parts.push(residency);
+  if (status.probeNotes && status.probeNotes.length > 0) parts.push(`note: ${status.probeNotes.join("; ")}`);
+  return parts.join(" ");
+}
+function statusTier(status) {
+  return status.runtime?.tier ?? "unknown";
+}
+function tierLabel(tier) {
+  switch (tier) {
+    case "protocol":
+      return "Protocol";
+    case "cloud":
+      return "Cloud";
+    case "subscription":
+      return "Subscription";
+    case "local-native":
+      return "Local native";
+    case "unknown":
+      return "Unknown";
+  }
+}
+function tierRank(tier) {
+  switch (tier) {
+    case "protocol":
+      return 0;
+    case "cloud":
+      return 1;
+    case "subscription":
+      return 2;
+    case "local-native":
+      return 3;
+    case "unknown":
+      return 4;
+  }
+}
+function compareStatusByTier(a, b) {
+  return tierRank(statusTier(a)) - tierRank(statusTier(b)) || a.target.id.localeCompare(b.target.id) || a.target.runtime.localeCompare(b.target.runtime);
+}
+function serializeStatus(status, extras = {
+  detectedReasoning: null,
+  candidateModelId: null
+}) {
+  const out = {
+    target: status.target,
+    runtime: status.runtime,
+    available: status.available,
+    reason: status.reason,
+    health: status.health,
+    capabilities: status.capabilities,
+    discoveredModels: status.discoveredModels,
+    tier: statusTier(status),
+    detectedReasoning: extras.detectedReasoning,
+    reasoningCandidateModelId: extras.candidateModelId
+  };
+  if (status.contextWindowProvenance !== void 0) {
+    out.contextWindowProvenance = status.contextWindowProvenance;
+  }
+  if (status.discoveredModelsSource !== void 0) {
+    out.discoveredModelsSource = status.discoveredModelsSource;
+  }
+  if (status.discoveredModelStates !== void 0) {
+    out.discoveredModelStates = status.discoveredModelStates;
+  }
+  if (status.probeCapabilities !== void 0) {
+    out.probeCapabilities = status.probeCapabilities;
+  }
+  if (status.probeModelId !== void 0) {
+    out.probeModelId = status.probeModelId;
+  }
+  if (status.probeNotes !== void 0) {
+    out.probeNotes = status.probeNotes;
+  }
+  return out;
+}
+export {
+  formatContextWindow,
+  formatTargetTable,
+  residentModelsSummary,
+  runTargetsCommand
+};
+//# sourceMappingURL=targets-DZMEZAH4.js.map