nomnomtokens 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, mkdirSync, copyFileSync, writeFileSync, statSync, createReadStream, readdirSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, copyFileSync, writeFileSync, statSync, readdirSync, createReadStream } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { Command } from 'commander';
@@ -4995,7 +4995,11 @@ var scopes = sqliteTable("scopes", {
   /** human-readable alias — local only, never synced */
   label: text("label").notNull(),
   provider: text("provider").notNull(),
-  lastSeen: integer("last_seen").notNull()
+  lastSeen: integer("last_seen").notNull(),
+  /** freelancer/client tag — local only, never attached to events */
+  client: text("client"),
+  /** 1 when the user renamed the label; ingest must not clobber it */
+  labelLocked: integer("label_locked").notNull().default(0)
 });
 var limits = sqliteTable("limits", {
   ts: integer("ts").notNull(),
@@ -5015,7 +5019,7 @@ var scanState = sqliteTable("scan_state", {
 });
 
 // packages/db/src/client.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 function defaultDataDir() {
   return process.env.NOMNOMTOKENS_HOME ?? join(homedir(), ".nomnomtokens");
 }
@@ -5045,7 +5049,9 @@ CREATE TABLE IF NOT EXISTS scopes (
   scope_hash TEXT PRIMARY KEY,
   label TEXT NOT NULL,
   provider TEXT NOT NULL,
-  last_seen INTEGER NOT NULL
+  last_seen INTEGER NOT NULL,
+  client TEXT,
+  label_locked INTEGER NOT NULL DEFAULT 0
 );
 
 CREATE TABLE IF NOT EXISTS limits (
@@ -5065,6 +5071,16 @@ CREATE TABLE IF NOT EXISTS scan_state (
   offset INTEGER NOT NULL
 );
 `;
+function migrate(sqlite, from) {
+  if (from < 2) {
+    const cols = sqlite.pragma("table_info(scopes)");
+    const names = new Set(cols.map((c2) => c2.name));
+    if (!names.has("client")) sqlite.exec("ALTER TABLE scopes ADD COLUMN client TEXT");
+    if (!names.has("label_locked")) {
+      sqlite.exec("ALTER TABLE scopes ADD COLUMN label_locked INTEGER NOT NULL DEFAULT 0");
+    }
+  }
+}
 function openDb(path = defaultDbPath()) {
   if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
   const sqlite = new Client(path);
@@ -5078,6 +5094,9 @@ function openDb(path = defaultDbPath()) {
     throw new Error(
       `Database at ${path} was written by a newer nomnomtokens (schema v${found}, this build understands v${SCHEMA_VERSION}). Upgrade the CLI.`
     );
+  } else if (found < SCHEMA_VERSION) {
+    migrate(sqlite, found);
+    sqlite.pragma(`user_version = ${SCHEMA_VERSION}`);
   }
   const db = drizzle(sqlite, { schema: sqlite_exports });
   return { db, sqlite, path };
@@ -5229,6 +5248,12 @@ function bucketStart(ts, g) {
       return d.getTime();
   }
 }
+function cacheHitRate(qty) {
+  const read = qty.cacheRead ?? 0;
+  const fresh = qty.in ?? 0;
+  const denom = read + fresh;
+  return denom === 0 ? null : read / denom;
+}
 
 // packages/core/src/forecast.ts
 function linearRegression(points) {
@@ -5278,13 +5303,6 @@ function forecastLimit(snapshots, now = Date.now()) {
     samples: current.length
   };
 }
-function moodFor(usedPct) {
-  if (usedPct < 5) return "hungry";
-  if (usedPct < 50) return "content";
-  if (usedPct < 80) return "full";
-  if (usedPct < 100) return "stuffed";
-  return "overstuffed";
-}
 
 // packages/core/src/export-format.ts
 var CSV_HEADERS = [
@@ -5293,6 +5311,7 @@ var CSV_HEADERS = [
   "kind",
   "session_id",
   "project",
+  "client",
   "scope_hash",
   "model",
   "cost_usd",
@@ -5318,6 +5337,7 @@ function formatExportCsv(rows) {
       csvCell(r.kind),
       csvCell(r.sessionId),
       csvCell(r.project),
+      csvCell(r.client),
       csvCell(r.scopeHash),
       csvCell(r.model),
       csvCell(r.costUsd),
@@ -5340,6 +5360,7 @@ function formatExportJson(rows) {
     kind: r.kind,
     sessionId: r.sessionId,
     project: r.project,
+    client: r.client,
     scopeHash: r.scopeHash,
     model: r.model,
     costUsd: r.costUsd,
@@ -5352,6 +5373,95 @@ function formatExportJson(rows) {
   })), null, 2)}
 `;
 }
+var NNT_ARCHIVE_VERSION = 1;
+function formatNntArchive(archive) {
+  return `${JSON.stringify({ ...archive, version: NNT_ARCHIVE_VERSION }, null, 2)}
+`;
+}
+function numbersOnly(meta) {
+  if (!meta || typeof meta !== "object") return {};
+  const out = {};
+  for (const [k, v] of Object.entries(meta)) {
+    if (typeof v === "number" && Number.isFinite(v)) out[k] = v;
+  }
+  return out;
+}
+function qtyOnly(qty) {
+  if (!qty || typeof qty !== "object") return {};
+  const out = {};
+  for (const [k, v] of Object.entries(qty)) {
+    if (typeof v === "number" && Number.isFinite(v)) out[k] = v;
+  }
+  return out;
+}
+function looksLikeNntArchive(text2) {
+  const trimmed = text2.trimStart();
+  if (!trimmed.startsWith("{")) return false;
+  try {
+    const parsed = JSON.parse(text2);
+    return parsed.version === NNT_ARCHIVE_VERSION && Array.isArray(parsed.events);
+  } catch {
+    return false;
+  }
+}
+function parseNntArchive(text2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch {
+    throw new Error("nnt archive is not valid JSON");
+  }
+  const data = parsed;
+  if (data.version !== NNT_ARCHIVE_VERSION || !Array.isArray(data.events)) {
+    throw new Error("not an nnt archive (expected { version: 1, events })");
+  }
+  const records = [];
+  for (const raw of data.events) {
+    if (!raw || typeof raw.id !== "string") continue;
+    const qty = qtyOnly(raw.qty);
+    const event = {
+      id: raw.id,
+      ts: typeof raw.ts === "number" ? raw.ts : 0,
+      provider: typeof raw.provider === "string" ? raw.provider : "nnt",
+      kind: typeof raw.kind === "string" ? raw.kind : "tokens",
+      sessionId: typeof raw.sessionId === "string" ? raw.sessionId : null,
+      scopeHash: typeof raw.scopeHash === "string" ? raw.scopeHash : "unknown",
+      unitLabel: typeof raw.unitLabel === "string" ? raw.unitLabel : null,
+      qty,
+      costUsd: typeof raw.costUsd === "number" ? raw.costUsd : null,
+      meta: numbersOnly(raw.meta)
+    };
+    if (!Number.isFinite(event.ts) || event.ts <= 0) continue;
+    void totalTokens(qty);
+    records.push({ type: "event", event });
+  }
+  for (const raw of data.limits ?? []) {
+    if (!raw || typeof raw.ts !== "number" || typeof raw.provider !== "string") continue;
+    records.push({
+      type: "limit",
+      limit: {
+        ts: raw.ts,
+        provider: raw.provider,
+        window: typeof raw.window === "string" ? raw.window : "7d",
+        usedPct: typeof raw.usedPct === "number" ? raw.usedPct : 0,
+        resetsAt: typeof raw.resetsAt === "number" ? raw.resetsAt : null
+      }
+    });
+  }
+  for (const raw of data.scopes ?? []) {
+    if (!raw || typeof raw.scopeHash !== "string" || typeof raw.label !== "string") continue;
+    records.push({
+      type: "scope",
+      scopeHash: raw.scopeHash,
+      label: raw.label,
+      provider: typeof raw.provider === "string" ? raw.provider : "nnt",
+      lastSeen: typeof raw.lastSeen === "number" ? raw.lastSeen : void 0,
+      client: typeof raw.client === "string" ? raw.client : null,
+      labelLocked: Boolean(raw.labelLocked)
+    });
+  }
+  return records;
+}
 
 // packages/core/src/prices-file.ts
 function parsePricesFile(text2) {
@@ -5453,6 +5563,368 @@ function evaluateAlerts(config, input) {
   return hits;
 }
 
+// packages/core/src/audit.ts
+function share(part, whole) {
+  if (whole <= 0) return null;
+  return part / whole;
+}
+function isFrontierModel(label) {
+  if (!label) return false;
+  const l = label.toLowerCase();
+  return l.includes("fable") || l.includes("opus");
+}
+function buildAuditReport(input) {
+  const modelLimit = input.modelLimit ?? 5;
+  const sessionLimit = input.sessionLimit ?? 5;
+  const totalCost = input.totals.costUsd;
+  const tagged = input.sidechain.taggedEvents > 0;
+  const models = [...input.models].sort((a, b) => b.costUsd - a.costUsd).slice(0, modelLimit).map((m) => ({
+    unitLabel: m.unitLabel,
+    costUsd: m.costUsd,
+    share: share(m.costUsd, totalCost) ?? 0
+  }));
+  const topSessions = input.sessions.slice(0, sessionLimit).map((s) => ({
+    sessionId: s.sessionId,
+    label: s.label,
+    costUsd: s.costUsd,
+    sidechainShare: s.sidechainTagged > 0 ? share(s.sidechainCostUsd, s.costUsd) : null
+  }));
+  const hitRate = cacheHitRate({
+    cacheRead: input.totals.qtyCacheRead,
+    in: input.totals.qtyIn
+  });
+  const sidechainShare = tagged ? share(input.sidechain.costUsd, totalCost) : null;
+  const report = {
+    range: input.range,
+    totals: {
+      costUsd: input.totals.costUsd,
+      tokens: input.totals.tokens,
+      events: input.totals.events
+    },
+    cache: {
+      hitRate,
+      readTokens: input.totals.qtyCacheRead,
+      freshInTokens: input.totals.qtyIn
+    },
+    sidechain: {
+      tagged,
+      costUsd: input.sidechain.costUsd,
+      tokens: input.sidechain.tokens,
+      shareOfCost: sidechainShare
+    },
+    models,
+    topSessions,
+    coldResumes: (input.coldResumes ?? []).slice(0, sessionLimit),
+    tips: []
+  };
+  report.tips = buildTips(report);
+  return report;
+}
+function formatGap(ms) {
+  const hours = Math.round(ms / 36e5);
+  if (hours < 1) return `${Math.max(1, Math.round(ms / 6e4))}m`;
+  return `${hours}h`;
+}
+function buildTips(report) {
+  const tips = [];
+  const cold = report.coldResumes[0];
+  if (cold) {
+    const name = cold.label ?? cold.sessionId.slice(0, 12);
+    const dollars = cold.costUsd < 0.01 ? `$${cold.costUsd.toFixed(4)}` : `$${cold.costUsd.toFixed(2)}`;
+    tips.push(
+      `Session ${name} went cold after ${formatGap(cold.gapMs)}; the next turn cost ${dollars} in cache writes \u2014 /clear is cheaper than resume.`
+    );
+  }
+  if (report.sidechain.tagged && report.sidechain.shareOfCost !== null && report.sidechain.shareOfCost >= 0.3) {
+    const pct2 = Math.round(report.sidechain.shareOfCost * 100);
+    tips.push(
+      `Subagents are ${pct2}% of cost in this range \u2014 set CLAUDE_CODE_SUBAGENT_MODEL to sonnet or haiku so Task-tool workers stop inheriting the frontier model.`
+    );
+  }
+  if (report.cache.hitRate !== null && report.cache.hitRate >= 0.85 && report.cache.readTokens > report.cache.freshInTokens) {
+    tips.push(
+      `Cache reads are ${Math.round(report.cache.hitRate * 100)}% of input tokens \u2014 they inflate the token count more than the dollar bill; watch cost, not raw tokens, when pacing limits.`
+    );
+  }
+  const top = report.models[0];
+  if (top && isFrontierModel(top.unitLabel) && top.share >= 0.5 && report.totals.costUsd > 0) {
+    const name = top.unitLabel ?? "frontier";
+    tips.push(
+      `${name} is ${Math.round(top.share * 100)}% of spend \u2014 reserve it for hard tasks and default the rest to a cheaper model.`
+    );
+  }
+  return tips.slice(0, 3);
+}
+
+// packages/core/src/cold-resume.ts
+var COLD_GAP_MS = 60 * 60 * 1e3;
+var MIN_CACHE_WRITE = 2e3;
+function cacheWriteTokens(qty) {
+  return (qty.cacheCreate ?? 0) + (qty.cacheCreate1h ?? 0);
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function detectColdResumes(sessionId, label, turns) {
+  if (turns.length < 2) return [];
+  const sorted = [...turns].sort((a, b) => a.ts - b.ts);
+  const writes = sorted.map((t) => cacheWriteTokens(t.qty));
+  if (!writes.some((w) => w > 0)) return [];
+  const medianWrite = median(writes.filter((w) => w > 0));
+  const out = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const cur = sorted[i];
+    const gapMs = cur.ts - prev.ts;
+    if (gapMs < COLD_GAP_MS) continue;
+    const write = cacheWriteTokens(cur.qty);
+    if (write < MIN_CACHE_WRITE) continue;
+    const inputish = write + (cur.qty.in ?? 0) + (cur.qty.cacheRead ?? 0);
+    const writeShare = inputish > 0 ? write / inputish : 0;
+    const aboveMedian = medianWrite > 0 ? write > medianWrite * 1.5 : true;
+    if (!aboveMedian && writeShare < 0.5) continue;
+    out.push({
+      sessionId,
+      label,
+      ts: cur.ts,
+      gapMs,
+      costUsd: cur.costUsd ?? 0,
+      cacheWriteTokens: write
+    });
+  }
+  return out;
+}
+function collectColdResumes(sessions, limit = 5) {
+  return sessions.flatMap((s) => detectColdResumes(s.sessionId, s.label, s.turns)).sort((a, b) => b.costUsd - a.costUsd).slice(0, limit);
+}
+
+// packages/core/src/verdict.ts
+var PLAN_ESTIMATES = {
+  asOf: "2026-09-02"};
+function latestPct(snapshots) {
+  if (snapshots.length === 0) return null;
+  const current = currentWindowSnapshots(snapshots);
+  const last = current[current.length - 1];
+  return last ? last.usedPct : null;
+}
+function elapsedWeekFraction(snapshots, now) {
+  const current = currentWindowSnapshots(snapshots);
+  const last = current[current.length - 1];
+  if (!last) return null;
+  const weekMs = 7 * 24 * 36e5;
+  if (last.resetsAt && last.resetsAt > now) {
+    const remaining = last.resetsAt - now;
+    const elapsed = weekMs - remaining;
+    if (elapsed <= 0) return 0.01;
+    return Math.min(1, Math.max(0.01, elapsed / weekMs));
+  }
+  if (current.length < 2) return null;
+  const span = last.ts - current[0].ts;
+  return Math.min(1, Math.max(0.01, span / weekMs));
+}
+function buildVerdict(input) {
+  const now = input.now ?? Date.now();
+  const weeklyUsedPct = latestPct(input.weekly);
+  const fiveHourUsedPct = latestPct(input.fiveHour);
+  const fc7 = forecastLimit(input.weekly, now);
+  const fc5 = forecastLimit(input.fiveHour, now);
+  const caveats = [
+    `Plan multipliers are estimates as of ${PLAN_ESTIMATES.asOf}, not Anthropic's bill.`,
+    '"20x" multiplies the 5-hour window; weekly headroom grows much less (two Max 5x accounts often beat one 20x).',
+    "Local used% is this machine only \u2014 other devices and claude.ai are invisible."
+  ];
+  if (weeklyUsedPct === null) {
+    return {
+      recommended: "unknown",
+      weeklyBound: false,
+      weeklyUsedPct: null,
+      fiveHourUsedPct,
+      weeklyCostUsd: input.weeklyCostUsd,
+      two5xVs20x: {
+        two5xWins: false,
+        reason: "No 7-day limit snapshots yet \u2014 run `nnt init` so the status line records weekly fill."
+      },
+      estimatesAsOf: PLAN_ESTIMATES.asOf,
+      caveats
+    };
+  }
+  const weeklyBound = fiveHourUsedPct === null || weeklyUsedPct >= fiveHourUsedPct || Boolean(fc7?.willExhaustBeforeReset && !fc5?.willExhaustBeforeReset);
+  const elapsed = elapsedWeekFraction(input.weekly, now);
+  const pace = elapsed ? weeklyUsedPct / elapsed : weeklyUsedPct;
+  let recommended;
+  if (pace >= 180 || weeklyUsedPct >= 98) {
+    recommended = "above-20x";
+  } else if (weeklyBound && (weeklyUsedPct >= 85 || fc7?.willExhaustBeforeReset)) {
+    recommended = weeklyUsedPct >= 92 ? "above-20x" : "max20x";
+  } else if ((fiveHourUsedPct ?? 0) >= 90 || fc5?.willExhaustBeforeReset) {
+    recommended = "max20x";
+  } else if ((fiveHourUsedPct ?? 0) >= 50 || weeklyUsedPct >= 40) {
+    recommended = "max5x";
+  } else {
+    recommended = "pro";
+  }
+  const two5xWins = weeklyBound;
+  const two5xVs20x = {
+    two5xWins,
+    reason: two5xWins ? "The weekly cap is the wall. Two Max 5x accounts roughly double weekly pool; one 20x mostly buys a bigger 5-hour burst." : "The 5-hour window is tighter than weekly, so 20x's 5h multiplier is the lever \u2014 two 5x accounts would not help as much."
+  };
+  return {
+    recommended,
+    weeklyBound,
+    weeklyUsedPct,
+    fiveHourUsedPct,
+    weeklyCostUsd: input.weeklyCostUsd,
+    two5xVs20x,
+    estimatesAsOf: PLAN_ESTIMATES.asOf,
+    caveats
+  };
+}
+
+// packages/core/src/weigh.ts
+var WEIGH_CLEAN_SHARE = 0.8;
+var WEIGH_MIN_CLEAN = 3;
+var CAVEATS = [
+  "Points per dollar use the list price stored now, not Anthropic's undocumented meter unit.",
+  "A gap counts for a model only when that model is at least 80% of priced cost.",
+  "Local used% is this machine only \u2014 other devices and claude.ai sit in the percent and not in the log."
+];
+function quantile(sorted, p) {
+  if (sorted.length === 1) return sorted[0];
+  const idx = (sorted.length - 1) * p;
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo];
+  const a = sorted[lo];
+  const b = sorted[hi];
+  return a + (b - a) * (idx - lo);
+}
+function band(rates) {
+  const sorted = [...rates].sort((a, b) => a - b);
+  return {
+    p25: quantile(sorted, 0.25),
+    median: quantile(sorted, 0.5),
+    p75: quantile(sorted, 0.75)
+  };
+}
+function priced(models) {
+  return models.filter((m) => m.costUsd > 0);
+}
+function pairRisingSnapshots(snapshots) {
+  const current = currentWindowSnapshots(snapshots);
+  const pairs = [];
+  for (let i = 1; i < current.length; i++) {
+    const prev = current[i - 1];
+    const next = current[i];
+    const deltaPct = next.usedPct - prev.usedPct;
+    if (deltaPct <= 0) continue;
+    pairs.push({ from: prev.ts, to: next.ts, deltaPct });
+  }
+  return pairs;
+}
+function buildWeigh(gaps) {
+  let risingPct = 0;
+  let risingUsd = 0;
+  let risingIntervals = 0;
+  let cleanIntervals = 0;
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const gap of gaps) {
+    if (gap.deltaPct <= 0) continue;
+    const models2 = priced(gap.models);
+    const total = models2.reduce((s, m) => s + m.costUsd, 0);
+    if (total <= 0) continue;
+    risingIntervals += 1;
+    risingPct += gap.deltaPct;
+    risingUsd += total;
+    const rate = gap.deltaPct / total;
+    const dominant = models2.reduce((a, b) => b.costUsd > a.costUsd ? b : a);
+    if (dominant.costUsd + 1e-9 < total * WEIGH_CLEAN_SHARE) continue;
+    cleanIntervals += 1;
+    const key = dominant.unitLabel ?? "";
+    const row = byLabel.get(key) ?? { label: dominant.unitLabel, rates: [] };
+    row.rates.push(rate);
+    byLabel.set(key, row);
+  }
+  const models = [...byLabel.values()].map((row) => {
+    const ok = row.rates.length >= WEIGH_MIN_CLEAN;
+    return {
+      unitLabel: row.label,
+      ppPerUsd: ok ? band(row.rates) : null,
+      cleanIntervals: row.rates.length,
+      status: ok ? "ok" : "unknown"
+    };
+  }).sort((a, b) => {
+    if (a.status !== b.status) return a.status === "ok" ? -1 : 1;
+    return (b.ppPerUsd?.median ?? 0) - (a.ppPerUsd?.median ?? 0);
+  });
+  return {
+    window: "7d",
+    provider: "claude-code",
+    blendedPpPerUsd: risingUsd > 0 ? risingPct / risingUsd : null,
+    risingIntervals,
+    cleanIntervals,
+    models,
+    caveats: CAVEATS
+  };
+}
+
+// packages/core/src/otel.ts
+function attr(key, value) {
+  return { key, value: { stringValue: value } };
+}
+function nano(ts) {
+  return `${BigInt(Math.max(0, Math.round(ts))) * 1000000n}`;
+}
+function eventsToOtlp(events2, opts = {}) {
+  const costPoints = [];
+  const tokenPoints = [];
+  for (const e of events2) {
+    const attributes = [
+      attr("provider", e.provider),
+      attr("unit_label", e.unitLabel ?? "unknown"),
+      attr("scope_hash", e.scopeHash)
+    ];
+    if (opts.includeLabels && e.label) attributes.push(attr("project", e.label));
+    const t = nano(e.ts);
+    if (e.costUsd !== null && Number.isFinite(e.costUsd)) {
+      costPoints.push({ asDouble: e.costUsd, timeUnixNano: t, attributes });
+    }
+    tokenPoints.push({ asDouble: e.tokens, timeUnixNano: t, attributes });
+  }
+  return {
+    resourceMetrics: [{
+      resource: {
+        attributes: [attr("service.name", opts.serviceName ?? "nomnomtokens")]
+      },
+      scopeMetrics: [{
+        scope: { name: "nomnomtokens" },
+        metrics: [
+          {
+            name: "nnt.cost_usd",
+            unit: "USD",
+            sum: {
+              dataPoints: costPoints,
+              aggregationTemporality: 2,
+              isMonotonic: true
+            }
+          },
+          {
+            name: "nnt.tokens",
+            unit: "1",
+            sum: {
+              dataPoints: tokenPoints,
+              aggregationTemporality: 2,
+              isMonotonic: true
+            }
+          }
+        ]
+      }]
+    }]
+  };
+}
+
 // packages/db/src/repo.ts
 var Repo = class {
   constructor(sqlite) {
@@ -5474,11 +5946,13 @@ var Repo = class {
       WHERE excluded.qty_total >= events.qty_total
     `);
     this.upsertScope = sqlite.prepare(`
-      INSERT INTO scopes (scope_hash, label, provider, last_seen)
-      VALUES (@scopeHash, @label, @provider, @lastSeen)
+      INSERT INTO scopes (scope_hash, label, provider, last_seen, client, label_locked)
+      VALUES (@scopeHash, @label, @provider, @lastSeen, @client, @labelLocked)
       ON CONFLICT(scope_hash) DO UPDATE SET
-        label = excluded.label,
-        last_seen = MAX(scopes.last_seen, excluded.last_seen)
+        label = CASE WHEN scopes.label_locked = 1 THEN scopes.label ELSE excluded.label END,
+        last_seen = MAX(scopes.last_seen, excluded.last_seen),
+        client = COALESCE(excluded.client, scopes.client),
+        label_locked = MAX(scopes.label_locked, excluded.label_locked)
     `);
     this.insertLimit = sqlite.prepare(`
       INSERT INTO limits (ts, provider, window, used_pct, resets_at)
@@ -5537,7 +6011,9 @@ var Repo = class {
             scopeHash: rec.scopeHash,
             label: rec.label,
             provider: rec.provider,
-            lastSeen: Date.now()
+            lastSeen: rec.lastSeen ?? Date.now(),
+            client: rec.client ?? null,
+            labelLocked: rec.labelLocked ? 1 : 0
           });
           result.scopes += 1;
         }
@@ -5569,6 +6045,24 @@ var Repo = class {
   eventCount() {
     return this.sqlite.prepare("SELECT COUNT(*) AS c FROM events").pluck().get();
   }
+  /**
+   * Rename a project or attach a client tag. Locks the label so a later scan
+   * cannot revert it to the folder basename.
+   */
+  updateScope(scopeHash2, patch) {
+    const row = this.sqlite.prepare(
+      "SELECT label, client FROM scopes WHERE scope_hash = ?"
+    ).get(scopeHash2);
+    if (!row) return false;
+    const label = patch.label !== void 0 ? patch.label.trim() || row.label : row.label;
+    const client = patch.client !== void 0 ? patch.client?.trim() || null : row.client;
+    this.sqlite.prepare(`
+      UPDATE scopes
+      SET label = @label, client = @client, label_locked = 1
+      WHERE scope_hash = @scopeHash
+    `).run({ scopeHash: scopeHash2, label, client });
+    return true;
+  }
   /**
    * Collapse Cursor Auto-mode placeholders (`default`, `default,default,…`)
    * into a null unit_label so the UI shows a single "unknown" bucket.
@@ -5630,6 +6124,12 @@ function buildWhere(f, prefix = "e") {
     });
     clauses.push(`${prefix}.scope_hash IN (${names.join(", ")})`);
   }
+  if (f.client) {
+    clauses.push(
+      `${prefix}.scope_hash IN (SELECT scope_hash FROM scopes WHERE client = @client)`
+    );
+    params.client = f.client;
+  }
   return { sql: clauses.length ? `WHERE ${clauses.join(" AND ")}` : "", params };
 }
 var BUCKET = {
@@ -5695,7 +6195,7 @@ var Queries = class {
   byScope(f = {}) {
     const w = buildWhere(f);
     return this.sqlite.prepare(`
-      SELECT e.scope_hash AS scopeHash, s.label AS label, s.last_seen AS lastSeen, ${TOTALS}
+      SELECT e.scope_hash AS scopeHash, s.label AS label, s.client AS client, s.last_seen AS lastSeen, ${TOTALS}
       FROM events e
       LEFT JOIN scopes s ON s.scope_hash = e.scope_hash
       ${w.sql}
@@ -5784,11 +6284,89 @@ var Queries = class {
   limitWindows() {
     return this.sqlite.prepare("SELECT DISTINCT provider, window FROM limits ORDER BY provider, window").all();
   }
+  /** Latest snapshot per (provider, window) — statusline Codex headroom. */
+  latestLimits() {
+    return this.sqlite.prepare(`
+      SELECT l.ts, l.provider, l.window, l.used_pct AS usedPct, l.resets_at AS resetsAt
+      FROM limits l
+      INNER JOIN (
+        SELECT provider, window, MAX(ts) AS ts
+        FROM limits
+        GROUP BY provider, window
+      ) latest ON latest.provider = l.provider AND latest.window = l.window AND latest.ts = l.ts
+      ORDER BY l.provider, l.window
+    `).all();
+  }
+  coldResumesFor(sessions, limit = 5) {
+    return collectColdResumes(
+      sessions.map((s) => ({
+        sessionId: s.sessionId,
+        label: s.label,
+        turns: this.sessionEvents(s.sessionId)
+      })),
+      limit
+    );
+  }
   scopeLabels() {
     return this.sqlite.prepare(`
-      SELECT scope_hash AS scopeHash, label, provider, last_seen AS lastSeen
+      SELECT scope_hash AS scopeHash, label, provider, last_seen AS lastSeen,
+             client, label_locked AS labelLocked
       FROM scopes ORDER BY last_seen DESC
-    `).all();
+    `).all().map((row) => {
+      const r = row;
+      return { ...r, labelLocked: r.labelLocked === 1 };
+    });
+  }
+  /**
+   * Spend tagged as a Claude Code sidechain (subagent) turn.
+   *
+   * `taggedEvents` counts rows that have any `meta.sidechain` key — parents omit
+   * it entirely, so zero tagged events means "this corpus has no sidechain
+   * signal" (Cursor/Codex), not "0% subagents".
+   */
+  sidechainTotals(f = {}) {
+    const w = buildWhere(f);
+    const sidechainClause = `json_extract(e.meta_json, '$.sidechain') = 1`;
+    const where = w.sql ? `${w.sql} AND ${sidechainClause}` : `WHERE ${sidechainClause}`;
+    const totals = this.sqlite.prepare(`SELECT ${TOTALS} FROM events e ${where}`).get(w.params);
+    const tagged = this.sqlite.prepare(`
+      SELECT COUNT(*) AS n
+      FROM events e ${w.sql}${w.sql ? " AND" : "WHERE"}
+        json_extract(e.meta_json, '$.sidechain') IS NOT NULL
+    `).get(w.params);
+    return { ...totals, taggedEvents: tagged.n };
+  }
+  /**
+   * Top sessions by cost, with the sidechain cost share when any turns are tagged.
+   * Used by the audit report — not a general-purpose sessions list.
+   */
+  sessionsAudit(f = {}, limit = 5) {
+    const w = buildWhere(f);
+    const params = { ...w.params, limit };
+    const rows = this.sqlite.prepare(`
+      SELECT
+        e.session_id AS sessionId,
+        MIN(e.scope_hash) AS scopeHash,
+        COALESCE(SUM(e.cost_usd), 0) AS costUsd,
+        COALESCE(SUM(e.qty_total), 0) AS tokens,
+        COALESCE(SUM(
+          CASE WHEN json_extract(e.meta_json, '$.sidechain') = 1
+            THEN e.cost_usd ELSE 0 END
+        ), 0) AS sidechainCostUsd,
+        SUM(
+          CASE WHEN json_extract(e.meta_json, '$.sidechain') IS NOT NULL
+            THEN 1 ELSE 0 END
+        ) AS sidechainTagged
+      FROM events e
+      ${w.sql}${w.sql ? " AND" : "WHERE"} e.session_id IS NOT NULL
+      GROUP BY e.session_id
+      ORDER BY costUsd DESC
+      LIMIT @limit
+    `).all(params);
+    return rows.map((r) => {
+      const scope = this.sqlite.prepare("SELECT label FROM scopes WHERE scope_hash = ?").pluck().get(r.scopeHash);
+      return { ...r, label: scope ?? null };
+    });
   }
   /**
    * Lines the agent changed while earning the spend in `f`.
@@ -5827,6 +6405,7 @@ var Queries = class {
         e.session_id AS sessionId,
         e.scope_hash AS scopeHash,
         s.label AS project,
+        s.client AS client,
         e.unit_label AS model,
         e.cost_usd AS costUsd,
         e.qty_total AS tokens,
@@ -5848,6 +6427,7 @@ var Queries = class {
         sessionId: r.sessionId,
         scopeHash: r.scopeHash,
         project: r.project,
+        client: r.client,
         model: r.model,
         costUsd: r.costUsd,
         tokens: r.tokens,
@@ -5860,6 +6440,28 @@ var Queries = class {
       };
     });
   }
+  exportSpendEvents(limit = 1e5) {
+    return this.sqlite.prepare(`
+      SELECT id, ts, provider, kind, session_id AS sessionId, scope_hash AS scopeHash,
+             unit_label AS unitLabel, qty_json AS qtyJson, cost_usd AS costUsd,
+             meta_json AS metaJson
+      FROM events ORDER BY ts ASC LIMIT ?
+    `).all(limit).map((row) => {
+      const r = row;
+      return {
+        id: r.id,
+        ts: r.ts,
+        provider: r.provider,
+        kind: r.kind,
+        sessionId: r.sessionId,
+        scopeHash: r.scopeHash,
+        unitLabel: r.unitLabel,
+        qty: JSON.parse(r.qtyJson),
+        costUsd: r.costUsd,
+        meta: JSON.parse(r.metaJson)
+      };
+    });
+  }
 };
 function defaultPricesPath() {
   return join(defaultDataDir(), "prices.json");
@@ -5952,6 +6554,9 @@ function duration(ms) {
   if (ms < 1e3) return `${Math.round(ms)}ms`;
   return `${(ms / 1e3).toFixed(1)}s`;
 }
+function pct(n) {
+  return n === null || n === void 0 ? "\u2014" : `${n.toFixed(1)}%`;
+}
 function untilReset(ms, now = Date.now()) {
   if (ms === null || ms === void 0 || !Number.isFinite(ms)) return null;
   const delta = ms - now;
@@ -6049,6 +6654,108 @@ function desktopNotify(hits) {
   }
 }
 
+// packages/cli/src/commands/audit.ts
+function rangeFromDays(days, now = Date.now()) {
+  const to = now;
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  start.setDate(start.getDate() - (days - 1));
+  return { from: start.getTime(), to };
+}
+function formatGap2(ms) {
+  const hours = Math.round(ms / 36e5);
+  if (hours < 1) return `${Math.max(1, Math.round(ms / 6e4))}m`;
+  return `${hours}h`;
+}
+function auditCommand(opts = {}) {
+  const days = opts.days && opts.days > 0 ? opts.days : 7;
+  const { from, to } = rangeFromDays(days);
+  const { sqlite, path: dbPath } = openDb(opts.db);
+  const q = new Queries(sqlite);
+  const filters = { from, to, kind: "tokens" };
+  const totals = q.totals(filters);
+  const sidechain = q.sidechainTotals(filters);
+  const models = q.byUnitLabel(filters);
+  const sessions = q.sessionsAudit(filters, 5);
+  const coldResumes = q.coldResumesFor(sessions);
+  sqlite.close();
+  const report = buildAuditReport({
+    range: { from, to },
+    totals: {
+      costUsd: totals.costUsd,
+      tokens: totals.tokens,
+      events: totals.events,
+      qtyIn: totals.qtyIn,
+      qtyCacheRead: totals.qtyCacheRead
+    },
+    sidechain: {
+      taggedEvents: sidechain.taggedEvents,
+      costUsd: sidechain.costUsd,
+      tokens: sidechain.tokens
+    },
+    models: models.map((m) => ({ unitLabel: m.unitLabel, costUsd: m.costUsd })),
+    sessions: sessions.map((s) => ({
+      sessionId: s.sessionId,
+      label: s.label,
+      costUsd: s.costUsd,
+      sidechainCostUsd: s.sidechainCostUsd,
+      sidechainTagged: s.sidechainTagged
+    })),
+    coldResumes
+  });
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  console.log(c.bold(`Audit \xB7 last ${days}d`));
+  console.log(c.dim(`from ${dbPath}`));
+  console.log();
+  console.log(`  cost         ${usd(report.totals.costUsd)}`);
+  console.log(`  tokens       ${compactNumber(report.totals.tokens)}`);
+  console.log(`  events       ${report.totals.events}`);
+  console.log(`  cache hit    ${pct(report.cache.hitRate !== null ? report.cache.hitRate * 100 : null)}`);
+  console.log(
+    `  subagents    ${report.sidechain.tagged ? `${pct(report.sidechain.shareOfCost !== null ? report.sidechain.shareOfCost * 100 : null)} \xB7 ${usd(report.sidechain.costUsd)}` : `${c.dim("n/a")} (Claude Code only)`}`
+  );
+  console.log();
+  if (report.models.length) {
+    console.log(c.bold("Models"));
+    for (const m of report.models.slice(0, 5)) {
+      const label = (m.unitLabel ?? "unknown").padEnd(28);
+      console.log(`  ${label} ${pct(m.share * 100).padStart(5)}  ${usd(m.costUsd)}`);
+    }
+    console.log();
+  }
+  if (report.topSessions.length) {
+    console.log(c.bold("Top sessions"));
+    for (const s of report.topSessions) {
+      const name = (s.label ?? s.sessionId.slice(0, 12)).padEnd(28);
+      const sc = s.sidechainShare !== null ? ` \xB7 sub ${pct(s.sidechainShare * 100)}` : "";
+      console.log(`  ${name} ${usd(s.costUsd)}${sc}`);
+    }
+    console.log();
+  }
+  if (report.coldResumes.length) {
+    console.log(c.bold("Cold resumes"));
+    for (const hit of report.coldResumes) {
+      const name = (hit.label ?? hit.sessionId.slice(0, 12)).padEnd(28);
+      console.log(`  ${name} ${usd(hit.costUsd)} after ${formatGap2(hit.gapMs)} idle`);
+    }
+    console.log();
+  }
+  if (report.tips.length) {
+    console.log(c.bold("Tips"));
+    for (const tip of report.tips) {
+      console.log(`  \u2022 ${tip}`);
+    }
+    console.log();
+  }
+  if (!opts.quiet && report.totals.events === 0) {
+    console.log(c.dim("No token events in this range. Run `nnt scan`, then try again."));
+  }
+}
+
 // packages/adapters/src/claude-code/jsonl.ts
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : 0;
@@ -7126,6 +7833,57 @@ async function detectAdapters(opts = {}) {
 }
 
 // packages/cli/src/commands/doctor.ts
+var DEFAULT_CLEANUP_DAYS = 30;
+function readCleanupPeriodDays(settingsPath2) {
+  if (!existsSync(settingsPath2)) return DEFAULT_CLEANUP_DAYS;
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath2, "utf8"));
+    const n = parsed.cleanupPeriodDays;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : DEFAULT_CLEANUP_DAYS;
+  } catch {
+    return DEFAULT_CLEANUP_DAYS;
+  }
+}
+function listJsonlFiles(root) {
+  if (!existsSync(root)) return [];
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(path);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(path);
+    }
+  }
+  return out;
+}
+function oldestMtime(paths) {
+  let min = null;
+  for (const path of paths) {
+    try {
+      const t = statSync(path).mtimeMs;
+      if (min === null || t < min) min = t;
+    } catch {
+    }
+  }
+  return min;
+}
+function transcriptRetentionWarning(opts) {
+  if (opts.storeFirst === null) return null;
+  const now = opts.now ?? Date.now();
+  const cutoff = now - opts.cleanupDays * 864e5;
+  const storeOlderThanRetention = opts.storeFirst < cutoff;
+  const transcriptsAlreadyGone = opts.oldestJsonlMtime !== null && opts.oldestJsonlMtime > opts.storeFirst + 864e5;
+  if (!storeOlderThanRetention && !transcriptsAlreadyGone) return null;
+  return `store keeps history from ${new Date(opts.storeFirst).toISOString().slice(0, 10)}; transcripts will not (cleanupPeriodDays=${opts.cleanupDays})`;
+}
 function check(ok, label, detail) {
   const mark = ok ? c.green("\u2714") : c.yellow("\u2717");
   console.log(`${mark} ${label}${detail ? c.dim(`  ${detail}`) : ""}`);
@@ -7134,7 +7892,7 @@ async function doctor(opts = {}) {
   console.log(c.bold("nomnomtokens doctor"));
   console.log();
   console.log(c.bold("Sources"));
-  const projects = claudeProjectsDir();
+  const projects = opts.claudeProjects ?? claudeProjectsDir();
   check(existsSync(projects), "Claude Code transcripts", projects);
   const cursorDb = cursorStateDbPath();
   check(existsSync(cursorDb), "Cursor state database", cursorDb);
@@ -7144,7 +7902,7 @@ async function doctor(opts = {}) {
   check(adapters.length > 0, `${adapters.length} adapter(s) detected`, adapters.map((a) => a.name).join(", ") || "none");
   console.log();
   console.log(c.bold("Status line"));
-  const settingsFile = join(homedir(), ".claude", "settings.json");
+  const settingsFile = opts.claudeSettings ?? join(homedir(), ".claude", "settings.json");
   let statusLineCommand;
   if (existsSync(settingsFile)) {
     try {
@@ -7176,6 +7934,14 @@ async function doctor(opts = {}) {
       check(false, `${totals.unpricedEvents} events could not be priced`, "unknown model id \u2014 see packages/core/src/pricing.ts");
     }
     check(windows.length > 0, "limit history", windows.length > 0 ? windows.map((w) => `${w.provider}/${w.window}`).join(", ") : "none yet \u2014 the status line hook has not fired");
+    const cleanupDays = readCleanupPeriodDays(settingsFile);
+    const jsonl = listJsonlFiles(projects);
+    const warning = transcriptRetentionWarning({
+      storeFirst: bounds.first,
+      oldestJsonlMtime: oldestMtime(jsonl),
+      cleanupDays
+    });
+    check(!warning, "transcript retention", warning ?? `cleanupPeriodDays ${cleanupDays}`);
     sqlite.close();
   }
   console.log();
@@ -7199,23 +7965,48 @@ function rangeFrom(range, now = Date.now()) {
   }
 }
 function exportCommand(opts = {}) {
-  const format = opts.format === "json" ? "json" : "csv";
+  const format = opts.format === "json" || opts.format === "nnt" ? opts.format : "csv";
   const { sqlite, path: dbPath } = openDb(opts.db);
   const q = new Queries(sqlite);
-  const from = rangeFrom(opts.range ?? "30d");
-  const rows = q.exportEvents({
-    from,
-    kind: "tokens",
-    provider: opts.provider ? [opts.provider] : void 0
-  });
+  let body;
+  let count;
+  if (format === "nnt") {
+    const scopes2 = q.scopeLabels();
+    body = formatNntArchive({
+      version: 1,
+      events: q.exportSpendEvents(),
+      limits: q.limitSnapshots(),
+      scopes: scopes2.map((s) => ({
+        scopeHash: s.scopeHash,
+        label: s.label,
+        provider: s.provider,
+        lastSeen: s.lastSeen,
+        client: s.client,
+        labelLocked: s.labelLocked
+      }))
+    });
+    count = q.bounds().events;
+    if (!opts.quiet) {
+      console.error(c.dim("nnt archive includes local project labels. Treat the file as the whole store."));
+    }
+  } else {
+    const from = rangeFrom(opts.range ?? "30d");
+    const rows = q.exportEvents({
+      from,
+      kind: "tokens",
+      provider: opts.provider ? [opts.provider] : void 0,
+      client: opts.client
+    });
+    body = format === "json" ? formatExportJson(rows) : formatExportCsv(rows);
+    count = rows.length;
+  }
   sqlite.close();
-  const body = format === "json" ? formatExportJson(rows) : formatExportCsv(rows);
   if (opts.out) {
     const dest = resolve(opts.out);
     writeFileSync(dest, body, "utf8");
     if (!opts.quiet) {
       console.log(
-        `${c.cyan("export")}  ${c.bold(String(rows.length))} events \u2192 ${dest}`
+        `${c.cyan("export")}  ${c.bold(String(count))} events \u2192 ${dest}`
       );
       console.log(c.dim(`from ${dbPath}`));
     }
@@ -7223,7 +8014,7 @@ function exportCommand(opts = {}) {
   }
   process.stdout.write(body);
   if (!opts.quiet && process.stdout.isTTY) {
-    console.error(c.dim(`${compactNumber(rows.length)} events \xB7 ${format}`));
+    console.error(c.dim(`${compactNumber(count)} events \xB7 ${format}`));
   }
 }
 async function importCsvCommand(opts) {
@@ -7274,6 +8065,47 @@ async function importCsvCommand(opts) {
     console.log(c.dim(`${compactNumber(before + added)} events in ${dbPath}`));
   }
 }
+
+// packages/cli/src/commands/import.ts
+async function importCommand(opts) {
+  const path = resolve(opts.file);
+  let text2;
+  try {
+    text2 = readFileSync(path, "utf8");
+  } catch (err) {
+    console.error(c.red(`Cannot read ${path}`));
+    console.error(c.dim(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+    return;
+  }
+  if (looksLikeNntArchive(text2)) {
+    let records;
+    try {
+      records = parseNntArchive(text2);
+    } catch (err) {
+      console.error(c.red(err instanceof Error ? err.message : String(err)));
+      process.exitCode = 1;
+      return;
+    }
+    const { sqlite, path: dbPath } = openDb(opts.db);
+    const repo = new Repo(sqlite);
+    const before = repo.eventCount();
+    const result = repo.ingest(records);
+    const added = repo.eventCount() - before;
+    sqlite.close();
+    if (!opts.quiet) {
+      console.log(
+        `${c.cyan("nnt")}  ${c.bold(String(added))} new  ` + c.dim(
+          `${result.events} events, ${result.duplicates} already known, ${result.limits} limits, ${result.scopes} scopes`
+        )
+      );
+      console.log(c.dim(`${compactNumber(before + added)} events in ${dbPath}`));
+      console.log(c.dim("Archive includes local project labels and client tags. scan_state is not imported."));
+    }
+    return;
+  }
+  await importCsvCommand(opts);
+}
 function settingsPath(override) {
   return override ?? join(homedir(), ".claude", "settings.json");
 }
@@ -7330,74 +8162,6 @@ function init(opts = {}) {
   console.log("Restart Claude Code, then run `nnt serve` to open the dashboard.");
   console.log(c.dim("Limits and live updates only start flowing once the hook has fired once."));
 }
-async function loadFromSource(from) {
-  let text2;
-  if (/^https?:\/\//i.test(from)) {
-    const res = await fetch(from);
-    if (!res.ok) throw new Error(`fetch ${from}: HTTP ${res.status}`);
-    text2 = await res.text();
-  } else {
-    text2 = readFileSync(resolve(from), "utf8");
-  }
-  const file = parsePricesFile(text2);
-  return {
-    ...file,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: from
-  };
-}
-function pricesShow() {
-  const { file, path } = loadPriceTable();
-  const overrideCount = file ? Object.keys(file.models).length : 0;
-  console.log(c.bold("Price table"));
-  console.log(`  file     ${existsLabel(path, file !== null)}`);
-  if (file?.updatedAt) console.log(`  updated  ${file.updatedAt}`);
-  if (file?.source) console.log(`  source   ${file.source}`);
-  console.log(`  bundled  ${Object.keys(PRICES).length} models`);
-  console.log(`  overrides ${overrideCount} model(s) in file`);
-  console.log();
-  console.log(c.dim("Sample (effective USD / 1M tokens):"));
-  for (const id of ["claude-sonnet-4-5", "claude-opus-4-6", "gpt-5.6", "gemini-3-flash"]) {
-    const key = resolveModelKey(id);
-    const p = key ? file?.models[key] ?? PRICES[key] : null;
-    console.log(`  ${id.padEnd(22)} ${formatPrice(p)}`);
-  }
-  console.log();
-  console.log(c.dim("Edit the file, or run `nnt prices refresh` / `nnt prices refresh --from <url|path>`."));
-}
-function existsLabel(path, ok) {
-  return ok ? path : `${path} ${c.dim("(missing \u2014 using bundled)")}`;
-}
-function formatPrice(p) {
-  if (!p) return c.dim("unpriced");
-  return `in $${p.input}  out $${p.output}`;
-}
-async function pricesRefresh(opts = {}) {
-  const path = defaultPricesPath();
-  let file;
-  if (opts.from) {
-    try {
-      file = await loadFromSource(opts.from);
-    } catch (err) {
-      console.error(c.red(err instanceof Error ? err.message : String(err)));
-      process.exitCode = 1;
-      return;
-    }
-    file = {
-      ...file,
-      models: { ...PRICES, ...file.models }
-    };
-    savePricesFile(file, path);
-  } else {
-    file = writeBundledPrices(path);
-  }
-  if (!opts.quiet) {
-    console.log(
-      `${c.cyan("prices")}  wrote ${c.bold(String(Object.keys(file.models).length))} models \u2192 ${path}`
-    );
-    if (file.source) console.log(c.dim(`source ${file.source}`));
-  }
-}
 
 // packages/cli/src/commands/scan.ts
 async function scan(opts = {}) {
@@ -7478,15 +8242,142 @@ async function scan(opts = {}) {
   if (opts.watch) {
     console.log(c.dim("\nWatching for changes. Ctrl-C to stop."));
     const stops = adapters.filter((a) => a.watch).map((a) => a.watch((rec) => repo.ingest([rec])));
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       process.on("SIGINT", () => {
         stops.forEach((stop) => stop());
-        resolve6();
+        resolve7();
       });
     });
   }
   sqlite.close();
 }
+
+// packages/cli/src/commands/otel.ts
+function otelEvents(q, includeLabels) {
+  const labels = new Map(q.scopeLabels().map((s) => [s.scopeHash, s.label]));
+  return q.exportSpendEvents().map((e) => {
+    const row = {
+      ts: e.ts,
+      provider: e.provider,
+      unitLabel: e.unitLabel,
+      scopeHash: e.scopeHash,
+      costUsd: e.costUsd,
+      tokens: totalTokens(e.qty)
+    };
+    if (includeLabels) row.label = labels.get(e.scopeHash) ?? null;
+    return row;
+  });
+}
+async function postOtlp(endpoint, body) {
+  const url = endpoint.replace(/\/$/, "");
+  const target = url.endsWith("/v1/metrics") ? url : `${url}/v1/metrics`;
+  const res = await fetch(target, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text2 = await res.text().catch(() => "");
+    throw new Error(`OTLP POST ${res.status} ${text2.slice(0, 200)}`);
+  }
+}
+async function otelCommand(opts) {
+  const endpoint = opts.endpoint.trim();
+  if (!endpoint) {
+    console.error(c.red("nnt otel requires --endpoint"));
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.scan || opts.watch) {
+    await scan({ db: opts.db, quiet: true });
+  }
+  const { sqlite, path: dbPath } = openDb(opts.db);
+  const q = new Queries(sqlite);
+  const events2 = otelEvents(q, Boolean(opts.includeLabels));
+  sqlite.close();
+  const body = eventsToOtlp(events2, { includeLabels: opts.includeLabels });
+  try {
+    await postOtlp(endpoint, body);
+  } catch (err) {
+    console.error(c.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+    return;
+  }
+  if (!opts.quiet) {
+    console.log(
+      `${c.cyan("otel")}  ${c.bold(String(events2.length))} events \u2192 ${endpoint}`
+    );
+    console.log(c.dim(`from ${dbPath} \xB7 numbers and hashes only`));
+  }
+}
+async function loadFromSource(from) {
+  let text2;
+  if (/^https?:\/\//i.test(from)) {
+    const res = await fetch(from);
+    if (!res.ok) throw new Error(`fetch ${from}: HTTP ${res.status}`);
+    text2 = await res.text();
+  } else {
+    text2 = readFileSync(resolve(from), "utf8");
+  }
+  const file = parsePricesFile(text2);
+  return {
+    ...file,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: from
+  };
+}
+function pricesShow() {
+  const { file, path } = loadPriceTable();
+  const overrideCount = file ? Object.keys(file.models).length : 0;
+  console.log(c.bold("Price table"));
+  console.log(`  file     ${existsLabel(path, file !== null)}`);
+  if (file?.updatedAt) console.log(`  updated  ${file.updatedAt}`);
+  if (file?.source) console.log(`  source   ${file.source}`);
+  console.log(`  bundled  ${Object.keys(PRICES).length} models`);
+  console.log(`  overrides ${overrideCount} model(s) in file`);
+  console.log();
+  console.log(c.dim("Sample (effective USD / 1M tokens):"));
+  for (const id of ["claude-sonnet-4-5", "claude-opus-4-6", "gpt-5.6", "gemini-3-flash"]) {
+    const key = resolveModelKey(id);
+    const p = key ? file?.models[key] ?? PRICES[key] : null;
+    console.log(`  ${id.padEnd(22)} ${formatPrice(p)}`);
+  }
+  console.log();
+  console.log(c.dim("Edit the file, or run `nnt prices refresh` / `nnt prices refresh --from <url|path>`."));
+}
+function existsLabel(path, ok) {
+  return ok ? path : `${path} ${c.dim("(missing \u2014 using bundled)")}`;
+}
+function formatPrice(p) {
+  if (!p) return c.dim("unpriced");
+  return `in $${p.input}  out $${p.output}`;
+}
+async function pricesRefresh(opts = {}) {
+  const path = defaultPricesPath();
+  let file;
+  if (opts.from) {
+    try {
+      file = await loadFromSource(opts.from);
+    } catch (err) {
+      console.error(c.red(err instanceof Error ? err.message : String(err)));
+      process.exitCode = 1;
+      return;
+    }
+    file = {
+      ...file,
+      models: { ...PRICES, ...file.models }
+    };
+    savePricesFile(file, path);
+  } else {
+    file = writeBundledPrices(path);
+  }
+  if (!opts.quiet) {
+    console.log(
+      `${c.cyan("prices")}  wrote ${c.bold(String(Object.keys(file.models).length))} models \u2192 ${path}`
+    );
+    if (file.source) console.log(c.dim(`source ${file.source}`));
+  }
+}
 var here = dirname(fileURLToPath(import.meta.url));
 function findBuiltServer() {
   let dir = here;
@@ -7544,24 +8435,73 @@ async function serve(opts = {}) {
   });
 }
 
-// packages/cli/src/commands/statusline.ts
-var MOOD_FACE = {
-  hungry: "(\u30FB_\u30FB)",
-  content: "(^_^)",
-  full: "(\uFF3E\uFF55\uFF3E)",
-  stuffed: "(>_<)",
-  overstuffed: "(x_x)"
-};
-function limitSegment(label, usedPct, resetsAtSeconds) {
+// packages/cli/src/statusline-render.ts
+var CLAUDE_WEEKLY_HINT = 80;
+var CODEX_HEADROOM = 50;
+var ESC2 = "\x1B";
+function paintLabel(label) {
+  if (process.env.NO_COLOR !== void 0) return label;
+  return `${ESC2}[36m${label}${ESC2}[0m`;
+}
+function limitSegment(label, usedPct, resetsAtSeconds, now) {
   const resetsAt = typeof resetsAtSeconds === "number" && Number.isFinite(resetsAtSeconds) ? resetsAtSeconds * 1e3 : null;
-  const left = untilReset(resetsAt);
-  return `${label} ${Math.round(usedPct)}%${left ? ` \xB7${left}` : ""}`;
+  const left = untilReset(resetsAt, now);
+  const head = `${paintLabel(label)}  ${Math.round(usedPct)}%`;
+  return left ? `${head}  ${left}` : head;
+}
+function resolveWindow(livePct, liveResetsAtSeconds, cached, now) {
+  if (livePct !== null) {
+    return { pct: livePct, resetsAtSeconds: liveResetsAtSeconds };
+  }
+  if (cached && cached.resetsAt !== null && cached.resetsAt > now) {
+    return { pct: cached.usedPct, resetsAtSeconds: cached.resetsAt / 1e3 };
+  }
+  return { pct: null };
+}
+function buildStatuslineParts(view) {
+  const now = view.now;
+  const five = view.fiveHour;
+  const seven = view.sevenDay;
+  const segments = [];
+  if (seven !== null) segments.push(limitSegment("7d", seven, view.sevenDayResetsAt, now));
+  if (five !== null) segments.push(limitSegment("5h", five, view.fiveHourResetsAt, now));
+  if (view.ctx !== null) segments.push(`${paintLabel("ctx")}. ${Math.round(view.ctx)}%`);
+  const model = view.model?.trim();
+  if (model) segments.push(paintLabel(model));
+  const codex = view.codexSevenDay;
+  if (seven !== null && seven >= CLAUDE_WEEKLY_HINT && typeof codex === "number" && Number.isFinite(codex) && codex <= CODEX_HEADROOM) {
+    segments.push(`${paintLabel("codex")}: ${Math.round(codex)}%`);
+  }
+  return segments.length === 0 ? "Limits:" : `Limits: ${segments.join("  |  ")}`;
 }
+
+// packages/cli/src/commands/statusline.ts
+var CODEX_FRESH_MS = 24 * 36e5;
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf8");
 }
+function readStoredLimits(db, now = Date.now()) {
+  const empty = { codexSevenDay: null, claudeFive: null, claudeSeven: null };
+  try {
+    const { sqlite } = openDb(db);
+    const latest = new Queries(sqlite).latestLimits();
+    sqlite.close();
+    const claude = (window) => {
+      const row = latest.find((l) => l.provider === "claude-code" && l.window === window);
+      return row ? { usedPct: row.usedPct, resetsAt: row.resetsAt } : null;
+    };
+    const codex = latest.find((l) => l.provider === "codex" && l.window === "7d");
+    return {
+      codexSevenDay: codex && now - codex.ts <= CODEX_FRESH_MS ? codex.usedPct : null,
+      claudeFive: claude("5h"),
+      claudeSeven: claude("7d")
+    };
+  } catch {
+    return empty;
+  }
+}
 async function statusline(opts = {}) {
   let payload;
   try {
@@ -7571,19 +8511,33 @@ async function statusline(opts = {}) {
     return;
   }
   const limits2 = payload.rate_limits;
-  const fiveHour = limits2?.five_hour?.used_percentage ?? null;
-  const sevenDay = limits2?.seven_day?.used_percentage ?? null;
-  const cost = payload.cost?.total_cost_usd ?? null;
+  const now = Date.now();
+  const stored = readStoredLimits(opts.db, now);
+  const five = resolveWindow(
+    limits2?.five_hour?.used_percentage ?? null,
+    limits2?.five_hour?.resets_at,
+    stored.claudeFive,
+    now
+  );
+  const seven = resolveWindow(
+    limits2?.seven_day?.used_percentage ?? null,
+    limits2?.seven_day?.resets_at,
+    stored.claudeSeven,
+    now
+  );
   const ctx = payload.context_window?.used_percentage ?? null;
-  const parts = [];
-  parts.push(MOOD_FACE[moodFor(Math.max(fiveHour ?? 0, sevenDay ?? 0))] ?? "(^_^)");
-  if (cost !== null) parts.push(usd(cost));
-  if (ctx !== null) parts.push(`ctx ${Math.round(ctx)}%`);
-  if (fiveHour !== null) parts.push(limitSegment("5h", fiveHour, limits2?.five_hour?.resets_at));
-  if (sevenDay !== null) parts.push(limitSegment("7d", sevenDay, limits2?.seven_day?.resets_at));
-  const lines = (payload.cost?.total_lines_added ?? 0) + (payload.cost?.total_lines_removed ?? 0);
-  if (lines > 0) parts.push(`${compactNumber(lines)} lines`);
-  process.stdout.write(`${parts.join("  ")}
+  const model = payload.model?.display_name?.trim() || payload.model?.id?.trim() || null;
+  const line = buildStatuslineParts({
+    fiveHour: five.pct,
+    sevenDay: seven.pct,
+    fiveHourResetsAt: five.resetsAtSeconds,
+    sevenDayResetsAt: seven.resetsAtSeconds,
+    ctx,
+    model,
+    codexSevenDay: stored.codexSevenDay,
+    now
+  });
+  process.stdout.write(`${line}
 `);
   if (opts.dryRun) return;
   try {
@@ -7595,6 +8549,94 @@ async function statusline(opts = {}) {
   }
 }
 
+// packages/cli/src/commands/verdict.ts
+function verdictCommand(opts = {}) {
+  const now = Date.now();
+  const weekFrom = now - 7 * 24 * 36e5;
+  const { sqlite, path: dbPath } = openDb(opts.db);
+  const q = new Queries(sqlite);
+  const weekly = q.limitSnapshots("claude-code", "7d", weekFrom);
+  const fiveHour = q.limitSnapshots("claude-code", "5h", weekFrom);
+  const weeklyCostUsd = q.totals({ from: weekFrom, to: now, kind: "tokens", provider: ["claude-code"] }).costUsd;
+  sqlite.close();
+  const report = buildVerdict({ weekly, fiveHour, weeklyCostUsd, now });
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  console.log(c.bold("Verdict"));
+  console.log(c.dim(`from ${dbPath}`));
+  console.log();
+  console.log(`  recommended  ${c.bold(report.recommended)}`);
+  console.log(`  weekly bound ${report.weeklyBound ? "yes" : "no"}`);
+  console.log(`  7d used      ${pct(report.weeklyUsedPct)}`);
+  console.log(`  5h used      ${pct(report.fiveHourUsedPct)}`);
+  console.log(`  week $       ${usd(report.weeklyCostUsd)}  ${c.dim("(list price, this machine)")}`);
+  console.log();
+  console.log(c.bold("Two Max 5x vs one 20x"));
+  console.log(`  ${report.two5xVs20x.two5xWins ? c.yellow("two 5x wins") : "20x wins the 5h burst"}`);
+  console.log(`  ${c.dim(report.two5xVs20x.reason)}`);
+  console.log();
+  console.log(c.bold("Caveats"));
+  for (const line of report.caveats) {
+    console.log(`  \u2022 ${line}`);
+  }
+}
+
+// packages/cli/src/commands/weigh.ts
+function weighCommand(opts = {}) {
+  const { sqlite, path: dbPath } = openDb(opts.db);
+  const q = new Queries(sqlite);
+  const snaps = q.limitSnapshots("claude-code", "7d");
+  const gaps = pairRisingSnapshots(snaps).map((p) => ({
+    deltaPct: p.deltaPct,
+    models: q.byUnitLabel({
+      from: p.from,
+      to: p.to,
+      provider: ["claude-code"],
+      kind: "tokens"
+    }).filter((row) => row.costUsd > 0).map((row) => ({ unitLabel: row.unitLabel, costUsd: row.costUsd }))
+  }));
+  sqlite.close();
+  const report = buildWeigh(gaps);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  printWeigh(report, dbPath);
+}
+function printWeigh(report, dbPath) {
+  console.log(c.bold("Weigh"));
+  console.log(c.dim(`from ${dbPath}`));
+  console.log();
+  console.log(`  window    ${report.provider} ${report.window}`);
+  console.log(`  blended   ${pp(report.blendedPpPerUsd)}  ${c.dim("per list-price dollar, all rising gaps")}`);
+  console.log(`  gaps      ${report.cleanIntervals} clean / ${report.risingIntervals} rising`);
+  console.log();
+  console.log(c.bold("Models"));
+  if (report.models.length === 0) {
+    console.log(c.dim("  no priced gaps in the current 7d window \u2014 run `nnt init` so the status line records weekly fill"));
+  }
+  for (const model of report.models) console.log(modelLine(model));
+  console.log();
+  console.log(c.bold("Caveats"));
+  for (const line of report.caveats) console.log(`  \u2022 ${line}`);
+}
+function modelLine(model) {
+  const name = model.unitLabel ?? "(unlabeled)";
+  if (model.status === "unknown" || !model.ppPerUsd) {
+    return `  ${name}  ${c.yellow("unknown")}  ${c.dim(`need 3 clean gaps, have ${model.cleanIntervals}`)}`;
+  }
+  const { p25, median: median2, p75 } = model.ppPerUsd;
+  return `  ${name}  ${pp(median2)}  ${c.dim(`p25 ${pp(p25)}  p75 ${pp(p75)}  ${model.cleanIntervals} gaps`)}`;
+}
+function pp(n) {
+  if (n === null) return "\u2014";
+  return `${n.toFixed(2)} pp/$`;
+}
+
 // packages/cli/src/index.ts
 function packageVersion() {
   let dir = dirname(fileURLToPath(import.meta.url));
@@ -7611,7 +8653,7 @@ function packageVersion() {
   return "0.0.0";
 }
 var program = new Command();
-program.name("nnt").description("nom nom nom \u2014 your agent is eating tokens. The dashboard shows exactly how many.").version(packageVersion()).option("--db <path>", "database file (default: ~/.nomnomtokens/data.db)");
+program.name("nnt").description("nom nom nom \u2014 your agents are eating tokens. One local store shows where.").version(packageVersion()).option("--db <path>", "database file (default: ~/.nomnomtokens/data.db)");
 program.command("scan", { isDefault: false }).description("read new records from every detected source into the local store").option("-w, --watch", "stay running and ingest new records as they are written").option("-q, --quiet", "suppress the summary").action(async (opts) => {
   await scan({ ...opts, db: program.opts().db });
 });
@@ -7632,8 +8674,8 @@ program.command("statusline").description("read Claude Code session JSON on stdi
 program.command("doctor").description("check sources, hook wiring and the local store").action(async () => {
   await doctor({ db: program.opts().db });
 });
-program.command("import <file>").description("import a CSV billing export or spreadsheet into the local store").option("--provider <name>", "provider label written on every row", "csv").option("--kind <kind>", "event kind (tokens, minutes, \u2026)", "tokens").option("-q, --quiet", "suppress the summary").action(async (file, opts) => {
-  await importCsvCommand({
+program.command("import <file>").description("import a billing CSV or an nnt archive JSON into the local store").option("--provider <name>", "provider label written on every row", "csv").option("--kind <kind>", "event kind (tokens, minutes, \u2026)", "tokens").option("-q, --quiet", "suppress the summary").action(async (file, opts) => {
+  await importCommand({
     file,
     provider: opts.provider,
     kind: opts.kind,
@@ -7641,14 +8683,15 @@ program.command("import <file>").description("import a CSV billing export or spr
     db: program.opts().db
   });
 });
-program.command("export").description("write filtered events as CSV or JSON (stdout or -o file)").option("--format <fmt>", "csv or json", "csv").option("-o, --out <file>", "write to a file instead of stdout").option("--range <range>", "24h | 7d | 30d | 90d | all", "30d").option("--provider <name>", "filter to one provider").option("-q, --quiet", "suppress the summary on stderr").action((opts) => {
-  const format = opts.format === "json" ? "json" : "csv";
+program.command("export").description("write filtered events as CSV, JSON, or an nnt archive").option("--format <fmt>", "csv, json, or nnt", "csv").option("-o, --out <file>", "write to a file instead of stdout").option("--range <range>", "24h | 7d | 30d | 90d | all", "30d").option("--provider <name>", "filter to one provider").option("--client <name>", "filter to a local client tag").option("-q, --quiet", "suppress the summary on stderr").action((opts) => {
+  const format = opts.format === "json" || opts.format === "nnt" ? opts.format : "csv";
   const range = ["24h", "7d", "30d", "90d", "all"].includes(opts.range) ? opts.range : "30d";
   exportCommand({
     format,
     out: opts.out,
     range,
     provider: opts.provider,
+    client: opts.client,
     quiet: opts.quiet,
     db: program.opts().db
   });
@@ -7670,6 +8713,37 @@ alerts.command("check").description("evaluate thresholds; exit 2 if any are firi
     db: program.opts().db
   });
 });
+program.command("audit").description("where spend went: cache, subagents, models, and tips").option("--days <n>", "calendar days to include (default 7)", (v) => Number.parseInt(v, 10), 7).option("--json", "print the audit report as JSON").option("-q, --quiet", "suppress empty-range hint").action((opts) => {
+  auditCommand({
+    days: opts.days,
+    json: opts.json,
+    quiet: opts.quiet,
+    db: program.opts().db
+  });
+});
+program.command("verdict").description("which Claude plan your weekly fill actually needs (Pro / 5x / 20x)").option("--json", "print the verdict as JSON").action((opts) => {
+  verdictCommand({
+    json: opts.json,
+    db: program.opts().db
+  });
+});
+program.command("weigh").description("weekly limit points per list-price dollar, from gaps one model dominates").option("--json", "print the weigh report as JSON").action((opts) => {
+  weighCommand({
+    json: opts.json,
+    db: program.opts().db
+  });
+});
+program.command("otel").description("opt-in OTLP/HTTP export of local numbers (never on by default)").requiredOption("--endpoint <url>", "OTLP HTTP base (we POST /v1/metrics)").option("--once", "export current store and exit (default)").option("-w, --watch", "scan once, then export").option("--scan", "run a catch-up scan before exporting").option("--include-labels", "attach local project labels (off by default)").option("-q, --quiet", "suppress the summary").action(async (opts) => {
+  await otelCommand({
+    endpoint: opts.endpoint,
+    once: opts.once,
+    watch: opts.watch,
+    scan: opts.scan,
+    includeLabels: opts.includeLabels,
+    quiet: opts.quiet,
+    db: program.opts().db
+  });
+});
 var COMMANDS = /* @__PURE__ */ new Set([
   "scan",
   "serve",
@@ -7680,6 +8754,10 @@ var COMMANDS = /* @__PURE__ */ new Set([
   "export",
   "prices",
   "alerts",
+  "audit",
+  "verdict",
+  "weigh",
+  "otel",
   "help"
 ]);
 var META_FLAGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version"]);