polymath-agent 0.1.0 → 0.2.0

package/README.md

@@ -93,8 +93,12 @@ poly usage                                # cost by date + model
 | `poly recommend <goal>` | Pre-run recommendation: cheapest / best-value / best-quality model combos + savings. |
 | `poly models` | Browse the catalog with pricing, tier, tool support. Filters: `--tier`, `--tools`, `--search`. |
 | `poly usage` | Recorded usage & cost grouped by **date + model**. `--today`, `--since`, `--sync`. |
-| `poly sync` | Push the local usage ledger to Firestore. |
-| `poly config show\|set\|firestore` | View/change settings. |
+| `poly analyze` | **Which approach reaches the goal with the fewest tokens** — best model per task type, objective × achievement, usage per command. |
+| `poly sync` | Push the analytics ledger to Firebase ([Data Connect SQL](dataconnect/) and/or Firestore). |
+| `poly config show\|set\|firestore\|dataconnect` | View/change settings. |
+
+After each `poly run`, rate the result 0–9 (one keypress) — your goal-achievement
+rating joins the auto score (completed/planned steps) to power `poly analyze`.
 
 ### Routing objectives
 

package/dist/cli.js

@@ -44,6 +44,11 @@ var DEFAULT_CONFIG = {
     enabled: false,
     projectId: "mathology-b8e3d",
     collection: "polymath_usage"
+  },
+  dataconnect: {
+    enabled: false,
+    location: "us-east4",
+    serviceId: "polymath"
   }
 };
 function loadConfig() {
@@ -54,7 +59,8 @@ function loadConfig() {
     return {
       ...DEFAULT_CONFIG,
       ...raw,
-      firestore: { ...DEFAULT_CONFIG.firestore, ...raw.firestore ?? {} }
+      firestore: { ...DEFAULT_CONFIG.firestore, ...raw.firestore ?? {} },
+      dataconnect: { ...DEFAULT_CONFIG.dataconnect, ...raw.dataconnect ?? {} }
     };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -560,7 +566,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 +579,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 };
@@ -935,14 +942,78 @@ 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);
   `);
+  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 +1025,8 @@ function recordUsage(e) {
     e.completionTokens,
     e.totalTokens,
     e.costUsd,
-    e.sessionId ?? null
+    e.sessionId ?? null,
+    e.command ?? "run"
   );
 }
 function reportByDateModel(filter = {}) {
@@ -1016,7 +1088,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 +1097,216 @@ 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 ${table2 === "sessions" ? "id" : "id"}=?`);
+  for (const id of ids) stmt.run(id);
+}
 
 // src/usage/report.ts
 function renderUsageReport(filter = {}) {
@@ -1066,6 +1349,101 @@ function renderUsageReport(filter = {}) {
   ].join("\n");
 }
 
+// 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.');
+  }
+  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) {
   if (!config.firestore.enabled) {
@@ -1119,6 +1497,225 @@ async function syncUsage(config) {
   return { synced: rows.length, message: `Synced ${rows.length} rows to ${config.firestore.collection}.` };
 }
 
+// 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) {
+  const dc = config.dataconnect;
+  if (!dc?.enabled) {
+    return { 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 };
+  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
+      }
+    );
+  }
+  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 {
+    sessions: sessions.length,
+    steps: steps.length,
+    commands: commands.length,
+    calls: calls.length,
+    message: `Synced ${sessions.length} sessions, ${steps.length} steps, ${commands.length} commands, ${calls.length} calls to Data Connect (${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
 import { useState, useEffect, useCallback } from "react";
 import { Box, Text, useApp, useInput } from "ink";
@@ -1274,46 +1871,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 +1903,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 +1924,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 +1935,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 +2068,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 +2135,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 +2144,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 +2179,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 +2206,7 @@ function App(props) {
         tokens(tok),
         " tokens \xB7 ",
         usd(cost),
+        rated != null ? ` \xB7 rated ${rated}/9` : "",
         " \u2014 press q to quit"
       ] })
     ] })
@@ -1596,7 +2274,7 @@ 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.2.0");
 function client(config) {
   return new OpenRouterClient({
     apiKey: resolveApiKey(config),
@@ -1613,6 +2291,29 @@ function buildPolicy(config, opts) {
     pinned: config.pinned
   };
 }
+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 });
   if (!models.length) {
@@ -1625,6 +2326,7 @@ 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) {
@@ -1635,12 +2337,13 @@ program.command("run", { isDefault: true }).description("Launch the interactive
   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 +2352,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 +2377,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 +2387,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 +2419,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 +2431,33 @@ 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 the local analytics ledger to Firebase (Data Connect SQL and/or Firestore)").action(async () => {
   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);
+      console.log(res.sessions + res.steps + res.commands + res.calls > 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);
+    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 +2499,18 @@ 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("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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polymath-agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Polymath — a cost-optimized, multi-model TUI coding agent. Decomposes work into typed tasks, routes each task to the cheapest capable model via OpenRouter, and logs real usage/cost by date + model.",
   "type": "module",
   "bin": {