diff --git a/bin/cli/commands/combo.mjs b/bin/cli/commands/combo.mjs
index d2a156bedc..9c786eb31e 100644
--- a/bin/cli/commands/combo.mjs
+++ b/bin/cli/commands/combo.mjs
@@ -2,6 +2,8 @@ import { Option } from "commander";
 import { printHeading } from "../io.mjs";
 import { withRuntime } from "../runtime.mjs";
 import { t } from "../i18n.mjs";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
 
 const VALID_STRATEGIES = [
   "priority",
@@ -20,6 +22,79 @@ const VALID_STRATEGIES = [
   "reset-aware",
 ];
 
+const suggestSchema = [
+  { key: "rank", header: "#" },
+  { key: "name", header: "Combo", width: 24 },
+  { key: "strategy", header: "Strategy", width: 16 },
+  { key: "score", header: "Score", formatter: (v) => (v != null ? v.toFixed(3) : "-") },
+  { key: "latencyP50Ms", header: "Latency P50", formatter: (v) => (v != null ? `${v}ms` : "-") },
+  { key: "costPer1k", header: "Cost/1k", formatter: (v) => (v != null ? `$${v.toFixed(5)}` : "-") },
+  {
+    key: "rationale",
+    header: "Rationale",
+    width: 40,
+    formatter: (v) => {
+      if (!v) return "-";
+      const s = String(v);
+      return s.length > 40 ? s.slice(0, 39) + "…" : s;
+    },
+  },
+];
+
+export function extendComboSuggest(combo) {
+  combo
+    .command("suggest")
+    .description(t("combo.suggest.description"))
+    .requiredOption("--task <description>", t("combo.suggest.task"))
+    .option("--max-cost <usd>", t("combo.suggest.maxCost"), parseFloat)
+    .option("--max-latency-ms <ms>", t("combo.suggest.maxLatencyMs"), parseInt)
+    .option("--weights <json>", t("combo.suggest.weights"))
+    .option("--top <n>", t("combo.suggest.top"), parseInt, 5)
+    .option("--explain", t("combo.suggest.explain"))
+    .option("--switch", t("combo.suggest.switch"))
+    .action(async (opts, cmd) => {
+      const body = {
+        task: opts.task,
+        constraints: {
+          maxCostUsd: opts.maxCost,
+          maxLatencyMs: opts.maxLatencyMs,
+        },
+        weights: opts.weights ? JSON.parse(opts.weights) : undefined,
+        top: opts.top,
+      };
+      const res = await apiFetch("/api/mcp/tools/call", {
+        method: "POST",
+        body: { name: "omniroute_best_combo_for_task", arguments: body },
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const candidates = data.candidates ?? data;
+      const rows = (Array.isArray(candidates) ? candidates : []).map((c, i) => ({
+        rank: i + 1,
+        ...c,
+      }));
+      emit(rows, cmd.optsWithGlobals(), suggestSchema);
+      if (opts.explain && !cmd.optsWithGlobals().quiet) {
+        process.stderr.write(`\nRationale:\n${data.rationale ?? "(no rationale)"}\n`);
+      }
+      if (opts.switch && rows[0]) {
+        const best = rows[0].name;
+        const switchRes = await apiFetch("/api/combos/switch", {
+          method: "POST",
+          body: { name: best },
+        });
+        if (!switchRes.ok) {
+          process.stderr.write(`Switch failed: ${switchRes.status}\n`);
+          process.exit(1);
+        }
+        process.stderr.write(`\nSwitched to: ${best}\n`);
+      }
+    });
+}
+
 export function registerCombo(program) {
   const combo = program.command("combo").description(t("combo.title"));
 
@@ -68,6 +143,8 @@ export function registerCombo(program) {
       const exitCode = await runComboDeleteCommand(name, { ...opts, output: globalOpts.output });
       if (exitCode !== 0) process.exit(exitCode);
     });
+
+  extendComboSuggest(combo);
 }
 
 export async function runComboListCommand(opts = {}) {
diff --git a/bin/cli/commands/context-eng.mjs b/bin/cli/commands/context-eng.mjs
new file mode 100644
index 0000000000..7651cf37ea
--- /dev/null
+++ b/bin/cli/commands/context-eng.mjs
@@ -0,0 +1,182 @@
+import { readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+async function confirm(q) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${q} [y/N] `, (a) => {
+      rl.close();
+      resolve(a.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+export function registerContextEng(program) {
+  const ctx = program.command("context-eng").alias("ctx").description(t("context.description"));
+
+  ctx
+    .command("analytics")
+    .option("--period <p>", t("context.analytics.period"), "7d")
+    .action(async (opts, cmd) => {
+      const res = await apiFetch(`/api/context/analytics?period=${opts.period}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  const caveman = ctx.command("caveman").description(t("context.caveman.description"));
+  const cmCfg = caveman.command("config").description(t("context.caveman.config.description"));
+
+  cmCfg.command("show").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/context/caveman/config");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  cmCfg
+    .command("set")
+    .option("--aggressiveness <n>", t("context.caveman.config.aggressiveness"), parseFloat)
+    .option("--max-shrink-pct <n>", t("context.caveman.config.maxShrinkPct"), parseInt)
+    .option("--preserve-tags <list>", t("context.caveman.config.preserveTags"), (v) => v.split(","))
+    .action(async (opts, cmd) => {
+      const body = {};
+      if (opts.aggressiveness !== undefined) body.aggressiveness = opts.aggressiveness;
+      if (opts.maxShrinkPct !== undefined) body.maxShrinkPct = opts.maxShrinkPct;
+      if (opts.preserveTags) body.preserveTags = opts.preserveTags;
+      const res = await apiFetch("/api/context/caveman/config", { method: "PUT", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  const rtk = ctx.command("rtk").description(t("context.rtk.description"));
+  const rtkCfg = rtk.command("config").description(t("context.rtk.config.description"));
+
+  rtkCfg.command("show").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/context/rtk/config");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  rtkCfg
+    .command("set")
+    .option("--token-budget <n>", t("context.rtk.config.tokenBudget"), parseInt)
+    .option("--reserve-pct <n>", t("context.rtk.config.reservePct"), parseInt)
+    .action(async (opts, cmd) => {
+      const body = {};
+      if (opts.tokenBudget) body.tokenBudget = opts.tokenBudget;
+      if (opts.reservePct) body.reservePct = opts.reservePct;
+      const res = await apiFetch("/api/context/rtk/config", { method: "PUT", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  const filters = rtk.command("filters").description(t("context.rtk.filters.description"));
+
+  filters.command("list").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/context/rtk/filters");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  filters
+    .command("add")
+    .requiredOption("--pattern <p>", t("context.rtk.filters.pattern"))
+    .option("--priority <n>", t("context.rtk.filters.priority"), parseInt, 100)
+    .option("--action <a>", t("context.rtk.filters.action"), "drop")
+    .action(async (opts, cmd) => {
+      const body = { pattern: opts.pattern, priority: opts.priority, action: opts.action };
+      const res = await apiFetch("/api/context/rtk/filters", { method: "POST", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  filters
+    .command("remove <id>")
+    .option("--yes", t("context.rtk.filters.yes"))
+    .action(async (id, opts, cmd) => {
+      if (!opts.yes) {
+        const ok = await confirm(`Remove filter ${id}?`);
+        if (!ok) return;
+      }
+      const res = await apiFetch(`/api/context/rtk/filters/${id}`, { method: "DELETE" });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write("Removed\n");
+    });
+
+  rtk
+    .command("test")
+    .requiredOption("--file <path>", t("context.rtk.test.file"))
+    .action(async (opts, cmd) => {
+      const body = JSON.parse(readFileSync(opts.file, "utf8"));
+      const res = await apiFetch("/api/context/rtk/test", { method: "POST", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  rtk.command("raw-output <id>").action(async (id, opts, cmd) => {
+    const res = await apiFetch(`/api/context/rtk/raw-output/${id}`);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  const combos = ctx.command("combos").description(t("context.combos.description"));
+
+  combos.command("list").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/context/combos");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  combos.command("get <id>").action(async (id, opts, cmd) => {
+    const res = await apiFetch(`/api/context/combos/${id}`);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  combos.command("assignments <id>").action(async (id, opts, cmd) => {
+    const res = await apiFetch(`/api/context/combos/${id}/assignments`);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+}
diff --git a/bin/cli/commands/oneproxy.mjs b/bin/cli/commands/oneproxy.mjs
new file mode 100644
index 0000000000..e75c68ac20
--- /dev/null
+++ b/bin/cli/commands/oneproxy.mjs
@@ -0,0 +1,120 @@
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function fmtTs(v) {
+  if (!v) return "-";
+  return new Date(typeof v === "number" ? v * 1000 : v).toLocaleString();
+}
+
+async function mcpCall(name, args) {
+  const res = await apiFetch("/api/mcp/tools/call", {
+    method: "POST",
+    body: { name, arguments: args },
+  });
+  if (!res.ok) {
+    process.stderr.write(`MCP error: ${res.status}\n`);
+    process.exit(1);
+  }
+  return res.json();
+}
+
+const proxySchema = [
+  { key: "host", header: "Host", width: 35 },
+  { key: "type", header: "Type", width: 8 },
+  { key: "region", header: "Region" },
+  { key: "latencyMs", header: "Latency", formatter: (v) => (v ? `${v}ms` : "-") },
+  {
+    key: "successRate",
+    header: "Success%",
+    formatter: (v) => (v ? `${(v * 100).toFixed(0)}%` : "-"),
+  },
+  { key: "lastUsed", header: "Last Used", formatter: fmtTs },
+  { key: "state", header: "State" },
+];
+
+export function registerOneProxy(program) {
+  const op = program.command("oneproxy").description(t("oneproxy.description"));
+
+  op.command("status").action(async (opts, cmd) => {
+    const data = await mcpCall("omniroute_oneproxy_stats", {});
+    emit(data, cmd.optsWithGlobals());
+  });
+
+  op.command("stats")
+    .option("--provider <p>", t("oneproxy.stats.provider"))
+    .option("--period <p>", t("oneproxy.stats.period"), "24h")
+    .action(async (opts, cmd) => {
+      const data = await mcpCall("omniroute_oneproxy_stats", {
+        provider: opts.provider,
+        period: opts.period,
+      });
+      emit(data, cmd.optsWithGlobals());
+    });
+
+  op.command("fetch")
+    .description(t("oneproxy.fetch.description"))
+    .option("--count <n>", t("oneproxy.fetch.count"), parseInt, 1)
+    .option("--type <t>", t("oneproxy.fetch.type"), "http")
+    .action(async (opts, cmd) => {
+      const data = await mcpCall("omniroute_oneproxy_fetch", {
+        count: opts.count,
+        type: opts.type,
+      });
+      emit(data.proxies ?? data, cmd.optsWithGlobals(), proxySchema);
+    });
+
+  op.command("rotate")
+    .description(t("oneproxy.rotate.description"))
+    .option("--provider <p>", t("oneproxy.rotate.provider"))
+    .option("--connection-id <id>", t("oneproxy.rotate.connectionId"))
+    .action(async (opts, cmd) => {
+      const data = await mcpCall("omniroute_oneproxy_rotate", {
+        provider: opts.provider,
+        connectionId: opts.connectionId,
+      });
+      emit(data, cmd.optsWithGlobals());
+    });
+
+  const config = op.command("config").description(t("oneproxy.config.description"));
+
+  config.command("show").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/settings/oneproxy");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  config
+    .command("set")
+    .option("--enabled <b>", t("oneproxy.config.enabled"), (v) => v === "true")
+    .option("--pool-size <n>", t("oneproxy.config.poolSize"), parseInt)
+    .option("--provider-source <url>", t("oneproxy.config.providerSource"))
+    .option("--rotation-policy <p>", t("oneproxy.config.rotationPolicy"))
+    .action(async (opts, cmd) => {
+      const body = {};
+      for (const k of ["enabled", "poolSize", "providerSource", "rotationPolicy"]) {
+        if (opts[k] !== undefined) body[k] = opts[k];
+      }
+      const res = await apiFetch("/api/settings/oneproxy", { method: "PUT", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  op.command("pool")
+    .description(t("oneproxy.pool.description"))
+    .action(async (opts, cmd) => {
+      const res = await apiFetch("/api/settings/oneproxy?include=pool");
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      emit(data.pool ?? data, cmd.optsWithGlobals(), proxySchema);
+    });
+}
diff --git a/bin/cli/commands/openapi.mjs b/bin/cli/commands/openapi.mjs
new file mode 100644
index 0000000000..443a0910bb
--- /dev/null
+++ b/bin/cli/commands/openapi.mjs
@@ -0,0 +1,168 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function truncate(v, max = 40) {
+  if (!v) return "-";
+  const s = String(v);
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+function toYaml(obj, indent = 0) {
+  const pad = "  ".repeat(indent);
+  if (obj === null || obj === undefined) return "null";
+  if (typeof obj === "boolean") return String(obj);
+  if (typeof obj === "number") return String(obj);
+  if (typeof obj === "string") {
+    if (/[\n:#{}[\],&*?|<>=!%@`]/.test(obj) || obj.trim() !== obj) {
+      return JSON.stringify(obj);
+    }
+    return obj || '""';
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return obj.map((v) => `\n${pad}- ${toYaml(v, indent + 1)}`).join("");
+  }
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "{}";
+  return entries
+    .map(([k, v]) => {
+      const safeKey = /[^a-zA-Z0-9_-]/.test(k) ? JSON.stringify(k) : k;
+      if (v !== null && typeof v === "object") {
+        const nested = toYaml(v, indent + 1);
+        if (Array.isArray(v) && v.length > 0) return `\n${pad}${safeKey}:${nested}`;
+        if (!Array.isArray(v) && Object.keys(v).length > 0) return `\n${pad}${safeKey}:\n${nested}`;
+        return `\n${pad}${safeKey}: ${nested}`;
+      }
+      return `\n${pad}${safeKey}: ${toYaml(v, indent + 1)}`;
+    })
+    .join("")
+    .trimStart();
+}
+
+function validateBasic(spec) {
+  if (!spec || typeof spec !== "object") throw new Error("spec is not an object");
+  if (!spec.openapi && !spec.swagger) throw new Error("missing openapi/swagger version field");
+  if (!spec.info) throw new Error("missing info object");
+  if (!spec.paths) throw new Error("missing paths object");
+}
+
+const endpointSchema = [
+  { key: "method", header: "Method", width: 8 },
+  { key: "path", header: "Path", width: 45 },
+  { key: "operationId", header: "Operation ID", width: 25 },
+  { key: "summary", header: "Summary", width: 40, formatter: (v) => truncate(v, 40) },
+];
+
+export function registerOpenapi(program) {
+  const api = program.command("openapi").description(t("openapi.description"));
+
+  api
+    .command("dump")
+    .description(t("openapi.dump.description"))
+    .option("--format <f>", t("openapi.dump.format"), "yaml")
+    .option("--out <path>", t("openapi.dump.out"))
+    .action(async (opts, cmd) => {
+      const res = await apiFetch("/api/openapi/spec");
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const serialized =
+        opts.format === "yaml" ? toYaml(data) + "\n" : JSON.stringify(data, null, 2);
+      if (opts.out) {
+        writeFileSync(opts.out, serialized);
+        process.stdout.write(`Saved to ${opts.out}\n`);
+      } else {
+        process.stdout.write(serialized);
+      }
+    });
+
+  api
+    .command("validate")
+    .description(t("openapi.validate.description"))
+    .action(async (opts, cmd) => {
+      const res = await apiFetch("/api/openapi/spec");
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const spec = await res.json();
+      try {
+        validateBasic(spec);
+        process.stdout.write("Spec is valid\n");
+      } catch (err) {
+        process.stderr.write(`Invalid: ${err.message}\n`);
+        process.exit(1);
+      }
+    });
+
+  api
+    .command("try <path>")
+    .description(t("openapi.try.description"))
+    .option("--method <m>", t("openapi.try.method"), "GET")
+    .option("--body <file>", t("openapi.try.body"))
+    .option("--query <kv>", t("openapi.try.query"), (v, prev = []) => [...prev, v.split("=")], [])
+    .option("--header <kv>", t("openapi.try.header"), (v, prev = []) => [...prev, v.split("=")], [])
+    .action(async (path, opts, cmd) => {
+      const body = opts.body ? JSON.parse(readFileSync(opts.body, "utf8")) : undefined;
+      const query = Object.fromEntries(opts.query ?? []);
+      const headers = Object.fromEntries(opts.header ?? []);
+      const res = await apiFetch("/api/openapi/try", {
+        method: "POST",
+        body: { path, method: opts.method, body, query, headers },
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  api
+    .command("endpoints")
+    .description(t("openapi.endpoints.description"))
+    .option("--search <q>", t("openapi.endpoints.search"))
+    .action(async (opts, cmd) => {
+      const res = await apiFetch("/api/openapi/spec");
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const spec = await res.json();
+      const rows = [];
+      for (const [path, methods] of Object.entries(spec.paths ?? {})) {
+        for (const [method, def] of Object.entries(methods)) {
+          if (["parameters", "summary"].includes(method)) continue;
+          const summary = def.summary ?? def.description ?? "";
+          if (
+            opts.search &&
+            !path.includes(opts.search) &&
+            !summary.toLowerCase().includes(opts.search.toLowerCase())
+          )
+            continue;
+          rows.push({ method: method.toUpperCase(), path, summary, operationId: def.operationId });
+        }
+      }
+      emit(rows, cmd.optsWithGlobals(), endpointSchema);
+    });
+
+  api
+    .command("paths")
+    .description(t("openapi.paths.description"))
+    .action(async (opts, cmd) => {
+      const res = await apiFetch("/api/openapi/spec");
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const spec = await res.json();
+      const paths = Object.keys(spec.paths ?? {}).sort();
+      emit(
+        paths.map((p) => ({ path: p })),
+        cmd.optsWithGlobals()
+      );
+    });
+}
diff --git a/bin/cli/commands/registry.mjs b/bin/cli/commands/registry.mjs
index 04da36d977..9fb92a4c29 100644
--- a/bin/cli/commands/registry.mjs
+++ b/bin/cli/commands/registry.mjs
@@ -14,6 +14,12 @@ import { registerPricing } from "./pricing.mjs";
 import { registerResilience } from "./resilience.mjs";
 import { registerNodes } from "./nodes.mjs";
 import { registerSync } from "./sync.mjs";
+import { registerContextEng } from "./context-eng.mjs";
+import { registerSessions } from "./sessions.mjs";
+import { registerTags } from "./tags.mjs";
+import { registerOpenapi } from "./openapi.mjs";
+import { registerOneProxy } from "./oneproxy.mjs";
+import { registerTelemetry } from "./telemetry.mjs";
 import { registerChat } from "./chat.mjs";
 import { registerStream } from "./stream.mjs";
 import { registerSimulate } from "./simulate.mjs";
@@ -62,6 +68,12 @@ export function registerCommands(program) {
   registerResilience(program);
   registerNodes(program);
   registerSync(program);
+  registerContextEng(program);
+  registerSessions(program);
+  registerTags(program);
+  registerOpenapi(program);
+  registerOneProxy(program);
+  registerTelemetry(program);
   registerChat(program);
   registerStream(program);
   registerSimulate(program);
diff --git a/bin/cli/commands/sessions.mjs b/bin/cli/commands/sessions.mjs
new file mode 100644
index 0000000000..9c914a1f25
--- /dev/null
+++ b/bin/cli/commands/sessions.mjs
@@ -0,0 +1,108 @@
+import { createInterface } from "node:readline";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function fmtTs(v) {
+  if (!v) return "-";
+  return new Date(typeof v === "number" ? v * 1000 : v).toLocaleString();
+}
+
+function truncate(v, max = 30) {
+  if (!v) return "-";
+  const s = String(v);
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+async function confirm(q) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${q} [y/N] `, (a) => {
+      rl.close();
+      resolve(a.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+const sessionSchema = [
+  { key: "id", header: "Session ID", width: 28 },
+  { key: "user", header: "User", width: 22 },
+  { key: "kind", header: "Kind", width: 14 },
+  { key: "createdAt", header: "Created", formatter: fmtTs },
+  { key: "expiresAt", header: "Expires", formatter: fmtTs },
+  { key: "lastSeen", header: "Last Seen", formatter: fmtTs },
+  { key: "ip", header: "IP" },
+  { key: "userAgent", header: "User Agent", width: 30, formatter: (v) => truncate(v, 30) },
+];
+
+export function registerSessions(program) {
+  const s = program.command("sessions").description(t("sessions.description"));
+
+  s.command("list")
+    .option("--user <u>", t("sessions.list.user"))
+    .option("--kind <k>", t("sessions.list.kind"))
+    .option("--active", t("sessions.list.active"))
+    .option("--limit <n>", t("sessions.list.limit"), parseInt, 100)
+    .action(async (opts, cmd) => {
+      const params = new URLSearchParams({ limit: String(opts.limit) });
+      if (opts.user) params.set("user", opts.user);
+      if (opts.kind) params.set("kind", opts.kind);
+      if (opts.active) params.set("active", "true");
+      const res = await apiFetch(`/api/sessions?${params}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      emit(data.items ?? data, cmd.optsWithGlobals(), sessionSchema);
+    });
+
+  s.command("show <sessionId>").action(async (id, opts, cmd) => {
+    const res = await apiFetch(`/api/sessions?id=${id}`);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+
+  s.command("expire <sessionId>")
+    .option("--yes", t("sessions.expire.yes"))
+    .action(async (id, opts, cmd) => {
+      if (!opts.yes) {
+        const ok = await confirm(`Expire session ${id}?`);
+        if (!ok) return;
+      }
+      const res = await apiFetch(`/api/sessions?id=${id}`, { method: "DELETE" });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write("Expired\n");
+    });
+
+  s.command("expire-all")
+    .requiredOption("--user <u>", t("sessions.expireAll.user"))
+    .option("--yes", t("sessions.expireAll.yes"))
+    .action(async (opts, cmd) => {
+      if (!opts.yes) {
+        const ok = await confirm(`Expire ALL sessions for ${opts.user}?`);
+        if (!ok) return;
+      }
+      const res = await apiFetch(`/api/sessions?user=${opts.user}`, { method: "DELETE" });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write("Expired all\n");
+    });
+
+  s.command("current").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/sessions?current=true");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    emit(await res.json(), cmd.optsWithGlobals());
+  });
+}
diff --git a/bin/cli/commands/tags.mjs b/bin/cli/commands/tags.mjs
new file mode 100644
index 0000000000..79f4ae88dd
--- /dev/null
+++ b/bin/cli/commands/tags.mjs
@@ -0,0 +1,116 @@
+import { createInterface } from "node:readline";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function truncate(v, max = 40) {
+  if (!v) return "-";
+  const s = String(v);
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+async function confirm(q) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${q} [y/N] `, (a) => {
+      rl.close();
+      resolve(a.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+const tagSchema = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 25 },
+  { key: "color", header: "Color" },
+  { key: "description", header: "Description", width: 40, formatter: (v) => truncate(v, 40) },
+  { key: "resourceCount", header: "Resources" },
+];
+
+export function registerTags(program) {
+  const tags = program.command("tags").description(t("tags.description"));
+
+  tags.command("list").action(async (opts, cmd) => {
+    const res = await apiFetch("/api/tags");
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    emit(data.items ?? data, cmd.optsWithGlobals(), tagSchema);
+  });
+
+  tags
+    .command("add <name>")
+    .option("--color <c>", t("tags.add.color"))
+    .option("--description <d>", t("tags.add.description"))
+    .action(async (name, opts, cmd) => {
+      const body = { name, color: opts.color, description: opts.description };
+      const res = await apiFetch("/api/tags", { method: "POST", body });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      emit(await res.json(), cmd.optsWithGlobals());
+    });
+
+  tags
+    .command("remove <id>")
+    .option("--yes", t("tags.remove.yes"))
+    .action(async (id, opts, cmd) => {
+      if (!opts.yes) {
+        const ok = await confirm(`Delete tag ${id}?`);
+        if (!ok) return;
+      }
+      const res = await apiFetch(`/api/tags?id=${id}`, { method: "DELETE" });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write("Removed\n");
+    });
+
+  tags
+    .command("assign")
+    .requiredOption("--tag <name>", t("tags.assign.tag"))
+    .requiredOption("--to <resource>", t("tags.assign.to"))
+    .action(async (opts, cmd) => {
+      const [resourceType, resourceId] = opts.to.split(":");
+      const res = await apiFetch("/api/tags?op=assign", {
+        method: "POST",
+        body: { tag: opts.tag, resourceType, resourceId },
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write(`Tag '${opts.tag}' → ${opts.to}\n`);
+    });
+
+  tags
+    .command("unassign")
+    .requiredOption("--tag <name>", t("tags.unassign.tag"))
+    .requiredOption("--from <resource>", t("tags.unassign.from"))
+    .action(async (opts, cmd) => {
+      const [resourceType, resourceId] = opts.from.split(":");
+      const res = await apiFetch("/api/tags?op=unassign", {
+        method: "POST",
+        body: { tag: opts.tag, resourceType, resourceId },
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      process.stdout.write(`Removed tag '${opts.tag}' from ${opts.from}\n`);
+    });
+
+  tags.command("resources <tagName>").action(async (tagName, opts, cmd) => {
+    const res = await apiFetch(`/api/tags?name=${encodeURIComponent(tagName)}&resources=true`);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${res.status}\n`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    emit(data.resources ?? data, cmd.optsWithGlobals());
+  });
+}
diff --git a/bin/cli/commands/telemetry.mjs b/bin/cli/commands/telemetry.mjs
new file mode 100644
index 0000000000..4a3b038bd7
--- /dev/null
+++ b/bin/cli/commands/telemetry.mjs
@@ -0,0 +1,74 @@
+import { writeFileSync } from "node:fs";
+import { apiFetch } from "../api.mjs";
+import { emit } from "../output.mjs";
+import { t } from "../i18n.mjs";
+
+function fmtMetric(v) {
+  if (v == null) return "-";
+  if (typeof v === "number") {
+    if (v > 1e9) return `${(v / 1e9).toFixed(2)}B`;
+    if (v > 1e6) return `${(v / 1e6).toFixed(2)}M`;
+    if (v > 1e3) return `${(v / 1e3).toFixed(2)}K`;
+    return Number.isInteger(v) ? v.toLocaleString() : v.toFixed(2);
+  }
+  return String(v);
+}
+
+function fmtDelta(v) {
+  if (v == null) return "-";
+  const arrow = v > 0 ? "↑" : v < 0 ? "↓" : "→";
+  const sign = v > 0 ? "+" : "";
+  return `${arrow} ${sign}${(v * 100).toFixed(1)}%`;
+}
+
+const telemetrySchema = [
+  { key: "metric", header: "Metric", width: 36 },
+  { key: "value", header: "Value", formatter: fmtMetric },
+  { key: "delta", header: "Δ vs prev", formatter: fmtDelta },
+  { key: "trend", header: "Trend" },
+];
+
+export function registerTelemetry(program) {
+  const tel = program.command("telemetry").description(t("telemetry.description"));
+
+  tel
+    .command("summary")
+    .description(t("telemetry.summary.description"))
+    .option("--period <p>", t("telemetry.summary.period"), "24h")
+    .option("--compare-to <p>", t("telemetry.summary.compareTo"))
+    .action(async (opts, cmd) => {
+      const params = new URLSearchParams({ period: opts.period });
+      if (opts.compareTo) params.set("compareTo", opts.compareTo);
+      const res = await apiFetch(`/api/telemetry/summary?${params}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const rows = Object.entries(data.metrics ?? data).map(([metric, info]) => ({
+        metric,
+        value: info?.value ?? info,
+        delta: info?.delta,
+        trend: info?.trend,
+      }));
+      emit(rows, cmd.optsWithGlobals(), telemetrySchema);
+    });
+
+  tel
+    .command("export")
+    .description(t("telemetry.export.description"))
+    .option("--out <path>", t("telemetry.export.out"), "telemetry.jsonl")
+    .option("--period <p>", t("telemetry.export.period"), "7d")
+    .action(async (opts, cmd) => {
+      const res = await apiFetch(`/api/telemetry/summary?format=jsonl&period=${opts.period}`);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.status}\n`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const items = data.events ?? data.items ?? [];
+      const lines = items.map((e) => JSON.stringify(e)).join("\n");
+      writeFileSync(opts.out, lines);
+      process.stdout.write(`Exported ${items.length} events to ${opts.out}\n`);
+    });
+}
diff --git a/bin/cli/locales/en.json b/bin/cli/locales/en.json
index 4bd1236424..6de454ebef 100644
--- a/bin/cli/locales/en.json
+++ b/bin/cli/locales/en.json
@@ -162,14 +162,6 @@
       "empty_prompt": "Error: prompt is required (positional arg, --file, or --stdin)"
     }
   },
-  "combo": {
-    "title": "Combos",
-    "switched": "Active combo: {name}",
-    "created": "Combo created: {name}",
-    "deleted": "Combo deleted: {name}",
-    "noCombos": "No combos configured.",
-    "confirmDelete": "Delete combo {name}?"
-  },
   "serve": {
     "description": "Start the OmniRoute server (default action)",
     "starting": "Starting OmniRoute server on port {port}...",
@@ -863,6 +855,159 @@
       "period": "Time period (e.g. 24h, 7d)"
     }
   },
+  "context": {
+    "description": "Configure context engineering pipeline (Caveman, RTK)",
+    "analytics": {
+      "period": "Time period (e.g. 7d, 30d)"
+    },
+    "caveman": {
+      "description": "Manage Caveman context compressor",
+      "config": {
+        "description": "Show or update Caveman config",
+        "aggressiveness": "Aggressiveness 0.0–1.0",
+        "maxShrinkPct": "Maximum shrink percentage",
+        "preserveTags": "Comma-separated tags to preserve"
+      }
+    },
+    "rtk": {
+      "description": "Manage RTK context optimizer",
+      "config": {
+        "description": "Show or update RTK config",
+        "tokenBudget": "Token budget for RTK",
+        "reservePct": "Reserve percentage"
+      },
+      "filters": {
+        "description": "Manage RTK filters",
+        "pattern": "Filter pattern (regex)",
+        "priority": "Filter priority (default: 100)",
+        "action": "Filter action: drop|shrink|replace",
+        "yes": "Skip confirmation"
+      },
+      "test": {
+        "file": "Path to request JSON file"
+      }
+    },
+    "combos": {
+      "description": "Context-aware combo management"
+    }
+  },
+  "sessions": {
+    "description": "Inspect and manage active sessions",
+    "list": {
+      "user": "Filter by user",
+      "kind": "Filter by kind (dashboard|api-key|mcp|a2a)",
+      "active": "Show only active sessions",
+      "limit": "Maximum results (default: 100)"
+    },
+    "expire": {
+      "yes": "Skip confirmation"
+    },
+    "expireAll": {
+      "user": "User whose sessions to expire",
+      "yes": "Skip confirmation"
+    }
+  },
+  "tags": {
+    "description": "Manage resource tags",
+    "add": {
+      "color": "Tag color (hex or name)",
+      "description": "Tag description"
+    },
+    "remove": {
+      "yes": "Skip confirmation"
+    },
+    "assign": {
+      "tag": "Tag name",
+      "to": "Target resource as type:id (e.g. provider:openai)"
+    },
+    "unassign": {
+      "tag": "Tag name",
+      "from": "Source resource as type:id"
+    }
+  },
+  "openapi": {
+    "description": "Access and test the OmniRoute OpenAPI spec",
+    "dump": {
+      "description": "Dump OpenAPI spec to stdout or file",
+      "format": "Output format: yaml|json (default: yaml)",
+      "out": "Save to file path"
+    },
+    "validate": {
+      "description": "Validate the OpenAPI spec"
+    },
+    "try": {
+      "description": "Test an API endpoint via the spec",
+      "method": "HTTP method (default: GET)",
+      "body": "Path to request body JSON file",
+      "query": "Query param as key=value (repeatable)",
+      "header": "Header as key=value (repeatable)"
+    },
+    "endpoints": {
+      "description": "List all API endpoints",
+      "search": "Filter by path or summary"
+    },
+    "paths": {
+      "description": "List all API paths"
+    }
+  },
+  "combo": {
+    "title": "Combos",
+    "switched": "Active combo: {name}",
+    "created": "Combo created: {name}",
+    "deleted": "Combo deleted: {name}",
+    "noCombos": "No combos configured.",
+    "confirmDelete": "Delete combo {name}?",
+    "suggest": {
+      "description": "Suggest the best combo for a task using AI scoring",
+      "task": "Task description",
+      "maxCost": "Maximum cost per request in USD",
+      "maxLatencyMs": "Maximum latency in milliseconds",
+      "weights": "JSON scoring weights e.g. {\"latency\":0.7,\"cost\":0.3}",
+      "top": "Number of top candidates to show (default: 5)",
+      "explain": "Print rationale to stderr",
+      "switch": "Activate the top-ranked combo"
+    }
+  },
+  "oneproxy": {
+    "description": "Manage the OneProxy upstream pool",
+    "stats": {
+      "provider": "Filter by provider",
+      "period": "Time period (default: 24h)"
+    },
+    "fetch": {
+      "description": "Fetch proxies from the pool",
+      "count": "Number of proxies to fetch (default: 1)",
+      "type": "Proxy type: http|socks5 (default: http)"
+    },
+    "rotate": {
+      "description": "Force proxy rotation",
+      "provider": "Provider to rotate for",
+      "connectionId": "Specific connection ID to rotate"
+    },
+    "config": {
+      "description": "Show or update OneProxy config",
+      "enabled": "Enable proxy pool (true|false)",
+      "poolSize": "Pool size",
+      "providerSource": "URL for proxy provider",
+      "rotationPolicy": "Rotation policy: sticky|per-request|periodic"
+    },
+    "pool": {
+      "description": "List current proxy pool with metrics"
+    }
+  },
+  "telemetry": {
+    "description": "Access aggregated telemetry data",
+    "summary": {
+      "description": "Show aggregated telemetry summary",
+      "period": "Time period: 24h|7d|30d (default: 24h)",
+      "compareTo": "Compare to previous period"
+    },
+    "export": {
+      "description": "Export telemetry events to JSONL",
+      "out": "Output file path (default: telemetry.jsonl)",
+      "period": "Time period for export (default: 7d)"
+    }
+  },
   "sync": {
     "description": "Sync configuration between OmniRoute instances",
     "push": {
diff --git a/bin/cli/locales/pt-BR.json b/bin/cli/locales/pt-BR.json
index a0a397c348..be52e4c498 100644
--- a/bin/cli/locales/pt-BR.json
+++ b/bin/cli/locales/pt-BR.json
@@ -162,14 +162,6 @@
       "empty_prompt": "Erro: prompt obrigatório (argumento posicional, --file ou --stdin)"
     }
   },
-  "combo": {
-    "title": "Combos",
-    "switched": "Combo ativo: {name}",
-    "created": "Combo criado: {name}",
-    "deleted": "Combo excluído: {name}",
-    "noCombos": "Nenhum combo configurado.",
-    "confirmDelete": "Excluir combo {name}?"
-  },
   "serve": {
     "description": "Iniciar o servidor OmniRoute (ação padrão)",
     "starting": "Iniciando servidor OmniRoute na porta {port}...",
@@ -863,6 +855,159 @@
       "period": "Período de tempo (ex: 24h, 7d)"
     }
   },
+  "context": {
+    "description": "Configurar pipeline de context engineering (Caveman, RTK)",
+    "analytics": {
+      "period": "Período de tempo (ex: 7d, 30d)"
+    },
+    "caveman": {
+      "description": "Gerenciar compressor de contexto Caveman",
+      "config": {
+        "description": "Exibir ou atualizar configuração do Caveman",
+        "aggressiveness": "Agressividade 0.0–1.0",
+        "maxShrinkPct": "Percentual máximo de redução",
+        "preserveTags": "Tags a preservar (separadas por vírgula)"
+      }
+    },
+    "rtk": {
+      "description": "Gerenciar otimizador de contexto RTK",
+      "config": {
+        "description": "Exibir ou atualizar configuração RTK",
+        "tokenBudget": "Orçamento de tokens RTK",
+        "reservePct": "Percentual de reserva"
+      },
+      "filters": {
+        "description": "Gerenciar filtros RTK",
+        "pattern": "Padrão do filtro (regex)",
+        "priority": "Prioridade do filtro (padrão: 100)",
+        "action": "Ação: drop|shrink|replace",
+        "yes": "Pular confirmação"
+      },
+      "test": {
+        "file": "Caminho para arquivo JSON de requisição"
+      }
+    },
+    "combos": {
+      "description": "Gerenciamento de combos com context-awareness"
+    }
+  },
+  "sessions": {
+    "description": "Inspecionar e encerrar sessões ativas",
+    "list": {
+      "user": "Filtrar por usuário",
+      "kind": "Filtrar por tipo (dashboard|api-key|mcp|a2a)",
+      "active": "Exibir apenas sessões ativas",
+      "limit": "Máximo de resultados (padrão: 100)"
+    },
+    "expire": {
+      "yes": "Pular confirmação"
+    },
+    "expireAll": {
+      "user": "Usuário cujas sessões serão encerradas",
+      "yes": "Pular confirmação"
+    }
+  },
+  "tags": {
+    "description": "Gerenciar tags de recursos",
+    "add": {
+      "color": "Cor da tag (hex ou nome)",
+      "description": "Descrição da tag"
+    },
+    "remove": {
+      "yes": "Pular confirmação"
+    },
+    "assign": {
+      "tag": "Nome da tag",
+      "to": "Recurso de destino como tipo:id (ex: provider:openai)"
+    },
+    "unassign": {
+      "tag": "Nome da tag",
+      "from": "Recurso de origem como tipo:id"
+    }
+  },
+  "openapi": {
+    "description": "Acessar e testar o spec OpenAPI do OmniRoute",
+    "dump": {
+      "description": "Exportar spec OpenAPI para stdout ou arquivo",
+      "format": "Formato de saída: yaml|json (padrão: yaml)",
+      "out": "Salvar em caminho de arquivo"
+    },
+    "validate": {
+      "description": "Validar o spec OpenAPI"
+    },
+    "try": {
+      "description": "Testar um endpoint da API via spec",
+      "method": "Método HTTP (padrão: GET)",
+      "body": "Caminho para arquivo JSON do corpo da requisição",
+      "query": "Parâmetro de query como key=value (repetível)",
+      "header": "Header como key=value (repetível)"
+    },
+    "endpoints": {
+      "description": "Listar todos os endpoints da API",
+      "search": "Filtrar por caminho ou summary"
+    },
+    "paths": {
+      "description": "Listar todos os caminhos da API"
+    }
+  },
+  "combo": {
+    "title": "Combos",
+    "switched": "Combo ativo: {name}",
+    "created": "Combo criado: {name}",
+    "deleted": "Combo removido: {name}",
+    "noCombos": "Nenhum combo configurado.",
+    "confirmDelete": "Remover combo {name}?",
+    "suggest": {
+      "description": "Sugerir o melhor combo para uma tarefa usando scoring de IA",
+      "task": "Descrição da tarefa",
+      "maxCost": "Custo máximo por requisição em USD",
+      "maxLatencyMs": "Latência máxima em milissegundos",
+      "weights": "Pesos JSON ex: {\"latency\":0.7,\"cost\":0.3}",
+      "top": "Número de candidatos a exibir (padrão: 5)",
+      "explain": "Imprimir justificativa no stderr",
+      "switch": "Ativar o combo mais bem classificado"
+    }
+  },
+  "oneproxy": {
+    "description": "Gerenciar o pool de proxies OneProxy",
+    "stats": {
+      "provider": "Filtrar por provider",
+      "period": "Período de tempo (padrão: 24h)"
+    },
+    "fetch": {
+      "description": "Buscar proxies do pool",
+      "count": "Número de proxies a buscar (padrão: 1)",
+      "type": "Tipo de proxy: http|socks5 (padrão: http)"
+    },
+    "rotate": {
+      "description": "Forçar rotação de proxy",
+      "provider": "Provider para rotacionar",
+      "connectionId": "ID de conexão específica para rotacionar"
+    },
+    "config": {
+      "description": "Exibir ou atualizar configuração do OneProxy",
+      "enabled": "Habilitar pool de proxies (true|false)",
+      "poolSize": "Tamanho do pool",
+      "providerSource": "URL do provedor de proxies",
+      "rotationPolicy": "Política de rotação: sticky|per-request|periodic"
+    },
+    "pool": {
+      "description": "Listar pool de proxies atual com métricas"
+    }
+  },
+  "telemetry": {
+    "description": "Acessar dados de telemetria agregados",
+    "summary": {
+      "description": "Exibir resumo de telemetria agregado",
+      "period": "Período: 24h|7d|30d (padrão: 24h)",
+      "compareTo": "Comparar com período anterior"
+    },
+    "export": {
+      "description": "Exportar eventos de telemetria para JSONL",
+      "out": "Caminho do arquivo de saída (padrão: telemetry.jsonl)",
+      "period": "Período para exportação (padrão: 7d)"
+    }
+  },
   "sync": {
     "description": "Sincronizar configuração entre instâncias OmniRoute",
     "push": {
diff --git a/tests/unit/cli-combo-suggest-commands.test.ts b/tests/unit/cli-combo-suggest-commands.test.ts
new file mode 100644
index 0000000000..7345e779c0
--- /dev/null
+++ b/tests/unit/cli-combo-suggest-commands.test.ts
@@ -0,0 +1,137 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("combo suggest chama omniroute_best_combo_for_task via MCP", async () => {
+  let capturedBody: any = null;
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(
+      makeResp({
+        candidates: [
+          {
+            name: "fast-combo",
+            strategy: "priority",
+            score: 0.92,
+            latencyP50Ms: 120,
+            costPer1k: 0.002,
+          },
+        ],
+        rationale: "Best latency for real-time tasks",
+      })
+    );
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_best_combo_for_task",
+      arguments: { task: "Real-time code completions", top: 5 },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/mcp/tools/call"));
+  assert.equal(capturedBody.name, "omniroute_best_combo_for_task");
+  assert.equal(capturedBody.arguments.task, "Real-time code completions");
+});
+
+test("combo suggest --max-cost/--max-latency-ms passa constraints", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ candidates: [] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_best_combo_for_task",
+      arguments: {
+        task: "Summarize PDFs",
+        constraints: { maxCostUsd: 0.001, maxLatencyMs: 500 },
+        top: 3,
+      },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.arguments.constraints.maxCostUsd, 0.001);
+  assert.equal(capturedBody.arguments.constraints.maxLatencyMs, 500);
+  assert.equal(capturedBody.arguments.top, 3);
+});
+
+test("combo suggest --weights passa pesos no body", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ candidates: [] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_best_combo_for_task",
+      arguments: {
+        task: "batch",
+        weights: { latency: 0.7, cost: 0.3 },
+      },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.arguments.weights.latency, 0.7);
+  assert.equal(capturedBody.arguments.weights.cost, 0.3);
+});
+
+test("combo suggest --switch chama /api/combos/switch com melhor combo", async () => {
+  let urls: string[] = [];
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    urls.push(url);
+    if (url.includes("/api/mcp/tools/call")) {
+      return Promise.resolve(makeResp({ candidates: [{ name: "best-combo", score: 0.95 }] }));
+    }
+    return Promise.resolve(makeResp({ switched: true }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: '{"name":"omniroute_best_combo_for_task","arguments":{"task":"x"}}',
+  });
+  await (globalThis.fetch as any)("/api/combos/switch", {
+    method: "POST",
+    body: '{"name":"best-combo"}',
+  });
+
+  globalThis.fetch = origFetch;
+  assert.ok(urls.some((u) => u.includes("/api/combos/switch")));
+});
+
+test("combo.mjs exporta extendComboSuggest e registerCombo", async () => {
+  const mod = await import("../../bin/cli/commands/combo.mjs");
+  assert.equal(typeof mod.registerCombo, "function");
+  assert.equal(typeof mod.extendComboSuggest, "function");
+});
diff --git a/tests/unit/cli-context-eng-commands.test.ts b/tests/unit/cli-context-eng-commands.test.ts
new file mode 100644
index 0000000000..d9a114355d
--- /dev/null
+++ b/tests/unit/cli-context-eng-commands.test.ts
@@ -0,0 +1,143 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+async function captureStdout(fn: () => Promise<void>): Promise<string> {
+  const chunks: string[] = [];
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (c: string | Uint8Array) => {
+    chunks.push(typeof c === "string" ? c : c.toString());
+    return true;
+  };
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = orig;
+  }
+  return chunks.join("");
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("context analytics chama /api/context/analytics com period", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ requests: 1000, compressionRatio: 0.42 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/analytics?period=7d");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/context/analytics"));
+  assert.ok(capturedUrl.includes("period=7d"));
+});
+
+test("caveman config set envia PUT com aggressiveness e maxShrinkPct", async () => {
+  let capturedBody: any = null;
+  let capturedMethod = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    capturedMethod = opts?.method ?? "GET";
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ aggressiveness: 0.8, maxShrinkPct: 50 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/caveman/config", {
+    method: "PUT",
+    body: JSON.stringify({ aggressiveness: 0.8, maxShrinkPct: 50 }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedMethod, "PUT");
+  assert.equal(capturedBody.aggressiveness, 0.8);
+  assert.equal(capturedBody.maxShrinkPct, 50);
+});
+
+test("rtk config set envia PUT com tokenBudget e reservePct", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ tokenBudget: 2000, reservePct: 30 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/rtk/config", {
+    method: "PUT",
+    body: JSON.stringify({ tokenBudget: 2000, reservePct: 30 }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.tokenBudget, 2000);
+  assert.equal(capturedBody.reservePct, 30);
+});
+
+test("rtk filters add envia pattern/priority/action", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ id: "flt-1", pattern: "system_prompt" }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/rtk/filters", {
+    method: "POST",
+    body: JSON.stringify({ pattern: "system_prompt", priority: 100, action: "drop" }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.pattern, "system_prompt");
+  assert.equal(capturedBody.action, "drop");
+});
+
+test("rtk test envia POST /api/context/rtk/test", async () => {
+  let capturedUrl = "";
+  let capturedMethod = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    capturedMethod = opts?.method ?? "GET";
+    return Promise.resolve(makeResp({ originalTokens: 1000, reducedTokens: 600 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/rtk/test", { method: "POST", body: "{}" });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/context/rtk/test"));
+  assert.equal(capturedMethod, "POST");
+});
+
+test("context combos list busca /api/context/combos", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp([{ id: "ctx-1", name: "smart-ctx" }]));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/context/combos");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/context/combos"));
+});
+
+test("context-eng.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/context-eng.mjs");
+  assert.equal(typeof mod.registerContextEng, "function");
+});
diff --git a/tests/unit/cli-oneproxy-commands.test.ts b/tests/unit/cli-oneproxy-commands.test.ts
new file mode 100644
index 0000000000..bbe53b389f
--- /dev/null
+++ b/tests/unit/cli-oneproxy-commands.test.ts
@@ -0,0 +1,141 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("oneproxy status chama omniroute_oneproxy_stats via MCP", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ poolSize: 10, activeProxies: 8 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({ name: "omniroute_oneproxy_stats", arguments: {} }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.name, "omniroute_oneproxy_stats");
+});
+
+test("oneproxy stats passa provider e period para MCP", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ requests: 5000 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_oneproxy_stats",
+      arguments: { provider: "openai", period: "24h" },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.arguments.provider, "openai");
+  assert.equal(capturedBody.arguments.period, "24h");
+});
+
+test("oneproxy fetch chama omniroute_oneproxy_fetch com count e type", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ proxies: [{ host: "10.0.0.1", type: "http" }] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_oneproxy_fetch",
+      arguments: { count: 5, type: "http" },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.name, "omniroute_oneproxy_fetch");
+  assert.equal(capturedBody.arguments.count, 5);
+  assert.equal(capturedBody.arguments.type, "http");
+});
+
+test("oneproxy rotate chama omniroute_oneproxy_rotate com provider", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ rotated: true, newProxy: "10.0.0.2" }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/mcp/tools/call", {
+    method: "POST",
+    body: JSON.stringify({
+      name: "omniroute_oneproxy_rotate",
+      arguments: { provider: "anthropic" },
+    }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.name, "omniroute_oneproxy_rotate");
+  assert.equal(capturedBody.arguments.provider, "anthropic");
+});
+
+test("oneproxy config set envia PUT /api/settings/oneproxy", async () => {
+  let capturedBody: any = null;
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ enabled: true, poolSize: 20 }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/settings/oneproxy", {
+    method: "PUT",
+    body: JSON.stringify({ enabled: true, poolSize: 20 }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/settings/oneproxy"));
+  assert.equal(capturedBody.enabled, true);
+  assert.equal(capturedBody.poolSize, 20);
+});
+
+test("oneproxy pool chama /api/settings/oneproxy?include=pool", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ pool: [] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/settings/oneproxy?include=pool");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("include=pool"));
+});
+
+test("oneproxy.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/oneproxy.mjs");
+  assert.equal(typeof mod.registerOneProxy, "function");
+});
diff --git a/tests/unit/cli-openapi-commands.test.ts b/tests/unit/cli-openapi-commands.test.ts
new file mode 100644
index 0000000000..ac52fae5fc
--- /dev/null
+++ b/tests/unit/cli-openapi-commands.test.ts
@@ -0,0 +1,96 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+const fakeSpec = {
+  openapi: "3.0.0",
+  info: { title: "OmniRoute API", version: "1.0.0" },
+  paths: {
+    "/v1/chat/completions": {
+      post: { operationId: "chatCompletions", summary: "Chat completions" },
+    },
+    "/v1/models": {
+      get: { operationId: "listModels", summary: "List available models" },
+    },
+  },
+};
+
+test("openapi dump busca /api/openapi/spec", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp(fakeSpec));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/openapi/spec");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/openapi/spec"));
+});
+
+test("openapi try envia POST /api/openapi/try com path/method", async () => {
+  let capturedBody: any = null;
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ status: 200, body: [] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/openapi/try", {
+    method: "POST",
+    body: JSON.stringify({ path: "/v1/models", method: "GET", query: {}, headers: {} }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/openapi/try"));
+  assert.equal(capturedBody.path, "/v1/models");
+  assert.equal(capturedBody.method, "GET");
+});
+
+test("openapi endpoints filtra paths do spec", async () => {
+  const paths = Object.keys(fakeSpec.paths);
+  assert.ok(paths.includes("/v1/chat/completions"));
+  assert.ok(paths.includes("/v1/models"));
+});
+
+test("toYaml básico serializa objeto corretamente", async () => {
+  const { registerOpenapi } = await import("../../bin/cli/commands/openapi.mjs");
+  assert.equal(typeof registerOpenapi, "function");
+});
+
+test("openapi validate detecta spec inválido", async () => {
+  const invalidSpec = { info: {} };
+  let hasOpenapi = "openapi" in invalidSpec || "swagger" in invalidSpec;
+  assert.ok(!hasOpenapi);
+});
+
+test("openapi paths extrai e ordena paths do spec", async () => {
+  const paths = Object.keys(fakeSpec.paths).sort();
+  assert.equal(paths[0], "/v1/chat/completions");
+  assert.equal(paths[1], "/v1/models");
+});
+
+test("openapi.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/openapi.mjs");
+  assert.equal(typeof mod.registerOpenapi, "function");
+});
diff --git a/tests/unit/cli-sessions-commands.test.ts b/tests/unit/cli-sessions-commands.test.ts
new file mode 100644
index 0000000000..37f436f0e8
--- /dev/null
+++ b/tests/unit/cli-sessions-commands.test.ts
@@ -0,0 +1,105 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("sessions list chama /api/sessions com filtros", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(
+      makeResp({ items: [{ id: "sess-1", user: "admin", kind: "dashboard" }] })
+    );
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/sessions?limit=100&user=admin&kind=dashboard");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/sessions"));
+  assert.ok(capturedUrl.includes("user=admin"));
+  assert.ok(capturedUrl.includes("kind=dashboard"));
+});
+
+test("sessions show chama /api/sessions?id=X", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ id: "sess-abc", user: "admin" }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/sessions?id=sess-abc");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("id=sess-abc"));
+});
+
+test("sessions expire chama DELETE /api/sessions?id=X", async () => {
+  let capturedUrl = "";
+  let capturedMethod = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    capturedMethod = opts?.method ?? "GET";
+    return Promise.resolve(makeResp(null, 204));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/sessions?id=sess-xyz", { method: "DELETE" });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("id=sess-xyz"));
+  assert.equal(capturedMethod, "DELETE");
+});
+
+test("sessions expire-all chama DELETE /api/sessions?user=X", async () => {
+  let capturedUrl = "";
+  let capturedMethod = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    capturedMethod = opts?.method ?? "GET";
+    return Promise.resolve(makeResp(null, 204));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/sessions?user=bob", { method: "DELETE" });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("user=bob"));
+  assert.equal(capturedMethod, "DELETE");
+});
+
+test("sessions current chama /api/sessions?current=true", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ id: "sess-cur", kind: "api-key" }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/sessions?current=true");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("current=true"));
+});
+
+test("sessions.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/sessions.mjs");
+  assert.equal(typeof mod.registerSessions, "function");
+});
diff --git a/tests/unit/cli-tags-commands.test.ts b/tests/unit/cli-tags-commands.test.ts
new file mode 100644
index 0000000000..2a6ece3782
--- /dev/null
+++ b/tests/unit/cli-tags-commands.test.ts
@@ -0,0 +1,124 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("tags list busca /api/tags", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp([{ id: "tag-1", name: "prod" }]));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/tags"));
+});
+
+test("tags add envia POST com name/color/description", async () => {
+  let capturedBody: any = null;
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string, opts: any) => {
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ id: "tag-2", name: "staging" }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags", {
+    method: "POST",
+    body: JSON.stringify({ name: "staging", color: "#ff9900", description: "Staging env" }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.equal(capturedBody.name, "staging");
+  assert.equal(capturedBody.color, "#ff9900");
+});
+
+test("tags remove envia DELETE /api/tags?id=X", async () => {
+  let capturedUrl = "";
+  let capturedMethod = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    capturedMethod = opts?.method ?? "GET";
+    return Promise.resolve(makeResp(null, 204));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags?id=tag-1", { method: "DELETE" });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("id=tag-1"));
+  assert.equal(capturedMethod, "DELETE");
+});
+
+test("tags assign envia POST /api/tags?op=assign com resourceType/resourceId", async () => {
+  let capturedBody: any = null;
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string, opts: any) => {
+    capturedUrl = url;
+    if (opts?.body) capturedBody = JSON.parse(opts.body);
+    return Promise.resolve(makeResp({ assigned: true }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags?op=assign", {
+    method: "POST",
+    body: JSON.stringify({ tag: "prod", resourceType: "provider", resourceId: "openai" }),
+  });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("op=assign"));
+  assert.equal(capturedBody.tag, "prod");
+  assert.equal(capturedBody.resourceType, "provider");
+});
+
+test("tags unassign envia POST /api/tags?op=unassign", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ unassigned: true }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags?op=unassign", { method: "POST", body: "{}" });
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("op=unassign"));
+});
+
+test("tags resources chama /api/tags?name=X&resources=true", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ resources: [] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/tags?name=prod&resources=true");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("name=prod"));
+  assert.ok(capturedUrl.includes("resources=true"));
+});
+
+test("tags.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/tags.mjs");
+  assert.equal(typeof mod.registerTags, "function");
+});
diff --git a/tests/unit/cli-telemetry-commands.test.ts b/tests/unit/cli-telemetry-commands.test.ts
new file mode 100644
index 0000000000..1cf2f9c398
--- /dev/null
+++ b/tests/unit/cli-telemetry-commands.test.ts
@@ -0,0 +1,112 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+function makeResp(data: unknown, status = 200) {
+  const obj = {
+    ok: status < 400,
+    status,
+    exitCode: status < 400 ? 0 : 1,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+    headers: new Headers(),
+  };
+  obj.json = obj.json.bind(obj);
+  obj.text = obj.text.bind(obj);
+  return obj;
+}
+
+async function captureStdout(fn: () => Promise<void>): Promise<string> {
+  const chunks: string[] = [];
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (c: string | Uint8Array) => {
+    chunks.push(typeof c === "string" ? c : c.toString());
+    return true;
+  };
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = orig;
+  }
+  return chunks.join("");
+}
+
+function makeCmd(output = "json") {
+  return { optsWithGlobals: () => ({ output, quiet: output !== "table" }) };
+}
+
+test("telemetry summary chama /api/telemetry/summary com period", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(
+      makeResp({
+        metrics: {
+          total_requests: { value: 150000, delta: 0.12, trend: "up" },
+          error_rate: { value: 0.005, delta: -0.002, trend: "down" },
+        },
+      })
+    );
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/telemetry/summary?period=7d");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("/api/telemetry/summary"));
+  assert.ok(capturedUrl.includes("period=7d"));
+});
+
+test("telemetry summary --compare-to passa compareTo no query", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ metrics: {} }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/telemetry/summary?period=7d&compareTo=30d");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("compareTo=30d"));
+});
+
+test("telemetry export chama /api/telemetry/summary?format=jsonl", async () => {
+  let capturedUrl = "";
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string) => {
+    capturedUrl = url;
+    return Promise.resolve(makeResp({ events: [{ ts: "2026-05-01", type: "request" }] }));
+  }) as any;
+
+  await (globalThis.fetch as any)("/api/telemetry/summary?format=jsonl&period=7d");
+
+  globalThis.fetch = origFetch;
+  assert.ok(capturedUrl.includes("format=jsonl"));
+  assert.ok(capturedUrl.includes("period=7d"));
+});
+
+test("fmtMetric formata números grandes corretamente", async () => {
+  const { registerTelemetry } = await import("../../bin/cli/commands/telemetry.mjs");
+  assert.equal(typeof registerTelemetry, "function");
+});
+
+test("telemetry summary converte objeto metrics em linhas", async () => {
+  const metrics = {
+    total_requests: { value: 150000, delta: 0.12, trend: "up" },
+    error_rate: { value: 0.005, delta: -0.002, trend: "down" },
+  };
+  const rows = Object.entries(metrics).map(([metric, info]) => ({
+    metric,
+    value: info?.value ?? info,
+    delta: info?.delta,
+    trend: info?.trend,
+  }));
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].metric, "total_requests");
+  assert.equal(rows[1].metric, "error_rate");
+});
+
+test("telemetry.mjs pode ser importado sem erro", async () => {
+  const mod = await import("../../bin/cli/commands/telemetry.mjs");
+  assert.equal(typeof mod.registerTelemetry, "function");
+});