polymath-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,1764 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+
+// src/index.ts
+import { Command } from "commander";
+import { randomUUID } from "node:crypto";
+import { createElement } from "react";
+import { render } from "ink";
+
+// src/config/store.ts
+import fs2 from "node:fs";
+
+// src/config/paths.ts
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+function configDir() {
+  const override = process.env.POLYMATH_HOME;
+  if (override) return override;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.trim() ? xdg : path.join(os.homedir(), ".config");
+  return path.join(base, "polymath");
+}
+function ensureConfigDir() {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+function dbFilePath() {
+  return path.join(configDir(), "usage.sqlite");
+}
+function modelCachePath() {
+  return path.join(configDir(), "models.cache.json");
+}
+
+// src/config/store.ts
+var DEFAULT_CONFIG = {
+  defaultObjective: "value",
+  referer: "https://github.com/polymath-agent",
+  title: "Polymath",
+  firestore: {
+    enabled: false,
+    projectId: "mathology-b8e3d",
+    collection: "polymath_usage"
+  }
+};
+function loadConfig() {
+  const file = configFilePath();
+  if (!fs2.existsSync(file)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = JSON.parse(fs2.readFileSync(file, "utf8"));
+    return {
+      ...DEFAULT_CONFIG,
+      ...raw,
+      firestore: { ...DEFAULT_CONFIG.firestore, ...raw.firestore ?? {} }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const file = configFilePath();
+  fs2.writeFileSync(file, JSON.stringify(config, null, 2), { mode: 384 });
+  try {
+    fs2.chmodSync(file, 384);
+  } catch {
+  }
+}
+function resolveApiKey(config) {
+  return process.env.OPENROUTER_API_KEY?.trim() || config.openrouterApiKey;
+}
+
+// src/providers/openrouter.ts
+var BASE = globalThis.process?.env?.OPENROUTER_BASE_URL?.replace(/\/$/, "") || "https://openrouter.ai/api/v1";
+var OpenRouterError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "OpenRouterError";
+    this.status = status;
+  }
+};
+var OpenRouterClient = class {
+  apiKey;
+  referer;
+  title;
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey;
+    this.referer = opts.referer ?? "https://github.com/polymath-agent";
+    this.title = opts.title ?? "Polymath";
+  }
+  headers(json = true) {
+    const h = {
+      Authorization: `Bearer ${this.apiKey ?? ""}`,
+      "HTTP-Referer": this.referer,
+      "X-Title": this.title
+    };
+    if (json) h["Content-Type"] = "application/json";
+    return h;
+  }
+  /** Raw /models payload (no auth required). */
+  async listRawModels() {
+    const res = await fetch(`${BASE}/models`, { headers: this.headers(false) });
+    if (!res.ok) {
+      throw new OpenRouterError(`Failed to list models (${res.status})`, res.status);
+    }
+    const json = await res.json();
+    return json.data ?? [];
+  }
+  /** Validate the configured key; returns key metadata or throws. */
+  async validateKey() {
+    if (!this.apiKey) throw new OpenRouterError("No API key set");
+    const res = await fetch(`${BASE}/key`, { headers: this.headers(false) });
+    if (res.status === 401) throw new OpenRouterError("Invalid API key (401)", 401);
+    if (!res.ok) throw new OpenRouterError(`Key check failed (${res.status})`, res.status);
+    const json = await res.json();
+    const d = json.data ?? {};
+    return { label: d.label, usage: d.usage, limit: d.limit };
+  }
+  buildBody(req, stream) {
+    return {
+      model: req.model,
+      messages: req.messages.map(serializeMessage),
+      ...req.tools && req.tools.length ? { tools: req.tools, tool_choice: "auto" } : {},
+      temperature: req.temperature ?? 0.2,
+      ...req.maxTokens ? { max_tokens: req.maxTokens } : {},
+      stream,
+      usage: { include: true }
+    };
+  }
+  /** Non-streaming completion. costUsd is computed from `pricing` (deterministic). */
+  async complete(req, pricing) {
+    if (!this.apiKey) throw new OpenRouterError("No API key set. Run `poly login`.");
+    const res = await fetch(`${BASE}/chat/completions`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(this.buildBody(req, false))
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new OpenRouterError(`Completion failed (${res.status}): ${truncate(text)}`, res.status);
+    }
+    const json = await res.json();
+    if (json?.error) {
+      throw new OpenRouterError(json.error.message ?? "Provider error", json.error.code);
+    }
+    const choice = json.choices?.[0] ?? {};
+    const msg = choice.message ?? {};
+    const usage = {
+      promptTokens: json.usage?.prompt_tokens ?? 0,
+      completionTokens: json.usage?.completion_tokens ?? 0,
+      totalTokens: json.usage?.total_tokens ?? 0
+    };
+    return {
+      content: typeof msg.content === "string" ? msg.content : "",
+      toolCalls: parseToolCalls(msg.tool_calls),
+      usage,
+      model: json.model ?? req.model,
+      costUsd: computeCost(usage, pricing, json.usage?.cost),
+      finishReason: choice.finish_reason ?? null
+    };
+  }
+  /**
+   * Streaming completion. Yields text deltas; returns the full CompletionResult.
+   * Tool-call deltas are accumulated and surfaced in the final result.
+   */
+  async *stream(req, pricing) {
+    if (!this.apiKey) throw new OpenRouterError("No API key set. Run `poly login`.");
+    const res = await fetch(`${BASE}/chat/completions`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(this.buildBody(req, true))
+    });
+    if (!res.ok || !res.body) {
+      const text = await res.text().catch(() => "");
+      throw new OpenRouterError(`Stream failed (${res.status}): ${truncate(text)}`, res.status);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    const toolAcc = /* @__PURE__ */ new Map();
+    let usageJson = null;
+    let finishReason = null;
+    let model = req.model;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data:")) continue;
+        const data = trimmed.slice(5).trim();
+        if (data === "[DONE]") continue;
+        let evt;
+        try {
+          evt = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (evt?.error) {
+          throw new OpenRouterError(evt.error.message ?? "Stream provider error", evt.error.code);
+        }
+        if (evt.model) model = evt.model;
+        if (evt.usage) usageJson = evt.usage;
+        const choice = evt.choices?.[0];
+        if (!choice) continue;
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+        const delta = choice.delta ?? {};
+        if (typeof delta.content === "string" && delta.content) {
+          content += delta.content;
+          yield delta.content;
+        }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index ?? 0;
+            const cur = toolAcc.get(idx) ?? { id: "", name: "", args: "" };
+            if (tc.id) cur.id = tc.id;
+            if (tc.function?.name) cur.name = tc.function.name;
+            if (tc.function?.arguments) cur.args += tc.function.arguments;
+            toolAcc.set(idx, cur);
+          }
+        }
+      }
+    }
+    const usage = {
+      promptTokens: usageJson?.prompt_tokens ?? 0,
+      completionTokens: usageJson?.completion_tokens ?? 0,
+      totalTokens: usageJson?.total_tokens ?? 0
+    };
+    const toolCalls = [...toolAcc.values()].filter((t) => t.name).map((t) => ({
+      id: t.id || `call_${t.name}`,
+      type: "function",
+      function: { name: t.name, arguments: t.args || "{}" }
+    }));
+    return {
+      content,
+      toolCalls,
+      usage,
+      model,
+      costUsd: computeCost(usage, pricing, usageJson?.cost),
+      finishReason
+    };
+  }
+};
+function serializeMessage(m) {
+  if (m.role === "assistant" && m.tool_calls?.length) {
+    return { role: "assistant", content: m.content ?? "", tool_calls: m.tool_calls };
+  }
+  if (m.role === "tool") {
+    return { role: "tool", tool_call_id: m.tool_call_id, content: m.content };
+  }
+  return { role: m.role, content: m.content };
+}
+function parseToolCalls(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((t) => ({
+    id: t.id ?? `call_${t.function?.name ?? "fn"}`,
+    type: "function",
+    function: {
+      name: t.function?.name ?? "",
+      arguments: t.function?.arguments ?? "{}"
+    }
+  }));
+}
+function computeCost(usage, pricing, providerCost) {
+  if (typeof providerCost === "number") return providerCost;
+  return usage.promptTokens / 1e6 * pricing.promptUsdPerMTok + usage.completionTokens / 1e6 * pricing.completionUsdPerMTok;
+}
+function truncate(s, n = 240) {
+  return s.length > n ? s.slice(0, n) + "\u2026" : s;
+}
+
+// src/models/registry.ts
+import fs3 from "node:fs";
+
+// src/models/tiers.ts
+var FRONTIER_PATTERNS = [
+  /claude.*(sonnet|opus)/,
+  /\bgpt-4o\b(?!-mini)/,
+  /\bgpt-4\.1\b(?!-mini|-nano)/,
+  /\bgpt-5\b/,
+  /\bo[1-4]\b/,
+  // o1 / o3 / o4 reasoning models
+  /gemini-(1\.5|2\.0|2\.5)-pro/,
+  /grok-[2-9]/,
+  /deepseek.*(r1|reasoner)/,
+  /llama-3\.1-405b/,
+  /llama-4-(maverick|behemoth)/,
+  /qwen.*(max|235b|plus)/,
+  /mistral-large/,
+  /command-(r-plus|a)\b/
+];
+var SMALL_PATTERNS = [
+  /mini/,
+  /flash/,
+  /haiku/,
+  /lite/,
+  /nano/,
+  /small/,
+  /-(1|2|3|7|8|9)b\b/,
+  /\b(1|2|3|7|8|9)b-/
+];
+function classifyTier(idOrName, completionPerMTok) {
+  const s = idOrName.toLowerCase();
+  const isFrontierFamily = FRONTIER_PATTERNS.some((re) => re.test(s));
+  const isSmallFamily = SMALL_PATTERNS.some((re) => re.test(s));
+  if (isFrontierFamily && !isSmallFamily) return "frontier";
+  if (!isSmallFamily && completionPerMTok >= 9) return "frontier";
+  if (completionPerMTok <= 1.5 || isSmallFamily) {
+    return completionPerMTok > 6 ? "standard" : "cheap";
+  }
+  return "standard";
+}
+
+// src/models/parse.ts
+function findModel(models, id) {
+  return models.find((m) => m.id === id);
+}
+function toPerMTok(raw) {
+  const n = typeof raw === "string" ? parseFloat(raw) : raw ?? 0;
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n * 1e6;
+}
+function parseModels(raw) {
+  const out = [];
+  for (const m of raw) {
+    if (!m?.id) continue;
+    const promptUsdPerMTok = toPerMTok(m.pricing?.prompt);
+    const completionUsdPerMTok = toPerMTok(m.pricing?.completion);
+    const provider = String(m.id).split("/")[0] ?? "unknown";
+    const modalities = m.architecture?.input_modalities ?? (typeof m.architecture?.modality === "string" ? String(m.architecture.modality).split(/[+\->]/) : []);
+    const supported = m.supported_parameters ?? [];
+    out.push({
+      id: m.id,
+      name: m.name ?? m.id,
+      provider,
+      contextLength: m.context_length ?? m.top_provider?.context_length ?? 0,
+      pricing: { promptUsdPerMTok, completionUsdPerMTok },
+      tier: classifyTier(`${m.id} ${m.name ?? ""}`, completionUsdPerMTok),
+      capabilities: {
+        tools: supported.includes("tools") || supported.includes("tool_choice"),
+        vision: modalities.some((x) => /image|vision/i.test(x))
+      }
+    });
+  }
+  return out;
+}
+
+// src/models/registry.ts
+var CACHE_TTL_MS = 1e3 * 60 * 60 * 12;
+function loadCachedModels(maxAgeMs = CACHE_TTL_MS) {
+  try {
+    const file = modelCachePath();
+    if (!fs3.existsSync(file)) return null;
+    const cache = JSON.parse(fs3.readFileSync(file, "utf8"));
+    if (Date.now() - cache.fetchedAt > maxAgeMs) return null;
+    return cache.models;
+  } catch {
+    return null;
+  }
+}
+function writeModelCache(models) {
+  ensureConfigDir();
+  const cache = { fetchedAt: Date.now(), models };
+  fs3.writeFileSync(modelCachePath(), JSON.stringify(cache));
+}
+async function getModels(client2, opts = {}) {
+  if (!opts.refresh) {
+    const cached = loadCachedModels();
+    if (cached && cached.length) return cached;
+  }
+  const raw = await client2.listRawModels();
+  const models = parseModels(raw);
+  writeModelCache(models);
+  return models;
+}
+
+// src/auth/onboarding.ts
+import readline from "node:readline";
+
+// src/util/format.ts
+import pc from "picocolors";
+function usd(amount) {
+  if (amount === 0) return "$0";
+  if (amount < 1e-4) return "<$0.0001";
+  if (amount < 1) return "$" + amount.toFixed(4);
+  if (amount < 100) return "$" + amount.toFixed(3);
+  return "$" + amount.toFixed(2);
+}
+function perMTok(usdPerMTok) {
+  if (usdPerMTok === 0) return "free";
+  if (usdPerMTok < 1) return "$" + usdPerMTok.toFixed(3) + "/M";
+  return "$" + usdPerMTok.toFixed(2) + "/M";
+}
+function tokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return (n / 1e3).toFixed(1).replace(/\.0$/, "") + "k";
+  return (n / 1e6).toFixed(2).replace(/\.00$/, "") + "M";
+}
+function tierColor(tier, text) {
+  const t = text ?? tier;
+  switch (tier) {
+    case "cheap":
+      return pc.green(t);
+    case "standard":
+      return pc.yellow(t);
+    case "frontier":
+      return pc.magenta(t);
+    default:
+      return t;
+  }
+}
+function table(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(visibleLen(h), ...rows.map((r) => visibleLen(r[i] ?? "")))
+  );
+  const sep = "  ";
+  const fmtRow = (cells) => cells.map((c2, i) => pad(c2, widths[i])).join(sep).trimEnd();
+  const lines = [
+    pc.bold(fmtRow(headers)),
+    widths.map((w) => "\u2500".repeat(w)).join(sep),
+    ...rows.map(fmtRow)
+  ];
+  return lines.join("\n");
+}
+var ANSI = /\x1b\[[0-9;]*m/g;
+function visibleLen(s) {
+  return s.replace(ANSI, "").length;
+}
+function pad(s, width) {
+  const extra = width - visibleLen(s);
+  return extra > 0 ? s + " ".repeat(extra) : s;
+}
+var c = pc;
+
+// src/auth/onboarding.ts
+function ask(query, opts = {}) {
+  return new Promise((resolve2) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    if (opts.hidden) {
+      const out = rl.output;
+      rl._writeToOutput = (str) => {
+        if (str.includes(query) || str.includes("\n") || str.includes("\r")) out.write(str);
+        else out.write("*");
+      };
+    }
+    rl.question(query, (answer) => {
+      rl.close();
+      if (opts.hidden) process.stdout.write("\n");
+      resolve2(answer.trim());
+    });
+  });
+}
+async function runLogin() {
+  const config = loadConfig();
+  const existing = resolveApiKey(config);
+  console.log(c.bold("\n\u{1F50C} Connect Polymath to your models (via OpenRouter)\n"));
+  console.log(
+    [
+      "Polymath reaches 300+ models from every major provider through a single OpenRouter key.",
+      "",
+      c.bold("1.") + " Create a key (free to sign up):  " + c.cyan("https://openrouter.ai/keys"),
+      c.bold("2.") + " Add credit or use free models:    " + c.cyan("https://openrouter.ai/credits"),
+      c.bold("3.") + " Paste the key (starts with " + c.dim("sk-or-...") + ") below.",
+      "",
+      c.dim("The key is stored locally at ~/.config/polymath/config.json (chmod 600) and never sent anywhere except OpenRouter."),
+      ""
+    ].join("\n")
+  );
+  if (existing) {
+    const mask = existing.slice(0, 8) + "\u2026" + existing.slice(-4);
+    const keep = await ask(`A key is already configured (${mask}). Replace it? [y/N] `);
+    if (!/^y/i.test(keep)) {
+      console.log(c.dim("Keeping existing key."));
+      return existing;
+    }
+  }
+  const key = await ask("OpenRouter API key: ", { hidden: true });
+  if (!key) {
+    console.log(c.yellow("No key entered \u2014 aborted."));
+    return null;
+  }
+  if (!/^sk-or-/.test(key)) {
+    console.log(c.yellow("Warning: key does not start with 'sk-or-'. Continuing anyway."));
+  }
+  process.stdout.write("Validating\u2026 ");
+  const client2 = new OpenRouterClient({ apiKey: key, referer: config.referer, title: config.title });
+  let ok = false;
+  let detail = "";
+  try {
+    const info = await client2.validateKey();
+    ok = true;
+    const used = typeof info.usage === "number" ? `$${info.usage.toFixed(2)} used` : "";
+    const limit = info.limit == null ? "no preset limit" : `$${info.limit} limit`;
+    detail = [info.label, used, limit].filter(Boolean).join(" \xB7 ");
+  } catch (err) {
+    console.log(c.red("failed."));
+    console.log(c.red(`  ${err?.message ?? err}`));
+    const save = await ask("Save the key anyway (e.g. offline)? [y/N] ");
+    if (!/^y/i.test(save)) return null;
+  }
+  config.openrouterApiKey = key;
+  saveConfig(config);
+  if (ok) console.log(c.green("ok") + c.dim(detail ? `  (${detail})` : ""));
+  console.log(c.green("\u2713 Saved. You're connected.") + c.dim('  Try: poly recommend "add a dark-mode toggle"'));
+  return key;
+}
+async function ensureApiKey(config) {
+  const existing = resolveApiKey(config);
+  if (existing) return existing;
+  console.log(c.yellow("No OpenRouter API key found \u2014 let's connect one."));
+  return runLogin();
+}
+
+// src/planner/tasks.ts
+var TASK_SPECS = {
+  plan: { type: "plan", minTier: "standard", needsTools: false, label: "Plan / decompose" },
+  search: { type: "search", minTier: "cheap", needsTools: true, label: "Search codebase" },
+  read: { type: "read", minTier: "cheap", needsTools: true, label: "Read & understand" },
+  edit: { type: "edit", minTier: "standard", needsTools: true, label: "Edit code" },
+  command: { type: "command", minTier: "cheap", needsTools: true, label: "Run command" },
+  review: { type: "review", minTier: "frontier", needsTools: false, label: "Review / critique" },
+  reason: { type: "reason", minTier: "frontier", needsTools: false, label: "Hard reasoning" },
+  explain: { type: "explain", minTier: "cheap", needsTools: false, label: "Explain" },
+  summarize: { type: "summarize", minTier: "cheap", needsTools: false, label: "Summarize" },
+  chat: { type: "chat", minTier: "cheap", needsTools: false, label: "Chat" }
+};
+var ALL_TASK_TYPES = Object.keys(TASK_SPECS);
+
+// src/planner/planner.ts
+var PLAN_SYSTEM = `You are the planning stage of a coding agent. Break the user's request into a short, ordered list of concrete steps.
+Each step must be classified by type, chosen from EXACTLY this set:
+  plan      - high-level decomposition / design decisions
+  search    - locate files, symbols, or information in the codebase
+  read      - read & understand existing code
+  edit      - write or modify code
+  command   - run a shell/build/test command
+  review    - critique code for correctness or bugs
+  reason    - hard algorithmic or architectural reasoning
+  explain   - explain results to the user
+  summarize - condense long content
+  chat      - a simple conversational reply
+
+Return ONLY minified JSON of the form:
+{"steps":[{"type":"<type>","description":"...","estPromptTokens":<int>,"estCompletionTokens":<int>}]}
+Use 3-8 steps for non-trivial work, fewer for simple requests. Estimate tokens realistically (prompts often 2000-15000, completions 200-3000).`;
+function heuristicPlan(goal) {
+  const steps = [
+    { id: 1, type: "plan", description: "Decompose the request", estPromptTokens: 2e3, estCompletionTokens: 600 },
+    { id: 2, type: "search", description: "Locate relevant files", estPromptTokens: 3e3, estCompletionTokens: 400 },
+    { id: 3, type: "read", description: "Read & understand code", estPromptTokens: 8e3, estCompletionTokens: 500 },
+    { id: 4, type: "edit", description: "Implement the change", estPromptTokens: 9e3, estCompletionTokens: 1500 },
+    { id: 5, type: "review", description: "Review the change", estPromptTokens: 6e3, estCompletionTokens: 800 }
+  ];
+  return { goal, steps };
+}
+async function planRequest(goal, client2, planModel) {
+  const result = await client2.complete(
+    {
+      model: planModel.id,
+      messages: [
+        { role: "system", content: PLAN_SYSTEM },
+        { role: "user", content: goal }
+      ],
+      temperature: 0,
+      maxTokens: 1200
+    },
+    planModel.pricing
+  );
+  const parsed = extractPlan(result.content);
+  if (!parsed) return heuristicPlan(goal);
+  return { goal, steps: parsed };
+}
+function extractPlan(text) {
+  const json = extractJson(text);
+  if (!json) return null;
+  try {
+    const obj = JSON.parse(json);
+    if (!Array.isArray(obj.steps)) return null;
+    const steps = obj.steps.map((s, i) => ({
+      id: i + 1,
+      type: coerceTaskType(s.type),
+      description: String(s.description ?? "").slice(0, 300) || "(step)",
+      estPromptTokens: clampInt(s.estPromptTokens, 500, 6e4, 4e3),
+      estCompletionTokens: clampInt(s.estCompletionTokens, 100, 8e3, 800)
+    }));
+    return steps.length ? steps : null;
+  } catch {
+    return null;
+  }
+}
+function coerceTaskType(v) {
+  const s = String(v).toLowerCase().trim();
+  return ALL_TASK_TYPES.includes(s) ? s : "edit";
+}
+function clampInt(v, min, max, fallback) {
+  const n = typeof v === "number" ? v : parseInt(String(v), 10);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, Math.round(n)));
+}
+function extractJson(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = fence ? fence[1] : text;
+  const start = body.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < body.length; i++) {
+    const ch = body[i];
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return body.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+
+// src/router/policy.ts
+var TIER_RANK = { cheap: 0, standard: 1, frontier: 2 };
+function tierAtLeast(tier, min) {
+  return TIER_RANK[tier] >= TIER_RANK[min];
+}
+function blendedPrice(m) {
+  return (m.pricing.promptUsdPerMTok * 3 + m.pricing.completionUsdPerMTok) / 4;
+}
+function valueScore(m) {
+  const price = Math.max(blendedPrice(m), 0.01);
+  const capability = TIER_RANK[m.tier] + 1;
+  return capability / price;
+}
+
+// src/models/strengths.ts
+var STRENGTH_RULES = [
+  // Anthropic — Claude Code's home turf: coding, agentic tool use, instruction following.
+  { pattern: /claude.*(opus)/, skills: { coding: 1.7, reasoning: 1.5, general: 1.5 } },
+  { pattern: /claude.*(sonnet)/, skills: { coding: 1.65, reasoning: 1.4, general: 1.45, vision: 1.3 } },
+  { pattern: /claude.*(haiku)/, skills: { coding: 1.4, speed: 1.55, general: 1.15 } },
+  // OpenAI
+  { pattern: /\bo[1-4]\b|gpt-5.*(thinking|pro)|o[1-4]-(mini|pro)/, skills: { reasoning: 1.7, coding: 1.35 } },
+  { pattern: /gpt-4o|gpt-4\.1|gpt-5/, skills: { coding: 1.45, reasoning: 1.3, general: 1.45, vision: 1.35 } },
+  { pattern: /gpt-4o-mini|gpt-4\.1-mini|gpt-5-mini|gpt-5-nano/, skills: { speed: 1.4, general: 1.1 } },
+  // DeepSeek — strong cheap coding & reasoning.
+  { pattern: /deepseek.*(r1|reasoner)/, skills: { reasoning: 1.75, coding: 1.4 } },
+  { pattern: /deepseek.*(v3|chat|coder|v2)/, skills: { coding: 1.55, reasoning: 1.25 } },
+  // Qwen
+  { pattern: /qwen.*coder/, skills: { coding: 1.65 } },
+  { pattern: /qwen.*(thinking|qwq)/, skills: { reasoning: 1.55, coding: 1.2 } },
+  { pattern: /qwen(3|2\.5)?[-.]?(max|235b|72b|plus)/, skills: { coding: 1.3, reasoning: 1.3, general: 1.25 } },
+  // Coding specialists
+  { pattern: /codestral|codex|code-|coder|kimi/, skills: { coding: 1.55, reasoning: 1.2 } },
+  // Google Gemini — long-context retrieval & cheap throughput.
+  { pattern: /gemini.*(flash|lite)/, skills: { speed: 1.6, retrieval: 1.55, general: 1.15 } },
+  { pattern: /gemini.*pro/, skills: { retrieval: 1.65, reasoning: 1.4, coding: 1.25, vision: 1.35 } },
+  // xAI / Meta / Mistral
+  { pattern: /grok-[3-9]/, skills: { reasoning: 1.4, coding: 1.3, general: 1.25 } },
+  { pattern: /llama.*(405b|maverick|70b)/, skills: { general: 1.25, coding: 1.15 } },
+  { pattern: /mistral-large|mixtral/, skills: { coding: 1.2, general: 1.2 } },
+  // Small/fast families — strong at cheap throughput, not hard tasks.
+  { pattern: /ministral|gemma|phi|nemotron-(nano|mini)|-(1|2|3|4)b\b|mini|nano|lite|small/, skills: { speed: 1.45 } }
+];
+var TASK_SKILL = {
+  plan: "reasoning",
+  search: "retrieval",
+  read: "retrieval",
+  edit: "coding",
+  command: "speed",
+  review: "reasoning",
+  reason: "reasoning",
+  explain: "general",
+  summarize: "speed",
+  chat: "speed"
+};
+var TIER_BASE = { cheap: 1, standard: 1.4, frontier: 1.8 };
+function skillBonus(m, skill) {
+  const s = `${m.id} ${m.name}`.toLowerCase();
+  let bonus = 1;
+  for (const rule of STRENGTH_RULES) {
+    if (rule.pattern.test(s)) {
+      const b = rule.skills[skill];
+      if (b && b > bonus) bonus = b;
+    }
+  }
+  return bonus;
+}
+function strengthFor(m, skill) {
+  return TIER_BASE[m.tier] * skillBonus(m, skill);
+}
+function taskStrength(m, taskType) {
+  return strengthFor(m, TASK_SKILL[taskType]);
+}
+var TASK_MIN_STRENGTH = {
+  edit: 1.4,
+  review: 1.5,
+  reason: 1.5,
+  plan: 1.2
+};
+var HEADLINE_SKILLS = ["coding", "reasoning", "retrieval", "speed"];
+
+// src/router/router.ts
+function projectCost(m, est) {
+  return est.promptTokens / 1e6 * m.pricing.promptUsdPerMTok + est.completionTokens / 1e6 * m.pricing.completionUsdPerMTok;
+}
+function taskValue(m, taskType) {
+  return taskStrength(m, taskType) / Math.max(blendedPrice(m), 0.01);
+}
+function candidatesFor(taskType, models, policy, est) {
+  const spec = TASK_SPECS[taskType];
+  const strengthFloor = TASK_MIN_STRENGTH[taskType] ?? 0;
+  return models.filter((m) => {
+    if (m.id === "openrouter/auto") return false;
+    const covers = tierAtLeast(m.tier, spec.minTier) || taskStrength(m, taskType) >= strengthFloor;
+    if (!covers) return false;
+    if (spec.needsTools && !m.capabilities.tools) return false;
+    if (policy.maxCostPerCallUsd != null && est) {
+      if (projectCost(m, est) > policy.maxCostPerCallUsd) return false;
+    }
+    return true;
+  });
+}
+function rank(models, policy, taskType) {
+  const sorted = [...models];
+  switch (policy.objective) {
+    case "cheapest":
+      sorted.sort((a, b) => blendedPrice(a) - blendedPrice(b));
+      break;
+    case "quality":
+      sorted.sort(
+        (a, b) => taskStrength(b, taskType) - taskStrength(a, taskType) || blendedPrice(b) - blendedPrice(a)
+      );
+      break;
+    case "value":
+    default:
+      sorted.sort((a, b) => taskValue(b, taskType) - taskValue(a, taskType));
+      break;
+  }
+  return sorted;
+}
+function route(taskType, models, policy, est = { promptTokens: 4e3, completionTokens: 1e3 }) {
+  const pinId = policy.pinned?.[taskType];
+  if (pinId) {
+    const pinned = findModel(models, pinId);
+    if (pinned) {
+      return { model: pinned, reason: `pinned for ${taskType}`, estCostUsd: projectCost(pinned, est) };
+    }
+  }
+  const cands = candidatesFor(taskType, models, policy, est);
+  if (!cands.length) return null;
+  const ranked = rank(cands, policy, taskType);
+  const chosen = ranked[0];
+  const skill = TASK_SKILL[taskType];
+  const reason = policy.objective === "cheapest" ? `cheapest model that covers ${skill}` : policy.objective === "quality" ? `strongest at ${skill}` : `best ${skill}-per-dollar`;
+  return { model: chosen, reason, estCostUsd: projectCost(chosen, est) };
+}
+
+// src/recommend/recommend.ts
+var OBJECTIVES = [
+  { objective: "cheapest", label: "Cheapest \u2014 minimize cost" },
+  { objective: "value", label: "Best value \u2014 capability per dollar" },
+  { objective: "quality", label: "Best quality \u2014 strongest per task" }
+];
+function estOf(step) {
+  return { promptTokens: step.estPromptTokens, completionTokens: step.estCompletionTokens };
+}
+function strategyFor(plan, models, objective, label) {
+  const policy = { objective };
+  const assignments = plan.steps.map((step) => {
+    const r = route(step.type, models, policy, estOf(step));
+    return r ? { step, model: r.model, estCostUsd: r.estCostUsd, reason: r.reason } : { step, model: null, estCostUsd: 0, reason: "no capable model" };
+  });
+  const totalCostUsd = assignments.reduce((s, a) => s + a.estCostUsd, 0);
+  const distinctModels = new Set(assignments.map((a) => a.model?.id).filter(Boolean)).size;
+  return { objective, label, assignments, totalCostUsd, distinctModels };
+}
+function bestValueBySkill(models) {
+  const out = {};
+  for (const skill of HEADLINE_SKILLS) {
+    out[skill] = models.filter((m) => m.id !== "openrouter/auto" && skillBonus(m, skill) > 1.05).sort(
+      (a, b) => strengthFor(b, skill) / Math.max(blendedPrice(b), 0.01) - strengthFor(a, skill) / Math.max(blendedPrice(a), 0.01)
+    ).slice(0, 4);
+  }
+  return out;
+}
+function bestValueByTier(models) {
+  const tiers = ["cheap", "standard", "frontier"];
+  const out = {};
+  for (const t of tiers) {
+    out[t] = models.filter((m) => m.tier === t && m.id !== "openrouter/auto").sort((a, b) => valueScore(b) - valueScore(a)).slice(0, 5);
+  }
+  return out;
+}
+function singleModelCost(plan, model) {
+  let feasible = true;
+  let total = 0;
+  for (const step of plan.steps) {
+    const spec = TASK_SPECS[step.type];
+    if (!tierAtLeast(model.tier, spec.minTier)) feasible = false;
+    if (spec.needsTools && !model.capabilities.tools) feasible = false;
+    total += projectCost(model, estOf(step));
+  }
+  return { model, totalCostUsd: total, feasible };
+}
+function buildRecommendation(plan, models) {
+  const strategies = OBJECTIVES.map((o) => strategyFor(plan, models, o.objective, o.label));
+  const byTier = bestValueByTier(models);
+  const picks = ["cheap", "standard", "frontier"].map((t) => byTier[t][0]).filter(Boolean);
+  const singleModelBaselines = picks.map((m) => singleModelCost(plan, m));
+  const valueStrategy = strategies.find((s) => s.objective === "value");
+  const qualityStrategy = strategies.find((s) => s.objective === "quality");
+  const savingsPct = qualityStrategy.totalCostUsd > 0 ? (1 - valueStrategy.totalCostUsd / qualityStrategy.totalCostUsd) * 100 : 0;
+  return {
+    plan,
+    strategies,
+    bestValueByTier: byTier,
+    bestValueBySkill: bestValueBySkill(models),
+    singleModelBaselines,
+    savingsPct
+  };
+}
+function renderRecommendation(rec) {
+  const out = [];
+  out.push(c.bold(`Plan for: ${c.cyan(rec.plan.goal)}`));
+  out.push(
+    table(
+      ["#", "Task", "Type", "Needs", "Est tok (in/out)"],
+      rec.plan.steps.map((s) => [
+        String(s.id),
+        s.description,
+        tierColor(TASK_SPECS[s.type].minTier, s.type),
+        TASK_SKILL[s.type],
+        `${s.estPromptTokens}/${s.estCompletionTokens}`
+      ])
+    )
+  );
+  out.push("");
+  for (const strat of rec.strategies) {
+    out.push(c.bold(strat.label) + c.dim(`  (${strat.distinctModels} model(s), est ${usd(strat.totalCostUsd)})`));
+    out.push(
+      table(
+        ["Step", "Model", "Tier", "Est cost"],
+        strat.assignments.map((a) => [
+          `${a.step.id} ${a.step.type}`,
+          a.model ? a.model.id : c.red("(none)"),
+          a.model ? tierColor(a.model.tier) : "-",
+          usd(a.estCostUsd)
+        ])
+      )
+    );
+    out.push("");
+  }
+  out.push(c.bold("Best value by skill") + c.dim("  (strongest-per-dollar for each kind of work)"));
+  for (const skill of HEADLINE_SKILLS) {
+    const list = rec.bestValueBySkill[skill];
+    if (!list || !list.length) continue;
+    out.push(
+      "  " + c.cyan(skill.padEnd(10)) + list.slice(0, 3).map((m) => `${m.id} ${c.dim(perMTok(blendedPrice(m)))}`).join(c.dim("  \xB7  "))
+    );
+  }
+  out.push("");
+  out.push(c.bold("Best-value models by tier") + c.dim("  (capability per dollar)"));
+  for (const tier of ["cheap", "standard", "frontier"]) {
+    const list = rec.bestValueByTier[tier];
+    if (!list.length) continue;
+    out.push(
+      "  " + tierColor(tier, tier.toUpperCase().padEnd(9)) + list.slice(0, 3).map((m) => `${m.id} ${c.dim(perMTok(blendedPrice(m)))}`).join(c.dim("  \xB7  "))
+    );
+  }
+  out.push("");
+  out.push(c.bold("Single-model baselines (whole plan on one model)"));
+  out.push(
+    table(
+      ["Model", "Tier", "Feasible?", "Est cost"],
+      rec.singleModelBaselines.map((b) => [
+        b.model.id,
+        tierColor(b.model.tier),
+        b.feasible ? c.green("yes") : c.yellow("partial"),
+        usd(b.totalCostUsd)
+      ])
+    )
+  );
+  out.push("");
+  if (rec.savingsPct > 0) {
+    out.push(
+      c.green(
+        `\u2192 Best-value routing costs ~${rec.savingsPct.toFixed(
+          0
+        )}% less than running every step on the strongest model.`
+      )
+    );
+  }
+  out.push(
+    c.dim(
+      "Estimates use a heuristic plan + token guesses; actuals are logged per call and shown in `poly usage`."
+    )
+  );
+  return out.join("\n");
+}
+
+// src/usage/db.ts
+import { DatabaseSync } from "node:sqlite";
+var db = null;
+function getDb() {
+  if (db) return db;
+  ensureConfigDir();
+  db = new DatabaseSync(dbFilePath());
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS usage_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      ts INTEGER NOT NULL,
+      date TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      task_type TEXT NOT NULL,
+      prompt_tokens INTEGER NOT NULL,
+      completion_tokens INTEGER NOT NULL,
+      total_tokens INTEGER NOT NULL,
+      cost_usd REAL NOT NULL,
+      session_id TEXT,
+      synced INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_usage_date ON usage_log(date);
+    CREATE INDEX IF NOT EXISTS idx_usage_model ON usage_log(model);
+  `);
+  return db;
+}
+function recordUsage(e) {
+  const stmt = getDb().prepare(`
+    INSERT INTO usage_log
+      (ts, date, provider, model, task_type, prompt_tokens, completion_tokens, total_tokens, cost_usd, session_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    e.ts,
+    e.date,
+    e.provider,
+    e.model,
+    e.taskType,
+    e.promptTokens,
+    e.completionTokens,
+    e.totalTokens,
+    e.costUsd,
+    e.sessionId ?? null
+  );
+}
+function reportByDateModel(filter = {}) {
+  const where = [];
+  const params = [];
+  if (filter.since) {
+    where.push("date >= ?");
+    params.push(filter.since);
+  }
+  if (filter.until) {
+    where.push("date <= ?");
+    params.push(filter.until);
+  }
+  const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+  const rows = getDb().prepare(
+    `SELECT date, model, provider,
+              COUNT(*) AS calls,
+              SUM(prompt_tokens) AS promptTokens,
+              SUM(completion_tokens) AS completionTokens,
+              SUM(total_tokens) AS totalTokens,
+              SUM(cost_usd) AS costUsd
+       FROM usage_log
+       ${whereSql}
+       GROUP BY date, model
+       ORDER BY date DESC, costUsd DESC`
+  ).all(...params);
+  return rows.map((r) => ({
+    date: String(r.date),
+    model: String(r.model),
+    provider: String(r.provider),
+    calls: Number(r.calls),
+    promptTokens: Number(r.promptTokens),
+    completionTokens: Number(r.completionTokens),
+    totalTokens: Number(r.totalTokens),
+    costUsd: Number(r.costUsd)
+  }));
+}
+function totals(filter = {}) {
+  const rows = reportByDateModel(filter);
+  return rows.reduce(
+    (acc, r) => ({
+      calls: acc.calls + r.calls,
+      totalTokens: acc.totalTokens + r.totalTokens,
+      costUsd: acc.costUsd + r.costUsd
+    }),
+    { calls: 0, totalTokens: 0, costUsd: 0 }
+  );
+}
+function unsyncedRows() {
+  const rows = getDb().prepare(`SELECT * FROM usage_log WHERE synced = 0 ORDER BY id ASC LIMIT 500`).all();
+  return rows.map((r) => ({
+    id: Number(r.id),
+    ts: Number(r.ts),
+    date: String(r.date),
+    provider: String(r.provider),
+    model: String(r.model),
+    taskType: String(r.task_type),
+    promptTokens: Number(r.prompt_tokens),
+    completionTokens: Number(r.completion_tokens),
+    totalTokens: Number(r.total_tokens),
+    costUsd: Number(r.cost_usd),
+    sessionId: r.session_id ? String(r.session_id) : void 0
+  }));
+}
+function markSynced(ids) {
+  if (!ids.length) return;
+  const stmt = getDb().prepare(`UPDATE usage_log SET synced = 1 WHERE id = ?`);
+  for (const id of ids) stmt.run(id);
+}
+
+// src/usage/report.ts
+function renderUsageReport(filter = {}) {
+  const rows = reportByDateModel(filter);
+  if (!rows.length) {
+    return c.dim('No usage recorded yet. Run `poly run "<task>"` to start tracking.');
+  }
+  const body = table(
+    ["Date", "Model", "Calls", "Prompt", "Compl.", "Cost"],
+    rows.map((r) => [
+      r.date,
+      r.model,
+      String(r.calls),
+      tokens(r.promptTokens),
+      tokens(r.completionTokens),
+      usd(r.costUsd)
+    ])
+  );
+  const t = totals(filter);
+  const byModel = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const cur = byModel.get(r.model) ?? { cost: 0, tokens: 0, calls: 0 };
+    cur.cost += r.costUsd;
+    cur.tokens += r.totalTokens;
+    cur.calls += r.calls;
+    byModel.set(r.model, cur);
+  }
+  const modelRollup = table(
+    ["Model", "Calls", "Tokens", "Cost"],
+    [...byModel.entries()].sort((a, b) => b[1].cost - a[1].cost).map(([model, v]) => [model, String(v.calls), tokens(v.tokens), usd(v.cost)])
+  );
+  return [
+    c.bold("Usage by date + model"),
+    body,
+    "",
+    c.bold("Totals by model"),
+    modelRollup,
+    "",
+    `${c.bold("TOTAL")}  ${t.calls} calls \xB7 ${tokens(t.totalTokens)} tokens \xB7 ${c.green(usd(t.costUsd))}`
+  ].join("\n");
+}
+
+// src/usage/firestoreSync.ts
+async function syncUsage(config) {
+  if (!config.firestore.enabled) {
+    return { synced: 0, message: "Firestore sync is disabled (enable with `poly config firestore on`)." };
+  }
+  let appMod, fsMod;
+  try {
+    appMod = await import("firebase-admin/app");
+    fsMod = await import("firebase-admin/firestore");
+  } catch {
+    return {
+      synced: 0,
+      message: "firebase-admin is not installed. Run `npm install firebase-admin` to enable sync."
+    };
+  }
+  const { initializeApp, getApps, cert } = appMod;
+  if (getApps().length === 0) {
+    const saJson = process.env.FIREBASE_SERVICE_ACCOUNT_KEY;
+    if (saJson) {
+      try {
+        initializeApp({ credential: cert(JSON.parse(saJson)) });
+      } catch {
+        initializeApp({ projectId: config.firestore.projectId });
+      }
+    } else {
+      initializeApp({ projectId: config.firestore.projectId });
+    }
+  }
+  const fdb = fsMod.getFirestore();
+  const rows = unsyncedRows();
+  if (!rows.length) return { synced: 0, message: "Nothing to sync \u2014 all rows already pushed." };
+  const batch = fdb.batch();
+  const col = fdb.collection(config.firestore.collection);
+  for (const r of rows) {
+    const ref = col.doc(`${r.date}__${r.id}`);
+    batch.set(ref, {
+      ts: r.ts,
+      date: r.date,
+      provider: r.provider,
+      model: r.model,
+      taskType: r.taskType,
+      promptTokens: r.promptTokens,
+      completionTokens: r.completionTokens,
+      totalTokens: r.totalTokens,
+      costUsd: r.costUsd,
+      sessionId: r.sessionId ?? null
+    });
+  }
+  await batch.commit();
+  markSynced(rows.map((r) => r.id));
+  return { synced: rows.length, message: `Synced ${rows.length} rows to ${config.firestore.collection}.` };
+}
+
+// src/tui/App.tsx
+import { useState, useEffect, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+
+// src/agent/tools.ts
+import fs4 from "node:fs";
+import path2 from "node:path";
+import { execSync } from "node:child_process";
+var TOOL_SCHEMAS = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read a UTF-8 text file relative to the working directory.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "File path" } },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Create or overwrite a UTF-8 text file. Creates parent directories as needed.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          content: { type: "string" }
+        },
+        required: ["path", "content"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_dir",
+      description: "List the entries of a directory.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "Directory path (default '.')" } }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description: "Run a shell command in the working directory and return combined stdout/stderr.",
+      parameters: {
+        type: "object",
+        properties: { command: { type: "string" } },
+        required: ["command"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "finish",
+      description: "Signal that the task is complete with a short summary for the user.",
+      parameters: {
+        type: "object",
+        properties: { summary: { type: "string" } },
+        required: ["summary"]
+      }
+    }
+  }
+];
+var MAX_OUTPUT = 8e3;
+function clip(s) {
+  return s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) + `
+\u2026(truncated, ${s.length} chars)` : s;
+}
+function redactSecrets(s) {
+  return s.replace(/sk-or-[A-Za-z0-9._-]+/g, "sk-or-***REDACTED***").replace(/"private_key"\s*:\s*"[^"]*"/g, '"private_key":"***REDACTED***"');
+}
+var SECRET_ENV = ["OPENROUTER_API_KEY", "FIREBASE_SERVICE_ACCOUNT_KEY", "GOOGLE_APPLICATION_CREDENTIALS"];
+function scrubbedEnv() {
+  const env = { ...process.env };
+  for (const k of SECRET_ENV) delete env[k];
+  return env;
+}
+function resolve(ctx, p) {
+  const root = path2.resolve(ctx.cwd);
+  const abs = path2.resolve(root, p);
+  const rel = path2.relative(root, abs);
+  if (rel === "") return abs;
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+    throw new Error(`path escapes the working directory: ${p}`);
+  }
+  return abs;
+}
+function executeTool(name, argsJson, ctx) {
+  let args = {};
+  try {
+    args = argsJson ? JSON.parse(argsJson) : {};
+  } catch {
+    return { result: `Error: could not parse arguments: ${argsJson}` };
+  }
+  try {
+    switch (name) {
+      case "read_file": {
+        const file = resolve(ctx, String(args.path));
+        if (!fs4.existsSync(file)) return { result: `Error: file not found: ${args.path}` };
+        return { result: clip(fs4.readFileSync(file, "utf8")) };
+      }
+      case "list_dir": {
+        const dir = resolve(ctx, String(args.path ?? "."));
+        const entries = fs4.readdirSync(dir, { withFileTypes: true });
+        return {
+          result: clip(
+            entries.map((e) => e.isDirectory() ? e.name + "/" : e.name).sort().join("\n")
+          )
+        };
+      }
+      case "write_file": {
+        if (!ctx.allowWrite) return { result: "Denied: write_file is disabled (read-only mode)." };
+        const file = resolve(ctx, String(args.path));
+        fs4.mkdirSync(path2.dirname(file), { recursive: true });
+        fs4.writeFileSync(file, String(args.content ?? ""), "utf8");
+        return { result: `Wrote ${args.path} (${String(args.content ?? "").length} bytes).` };
+      }
+      case "run_command": {
+        if (!ctx.allowCommands) return { result: "Denied: run_command is disabled." };
+        const out = execSync(String(args.command), {
+          cwd: ctx.cwd,
+          encoding: "utf8",
+          env: scrubbedEnv(),
+          // never expose API key / service-account JSON to the child
+          stdio: ["ignore", "pipe", "pipe"],
+          timeout: 6e4,
+          maxBuffer: 10 * 1024 * 1024
+        });
+        return { result: clip(redactSecrets(out || "(no output)")) };
+      }
+      case "finish":
+        return { result: "ok", finishSummary: String(args.summary ?? "Done.") };
+      default:
+        return { result: `Error: unknown tool ${name}` };
+    }
+  } catch (err) {
+    const stdout = err?.stdout?.toString?.() ?? "";
+    const stderr = err?.stderr?.toString?.() ?? "";
+    return { result: clip(redactSecrets(`Error: ${err?.message ?? String(err)}
+${stdout}
+${stderr}`)) };
+  }
+}
+
+// src/usage/logger.ts
+function localDate(d = /* @__PURE__ */ new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function providerOf(modelId) {
+  return modelId.split("/")[0] ?? "unknown";
+}
+function logCompletion(result, taskType, sessionId) {
+  const now = /* @__PURE__ */ new Date();
+  const entry = {
+    ts: now.getTime(),
+    date: localDate(now),
+    provider: providerOf(result.model),
+    model: result.model,
+    taskType,
+    promptTokens: result.usage.promptTokens,
+    completionTokens: result.usage.completionTokens,
+    totalTokens: result.usage.totalTokens,
+    costUsd: result.costUsd,
+    sessionId
+  };
+  recordUsage(entry);
+  return entry;
+}
+
+// src/agent/loop.ts
+var MAX_ITERS_PER_STEP = 6;
+async function runAgent(goal, deps, emit) {
+  const { client: client2, models, policy, sessionId, cwd } = deps;
+  let totalCostUsd = 0;
+  let totalTokens = 0;
+  let calls = 0;
+  const planRoute = route("plan", models, policy);
+  let plan;
+  if (planRoute) {
+    try {
+      plan = await planRequest(goal, client2, planRoute.model);
+    } catch {
+      plan = heuristicPlan(goal);
+    }
+  } else {
+    plan = heuristicPlan(goal);
+  }
+  emit({ type: "plan", plan, planModel: planRoute?.model.id ?? "heuristic" });
+  const toolCtx = {
+    cwd,
+    allowWrite: deps.allowWrite,
+    allowCommands: deps.allowCommands
+  };
+  const priorSummaries = [];
+  for (const step of plan.steps) {
+    const r = route(step.type, models, policy, {
+      promptTokens: step.estPromptTokens,
+      completionTokens: step.estCompletionTokens
+    });
+    if (!r) {
+      emit({ type: "error", message: `No capable model for step ${step.id} (${step.type}).` });
+      continue;
+    }
+    const model = r.model;
+    emit({ type: "step-start", step, model, estCostUsd: r.estCostUsd });
+    const useTools = model.capabilities.tools;
+    const messages = [
+      { role: "system", content: stepSystemPrompt(goal, step, priorSummaries, useTools) },
+      { role: "user", content: step.description }
+    ];
+    let summary = "";
+    for (let iter = 0; iter < MAX_ITERS_PER_STEP; iter++) {
+      const gen = client2.stream(
+        {
+          model: model.id,
+          messages,
+          tools: useTools ? TOOL_SCHEMAS : void 0,
+          temperature: 0.2,
+          maxTokens: 2e3
+        },
+        model.pricing
+      );
+      let next = await gen.next();
+      while (!next.done) {
+        emit({ type: "text", delta: next.value });
+        next = await gen.next();
+      }
+      const result = next.value;
+      const entry = logCompletion(result, step.type, sessionId);
+      emit({ type: "usage", entry });
+      totalCostUsd += entry.costUsd;
+      totalTokens += entry.totalTokens;
+      calls++;
+      if (result.toolCalls.length && useTools) {
+        messages.push({ role: "assistant", content: result.content, tool_calls: result.toolCalls });
+        let finished = false;
+        for (const tc of result.toolCalls) {
+          emit({ type: "tool-call", name: tc.function.name, args: tc.function.arguments });
+          const outcome = executeTool(tc.function.name, tc.function.arguments, toolCtx);
+          emit({ type: "tool-result", name: tc.function.name, result: outcome.result });
+          messages.push({ role: "tool", tool_call_id: tc.id, name: tc.function.name, content: outcome.result });
+          if (outcome.finishSummary != null) {
+            summary = outcome.finishSummary;
+            finished = true;
+          }
+        }
+        if (finished) break;
+        continue;
+      }
+      summary = result.content || summary;
+      break;
+    }
+    if (!summary) summary = "(no summary)";
+    priorSummaries.push(`Step ${step.id} (${step.type}): ${summary}`);
+    emit({ type: "step-end", step, summary });
+  }
+  emit({ type: "done", totalCostUsd, totalTokens, calls });
+  return { totalCostUsd, totalTokens, calls };
+}
+function stepSystemPrompt(goal, step, priorSummaries, useTools) {
+  const context = priorSummaries.length ? `
+
+What previous steps accomplished:
+${priorSummaries.join("\n")}` : "";
+  const toolNote = useTools ? `
+You may use the provided tools (read_file, write_file, list_dir, run_command). Call the \`finish\` tool with a one-line summary when this step's objective is met.` : `
+Return a concise result for this step. Do not ask the user questions.`;
+  return `You are the "${step.type}" stage of an autonomous coding agent.
+Overall goal: ${goal}
+Your current step: ${step.description}${context}${toolNote}
+Be efficient \u2014 you were selected as the cheapest capable model for this step.`;
+}
+
+// src/tui/App.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function App(props) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState(props.initialGoal ? "preview" : "input");
+  const [goal, setGoal] = useState(props.initialGoal ?? "");
+  const [draft, setDraft] = useState("");
+  const [rec, setRec] = useState(null);
+  const [log, setLog] = useState([]);
+  const [cost, setCost] = useState(0);
+  const [tok, setTok] = useState(0);
+  const [calls, setCalls] = useState(0);
+  const push = useCallback((text, color) => {
+    setLog((l) => [...l, { key: l.length, text, color }]);
+  }, []);
+  useEffect(() => {
+    if (phase === "preview" && goal) {
+      setRec(buildRecommendation(heuristicPlan(goal), props.models));
+    }
+  }, [phase, goal, props.models]);
+  const start = useCallback(async () => {
+    setPhase("running");
+    const deps = {
+      client: props.client,
+      models: props.models,
+      policy: props.policy,
+      sessionId: props.sessionId,
+      cwd: props.cwd,
+      allowWrite: props.allowWrite,
+      allowCommands: props.allowCommands
+    };
+    let textBuf = "";
+    const flush = () => {
+      if (textBuf.trim()) push(textBuf.trim(), "white");
+      textBuf = "";
+    };
+    const emit = (e) => {
+      switch (e.type) {
+        case "plan":
+          push(`\u{1F4CB} Plan (${e.plan.steps.length} steps) \xB7 planner: ${e.planModel}`, "cyan");
+          break;
+        case "step-start":
+          flush();
+          push(`\u25B6 Step ${e.step.id} [${e.step.type}] \u2192 ${e.model.id}  ~${usd(e.estCostUsd)}`, "yellow");
+          break;
+        case "text":
+          textBuf += e.delta;
+          break;
+        case "tool-call":
+          flush();
+          push(`  \u{1F527} ${e.name}(${truncate2(e.args, 80)})`, "magenta");
+          break;
+        case "tool-result":
+          push(`  \u21B3 ${truncate2(e.result.replace(/\n/g, " "), 100)}`, "gray");
+          break;
+        case "usage":
+          setCost((c2) => c2 + e.entry.costUsd);
+          setTok((t) => t + e.entry.totalTokens);
+          setCalls((n) => n + 1);
+          break;
+        case "step-end":
+          flush();
+          push(`  \u2713 ${truncate2(e.summary.replace(/\n/g, " "), 120)}`, "green");
+          break;
+        case "error":
+          flush();
+          push(`  \u26A0 ${e.message}`, "red");
+          break;
+        case "done":
+          flush();
+          break;
+      }
+    };
+    try {
+      await runAgent(goal, deps, emit);
+    } catch (err) {
+      push(`Fatal: ${err?.message ?? err}`, "red");
+    }
+    setPhase("done");
+  }, [goal, props, push]);
+  useInput((input, key) => {
+    if (phase === "preview") {
+      if (input === "y" || key.return) void start();
+      else if (input === "e") {
+        setDraft(goal);
+        setPhase("input");
+      } else if (input === "q") exit();
+    } else if (phase === "done") {
+      if (input === "q" || key.return) exit();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Header, { objectiveLabel: props.objectiveLabel, cost, tok, calls }),
+    phase === "input" && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "What should Polymath do? " }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: draft,
+          onChange: setDraft,
+          onSubmit: (v) => {
+            if (v.trim()) {
+              setGoal(v.trim());
+              setPhase("preview");
+            }
+          }
+        }
+      )
+    ] }),
+    phase === "preview" && rec && /* @__PURE__ */ jsx(Preview, { rec }),
+    (phase === "running" || phase === "done") && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      log.slice(-18).map((l) => /* @__PURE__ */ jsx(Text, { color: l.color, children: l.text }, l.key)),
+      phase === "running" && /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+        " working\u2026"
+      ] }),
+      phase === "done" && /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+        "\u2713 Done \xB7 ",
+        calls,
+        " calls \xB7 ",
+        tokens(tok),
+        " tokens \xB7 ",
+        usd(cost),
+        " \u2014 press q to quit"
+      ] })
+    ] })
+  ] });
+}
+function Header(props) {
+  return /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "magentaBright", bold: true, children: "Polymath" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 policy: " }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: props.objectiveLabel })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      props.calls,
+      " calls \xB7 ",
+      tokens(props.tok),
+      " tok \xB7 ",
+      /* @__PURE__ */ jsx(Text, { color: "green", children: usd(props.cost) })
+    ] })
+  ] });
+}
+function Preview(props) {
+  const { rec } = props;
+  const value = rec.strategies.find((s) => s.objective === "value");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+      "Goal: ",
+      rec.plan.goal
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "Recommended routing (best value) \u2014 estimate before running:" }),
+    value.assignments.map((a) => /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        " ",
+        a.step.id,
+        ". [",
+        a.step.type,
+        "]"
+      ] }),
+      " ",
+      /* @__PURE__ */ jsx(Text, { color: "white", children: a.model ? a.model.id : "(none)" }),
+      " ",
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "~",
+        usd(a.estCostUsd)
+      ] })
+    ] }, a.step.id)),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: " Est total: " }),
+      /* @__PURE__ */ jsx(Text, { color: "green", children: usd(value.totalCostUsd) }),
+      rec.savingsPct > 0 && /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+        " (~",
+        rec.savingsPct.toFixed(0),
+        "% vs all-frontier)"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "Run this? " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "[y] run \xB7 [e] edit goal \xB7 [q] quit" })
+    ] })
+  ] });
+}
+function truncate2(s, n) {
+  return s.length > n ? s.slice(0, n) + "\u2026" : s;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("poly").description("Polymath \u2014 cost-optimized, multi-model TUI coding agent").version("0.1.0");
+function client(config) {
+  return new OpenRouterClient({
+    apiKey: resolveApiKey(config),
+    referer: config.referer,
+    title: config.title
+  });
+}
+function buildPolicy(config, opts) {
+  const objective = opts.objective || config.defaultObjective;
+  const maxCost = opts.maxCost != null ? parseFloat(opts.maxCost) : config.maxCostPerCallUsd;
+  return {
+    objective,
+    maxCostPerCallUsd: Number.isFinite(maxCost) ? maxCost : void 0,
+    pinned: config.pinned
+  };
+}
+async function loadCatalog(config, refresh = false) {
+  const models = await getModels(client(config), { refresh });
+  if (!models.length) {
+    console.error(c.red("Could not load the model catalog. Check your connection."));
+    process.exit(1);
+  }
+  return models;
+}
+program.command("login").description("Connect Polymath to OpenRouter (set/replace your API key)").action(async () => {
+  await runLogin();
+});
+program.command("run", { isDefault: true }).description("Launch the interactive agent (TUI)").argument("[goal...]", "what to do (optional; prompts if omitted)").option("-o, --objective <name>", "routing objective: cheapest | value | quality").option("--max-cost <usd>", "exclude models whose projected per-call cost exceeds this").option("-w, --write", "allow the agent to write files (confined to --cwd)", false).option("-x, --commands", "DANGER: let the model run arbitrary shell commands in --cwd", false).option("-C, --cwd <dir>", "working directory", process.cwd()).action(async (goalParts, opts) => {
+  const config = loadConfig();
+  const key = await ensureApiKey(config);
+  if (!key) {
+    console.error(c.red("No API key \u2014 cannot run. Try `poly login`."));
+    process.exit(1);
+  }
+  const reloaded = loadConfig();
+  const models = await loadCatalog(reloaded);
+  const policy = buildPolicy(reloaded, opts);
+  const goal = goalParts?.join(" ").trim() || void 0;
+  const instance = render(
+    createElement(App, {
+      client: client(reloaded),
+      models,
+      policy,
+      sessionId: randomUUID(),
+      cwd: opts.cwd,
+      allowWrite: !!opts.write,
+      allowCommands: !!opts.commands,
+      objectiveLabel: policy.objective,
+      initialGoal: goal
+    })
+  );
+  await instance.waitUntilExit();
+});
+program.command("recommend").description("Recommend the best / best-value model combos for a task BEFORE running").argument("<goal...>", "task description").option("--smart", "use an LLM to produce a tailored plan (costs a few cents)", false).option("-o, --objective <name>", "highlight a specific objective").action(async (goalParts, opts) => {
+  const config = loadConfig();
+  const models = await loadCatalog(config);
+  const goal = goalParts.join(" ");
+  let plan = heuristicPlan(goal);
+  if (opts.smart) {
+    const key = resolveApiKey(config);
+    if (!key) {
+      console.error(c.yellow("--smart needs an API key; falling back to heuristic plan. Run `poly login`."));
+    } else {
+      const planRoute = route("plan", models, buildPolicy(config, {}));
+      if (planRoute) {
+        try {
+          plan = await planRequest(goal, client(config), planRoute.model);
+        } catch (e) {
+          console.error(c.yellow(`Smart plan failed (${e?.message}); using heuristic.`));
+        }
+      }
+    }
+  }
+  console.log(renderRecommendation(buildRecommendation(plan, models)));
+});
+program.command("models").description("Browse the model catalog with pricing and tiers").option("-t, --tier <tier>", "filter by tier: cheap | standard | frontier").option("--tools", "only models that support tool/function calling", false).option("-s, --search <text>", "filter by id/name substring").option("--refresh", "force-refresh the catalog from OpenRouter", false).option("-n, --limit <n>", "max rows", "40").action(async (opts) => {
+  const config = loadConfig();
+  let models = await loadCatalog(config, !!opts.refresh);
+  if (opts.tier) models = models.filter((m) => m.tier === opts.tier);
+  if (opts.tools) models = models.filter((m) => m.capabilities.tools);
+  if (opts.search) {
+    const q = String(opts.search).toLowerCase();
+    models = models.filter((m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q));
+  }
+  models.sort((a, b) => blendedPrice(a) - blendedPrice(b));
+  const limit = parseInt(opts.limit, 10) || 40;
+  const rows = models.slice(0, limit).map((m) => [
+    m.id,
+    tierColor(m.tier),
+    perMTok(m.pricing.promptUsdPerMTok),
+    perMTok(m.pricing.completionUsdPerMTok),
+    m.capabilities.tools ? "\u2713" : "",
+    String(m.contextLength)
+  ]);
+  console.log(table(["Model", "Tier", "In", "Out", "Tools", "Ctx"], rows));
+  console.log(c.dim(`
+${models.length} models match \xB7 showing ${rows.length}`));
+});
+program.command("usage").description("Show recorded usage & cost by date + model").option("--since <date>", "YYYY-MM-DD inclusive").option("--until <date>", "YYYY-MM-DD inclusive").option("--today", "only today", false).option("--sync", "also push unsynced rows to Firestore", false).action(async (opts) => {
+  const config = loadConfig();
+  let since = opts.since;
+  let until = opts.until;
+  if (opts.today) {
+    const d = /* @__PURE__ */ new Date();
+    const iso = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(
+      d.getDate()
+    ).padStart(2, "0")}`;
+    since = iso;
+    until = iso;
+  }
+  console.log(renderUsageReport({ since, until }));
+  if (opts.sync) {
+    const res = await syncUsage(config);
+    console.log(res.synced > 0 ? c.green(res.message) : c.dim(res.message));
+  }
+});
+program.command("sync").description("Push unsynced usage rows to Firestore (mathology-b8e3d)").action(async () => {
+  const config = loadConfig();
+  const res = await syncUsage(config);
+  console.log(res.synced > 0 ? c.green(res.message) : c.yellow(res.message));
+});
+var cfg = program.command("config").description("View or change Polymath settings");
+cfg.command("show").description("Print the current config (key is masked)").action(() => {
+  const config = loadConfig();
+  const key = resolveApiKey(config);
+  console.log(
+    JSON.stringify(
+      { ...config, openrouterApiKey: key ? key.slice(0, 8) + "\u2026" + key.slice(-4) : null },
+      null,
+      2
+    )
+  );
+});
+cfg.command("set").description("Set a setting: objective <cheapest|value|quality> | maxcost <usd> | referer <url> | title <text>").argument("<key>").argument("<value>").action((key, value) => {
+  const config = loadConfig();
+  switch (key) {
+    case "objective":
+      config.defaultObjective = value;
+      break;
+    case "maxcost":
+      config.maxCostPerCallUsd = parseFloat(value);
+      break;
+    case "referer":
+      config.referer = value;
+      break;
+    case "title":
+      config.title = value;
+      break;
+    default:
+      console.error(c.red(`Unknown setting: ${key}`));
+      return;
+  }
+  saveConfig(config);
+  console.log(c.green(`Set ${key} = ${value}`));
+});
+cfg.command("firestore").description("Enable/disable Firestore sync: on | off").argument("<state>").action((state) => {
+  const config = loadConfig();
+  config.firestore.enabled = /^on|true|1$/i.test(state);
+  saveConfig(config);
+  console.log(c.green(`Firestore sync ${config.firestore.enabled ? "enabled" : "disabled"}.`));
+});
+program.parseAsync().catch((err) => {
+  console.error(c.red(err?.message ?? String(err)));
+  process.exit(1);
+});