@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/targets-AJWA6E7Z.js

@@ -0,0 +1,1207 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  resolveSupportedWireModels,
+  runConfigureCommand,
+  runTargetRemove,
+  runTargetRename
+} from "./chunk-EX57VVWW.js";
+import "./chunk-HSQQFDB3.js";
+import "./chunk-LK2FN5JY.js";
+import "./chunk-N24R6KWS.js";
+import {
+  column,
+  terminalColumns,
+  truncate,
+  wrapPlain
+} from "./chunk-ZIDFQJRB.js";
+import "./chunk-R2CT5YDO.js";
+import "./chunk-4VDHLCF5.js";
+import "./chunk-HOYZUKG7.js";
+import "./chunk-QHSBROEW.js";
+import "./chunk-NASYVWDB.js";
+import "./chunk-IN7DGBVS.js";
+import {
+  ensureClioState
+} from "./chunk-NOCSM22Y.js";
+import "./chunk-KW5HXKLJ.js";
+import "./chunk-URCXX7WJ.js";
+import "./chunk-U26XXPJS.js";
+import "./chunk-T2MDZES3.js";
+import "./chunk-4A6YRGV4.js";
+import "./chunk-UCINIRHW.js";
+import "./chunk-GGPF6LLE.js";
+import "./chunk-VOYUCAQF.js";
+import "./chunk-GGWI3OVM.js";
+import "./chunk-LJRBX7QR.js";
+import {
+  ConfigDomainModule
+} from "./chunk-JPXLJSGR.js";
+import "./chunk-3UW3KU4A.js";
+import "./chunk-GN7QBEEI.js";
+import "./chunk-E6IPKW2E.js";
+import "./chunk-XMDBTYCH.js";
+import "./chunk-TKDRT2DF.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-ZU4JPCPR.js";
+import "./chunk-SD7SHNDW.js";
+import {
+  printError,
+  printOk
+} from "./chunk-NBXFPI7U.js";
+import {
+  source_default
+} from "./chunk-SQZHXUB3.js";
+import "./chunk-ZARZ4POR.js";
+import "./chunk-UX2L5CUD.js";
+import "./chunk-LAR7DX5E.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-CDQ2UC6W.js";
+import "./chunk-5LP5FNNR.js";
+import "./chunk-NVPXXW2H.js";
+import "./chunk-ZNUZ3EXD.js";
+import "./chunk-DOUISWEE.js";
+import "./chunk-VKHLUZNO.js";
+import "./chunk-7QXCO3AF.js";
+import "./chunk-T33IYTZM.js";
+import "./chunk-BRCOSE7O.js";
+import "./chunk-DE2LU267.js";
+import "./chunk-733ZBT5P.js";
+import "./chunk-6CTHLZFB.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-X6FLVUM5.js";
+import {
+  ProvidersDomainModule
+} from "./chunk-EYTLV3W3.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-DVTBERFY.js";
+import {
+  isDispatchEligibleRuntime,
+  isOrchestratorEligibleRuntime
+} from "./chunk-6EJYVCTN.js";
+import {
+  endpointCapacityForStatus
+} from "./chunk-W53XSRQE.js";
+import "./chunk-6W75D37F.js";
+import {
+  registerBuiltinRuntimes
+} from "./chunk-77DCC6JZ.js";
+import "./chunk-SYF7FVBL.js";
+import "./chunk-Z4GLJ6J4.js";
+import "./chunk-VNBICSS2.js";
+import {
+  closestRuntimeId,
+  getRuntimeRegistry
+} from "./chunk-2WVPJF3Z.js";
+import "./chunk-27YTM2CV.js";
+import "./chunk-L7G7K4I2.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-I4Y4WKZR.js";
+import "./chunk-UZVYEF57.js";
+import "./chunk-EKV4UBCM.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-LNOXCGN2.js";
+import "./chunk-BJH6WFIB.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-VYRQHORQ.js";
+import "./chunk-P4GNZPXO.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-V4XJWDHR.js";
+import {
+  bindAgentProfileInSettings,
+  readSettings,
+  removeFleetProfileFromSettings,
+  setFleetProfileInSettings,
+  updateSettings,
+  useTargetInSettings
+} from "./chunk-56XP4FJU.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-QZTTRSJE.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import {
+  warnLegacyNaming
+} from "./chunk-O63U2I6I.js";
+import "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-53OXPRI6.js";
+import "./chunk-2EMLKSCX.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-2VLYHHFT.js";
+import "./chunk-3JHUFKG7.js";
+import "./chunk-ZPST2KQO.js";
+import {
+  loadDomains
+} from "./chunk-L4APUGCT.js";
+import "./chunk-DCGHJQ2U.js";
+import "./chunk-JQCLXSFI.js";
+import "./chunk-PS6JAWJZ.js";
+import "./chunk-FD2I4KBR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/targets.ts
+init_esm_shims();
+var HEADER = ["id", "tier", "runtime", "auth", "url", "model", "health", "caps", "notes"];
+var HELP = `clio-coder targets
+
+List and manage configured model targets.
+--reasoning and --tools opt into generating qualification and can load models.
+
+Usage:
+  clio-coder targets [--json] [--probe [--reasoning] [--tools [--tools-timeout <seconds>]]] [--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>
+`;
+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, reasoning: false, tools: 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 === "--reasoning") {
+      parsed.reasoning = true;
+      continue;
+    }
+    if (arg === "--tools") {
+      parsed.tools = true;
+      continue;
+    }
+    if (arg === "--tools-timeout") {
+      const value = args[i + 1];
+      const seconds = value === void 0 ? Number.NaN : Number(value);
+      if (!Number.isFinite(seconds) || seconds <= 0)
+        throw new Error("--tools-timeout requires a positive number of seconds");
+      parsed.toolsTimeoutMs = Math.round(seconds * 1e3);
+      i += 1;
+      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}`);
+  }
+  if (parsed.reasoning && !parsed.probe) throw new Error("--reasoning requires --probe");
+  if (parsed.tools && !parsed.probe) throw new Error("--tools requires --probe");
+  if (parsed.toolsTimeoutMs !== void 0 && !parsed.tools) throw new Error("--tools-timeout requires --tools");
+  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 {
+      const probeOptions = {
+        reasoning: parsed.reasoning,
+        tools: parsed.tools,
+        ...parsed.toolsTimeoutMs !== void 0 ? { toolsTimeoutMs: parsed.toolsTimeoutMs } : {}
+      };
+      if (parsed.target !== void 0) await providers.probeTarget(parsed.target, probeOptions);
+      else await providers.probeAllLive(probeOptions);
+    } 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.chat?.target === status.target.id ? settings.chat?.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") {
+      parsed.workerModel = need();
+      continue;
+    }
+    if (arg === "--fleet-target") {
+      parsed.workerTarget = need();
+      continue;
+    }
+    if (arg?.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown targets use argument: ${arg}`);
+  }
+  return parsed;
+}
+async 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 options = {
+    ...parsed.model !== void 0 ? { model: parsed.model } : {},
+    ...parsed.orchestratorModel !== void 0 ? { orchestratorModel: parsed.orchestratorModel } : {},
+    ...parsed.workerModel !== void 0 ? { workerModel: parsed.workerModel } : {},
+    ...parsed.workerTarget !== void 0 ? { workerTargetId: parsed.workerTarget } : {},
+    ...parsed.backgroundModel !== void 0 ? { backgroundModel: parsed.backgroundModel } : {}
+  };
+  const candidate = structuredClone(settings);
+  const selection = useTargetInSettings(candidate, target.id, options);
+  if (!selection) {
+    printError(`no target with id ${parsed.workerTarget}`);
+    return 1;
+  }
+  const labels = {
+    chat: "chat",
+    fleet: "fleet dispatch",
+    memory: "background memory"
+  };
+  const routes = { chat: candidate.chat, fleet: candidate.fleet.default, memory: candidate.context.memory };
+  const inventories = /* @__PURE__ */ new Map();
+  const checkedTargets = /* @__PURE__ */ new Map();
+  for (const role of selection.roles) {
+    const route = routes[role];
+    const selectedTarget = candidate.targets.find((entry) => entry.id === route.target);
+    if (!selectedTarget) throw new Error("selected target disappeared");
+    const runtime = registry.get(selectedTarget.runtime);
+    if (!runtime || !(role === "fleet" ? isDispatchEligibleRuntime(runtime) : isOrchestratorEligibleRuntime(runtime))) {
+      printError(
+        `cannot use target '${selectedTarget.id}' for ${labels[role]}: runtime '${selectedTarget.runtime}' is not eligible`
+      );
+      return 1;
+    }
+    checkedTargets.set(selectedTarget.id, JSON.stringify(selectedTarget));
+    if (route.model === null) continue;
+    let inventory = inventories.get(selectedTarget.id);
+    if (!inventory) {
+      inventory = await resolveSupportedWireModels(runtime, selectedTarget, selectedTarget);
+      inventories.set(selectedTarget.id, inventory);
+    }
+    if (inventory.models.length > 0 && !inventory.models.includes(route.model)) {
+      printError(
+        `target '${selectedTarget.id}' does not list model '${route.model}' for ${labels[role]} (${inventory.source} inventory). Use an exact listed model id: ${inventory.models.slice(0, 10).join(", ")}`
+      );
+      return 1;
+    }
+    if (inventory.models.length === 0) {
+      process.stderr.write(
+        `warning: could not verify model '${route.model}' for ${labels[role]}: target '${selectedTarget.id}' returned no model list; saving the id as written
+`
+      );
+    } else if (inventory.source === "cache" || inventory.source === "legacy") {
+      process.stderr.write(
+        `warning: using ${inventory.source} model inventory for target '${selectedTarget.id}'; live availability was not verified
+`
+      );
+    }
+  }
+  let changedRoles = [];
+  try {
+    updateSettings((fresh) => {
+      for (const [id, descriptor] of checkedTargets) {
+        if (JSON.stringify(fresh.targets.find((entry) => entry.id === id)) !== descriptor) {
+          throw new Error(`target '${id}' changed while checking models; retry targets use`);
+        }
+      }
+      const applied = useTargetInSettings(fresh, target.id, options);
+      if (!applied) throw new Error("target changed while checking models; retry targets use");
+      changedRoles = applied.changedRoles;
+    });
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const changedByTarget = /* @__PURE__ */ new Map();
+  for (const role of changedRoles) {
+    const id = routes[role].target;
+    const names = changedByTarget.get(id) ?? [];
+    names.push(labels[role]);
+    changedByTarget.set(id, names);
+  }
+  printOk(
+    changedRoles.length === 0 ? "no role settings changed" : `using ${[...changedByTarget].map(([id, names]) => `target ${id} for ${names.join(" and ")}`).join("; ")}`
+  );
+  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;
+  updateSettings((fresh) => {
+    setFleetProfileInSettings(fresh, parsed.name, target.id, {
+      ...parsed.model !== void 0 ? { model: parsed.model } : {},
+      ...parsed.thinkingLevel !== void 0 ? { thinkingLevel: parsed.thinkingLevel } : {}
+    });
+  });
+  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.fleet.profiles[parsed.name]) {
+    printError(`no fleet profile named ${parsed.name}`);
+    return 1;
+  }
+  const boundAgents = Object.entries(settings.fleet.agentProfiles).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) => {
+    removedBindings = removeFleetProfileFromSettings(fresh, parsed.name);
+  });
+  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.fleet.profiles[parsed.oldName]) {
+    printError(`no fleet profile named ${parsed.oldName}`);
+    return 1;
+  }
+  if (settings.fleet.profiles[parsed.newName]) {
+    printError(`fleet profile already exists: ${parsed.newName}`);
+    return 2;
+  }
+  let updatedBindings = 0;
+  updateSettings((fresh) => {
+    const profile = fresh.fleet.profiles[parsed.oldName];
+    if (!profile) return;
+    fresh.fleet.profiles[parsed.newName] = profile;
+    delete fresh.fleet.profiles[parsed.oldName];
+    for (const [agentId, profileName] of Object.entries(fresh.fleet.agentProfiles)) {
+      if (profileName !== parsed.oldName) continue;
+      fresh.fleet.agentProfiles[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.integrations.externalAgents.entries.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.fleet.profiles[parsed.profileName]) {
+    process.stderr.write(
+      `${source_default.yellow("warning:")} fleet profile '${parsed.profileName}' is not configured; binding will resolve after the profile exists
+`
+    );
+  }
+  updateSettings((fresh) => {
+    bindAgentProfileInSettings(fresh, 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.fleet.agentProfiles[parsed]) {
+    printError(`agent ${parsed} is not bound to a fleet profile`);
+    return 1;
+  }
+  updateSettings((fresh) => {
+    delete fresh.fleet.agentProfiles[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.fleet.agentProfiles).sort(([a], [b]) => a.localeCompare(b)).map(([agentId, profileName]) => {
+    const profile = settings.fleet.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.fleet.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) {
+    const suggestion = closestRuntimeId(registry, runtimeId);
+    printError(
+      `unknown runtime id: ${runtimeId}${suggestion ? ` (did you mean '${suggestion}'?)` : ""} (run \`clio-coder configure --list\` to see registered runtimes)`
+    );
+    return 2;
+  }
+  if (runtimeId !== runtime.id) {
+    warnLegacyNaming(runtimeId, runtime.id);
+    runtimeId = runtime.id;
+  }
+  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.chat.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();
+  const formatted = rows.map((row) => {
+    const cells = TABLE_COLUMNS.map((key) => column(row[key], widths[key]));
+    const plain = line(cells);
+    const rendered = plain.length > width ? truncate(plain, width) : line(cells.map((cell, index) => TABLE_COLUMNS[index] === "health" ? paintHealth(cell, row) : cell));
+    const diagnosticFits = !row.diagnostic || plain.length <= width && widths.notes >= row.diagnostic.length;
+    const details = diagnosticFits ? [] : targetDiagnosticDetails(row.diagnostic ?? "", width);
+    return { rendered, details };
+  });
+  return {
+    header: truncate(line(TABLE_COLUMNS.map((key, index) => column(HEADER[index] ?? key, widths[key]))), width),
+    rows: formatted.map(({ rendered }) => rendered),
+    details: formatted.map(({ details }) => details)
+  };
+}
+function targetDiagnosticDetails(diagnostic, width) {
+  const indent = 2;
+  return wrapPlain(`reason: ${diagnostic}`, Math.max(8, width - indent), indent).map(
+    (line, index) => index === 0 ? `${" ".repeat(indent)}${line}` : line
+  );
+}
+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(`${source_default.bold(tierLabel(tier))}
+`);
+      process.stdout.write(`${source_default.bold(table.header)}
+`);
+    }
+    process.stdout.write(`${table.rows[index] ?? ""}
+`);
+    for (const detail of table.details[index] ?? []) process.stdout.write(`${detail}
+`);
+  }
+}
+function targetTableRow(providers, status) {
+  const diagnostic = degradedHealthDiagnostic(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),
+    ...diagnostic ? { diagnostic } : {}
+  };
+}
+function healthColor(status) {
+  switch (status) {
+    case "healthy":
+      return source_default.green;
+    case "degraded":
+      return source_default.yellow;
+    case "down":
+      return source_default.red;
+    default:
+      return source_default.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.externalAgentLoop !== void 0 && status.runtime.auth !== "claude-cli") return "operator session";
+  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;
+  const modelState = status.target?.defaultModel ? status.discoveredModelStates?.[status.target.defaultModel] : void 0;
+  const serving = modelState?.contextLength;
+  const requested = status.target ? status.runtime?.requestedContextWindow?.(status.target) : void 0;
+  if (requested !== void 0) {
+    const known = status.contextWindowProvenance !== "runtime-default";
+    const planned = known ? Math.min(requested, window) : requested;
+    const bounds = ["num_ctx", ...serving !== void 0 && serving !== planned ? [`serving ${serving}`] : []];
+    if (known && window !== planned) bounds.push(`model max ${window}`);
+    return `ctx ${planned} (${bounds.join("; ")})`;
+  }
+  if (serving !== void 0 && serving > 0) {
+    if (status.contextWindowProvenance === "configured" && window < serving) return `ctx ${window} (serving ${serving})`;
+    if (status.contextWindowProvenance === "runtime-default" || window === serving) return `ctx ${serving} (serving)`;
+    return `ctx ${serving} (serving; model max ${window})`;
+  }
+  if (status.contextWindowProvenance === "runtime-default") return `ctx ${window} (unverified runtime default)`;
+  const cold = status.runtime?.coldContextWindowCap;
+  if (cold !== void 0 && status.contextWindowProvenance !== "configured" && window > cold) {
+    return `ctx ${cold} (cold; model max ${window})`;
+  }
+  const slots = modelState?.contextSlots;
+  return slots && Math.floor(slots.totalContextSize / slots.slots) === window ? `ctx ${window} (${slots.totalContextSize} / ${slots.slots} slots)` : `ctx ${window}`;
+}
+function formatNotes(status) {
+  const parts = [];
+  const diagnostic = degradedHealthDiagnostic(status);
+  if (diagnostic) parts.push(diagnostic);
+  const endpoint = endpointCapacityForStatus(status);
+  if (endpoint) parts.push(`slots ${endpoint.limit}`);
+  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("; ")}`);
+  const tools = formatToolProbe(status.toolProbe);
+  if (tools) parts.push(tools);
+  return parts.join(" ");
+}
+function formatToolProbe(probe) {
+  if (!probe) return null;
+  const model = probe.modelId ?? "no model";
+  if (probe.status === "verified") return `tools verified (${model}, ${probe.latencyMs}ms)`;
+  return `tools ${probe.status} (${model}): ${probe.error ?? "unknown error"}`;
+}
+function degradedHealthDiagnostic(status) {
+  return status.health.status === "degraded" && status.health.lastError ? status.health.lastError : null;
+}
+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.discoveredModelLabels !== void 0) out.discoveredModelLabels = status.discoveredModelLabels;
+  const endpointCapacity = endpointCapacityForStatus(status);
+  if (endpointCapacity !== null) out.endpointCapacity = endpointCapacity;
+  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;
+  }
+  if (status.probeSurfaces !== void 0) {
+    out.probeSurfaces = status.probeSurfaces;
+  }
+  if (status.toolProbe !== void 0) {
+    out.toolProbe = status.toolProbe;
+  }
+  return out;
+}
+export {
+  runTargetsCommand
+};
+//# sourceMappingURL=targets-AJWA6E7Z.js.map