polymath-agent 0.1.0 → 0.3.0

package/dist/cli.js

@@ -44,6 +44,16 @@ var DEFAULT_CONFIG = {
     enabled: false,
     projectId: "mathology-b8e3d",
     collection: "polymath_usage"
+  },
+  dataconnect: {
+    enabled: false,
+    location: "us-east4",
+    serviceId: "polymath"
+  },
+  local: {
+    enabled: false,
+    baseUrl: "http://localhost:11434/v1"
+    // Ollama default; LM Studio: http://localhost:1234/v1
   }
 };
 function loadConfig() {
@@ -54,7 +64,9 @@ function loadConfig() {
     return {
       ...DEFAULT_CONFIG,
       ...raw,
-      firestore: { ...DEFAULT_CONFIG.firestore, ...raw.firestore ?? {} }
+      firestore: { ...DEFAULT_CONFIG.firestore, ...raw.firestore ?? {} },
+      dataconnect: { ...DEFAULT_CONFIG.dataconnect, ...raw.dataconnect ?? {} },
+      local: { ...DEFAULT_CONFIG.local, ...raw.local ?? {} }
     };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -75,6 +87,7 @@ function resolveApiKey(config) {
 
 // src/providers/openrouter.ts
 var BASE = globalThis.process?.env?.OPENROUTER_BASE_URL?.replace(/\/$/, "") || "https://openrouter.ai/api/v1";
+var LOCAL_PREFIX = "local/";
 var OpenRouterError = class extends Error {
   status;
   constructor(message, status) {
@@ -87,10 +100,12 @@ var OpenRouterClient = class {
   apiKey;
   referer;
   title;
+  localBaseUrl;
   constructor(opts = {}) {
     this.apiKey = opts.apiKey;
     this.referer = opts.referer ?? "https://github.com/polymath-agent";
     this.title = opts.title ?? "Polymath";
+    this.localBaseUrl = opts.localBaseUrl?.replace(/\/$/, "");
   }
   headers(json = true) {
     const h = {
@@ -101,6 +116,24 @@ var OpenRouterClient = class {
     if (json) h["Content-Type"] = "application/json";
     return h;
   }
+  /** Resolve where a model's request goes: the local server for `local/*`, else OpenRouter. */
+  target(modelId) {
+    if (this.localBaseUrl && modelId.startsWith(LOCAL_PREFIX)) {
+      return { base: this.localBaseUrl, model: modelId.slice(LOCAL_PREFIX.length), isLocal: true };
+    }
+    return { base: BASE, model: modelId, isLocal: false };
+  }
+  requireKeyFor(isLocal) {
+    if (!isLocal && !this.apiKey) throw new OpenRouterError("No API key set. Run `poly login`.");
+  }
+  /** List models from the local OpenAI-compatible server (Ollama / LM Studio). */
+  async listLocalRawModels() {
+    if (!this.localBaseUrl) return [];
+    const res = await fetch(`${this.localBaseUrl}/models`);
+    if (!res.ok) throw new OpenRouterError(`Local server: failed to list models (${res.status})`, res.status);
+    const json = await res.json();
+    return json.data ?? [];
+  }
   /** Raw /models payload (no auth required). */
   async listRawModels() {
     const res = await fetch(`${BASE}/models`, { headers: this.headers(false) });
@@ -120,24 +153,28 @@ var OpenRouterClient = class {
     const d = json.data ?? {};
     return { label: d.label, usage: d.usage, limit: d.limit };
   }
-  buildBody(req, stream) {
+  buildBody(req, stream, modelOverride, isLocal) {
     return {
-      model: req.model,
+      model: modelOverride,
       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 }
+      // OpenRouter-specific accounting param; local servers may reject unknown fields.
+      ...isLocal ? {} : { usage: { include: true } },
+      // OpenAI-compat way to get token usage in the final stream chunk (Ollama/LM Studio).
+      ...isLocal && stream ? { stream_options: { include_usage: 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`, {
+    const t = this.target(req.model);
+    this.requireKeyFor(t.isLocal);
+    const res = await fetch(`${t.base}/chat/completions`, {
       method: "POST",
       headers: this.headers(),
-      body: JSON.stringify(this.buildBody(req, false))
+      body: JSON.stringify(this.buildBody(req, false, t.model, t.isLocal))
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -158,8 +195,10 @@ var OpenRouterClient = class {
       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),
+      // Keep the prefixed id for local models so the ledger stays consistent.
+      model: t.isLocal ? req.model : json.model ?? req.model,
+      // Local inference is free regardless of what the server claims to report.
+      costUsd: computeCost(usage, pricing, t.isLocal ? void 0 : json.usage?.cost),
       finishReason: choice.finish_reason ?? null
     };
   }
@@ -168,11 +207,12 @@ var OpenRouterClient = class {
    * 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`, {
+    const t = this.target(req.model);
+    this.requireKeyFor(t.isLocal);
+    const res = await fetch(`${t.base}/chat/completions`, {
       method: "POST",
       headers: this.headers(),
-      body: JSON.stringify(this.buildBody(req, true))
+      body: JSON.stringify(this.buildBody(req, true, t.model, t.isLocal))
     });
     if (!res.ok || !res.body) {
       const text = await res.text().catch(() => "");
@@ -206,7 +246,7 @@ var OpenRouterClient = class {
         if (evt?.error) {
           throw new OpenRouterError(evt.error.message ?? "Stream provider error", evt.error.code);
         }
-        if (evt.model) model = evt.model;
+        if (evt.model && !t.isLocal) model = evt.model;
         if (evt.usage) usageJson = evt.usage;
         const choice = evt.choices?.[0];
         if (!choice) continue;
@@ -233,17 +273,17 @@ var OpenRouterClient = class {
       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}`,
+    const toolCalls = [...toolAcc.values()].filter((t2) => t2.name).map((t2) => ({
+      id: t2.id || `call_${t2.name}`,
       type: "function",
-      function: { name: t.name, arguments: t.args || "{}" }
+      function: { name: t2.name, arguments: t2.args || "{}" }
     }));
     return {
       content,
       toolCalls,
       usage,
       model,
-      costUsd: computeCost(usage, pricing, usageJson?.cost),
+      costUsd: computeCost(usage, pricing, t.isLocal ? void 0 : usageJson?.cost),
       finishReason
     };
   }
@@ -381,6 +421,38 @@ async function getModels(client2, opts = {}) {
   return models;
 }
 
+// src/models/local.ts
+function parseLocalModels(raw) {
+  const out = [];
+  for (const m of raw) {
+    if (!m?.id) continue;
+    const name = String(m.id);
+    out.push({
+      id: LOCAL_PREFIX + name,
+      name: `${name} (local)`,
+      provider: "local",
+      contextLength: m.context_length ?? 8192,
+      pricing: { promptUsdPerMTok: 0, completionUsdPerMTok: 0 },
+      tier: classifyTier(name, 0),
+      capabilities: {
+        // OpenAI-compatible local servers pass tool schemas through; models that
+        // can't call tools simply reply with text, which the agent loop handles.
+        tools: true,
+        vision: /llava|vision|vl\b|moondream/i.test(name)
+      }
+    });
+  }
+  return out;
+}
+async function getLocalModels(client2) {
+  try {
+    const raw = await client2.listLocalRawModels();
+    return parseLocalModels(raw);
+  } catch {
+    return [];
+  }
+}
+
 // src/auth/onboarding.ts
 import readline from "node:readline";
 
@@ -560,7 +632,7 @@ function heuristicPlan(goal) {
   ];
   return { goal, steps };
 }
-async function planRequest(goal, client2, planModel) {
+async function planRequest(goal, client2, planModel, onUsage) {
   const result = await client2.complete(
     {
       model: planModel.id,
@@ -573,6 +645,7 @@ async function planRequest(goal, client2, planModel) {
     },
     planModel.pricing
   );
+  onUsage?.(result);
   const parsed = extractPlan(result.content);
   if (!parsed) return heuristicPlan(goal);
   return { goal, steps: parsed };
@@ -716,8 +789,11 @@ var HEADLINE_SKILLS = ["coding", "reasoning", "retrieval", "speed"];
 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 taskValue(m, taskType, empirical) {
+  const base = taskStrength(m, taskType) / Math.max(blendedPrice(m), 0.01);
+  const savings = empirical?.[`${taskType}:${m.id}`];
+  const boost = savings ? 1 + Math.min(savings, 100) / 100 : 1;
+  return base * boost;
 }
 function candidatesFor(taskType, models, policy, est) {
   const spec = TASK_SPECS[taskType];
@@ -746,7 +822,9 @@ function rank(models, policy, taskType) {
       break;
     case "value":
     default:
-      sorted.sort((a, b) => taskValue(b, taskType) - taskValue(a, taskType));
+      sorted.sort(
+        (a, b) => taskValue(b, taskType, policy.empirical) - taskValue(a, taskType, policy.empirical)
+      );
       break;
   }
   return sorted;
@@ -764,7 +842,8 @@ function route(taskType, models, policy, est = { promptTokens: 4e3, completionTo
   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`;
+  const proven = policy.empirical?.[`${taskType}:${chosen.id}`];
+  const reason = policy.objective === "cheapest" ? `cheapest model that covers ${skill}` : policy.objective === "quality" ? `strongest at ${skill}` : proven ? `proven ${Math.round(proven)}% fewer tokens on ${taskType} (playbook)` : `best ${skill}-per-dollar`;
   return { model: chosen, reason, estCostUsd: projectCost(chosen, est) };
 }
 
@@ -935,14 +1014,95 @@ function getDb() {
     );
     CREATE INDEX IF NOT EXISTS idx_usage_date ON usage_log(date);
     CREATE INDEX IF NOT EXISTS idx_usage_model ON usage_log(model);
+
+    -- One row per agent session (a \`poly run\`): goal + outcome + achievement scores.
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      ts INTEGER NOT NULL,
+      date TEXT NOT NULL,
+      goal TEXT NOT NULL,
+      command TEXT NOT NULL DEFAULT 'run',
+      objective TEXT NOT NULL,
+      planned_steps INTEGER NOT NULL DEFAULT 0,
+      completed_steps INTEGER NOT NULL DEFAULT 0,
+      failed_steps INTEGER NOT NULL DEFAULT 0,
+      auto_score REAL,                -- 0..1 = completed/planned (agent-computed)
+      user_score INTEGER,             -- 0..9 user-rated goal achievement (nullable)
+      prompt_tokens INTEGER NOT NULL DEFAULT 0,
+      completion_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      duration_ms INTEGER NOT NULL DEFAULT 0,
+      synced INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_sessions_date ON sessions(date);
+
+    -- One row per executed plan step: which model, how many round-trips, how it ended.
+    CREATE TABLE IF NOT EXISTS step_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      step_no INTEGER NOT NULL,
+      task_type TEXT NOT NULL,
+      skill TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      iterations INTEGER NOT NULL,    -- LLM round-trips used for this step
+      tool_calls INTEGER NOT NULL,
+      prompt_tokens INTEGER NOT NULL,
+      completion_tokens INTEGER NOT NULL,
+      cost_usd REAL NOT NULL,
+      finished_by TEXT NOT NULL,      -- 'finish-tool' | 'text' | 'max-iters' | 'error'
+      success INTEGER NOT NULL,       -- 1 = ended cleanly (finish-tool or text)
+      duration_ms INTEGER NOT NULL,
+      synced INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_steps_session ON step_runs(session_id);
+    CREATE INDEX IF NOT EXISTS idx_steps_model ON step_runs(model, task_type);
+
+    -- One row per CLI command invocation (run/recommend/...): tokens spent per command.
+    CREATE TABLE IF NOT EXISTS command_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      ts INTEGER NOT NULL,
+      date TEXT NOT NULL,
+      command TEXT NOT NULL,
+      args TEXT,
+      objective TEXT,
+      prompt_tokens INTEGER NOT NULL DEFAULT 0,
+      completion_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      duration_ms INTEGER NOT NULL DEFAULT 0,
+      synced INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_cmd_date ON command_runs(date);
+
+    -- Distilled efficiency insights: ONLY the notably cost-efficient approaches.
+    -- This is what syncs to the cloud by default (raw logs stay local).
+    CREATE TABLE IF NOT EXISTS insights (
+      id TEXT PRIMARY KEY,            -- "<task_type>__<model>"
+      computed_at INTEGER NOT NULL,
+      task_type TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      samples INTEGER NOT NULL,       -- successful steps observed
+      success_rate REAL NOT NULL,
+      avg_tokens REAL NOT NULL,       -- per successful step
+      baseline_tokens REAL NOT NULL,  -- median across qualified competitors
+      savings_pct REAL NOT NULL,      -- vs baseline (the "\uC720\uB3C5" margin)
+      avg_cost_usd REAL NOT NULL,
+      synced INTEGER NOT NULL DEFAULT 0
+    );
   `);
+  const cols = db.prepare(`PRAGMA table_info(usage_log)`).all();
+  if (!cols.some((c2) => c2.name === "command")) {
+    db.exec(`ALTER TABLE usage_log ADD COLUMN command TEXT NOT NULL DEFAULT 'run'`);
+  }
   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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      (ts, date, provider, model, task_type, prompt_tokens, completion_tokens, total_tokens, cost_usd, session_id, command)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   stmt.run(
     e.ts,
@@ -954,7 +1114,8 @@ function recordUsage(e) {
     e.completionTokens,
     e.totalTokens,
     e.costUsd,
-    e.sessionId ?? null
+    e.sessionId ?? null,
+    e.command ?? "run"
   );
 }
 function reportByDateModel(filter = {}) {
@@ -1016,7 +1177,8 @@ function unsyncedRows() {
     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
+    sessionId: r.session_id ? String(r.session_id) : void 0,
+    command: r.command ? String(r.command) : "run"
   }));
 }
 function markSynced(ids) {
@@ -1024,6 +1186,269 @@ function markSynced(ids) {
   const stmt = getDb().prepare(`UPDATE usage_log SET synced = 1 WHERE id = ?`);
   for (const id of ids) stmt.run(id);
 }
+function startSession(s) {
+  getDb().prepare(
+    `INSERT OR REPLACE INTO sessions (id, ts, date, goal, command, objective, planned_steps)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(s.id, s.ts, s.date, s.goal, s.command, s.objective, s.plannedSteps);
+}
+function finishSession(id, u) {
+  getDb().prepare(
+    `UPDATE sessions SET planned_steps=?, completed_steps=?, failed_steps=?, auto_score=?,
+         prompt_tokens=?, completion_tokens=?, cost_usd=?, duration_ms=? WHERE id=?`
+  ).run(
+    u.plannedSteps,
+    u.completedSteps,
+    u.failedSteps,
+    u.autoScore,
+    u.promptTokens,
+    u.completionTokens,
+    u.costUsd,
+    u.durationMs,
+    id
+  );
+}
+function setUserScore(sessionId, score) {
+  getDb().prepare(`UPDATE sessions SET user_score=? WHERE id=?`).run(score, sessionId);
+}
+function recordStepRun(s) {
+  getDb().prepare(
+    `INSERT INTO step_runs
+        (session_id, step_no, task_type, skill, model, provider, iterations, tool_calls,
+         prompt_tokens, completion_tokens, cost_usd, finished_by, success, duration_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    s.sessionId,
+    s.stepNo,
+    s.taskType,
+    s.skill,
+    s.model,
+    s.provider,
+    s.iterations,
+    s.toolCalls,
+    s.promptTokens,
+    s.completionTokens,
+    s.costUsd,
+    s.finishedBy,
+    s.success ? 1 : 0,
+    s.durationMs
+  );
+}
+function recordCommandRun(c2) {
+  getDb().prepare(
+    `INSERT INTO command_runs
+        (session_id, ts, date, command, args, objective, prompt_tokens, completion_tokens, cost_usd, duration_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    c2.sessionId ?? null,
+    c2.ts,
+    c2.date,
+    c2.command,
+    c2.args ?? null,
+    c2.objective ?? null,
+    c2.promptTokens,
+    c2.completionTokens,
+    c2.costUsd,
+    c2.durationMs
+  );
+}
+function sessionUsageTotals(sessionId) {
+  const r = getDb().prepare(
+    `SELECT COALESCE(SUM(prompt_tokens),0) AS p, COALESCE(SUM(completion_tokens),0) AS c, COALESCE(SUM(cost_usd),0) AS cost
+       FROM usage_log WHERE session_id = ?`
+  ).get(sessionId);
+  return { promptTokens: Number(r?.p ?? 0), completionTokens: Number(r?.c ?? 0), costUsd: Number(r?.cost ?? 0) };
+}
+function modelTaskEfficiency(filter = {}) {
+  const { whereSql, params } = dateWhere(filter, "s.ts");
+  const rows = getDb().prepare(
+    `SELECT task_type AS taskType, model,
+              COUNT(*) AS steps,
+              AVG(success) AS successRate,
+              AVG(CASE WHEN success=1 THEN prompt_tokens + completion_tokens END) AS avgTokensPerSuccess,
+              AVG(CASE WHEN success=1 THEN cost_usd END) AS avgCostPerSuccess,
+              AVG(iterations) AS avgIterations
+       FROM step_runs s ${whereSql}
+       GROUP BY task_type, model
+       ORDER BY task_type, avgTokensPerSuccess ASC`
+  ).all(...params);
+  return rows.map((r) => ({
+    taskType: String(r.taskType),
+    model: String(r.model),
+    steps: Number(r.steps),
+    successRate: Number(r.successRate ?? 0),
+    avgTokensPerSuccess: Number(r.avgTokensPerSuccess ?? 0),
+    avgCostPerSuccess: Number(r.avgCostPerSuccess ?? 0),
+    avgIterations: Number(r.avgIterations ?? 0)
+  }));
+}
+function objectiveEfficiency(filter = {}) {
+  const { whereSql, params } = dateWhere(filter, "ts");
+  const rows = getDb().prepare(
+    `SELECT objective,
+              COUNT(*) AS sessions,
+              AVG(prompt_tokens + completion_tokens) AS avgTokens,
+              AVG(cost_usd) AS avgCostUsd,
+              AVG(auto_score) AS avgAutoScore,
+              AVG(user_score) AS avgUserScore
+       FROM sessions ${whereSql}
+       GROUP BY objective ORDER BY avgTokens ASC`
+  ).all(...params);
+  return rows.map((r) => ({
+    objective: String(r.objective),
+    sessions: Number(r.sessions),
+    avgTokens: Number(r.avgTokens ?? 0),
+    avgCostUsd: Number(r.avgCostUsd ?? 0),
+    avgAutoScore: r.avgAutoScore == null ? null : Number(r.avgAutoScore),
+    avgUserScore: r.avgUserScore == null ? null : Number(r.avgUserScore)
+  }));
+}
+function commandUsage(filter = {}) {
+  const { whereSql, params } = dateWhere(filter, "ts");
+  const rows = getDb().prepare(
+    `SELECT command, COUNT(*) AS runs,
+              SUM(prompt_tokens) AS promptTokens,
+              SUM(completion_tokens) AS completionTokens,
+              SUM(cost_usd) AS costUsd
+       FROM command_runs ${whereSql}
+       GROUP BY command ORDER BY costUsd DESC`
+  ).all(...params);
+  return rows.map((r) => ({
+    command: String(r.command),
+    runs: Number(r.runs),
+    promptTokens: Number(r.promptTokens ?? 0),
+    completionTokens: Number(r.completionTokens ?? 0),
+    costUsd: Number(r.costUsd ?? 0)
+  }));
+}
+function dateWhere(filter, tsCol) {
+  const where = [];
+  const params = [];
+  if (filter.since) {
+    where.push(`date(${tsCol}/1000, 'unixepoch', 'localtime') >= ?`);
+    params.push(filter.since);
+  }
+  if (filter.until) {
+    where.push(`date(${tsCol}/1000, 'unixepoch', 'localtime') <= ?`);
+    params.push(filter.until);
+  }
+  return { whereSql: where.length ? `WHERE ${where.join(" AND ")}` : "", params };
+}
+function unsyncedSessions() {
+  const rows = getDb().prepare(`SELECT * FROM sessions WHERE synced=0 LIMIT 200`).all();
+  return rows.map((r) => ({
+    _table: "sessions",
+    id: String(r.id),
+    ts: Number(r.ts),
+    date: String(r.date),
+    goal: String(r.goal),
+    command: String(r.command),
+    objective: String(r.objective),
+    plannedSteps: Number(r.planned_steps),
+    completedSteps: Number(r.completed_steps),
+    failedSteps: Number(r.failed_steps),
+    autoScore: r.auto_score == null ? null : Number(r.auto_score),
+    userScore: r.user_score == null ? null : Number(r.user_score),
+    promptTokens: Number(r.prompt_tokens),
+    completionTokens: Number(r.completion_tokens),
+    costUsd: Number(r.cost_usd),
+    durationMs: Number(r.duration_ms)
+  }));
+}
+function unsyncedStepRuns() {
+  const rows = getDb().prepare(`SELECT * FROM step_runs WHERE synced=0 LIMIT 500`).all();
+  return rows.map((r) => ({
+    id: Number(r.id),
+    sessionId: String(r.session_id),
+    stepNo: Number(r.step_no),
+    taskType: String(r.task_type),
+    skill: String(r.skill),
+    model: String(r.model),
+    provider: String(r.provider),
+    iterations: Number(r.iterations),
+    toolCalls: Number(r.tool_calls),
+    promptTokens: Number(r.prompt_tokens),
+    completionTokens: Number(r.completion_tokens),
+    costUsd: Number(r.cost_usd),
+    finishedBy: String(r.finished_by),
+    success: Number(r.success) === 1,
+    durationMs: Number(r.duration_ms)
+  }));
+}
+function unsyncedCommandRuns() {
+  const rows = getDb().prepare(`SELECT * FROM command_runs WHERE synced=0 LIMIT 500`).all();
+  return rows.map((r) => ({
+    id: Number(r.id),
+    sessionId: r.session_id ? String(r.session_id) : void 0,
+    ts: Number(r.ts),
+    date: String(r.date),
+    command: String(r.command),
+    args: r.args ? String(r.args) : void 0,
+    objective: r.objective ? String(r.objective) : void 0,
+    promptTokens: Number(r.prompt_tokens),
+    completionTokens: Number(r.completion_tokens),
+    costUsd: Number(r.cost_usd),
+    durationMs: Number(r.duration_ms)
+  }));
+}
+function markTableSynced(table2, ids) {
+  if (!ids.length) return;
+  const stmt = getDb().prepare(`UPDATE ${table2} SET synced=1 WHERE id=?`);
+  for (const id of ids) stmt.run(id);
+}
+function upsertInsight(i) {
+  getDb().prepare(
+    `INSERT INTO insights (id, computed_at, task_type, model, provider, samples, success_rate,
+         avg_tokens, baseline_tokens, savings_pct, avg_cost_usd, synced)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+       ON CONFLICT(id) DO UPDATE SET
+         computed_at=excluded.computed_at, samples=excluded.samples,
+         success_rate=excluded.success_rate, avg_tokens=excluded.avg_tokens,
+         baseline_tokens=excluded.baseline_tokens, savings_pct=excluded.savings_pct,
+         avg_cost_usd=excluded.avg_cost_usd, synced=0`
+  ).run(
+    i.id,
+    i.computedAt,
+    i.taskType,
+    i.model,
+    i.provider,
+    i.samples,
+    i.successRate,
+    i.avgTokens,
+    i.baselineTokens,
+    i.savingsPct,
+    i.avgCostUsd
+  );
+}
+function deleteInsightsExcept(validIds) {
+  const all = getDb().prepare(`SELECT id FROM insights`).all();
+  const keep = new Set(validIds);
+  const del = getDb().prepare(`DELETE FROM insights WHERE id=?`);
+  for (const r of all) if (!keep.has(String(r.id))) del.run(String(r.id));
+}
+function listInsights() {
+  const rows = getDb().prepare(`SELECT * FROM insights ORDER BY savings_pct DESC`).all();
+  return rows.map(mapInsight);
+}
+function unsyncedInsights() {
+  const rows = getDb().prepare(`SELECT * FROM insights WHERE synced=0`).all();
+  return rows.map(mapInsight);
+}
+function mapInsight(r) {
+  return {
+    id: String(r.id),
+    computedAt: Number(r.computed_at),
+    taskType: String(r.task_type),
+    model: String(r.model),
+    provider: String(r.provider),
+    samples: Number(r.samples),
+    successRate: Number(r.success_rate),
+    avgTokens: Number(r.avg_tokens),
+    baselineTokens: Number(r.baseline_tokens),
+    savingsPct: Number(r.savings_pct),
+    avgCostUsd: Number(r.avg_cost_usd)
+  };
+}
 
 // src/usage/report.ts
 function renderUsageReport(filter = {}) {
@@ -1066,8 +1491,180 @@ function renderUsageReport(filter = {}) {
   ].join("\n");
 }
 
+// src/usage/insights.ts
+var MIN_SAMPLES = 3;
+var MIN_SUCCESS = 0.7;
+var MIN_MARGIN = 0.2;
+function median(xs) {
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+function distillInsights(now = Date.now()) {
+  const eff = modelTaskEfficiency();
+  const byTask = /* @__PURE__ */ new Map();
+  for (const r of eff) {
+    const list = byTask.get(r.taskType) ?? [];
+    list.push(r);
+    byTask.set(r.taskType, list);
+  }
+  const valid = [];
+  for (const [taskType, list] of byTask) {
+    const qualified = list.filter(
+      (r) => r.steps >= MIN_SAMPLES && r.successRate >= MIN_SUCCESS && r.avgTokensPerSuccess > 0
+    );
+    if (qualified.length < 2) continue;
+    const baseline = median(qualified.map((r) => r.avgTokensPerSuccess));
+    for (const r of qualified) {
+      const savings = 1 - r.avgTokensPerSuccess / baseline;
+      if (savings >= MIN_MARGIN) {
+        const id = `${taskType}__${r.model}`;
+        valid.push(id);
+        upsertInsight({
+          id,
+          computedAt: now,
+          taskType,
+          model: r.model,
+          provider: r.model.split("/")[0] ?? "unknown",
+          samples: r.steps,
+          successRate: r.successRate,
+          avgTokens: r.avgTokensPerSuccess,
+          baselineTokens: baseline,
+          savingsPct: savings * 100,
+          avgCostUsd: r.avgCostPerSuccess
+        });
+      }
+    }
+  }
+  deleteInsightsExcept(valid);
+  return listInsights();
+}
+function insightBoostMap(insights) {
+  const map = {};
+  for (const i of insights) map[`${i.taskType}:${i.model}`] = i.savingsPct;
+  return map;
+}
+function renderPlaybook(insights) {
+  if (!insights.length) {
+    return c.bold("Efficiency playbook") + "\n" + c.dim(
+      `Nothing distilled yet \u2014 needs \u22652 models with \u2265${MIN_SAMPLES} successful steps on the same task type,
+where one beats the median by \u2265${MIN_MARGIN * 100}% tokens. Keep running tasks (vary models with -o / pins).`
+    );
+  }
+  return c.bold("Efficiency playbook") + c.dim("  (the notably efficient approaches \u2014 this is what `poly sync` uploads)") + "\n" + table(
+    ["Task", "Model", "Avg tok", "Baseline", "Savings", "Success", "n"],
+    insights.map((i) => [
+      i.taskType,
+      c.green(i.model),
+      tokens(Math.round(i.avgTokens)),
+      tokens(Math.round(i.baselineTokens)),
+      c.green(`-${i.savingsPct.toFixed(0)}%`),
+      `${Math.round(i.successRate * 100)}%`,
+      String(i.samples)
+    ])
+  );
+}
+
+// src/usage/analyze.ts
+var MIN_SUCCESS_RATE = 0.5;
+function renderAnalysis(filter = {}) {
+  const out = [];
+  const byModelTask = modelTaskEfficiency(filter);
+  const byObjective = objectiveEfficiency(filter);
+  const byCommand = commandUsage(filter);
+  if (!byModelTask.length && !byObjective.length && !byCommand.length) {
+    return c.dim('No analytics yet. Run `poly run "<task>"` a few times (and rate the result) first.');
+  }
+  const insights = distillInsights();
+  out.push(renderPlaybook(insights));
+  out.push("");
+  if (byModelTask.length) {
+    const byTask = /* @__PURE__ */ new Map();
+    for (const r of byModelTask) {
+      const list = byTask.get(r.taskType) ?? [];
+      list.push(r);
+      byTask.set(r.taskType, list);
+    }
+    const rows = [];
+    for (const [task, list] of byTask) {
+      const eligible = list.filter((r) => r.successRate >= MIN_SUCCESS_RATE && r.avgTokensPerSuccess > 0).sort((a, b) => a.avgTokensPerSuccess - b.avgTokensPerSuccess);
+      const best = eligible[0];
+      const runnerUp = eligible[1];
+      if (!best) {
+        rows.push([task, c.dim("(no reliable model yet)"), "-", "-", "-"]);
+        continue;
+      }
+      rows.push([
+        task,
+        c.green(best.model),
+        tokens(Math.round(best.avgTokensPerSuccess)),
+        `${Math.round(best.successRate * 100)}%`,
+        runnerUp ? `${runnerUp.model} ${c.dim(tokens(Math.round(runnerUp.avgTokensPerSuccess)))}` : c.dim("\u2014")
+      ]);
+    }
+    out.push(c.bold("Minimum-token model per task") + c.dim(`  (successful steps only, success \u2265 ${MIN_SUCCESS_RATE * 100}%)`));
+    out.push(table(["Task", "Best model", "Avg tok/success", "Success", "Runner-up"], rows));
+    out.push("");
+    out.push(c.bold("Model \xD7 task efficiency (all observations)"));
+    out.push(
+      table(
+        ["Task", "Model", "Steps", "Success", "Avg tok", "Avg iters", "Avg cost"],
+        byModelTask.map((r) => [
+          r.taskType,
+          r.model,
+          String(r.steps),
+          `${Math.round(r.successRate * 100)}%`,
+          r.avgTokensPerSuccess ? tokens(Math.round(r.avgTokensPerSuccess)) : c.dim("-"),
+          r.avgIterations.toFixed(1),
+          r.avgCostPerSuccess ? usd(r.avgCostPerSuccess) : c.dim("-")
+        ])
+      )
+    );
+    out.push("");
+  }
+  if (byObjective.length) {
+    out.push(c.bold("Approach efficiency") + c.dim("  (routing objective: tokens spent vs goal achievement)"));
+    out.push(
+      table(
+        ["Objective", "Sessions", "Avg tokens", "Avg cost", "Auto score", "Your rating"],
+        byObjective.map((r) => [
+          r.objective,
+          String(r.sessions),
+          tokens(Math.round(r.avgTokens)),
+          usd(r.avgCostUsd),
+          r.avgAutoScore == null ? c.dim("-") : `${Math.round(r.avgAutoScore * 100)}%`,
+          r.avgUserScore == null ? c.dim("unrated") : `${r.avgUserScore.toFixed(1)}/9`
+        ])
+      )
+    );
+    const scored = byObjective.filter((r) => r.avgAutoScore != null);
+    if (scored.length >= 2) {
+      const bestScore = Math.max(...scored.map((r) => r.avgAutoScore));
+      const winner = scored.filter((r) => r.avgAutoScore >= bestScore - 0.1).sort((a, b) => a.avgTokens - b.avgTokens)[0];
+      if (winner) {
+        out.push(
+          c.green(
+            `\u2192 Lowest-token approach with top-tier achievement: "${winner.objective}" (${tokens(Math.round(winner.avgTokens))} avg tokens, ${Math.round(winner.avgAutoScore * 100)}% auto score)`
+          )
+        );
+      }
+    }
+    out.push("");
+  }
+  if (byCommand.length) {
+    out.push(c.bold("Usage by command"));
+    out.push(
+      table(
+        ["Command", "Runs", "Prompt", "Compl.", "Cost"],
+        byCommand.map((r) => [r.command, String(r.runs), tokens(r.promptTokens), tokens(r.completionTokens), usd(r.costUsd)])
+      )
+    );
+  }
+  return out.join("\n");
+}
+
 // src/usage/firestoreSync.ts
-async function syncUsage(config) {
+async function syncUsage(config, opts = {}) {
   if (!config.firestore.enabled) {
     return { synced: 0, message: "Firestore sync is disabled (enable with `poly config firestore on`)." };
   }
@@ -1095,28 +1692,324 @@ async function syncUsage(config) {
     }
   }
   const fdb = fsMod.getFirestore();
+  distillInsights();
+  const insights = unsyncedInsights();
+  if (insights.length) {
+    const batch = fdb.batch();
+    const col = fdb.collection("polymath_insights");
+    for (const i of insights) {
+      batch.set(col.doc(i.id), {
+        computedAt: i.computedAt,
+        taskType: i.taskType,
+        model: i.model,
+        provider: i.provider,
+        samples: i.samples,
+        successRate: i.successRate,
+        avgTokens: i.avgTokens,
+        baselineTokens: i.baselineTokens,
+        savingsPct: i.savingsPct,
+        avgCostUsd: i.avgCostUsd
+      });
+    }
+    await batch.commit();
+    markTableSynced("insights", insights.map((i) => i.id));
+  }
+  if (!opts.raw) {
+    return {
+      synced: insights.length,
+      message: insights.length ? `Synced ${insights.length} efficiency insight(s) to polymath_insights. Raw logs stayed local (use --raw to push).` : "No new insights to sync \u2014 raw logs stay local by default (use --raw to push them)."
+    };
+  }
   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
-    });
+  if (!rows.length && !insights.length) return { synced: 0, message: "Nothing to sync \u2014 all rows already pushed." };
+  if (rows.length) {
+    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,
+        command: r.command ?? "run",
+        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: insights.length + rows.length,
+    message: `Synced ${insights.length} insights + ${rows.length} raw rows to Firestore.`
+  };
+}
+
+// src/usage/dataconnect.ts
+async function adminAccessToken(projectId) {
+  let appMod;
+  try {
+    appMod = await import("firebase-admin/app");
+  } catch {
+    throw new Error("firebase-admin is not installed. Run `npm install firebase-admin`.");
+  }
+  const { initializeApp, getApps, cert, applicationDefault } = appMod;
+  let app = getApps()[0];
+  if (!app) {
+    const saJson = process.env.FIREBASE_SERVICE_ACCOUNT_KEY;
+    if (saJson) {
+      try {
+        app = initializeApp({ credential: cert(JSON.parse(saJson)), projectId });
+      } catch {
+        app = initializeApp({ credential: applicationDefault(), projectId });
+      }
+    } else {
+      app = initializeApp({ credential: applicationDefault(), projectId });
+    }
+  }
+  const token = await app.options.credential.getAccessToken();
+  return token.access_token;
+}
+async function executeGraphql(cfg2, token, query, variables) {
+  const url = `https://firebasedataconnect.googleapis.com/v1/projects/${cfg2.projectId}/locations/${cfg2.location}/services/${cfg2.serviceId}:executeGraphql`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Data Connect ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    throw new Error(`Data Connect GraphQL errors: ${JSON.stringify(json.errors).slice(0, 300)}`);
+  }
+}
+var iso = (ms) => new Date(ms).toISOString();
+async function syncDataConnect(config, opts = {}) {
+  const dc = config.dataconnect;
+  if (!dc?.enabled) {
+    return { insights: 0, sessions: 0, steps: 0, commands: 0, calls: 0, message: "Data Connect sync is disabled (enable with `poly config dataconnect on`)." };
+  }
+  const projectId = config.firestore.projectId;
+  const token = await adminAccessToken(projectId);
+  const cfg2 = { projectId, location: dc.location, serviceId: dc.serviceId };
+  distillInsights();
+  const insights = unsyncedInsights();
+  for (const i of insights) {
+    await executeGraphql(
+      cfg2,
+      token,
+      `mutation UpsertInsight($id: String!, $computedAt: Timestamp!, $taskType: String!,
+         $model: String!, $provider: String!, $samples: Int!, $successRate: Float!,
+         $avgTokens: Float!, $baselineTokens: Float!, $savingsPct: Float!, $avgCostUsd: Float!) {
+         insight_upsert(data: {
+           id: $id, computedAt: $computedAt, taskType: $taskType, model: $model,
+           provider: $provider, samples: $samples, successRate: $successRate,
+           avgTokens: $avgTokens, baselineTokens: $baselineTokens,
+           savingsPct: $savingsPct, avgCostUsd: $avgCostUsd
+         })
+       }`,
+      {
+        id: i.id,
+        computedAt: iso(i.computedAt),
+        taskType: i.taskType,
+        model: i.model,
+        provider: i.provider,
+        samples: i.samples,
+        successRate: i.successRate,
+        avgTokens: i.avgTokens,
+        baselineTokens: i.baselineTokens,
+        savingsPct: i.savingsPct,
+        avgCostUsd: i.avgCostUsd
+      }
+    );
+  }
+  markTableSynced("insights", insights.map((i) => i.id));
+  if (!opts.raw) {
+    return {
+      insights: insights.length,
+      sessions: 0,
+      steps: 0,
+      commands: 0,
+      calls: 0,
+      message: `Synced ${insights.length} efficiency insight(s) to Data Connect (${cfg2.serviceId}@${cfg2.location}). Raw logs stayed local \u2014 use \`poly sync --raw\` to push everything.`
+    };
+  }
+  const sessions = unsyncedSessions();
+  for (const s of sessions) {
+    await executeGraphql(
+      cfg2,
+      token,
+      `mutation UpsertSession($id: String!, $startedAt: Timestamp!, $date: Date!, $goal: String!,
+         $command: String!, $objective: String!, $plannedSteps: Int!, $completedSteps: Int!,
+         $failedSteps: Int!, $autoScore: Float, $userScore: Int, $promptTokens: Int!,
+         $completionTokens: Int!, $costUsd: Float!, $durationMs: Int!) {
+         session_upsert(data: {
+           id: $id, startedAt: $startedAt, date: $date, goal: $goal, command: $command,
+           objective: $objective, plannedSteps: $plannedSteps, completedSteps: $completedSteps,
+           failedSteps: $failedSteps, autoScore: $autoScore, userScore: $userScore,
+           promptTokens: $promptTokens, completionTokens: $completionTokens,
+           costUsd: $costUsd, durationMs: $durationMs
+         })
+       }`,
+      {
+        id: s.id,
+        startedAt: iso(s.ts),
+        date: s.date,
+        goal: s.goal,
+        command: s.command,
+        objective: s.objective,
+        plannedSteps: s.plannedSteps,
+        completedSteps: s.completedSteps,
+        failedSteps: s.failedSteps,
+        autoScore: s.autoScore,
+        userScore: s.userScore,
+        promptTokens: s.promptTokens,
+        completionTokens: s.completionTokens,
+        costUsd: s.costUsd,
+        durationMs: s.durationMs
+      }
+    );
+  }
+  markTableSynced("sessions", sessions.map((s) => s.id));
+  const steps = unsyncedStepRuns();
+  for (const st of steps) {
+    await executeGraphql(
+      cfg2,
+      token,
+      `mutation InsertStep($sessionId: String!, $stepNo: Int!, $taskType: String!, $skill: String!,
+         $model: String!, $provider: String!, $iterations: Int!, $toolCalls: Int!,
+         $promptTokens: Int!, $completionTokens: Int!, $costUsd: Float!,
+         $finishedBy: String!, $success: Boolean!, $durationMs: Int!) {
+         stepRun_insert(data: {
+           sessionId: $sessionId, stepNo: $stepNo, taskType: $taskType, skill: $skill,
+           model: $model, provider: $provider, iterations: $iterations, toolCalls: $toolCalls,
+           promptTokens: $promptTokens, completionTokens: $completionTokens, costUsd: $costUsd,
+           finishedBy: $finishedBy, success: $success, durationMs: $durationMs
+         })
+       }`,
+      {
+        sessionId: st.sessionId,
+        stepNo: st.stepNo,
+        taskType: st.taskType,
+        skill: st.skill,
+        model: st.model,
+        provider: st.provider,
+        iterations: st.iterations,
+        toolCalls: st.toolCalls,
+        promptTokens: st.promptTokens,
+        completionTokens: st.completionTokens,
+        costUsd: st.costUsd,
+        finishedBy: st.finishedBy,
+        success: st.success,
+        durationMs: st.durationMs
+      }
+    );
+  }
+  markTableSynced("step_runs", steps.map((s) => s.id));
+  const commands = unsyncedCommandRuns();
+  for (const cr of commands) {
+    await executeGraphql(
+      cfg2,
+      token,
+      `mutation InsertCommand($sessionId: String, $ts: Timestamp!, $date: Date!, $command: String!,
+         $args: String, $objective: String, $promptTokens: Int!, $completionTokens: Int!,
+         $costUsd: Float!, $durationMs: Int!) {
+         commandRun_insert(data: {
+           sessionId: $sessionId, ts: $ts, date: $date, command: $command, args: $args,
+           objective: $objective, promptTokens: $promptTokens, completionTokens: $completionTokens,
+           costUsd: $costUsd, durationMs: $durationMs
+         })
+       }`,
+      {
+        sessionId: cr.sessionId ?? null,
+        ts: iso(cr.ts),
+        date: cr.date,
+        command: cr.command,
+        args: cr.args ?? null,
+        objective: cr.objective ?? null,
+        promptTokens: cr.promptTokens,
+        completionTokens: cr.completionTokens,
+        costUsd: cr.costUsd,
+        durationMs: cr.durationMs
+      }
+    );
   }
-  await batch.commit();
-  markSynced(rows.map((r) => r.id));
-  return { synced: rows.length, message: `Synced ${rows.length} rows to ${config.firestore.collection}.` };
+  markTableSynced("command_runs", commands.map((c2) => c2.id));
+  const calls = unsyncedRows();
+  for (const u of calls) {
+    await executeGraphql(
+      cfg2,
+      token,
+      `mutation InsertCall($sessionId: String, $ts: Timestamp!, $date: Date!, $command: String!,
+         $taskType: String!, $model: String!, $provider: String!, $promptTokens: Int!,
+         $completionTokens: Int!, $totalTokens: Int!, $costUsd: Float!) {
+         modelCall_insert(data: {
+           sessionId: $sessionId, ts: $ts, date: $date, command: $command, taskType: $taskType,
+           model: $model, provider: $provider, promptTokens: $promptTokens,
+           completionTokens: $completionTokens, totalTokens: $totalTokens, costUsd: $costUsd
+         })
+       }`,
+      {
+        sessionId: u.sessionId ?? null,
+        ts: iso(u.ts),
+        date: u.date,
+        command: u.command ?? "run",
+        taskType: u.taskType,
+        model: u.model,
+        provider: u.provider,
+        promptTokens: u.promptTokens,
+        completionTokens: u.completionTokens,
+        totalTokens: u.totalTokens,
+        costUsd: u.costUsd
+      }
+    );
+  }
+  markSynced(calls.map((c2) => c2.id));
+  return {
+    insights: insights.length,
+    sessions: sessions.length,
+    steps: steps.length,
+    commands: commands.length,
+    calls: calls.length,
+    message: `Synced ${insights.length} insights + raw: ${sessions.length} sessions, ${steps.length} steps, ${commands.length} commands, ${calls.length} calls (${cfg2.serviceId}@${cfg2.location}).`
+  };
+}
+
+// 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, command = "run") {
+  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,
+    command
+  };
+  recordUsage(entry);
+  return entry;
 }
 
 // src/tui/App.tsx
@@ -1274,46 +2167,31 @@ ${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 totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
   let calls = 0;
+  const sessionStart = Date.now();
+  let completedSteps = 0;
+  let failedSteps = 0;
   const planRoute = route("plan", models, policy);
   let plan;
   if (planRoute) {
     try {
-      plan = await planRequest(goal, client2, planRoute.model);
+      plan = await planRequest(goal, client2, planRoute.model, (result) => {
+        const entry = logCompletion(result, "plan", sessionId);
+        emit({ type: "usage", entry });
+        totalCostUsd += entry.costUsd;
+        totalTokens += entry.totalTokens;
+        totalPromptTokens += entry.promptTokens;
+        totalCompletionTokens += entry.completionTokens;
+        calls++;
+      });
     } catch {
       plan = heuristicPlan(goal);
     }
@@ -1321,6 +2199,15 @@ async function runAgent(goal, deps, emit) {
     plan = heuristicPlan(goal);
   }
   emit({ type: "plan", plan, planModel: planRoute?.model.id ?? "heuristic" });
+  startSession({
+    id: sessionId,
+    ts: sessionStart,
+    date: localDate2(),
+    goal,
+    command: "run",
+    objective: policy.objective,
+    plannedSteps: plan.steps.length
+  });
   const toolCtx = {
     cwd,
     allowWrite: deps.allowWrite,
@@ -1333,6 +2220,7 @@ async function runAgent(goal, deps, emit) {
       completionTokens: step.estCompletionTokens
     });
     if (!r) {
+      failedSteps++;
       emit({ type: "error", message: `No capable model for step ${step.id} (${step.type}).` });
       continue;
     }
@@ -1343,55 +2231,113 @@ async function runAgent(goal, deps, emit) {
       { role: "system", content: stepSystemPrompt(goal, step, priorSummaries, useTools) },
       { role: "user", content: step.description }
     ];
+    const stepStart = Date.now();
+    let stepPrompt = 0;
+    let stepCompletion = 0;
+    let stepCost = 0;
+    let stepToolCalls = 0;
+    let iterations = 0;
+    let finishedBy = "max-iters";
     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;
+    try {
+      for (let iter = 0; iter < MAX_ITERS_PER_STEP; iter++) {
+        iterations = iter + 1;
+        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;
+        totalPromptTokens += entry.promptTokens;
+        totalCompletionTokens += entry.completionTokens;
+        stepPrompt += entry.promptTokens;
+        stepCompletion += entry.completionTokens;
+        stepCost += entry.costUsd;
+        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) {
+            stepToolCalls++;
+            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) {
+            finishedBy = "finish-tool";
+            break;
           }
+          continue;
         }
-        if (finished) break;
-        continue;
+        summary = result.content || summary;
+        if (summary) finishedBy = "text";
+        break;
       }
-      summary = result.content || summary;
-      break;
+    } catch (err) {
+      finishedBy = "error";
+      emit({ type: "error", message: `Step ${step.id} failed: ${err?.message ?? err}` });
     }
+    const success = finishedBy === "finish-tool" || finishedBy === "text";
+    if (success) completedSteps++;
+    else failedSteps++;
+    recordStepRun({
+      sessionId,
+      stepNo: step.id,
+      taskType: step.type,
+      skill: TASK_SKILL[step.type],
+      model: model.id,
+      provider: model.provider,
+      iterations,
+      toolCalls: stepToolCalls,
+      promptTokens: stepPrompt,
+      completionTokens: stepCompletion,
+      costUsd: stepCost,
+      finishedBy,
+      success,
+      durationMs: Date.now() - stepStart
+    });
     if (!summary) summary = "(no summary)";
     priorSummaries.push(`Step ${step.id} (${step.type}): ${summary}`);
     emit({ type: "step-end", step, summary });
   }
+  finishSession(sessionId, {
+    plannedSteps: plan.steps.length,
+    completedSteps,
+    failedSteps,
+    autoScore: plan.steps.length ? completedSteps / plan.steps.length : null,
+    promptTokens: totalPromptTokens,
+    completionTokens: totalCompletionTokens,
+    costUsd: totalCostUsd,
+    durationMs: Date.now() - sessionStart
+  });
   emit({ type: "done", totalCostUsd, totalTokens, calls });
   return { totalCostUsd, totalTokens, calls };
 }
+function localDate2(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 stepSystemPrompt(goal, step, priorSummaries, useTools) {
   const context = priorSummaries.length ? `
 
@@ -1418,6 +2364,7 @@ function App(props) {
   const [cost, setCost] = useState(0);
   const [tok, setTok] = useState(0);
   const [calls, setCalls] = useState(0);
+  const [rated, setRated] = useState(null);
   const push = useCallback((text, color) => {
     setLog((l) => [...l, { key: l.length, text, color }]);
   }, []);
@@ -1484,7 +2431,7 @@ function App(props) {
     } catch (err) {
       push(`Fatal: ${err?.message ?? err}`, "red");
     }
-    setPhase("done");
+    setPhase("rate");
   }, [goal, props, push]);
   useInput((input, key) => {
     if (phase === "preview") {
@@ -1493,6 +2440,18 @@ function App(props) {
         setDraft(goal);
         setPhase("input");
       } else if (input === "q") exit();
+    } else if (phase === "rate") {
+      if (/^[0-9]$/.test(input)) {
+        const score = parseInt(input, 10);
+        try {
+          setUserScore(props.sessionId, score);
+        } catch {
+        }
+        setRated(score);
+        setPhase("done");
+      } else if (key.return || input === "q") {
+        setPhase("done");
+      }
     } else if (phase === "done") {
       if (input === "q" || key.return) exit();
     }
@@ -1516,12 +2475,26 @@ function App(props) {
       )
     ] }),
     phase === "preview" && rec && /* @__PURE__ */ jsx(Preview, { rec }),
-    (phase === "running" || phase === "done") && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    (phase === "running" || phase === "rate" || 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 === "rate" && /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+          "\u2713 Done \xB7 ",
+          calls,
+          " calls \xB7 ",
+          tokens(tok),
+          " tokens \xB7 ",
+          usd(cost)
+        ] }),
+        "\n",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "How well was your goal achieved? " }),
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "[0-9]" }),
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: " (9 = perfect \xB7 enter = skip) \u2014 feeds `poly analyze`" })
+      ] }),
       phase === "done" && /* @__PURE__ */ jsxs(Text, { color: "green", children: [
         "\u2713 Done \xB7 ",
         calls,
@@ -1529,6 +2502,7 @@ function App(props) {
         tokens(tok),
         " tokens \xB7 ",
         usd(cost),
+        rated != null ? ` \xB7 rated ${rated}/9` : "",
         " \u2014 press q to quit"
       ] })
     ] })
@@ -1596,27 +2570,73 @@ function truncate2(s, n) {
 
 // src/index.ts
 var program = new Command();
-program.name("poly").description("Polymath \u2014 cost-optimized, multi-model TUI coding agent").version("0.1.0");
+program.name("poly").description("Polymath \u2014 cost-optimized, multi-model TUI coding agent").version("0.3.0");
 function client(config) {
   return new OpenRouterClient({
     apiKey: resolveApiKey(config),
     referer: config.referer,
-    title: config.title
+    title: config.title,
+    localBaseUrl: config.local.enabled ? config.local.baseUrl : void 0
   });
 }
 function buildPolicy(config, opts) {
   const objective = opts.objective || config.defaultObjective;
   const maxCost = opts.maxCost != null ? parseFloat(opts.maxCost) : config.maxCostPerCallUsd;
+  let empirical;
+  try {
+    empirical = insightBoostMap(listInsights());
+    if (!Object.keys(empirical).length) empirical = void 0;
+  } catch {
+    empirical = void 0;
+  }
   return {
     objective,
     maxCostPerCallUsd: Number.isFinite(maxCost) ? maxCost : void 0,
-    pinned: config.pinned
+    pinned: config.pinned,
+    empirical
   };
 }
+function localDate3(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 trackCommand(opts) {
+  try {
+    recordCommandRun({
+      sessionId: opts.sessionId,
+      ts: opts.startedAt,
+      date: localDate3(new Date(opts.startedAt)),
+      command: opts.command,
+      args: opts.args?.slice(0, 300),
+      objective: opts.objective,
+      promptTokens: opts.promptTokens ?? 0,
+      completionTokens: opts.completionTokens ?? 0,
+      costUsd: opts.costUsd ?? 0,
+      durationMs: Date.now() - opts.startedAt
+    });
+  } catch {
+  }
+}
 async function loadCatalog(config, refresh = false) {
-  const models = await getModels(client(config), { refresh });
+  const cl = client(config);
+  const hasKey = !!resolveApiKey(config);
+  let models = [];
+  try {
+    models = await getModels(cl, { refresh });
+  } catch (e) {
+    if (!config.local.enabled) throw e;
+  }
+  if (config.local.enabled) {
+    const local = await getLocalModels(cl);
+    if (!local.length) {
+      console.error(c.yellow(`Local server (${config.local.baseUrl}) returned no models \u2014 is it running?`));
+    }
+    models = hasKey ? [...local, ...models] : local;
+  }
   if (!models.length) {
-    console.error(c.red("Could not load the model catalog. Check your connection."));
+    console.error(c.red("No models available. Check your connection, or `poly config local on` with a running Ollama/LM Studio."));
     process.exit(1);
   }
   return models;
@@ -1625,22 +2645,26 @@ program.command("login").description("Connect Polymath to OpenRouter (set/replac
   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 startedAt = Date.now();
   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);
+  if (!config.local.enabled || resolveApiKey(config)) {
+    const key = await ensureApiKey(config);
+    if (!key && !config.local.enabled) {
+      console.error(c.red("No API key \u2014 cannot run. Try `poly login`, or `poly config local on` for a local LLM."));
+      process.exit(1);
+    }
   }
   const reloaded = loadConfig();
   const models = await loadCatalog(reloaded);
   const policy = buildPolicy(reloaded, opts);
   const goal = goalParts?.join(" ").trim() || void 0;
+  const sessionId = randomUUID();
   const instance = render(
     createElement(App, {
       client: client(reloaded),
       models,
       policy,
-      sessionId: randomUUID(),
+      sessionId,
       cwd: opts.cwd,
       allowWrite: !!opts.write,
       allowCommands: !!opts.commands,
@@ -1649,11 +2673,22 @@ program.command("run", { isDefault: true }).description("Launch the interactive
     })
   );
   await instance.waitUntilExit();
+  const totals2 = sessionUsageTotals(sessionId);
+  trackCommand({
+    command: "run",
+    startedAt,
+    sessionId,
+    args: goal,
+    objective: policy.objective,
+    ...totals2
+  });
 });
 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 startedAt = Date.now();
   const config = loadConfig();
   const models = await loadCatalog(config);
   const goal = goalParts.join(" ");
+  const sessionId = randomUUID();
   let plan = heuristicPlan(goal);
   if (opts.smart) {
     const key = resolveApiKey(config);
@@ -1663,7 +2698,9 @@ program.command("recommend").description("Recommend the best / best-value model
       const planRoute = route("plan", models, buildPolicy(config, {}));
       if (planRoute) {
         try {
-          plan = await planRequest(goal, client(config), planRoute.model);
+          plan = await planRequest(goal, client(config), planRoute.model, (result) => {
+            logCompletion(result, "plan", sessionId, "recommend");
+          });
         } catch (e) {
           console.error(c.yellow(`Smart plan failed (${e?.message}); using heuristic.`));
         }
@@ -1671,6 +2708,8 @@ program.command("recommend").description("Recommend the best / best-value model
     }
   }
   console.log(renderRecommendation(buildRecommendation(plan, models)));
+  const totals2 = sessionUsageTotals(sessionId);
+  trackCommand({ command: "recommend", startedAt, sessionId, args: goal, objective: config.defaultObjective, ...totals2 });
 });
 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();
@@ -1701,11 +2740,11 @@ program.command("usage").description("Show recorded usage & cost by date + model
   let until = opts.until;
   if (opts.today) {
     const d = /* @__PURE__ */ new Date();
-    const iso = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(
+    const iso2 = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(
       d.getDate()
     ).padStart(2, "0")}`;
-    since = iso;
-    until = iso;
+    since = iso2;
+    until = iso2;
   }
   console.log(renderUsageReport({ since, until }));
   if (opts.sync) {
@@ -1713,10 +2752,34 @@ program.command("usage").description("Show recorded usage & cost by date + model
     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 () => {
+program.command("analyze").description("Which approach reaches the goal with the FEWEST tokens \u2014 per model, task, objective, command").option("--since <date>", "YYYY-MM-DD inclusive").option("--until <date>", "YYYY-MM-DD inclusive").action(async (opts) => {
+  console.log(renderAnalysis({ since: opts.since, until: opts.until }));
+});
+program.command("sync").description("Push DISTILLED efficiency insights to Firebase (raw logs stay local unless --raw)").option("--raw", "also push the full raw ledger (sessions/steps/calls/commands)", false).action(async (opts) => {
   const config = loadConfig();
-  const res = await syncUsage(config);
-  console.log(res.synced > 0 ? c.green(res.message) : c.yellow(res.message));
+  let pushed = false;
+  if (config.dataconnect.enabled) {
+    pushed = true;
+    try {
+      const res = await syncDataConnect(config, { raw: !!opts.raw });
+      const n = res.insights + res.sessions + res.steps + res.commands + res.calls;
+      console.log(n > 0 ? c.green(res.message) : c.dim(res.message));
+    } catch (e) {
+      console.error(c.red(`Data Connect sync failed: ${e?.message ?? e}`));
+    }
+  }
+  if (config.firestore.enabled) {
+    pushed = true;
+    const res = await syncUsage(config, { raw: !!opts.raw });
+    console.log(res.synced > 0 ? c.green(res.message) : c.dim(res.message));
+  }
+  if (!pushed) {
+    console.log(
+      c.yellow(
+        "No sync target enabled. Use `poly config dataconnect on` (SQL) or `poly config firestore on`."
+      )
+    );
+  }
 });
 var cfg = program.command("config").description("View or change Polymath settings");
 cfg.command("show").description("Print the current config (key is masked)").action(() => {
@@ -1758,6 +2821,29 @@ cfg.command("firestore").description("Enable/disable Firestore sync: on | off").
   saveConfig(config);
   console.log(c.green(`Firestore sync ${config.firestore.enabled ? "enabled" : "disabled"}.`));
 });
+cfg.command("local").description("Enable/disable a local LLM server (Ollama/LM Studio): on | off [--base <url>]").argument("<state>").option("--base <url>", "OpenAI-compatible base URL (default http://localhost:11434/v1)").action((state, opts) => {
+  const config = loadConfig();
+  config.local.enabled = /^on|true|1$/i.test(state);
+  if (opts.base) config.local.baseUrl = String(opts.base).replace(/\/$/, "");
+  saveConfig(config);
+  console.log(
+    c.green(
+      `Local LLM ${config.local.enabled ? "enabled" : "disabled"} (${config.local.baseUrl}). Models appear as local/<name> with $0 cost.`
+    )
+  );
+});
+cfg.command("dataconnect").description("Enable/disable Firebase Data Connect (SQL) sync: on | off [--location <loc>] [--service <id>]").argument("<state>").option("--location <loc>", "Data Connect location (default us-east4)").option("--service <id>", "Data Connect service id (default polymath)").action((state, opts) => {
+  const config = loadConfig();
+  config.dataconnect.enabled = /^on|true|1$/i.test(state);
+  if (opts.location) config.dataconnect.location = opts.location;
+  if (opts.service) config.dataconnect.serviceId = opts.service;
+  saveConfig(config);
+  console.log(
+    c.green(
+      `Data Connect sync ${config.dataconnect.enabled ? "enabled" : "disabled"} (service ${config.dataconnect.serviceId} @ ${config.dataconnect.location}).`
+    )
+  );
+});
 program.parseAsync().catch((err) => {
   console.error(c.red(err?.message ?? String(err)));
   process.exit(1);