burner-cc 0.1.2 → 0.3.0

package/src/classifier.js

@@ -0,0 +1,140 @@
+// Session intent: who decided, in order of trust —
+//   1. a tag (from /burner-tag, the report UI, or the CLI)
+//   2. the project's default category (or its only allowed one)
+//   3. the learned model, when it has been trained and is confident
+//   4. otherwise "untagged" - no guessing from tool counts.
+
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FILES, readJson, writeJson, UNTAGGED, mapLegacyCategory } from './config.js';
+
+const MODEL_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'model');
+
+export function allowedCategories(project, cfg) {
+  const all = cfg.categories;
+  if (!project?.categories?.length) return all;
+  const allowed = all.filter((c) => project.categories.includes(c.id));
+  return allowed.length ? allowed : all;
+}
+
+export function resolveCategory({ tag, project, cfg, digest, learned }) {
+  const ids = new Set(cfg.categories.map((c) => c.id));
+  const tagCat = tag?.category ? mapLegacyCategory(tag.category) : null;
+  if (tagCat && ids.has(tagCat)) return { category: tagCat, source: tag.source ?? 'manual', confidence: tag.confidence ?? null };
+  if (project?.defaultCategory && ids.has(mapLegacyCategory(project.defaultCategory))) return { category: mapLegacyCategory(project.defaultCategory), source: 'project' };
+  if (project?.categories?.length === 1 && ids.has(project.categories[0])) return { category: project.categories[0], source: 'project' };
+  if (learned && cfg.tagging?.learned !== false && digest) {
+    const allowed = allowedCategories(project, cfg).map((c) => c.id);
+    const p = predictLearned(learned, digest, allowed);
+    if (p && p.confidence >= 0.6) return { category: p.category, source: 'learned', confidence: p.confidence };
+  }
+  return { category: UNTAGGED.id, source: 'none' };
+}
+
+// ── Digest: a compact summary of what a session was about ────────────────────
+
+export function buildDigest(parsed, { title, projectName } = {}) {
+  const d = parsed.digest ?? parsed;
+  const counts = {};
+  for (const step of d.tools ?? []) counts[step] = (counts[step] ?? 0) + 1;
+  const topTools = Object.entries(counts).sort((a, b) => b[1] - a[1]).slice(0, 15);
+  const prompts = (d.prompts ?? []).slice(0, 8).map((p) => p.text.replace(/\s+/g, ' ').slice(0, 400));
+  return {
+    project: projectName ?? null,
+    title: d.aiTitle ?? title ?? null,
+    branch: d.gitBranch ?? null,
+    prompts,
+    tools: topTools,
+    toolCount: (d.tools ?? []).length,
+  };
+}
+
+// ── Learned model: multinomial naive Bayes over prompt words + tool steps ────
+
+const STOP = new Set('the a an and or to of in on for is it this that with be as are was at by from can you i me my we our please just so do does not no yes if then there here what how why when which would could should will let lets ok okay'.split(' '));
+
+export function features(digest) {
+  const out = [];
+  for (const p of digest.prompts ?? []) {
+    const text = typeof p === 'string' ? p : String(p?.text ?? '');
+    if (!text) continue;
+    for (const w of text.toLowerCase().match(/[a-z][a-z0-9_+#.-]{1,24}/g) ?? []) {
+      const word = w.replace(/[.-]+$/, '');
+      if (!STOP.has(word)) out.push(word);
+    }
+  }
+  for (const [step, n] of digest.tools ?? []) {
+    const tok = 't:' + step.toLowerCase();
+    for (let i = 0; i < Math.min(n, 5); i++) out.push(tok);
+    out.push('t:' + step.toLowerCase().replace(/\(.*$/, ''));
+  }
+  return out;
+}
+
+export function trainLearned(examples, { prior } = {}) {
+  const model = prior ? JSON.parse(JSON.stringify(prior)) : { version: 1, classes: {}, vocab: {}, trainedAt: null, examples: 0, sources: {} };
+  for (const { digest, category, weight = 1, source = 'local' } of examples) {
+    if (!category) continue;
+    const cls = (model.classes[category] ??= { docs: 0, tokens: 0, counts: {} });
+    cls.docs += weight;
+    for (const f of features(digest)) {
+      cls.counts[f] = (cls.counts[f] ?? 0) + weight;
+      cls.tokens += weight;
+      model.vocab[f] = 1;
+    }
+    model.examples += 1;
+    model.sources[source] = (model.sources[source] ?? 0) + 1;
+  }
+  model.trainedAt = new Date().toISOString();
+  return model;
+}
+
+export function predictLearned(model, digest, allowed) {
+  const classes = Object.entries(model.classes).filter(([id, c]) => c.docs > 0 && (!allowed || allowed.includes(id)));
+  if (classes.length < 2) return null;
+  const feats = features(digest);
+  if (!feats.length) return null;
+  const V = Object.keys(model.vocab).length || 1;
+  const totalDocs = classes.reduce((s, [, c]) => s + c.docs, 0);
+  const scores = classes.map(([id, c]) => {
+    let s = Math.log(c.docs / totalDocs);
+    for (const f of feats) s += Math.log(((c.counts[f] ?? 0) + 1) / (c.tokens + V));
+    return [id, s];
+  });
+  const max = Math.max(...scores.map(([, s]) => s));
+  const exp = scores.map(([id, s]) => [id, Math.exp(s - max)]);
+  const z = exp.reduce((a, [, v]) => a + v, 0);
+  exp.sort((a, b) => b[1] - a[1]);
+  return { category: exp[0][0], confidence: Math.round((exp[0][1] / z) * 1000) / 1000 };
+}
+
+function readBundled(name) {
+  try { return JSON.parse(readFileSync(path.join(MODEL_DIR, name), 'utf-8')); } catch { return null; }
+}
+
+// The built-in model, trained on public datasets (see src/model/prior.meta.json).
+// Not used when its own evaluation said it isn't better than guessing.
+export function loadPrior() {
+  const meta = readBundled('prior.meta.json');
+  if (meta && meta.recommended === false) return null;
+  const model = readBundled('prior.json');
+  return model?.classes ? model : null;
+}
+
+export function priorMeta() {
+  return readBundled('prior.meta.json');
+}
+
+// The user's own trained model if there is one (it starts from the built-in
+// one), otherwise the built-in model.
+export function loadLearned() {
+  const own = readJson(FILES.model, null);
+  if (own) return own;
+  const prior = loadPrior();
+  return prior ? { ...prior, builtin: true } : null;
+}
+
+export function saveLearned(model) {
+  writeJson(FILES.model, model);
+}

package/src/cli.js

@@ -1,118 +1,215 @@
-import { readFileSync } from 'node:fs';
+import { writeFileSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { discoverSessions, findSession, latestSession } from './discover.js';
-import { buildReceipt, loadPricingTable } from './build-receipt.js';
-import { renderReceipts, openInBrowser } from './render.js';
-import { detectBillingMode } from './billing-mode.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const HELP_TEXT = `burner-cc — itemized cost receipts for Claude Code sessions
-
-Usage:
-  burner-cc                    latest session -> opens a receipt
-  burner-cc <session>          specific session (title, slug, or id prefix)
-  burner-cc --all              every session found, sliding carousel
-  burner-cc list               quick terminal table, no browser
-  burner-cc --json             machine-readable output, no browser
-  burner-cc -h, --help         show this help
-  burner-cc -v, --version      show version
-
-Examples:
-  burner-cc
-  burner-cc my-renamed-session
-  burner-cc --all --json
+import { spawn } from 'node:child_process';
+import { analyzeSessions } from './analyze.js';
+import { renderReport } from './report.js';
+import { renderReceipt } from './receipt.js';
+import { loadConfig, HOME, UNTAGGED } from './config.js';
+import { loadPricingTable } from './pricing.js';
+import { clearTag } from './tags.js';
+import { applyTagging, installStatus, uninstall, SKILL_NAME } from './install.js';
+import { tagFromCli, trainFromTags, fetchSweChat, readJsonl, resolveCurrentSession } from './tagging.js';
+import { readHookPayload, tagSessionAtEnd } from './tag-end.js';
+
+const HELP = `
+  burner - what your Claude Code sessions cost, and what they were for
+
+  Usage
+    burner                          open the web app (report + settings) on 127.0.0.1:4777
+    burner serve [--port N] [--no-open]
+    burner report [--no-open]       write a static report to ~/.burner/report.html
+    burner list                     terminal table
+    burner receipt [id|title]       one session's receipt (default: latest)
+
+  Tagging
+    burner tag <category> [--session ID] [--reason TEXT] [--task]
+    burner tag --clear [--session ID]
+    burner install                  install /${SKILL_NAME} globally + apply the tagging level
+    burner uninstall                remove the skill and CLAUDE.md block
+    burner status
+
+  Pricing & model
+    burner pricing refresh          fetch fresh public prices now
+    burner model train [--swe-chat] [--data FILE.jsonl] [--prior]   learn from your tags (+ optional public labels)
+
+  Filters: --project <name>  --from YYYY-MM-DD  --to YYYY-MM-DD  --json  --offline
+  Files:   ${HOME}
 `;
 
-function printVersion() {
-  const pkg = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
-  console.log(pkg.version);
+function parseArgs(argv) {
+  const opts = { _: [], open: true };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') opts.help = true;
+    else if (a === '--json') opts.json = true;
+    else if (a === '--no-open') opts.open = false;
+    else if (a === '--offline') opts.offline = true;
+    else if (a === '--all') opts.all = true;
+    else if (a === '--task') opts.task = true;
+    else if (a === '--clear') opts.clear = true;
+    else if (a === '--swe-chat') opts.sweChat = true;
+    else if (a === '--prior') opts.prior = true;
+    else if (['--project', '--from', '--to', '--session', '--reason', '--port'].includes(a)) opts[a.slice(2)] = argv[++i];
+    else if (a === '--data') opts.file = argv[++i];
+    else opts._.push(a);
+  }
+  return opts;
 }
 
-function fmtUsd(n) {
-  return '$' + n.toFixed(3);
+const fmtTok = (n) => (n >= 1e6 ? (n / 1e6).toFixed(2) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'K' : String(n));
+const fmtCost = (n) => '$' + n.toFixed(n > 0 && n < 0.01 ? 4 : 2);
+const pad = (s, n) => String(s ?? '').slice(0, n).padEnd(n);
+
+function openUrl(target) {
+  const cmd = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '""', target] : [target];
+  spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
 }
 
-function printList(sessions, table) {
-  console.log('SESSION   TITLE                 PROJECT                     DATE          MODELS   COST');
-  for (const s of sessions) {
-    const r = buildReceipt(s, table);
-    const date = r.startedAt ? new Date(r.startedAt).toISOString().slice(0, 10) : 'unknown';
-    const models = r.models.map((m) => m.displayName.replace(/\s*\(.*\)/, '')).join(', ') || 'none';
-    const title = (s.title ?? '').slice(0, 20);
-    console.log(
-      `${s.sessionId.slice(0, 8)}  ${title.padEnd(20)}  ${s.project.slice(0, 25).padEnd(25)}  ${date.padEnd(12)}  ${models.padEnd(8)}  ${fmtUsd(r.totals.cost.total)}`
-    );
+function printList(data) {
+  const label = Object.fromEntries(data.categories.map((c) => [c.id, c.label]));
+  const header = [pad('DATE', 10), pad('TITLE', 30), pad('PROJECT', 16), pad('CATEGORY', 15), pad('MODEL', 20), pad('TOKENS', 8), pad('COST', 9)].join('  ');
+  console.log('\n  ' + header + '\n  ' + '─'.repeat(header.length));
+  for (const s of data.sessions) {
+    const model = s.models.map((m) => m.rawModel).join('+') || '-';
+    const cat = (label[s.category] ?? s.category) + (s.categorySource === 'learned' ? '?' : '');
+    console.log('  ' + [pad(s.date, 10), pad(s.title, 30), pad(s.project, 16), pad(cat, 15), pad(model, 20), pad(fmtTok(s.totalTokens.total), 8), pad(fmtCost(s.totalCost.total) + (s.hasUnpriced ? '*' : ''), 9)].join('  '));
   }
+  const tok = data.sessions.reduce((a, s) => a + s.totalTokens.total, 0);
+  const cost = data.sessions.reduce((a, s) => a + s.totalCost.total, 0);
+  console.log(`\n  ${data.sessions.length} sessions | ${fmtTok(tok)} tokens | ${fmtCost(cost)} | pricing ${data.pricing.source}`);
+  if (data.unpricedModels.length) console.log(`  * $0 until priced: ${data.unpricedModels.join(', ')} - set rates on Settings -> Pricing`);
+  console.log('');
 }
 
 async function main() {
-  const args = process.argv.slice(2);
+  const opts = parseArgs(process.argv.slice(2));
+  const [cmd = 'serve', sub] = opts._;
+  if (opts.help || cmd === 'help') return console.log(HELP);
+
+  if (cmd === 'tag') {
+    if (opts.clear) {
+      const s = resolveCurrentSession(opts.session);
+      if (!s) throw new Error('no session found');
+      clearTag(s.sessionId);
+      return console.log(`cleared tag on ${s.sessionId}`);
+    }
+    if (!sub) {
+      const cfg = loadConfig();
+      return console.log('categories: ' + cfg.categories.map((c) => c.id).join(', '));
+    }
+    const r = tagFromCli({ category: sub, session: opts.session, reason: opts.reason, task: opts.task });
+    return console.log(`tagged ${r.category}${opts.task ? ' (task)' : ''} | ${r.project} | ${r.sessionId.slice(0, 8)}`);
+  }
 
-  if (args.includes('-h') || args.includes('--help')) {
-    console.log(HELP_TEXT);
+  if (cmd === 'hook' && sub === 'session-end') {
+    const payload = await readHookPayload();
+    const sid = payload.session_id ?? payload.sessionId ?? process.env.CLAUDE_SESSION_ID;
+    const r = await tagSessionAtEnd({ sessionId: sid });
+    if (r.skipped) return;
+    if (r.error) {
+      console.error(`  session-end tag failed: ${r.error}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (r.ok) console.log(`  tagged ${r.category} (${r.model})`);
     return;
   }
-  if (args.includes('-v') || args.includes('--version')) {
-    printVersion();
+
+  if (cmd === 'install') {
+    const st = applyTagging(loadConfig());
+    console.log(`  /${st.skillName} -> ${st.skillPath}${st.skillInstalled ? '' : ' (not installed: level is off)'}`);
+    console.log(`  CLAUDE.md block: ${st.claudeMdLevel ?? 'none'}`);
+    if (st.sessionEndHook) console.log(`  SessionEnd hook: on (model ${st.endModel || '?'})`);
     return;
   }
+  if (cmd === 'uninstall') {
+    uninstall();
+    return console.log('  removed skill and CLAUDE.md block');
+  }
+  if (cmd === 'status') {
+    const cfg = loadConfig();
+    return console.log(JSON.stringify({ home: HOME, tagging: cfg.tagging, install: installStatus(cfg) }, null, 2));
+  }
 
-  const asJson = args.includes('--json');
-  const filtered = args.filter((a) => a !== '--json');
+  if (cmd === 'pricing') {
+    const t = await loadPricingTable({ force: sub === 'refresh' });
+    console.log(`  pricing: ${t.source} | ${Object.keys(t.models).length} models${t.error ? ' | ' + t.error : ''}`);
+    if (sub === 'refresh' && t.source !== 'live') process.exitCode = 1;
+    return;
+  }
 
-  if (filtered[0] === 'list') {
-    const sessions = discoverSessions();
-    if (!sessions.length) {
-      console.log('No Claude Code sessions found under ~/.claude/projects.');
-      return;
+  if (cmd === 'model' && sub === 'train') {
+    let prior = [];
+    if (opts.sweChat) {
+      process.stdout.write('  fetching SWE-chat prompt intents…');
+      prior = (await fetchSweChat({ token: process.env.HF_TOKEN, onProgress: (n) => process.stdout.write(`\r  fetching SWE-chat prompt intents… ${n}`) })).map((r) => ({ ...r, source: 'swe-chat' }));
+      console.log('');
     }
-    const table = await loadPricingTable();
-    if (asJson) {
-      const billingMode = detectBillingMode();
-      console.log(JSON.stringify(sessions.map((s) => ({ ...buildReceipt(s, table), billingMode })), null, 2));
-    } else {
-      printList(sessions, table);
+    if (opts.file) prior.push(...readJsonl(opts.file).map((r) => ({ text: r.text, category: r.category ?? r.label, source: path.basename(opts.file) })));
+    const r = await trainFromTags({ prior, bootstrapPrior: !!opts.prior });
+    return console.log(r.ok ? `  trained on ${r.examples} examples: ${JSON.stringify(r.classes)}` : '  ' + r.message);
+  }
+
+  if (cmd === 'serve') {
+    const { startServer } = await import('./server.js');
+    const want = Number(opts.port ?? 4777);
+    let url;
+    try {
+      ({ url } = await startServer({ port: want }));
+      console.log(`  burner -> ${url}   (settings: ${url}/settings) | Ctrl+C to stop`);
+    } catch (err) {
+      if (err.code !== 'EADDRINUSE') throw err;
+      const base = `http://127.0.0.1:${want}`;
+      const running = await fetch(base + '/api/state', { signal: AbortSignal.timeout(3000) }).then((r) => r.ok).catch(() => false);
+      if (running) {
+        console.log(`  burner is already running -> ${base}   (settings: ${base}/settings)`);
+        if (opts.open) openUrl(base);
+        return;
+      }
+      if (opts.port) throw new Error(`port ${want} is in use by another program; pick one with --port`);
+      ({ url } = await startServer({ port: 0 }));
+      console.log(`  port ${want} is busy, using ${url}   (settings: ${url}/settings) | Ctrl+C to stop`);
     }
+    if (opts.open) openUrl(url);
     return;
   }
 
-  let sessions;
-  if (filtered.includes('--all')) {
-    sessions = discoverSessions();
-  } else if (filtered[0]) {
-    const found = findSession(filtered[0]);
-    if (!found) {
-      console.error(`No session found matching "${filtered[0]}". Try "burner-cc list".`);
-      process.exitCode = 1;
-      return;
-    }
-    sessions = [found];
-  } else {
-    const latest = latestSession();
-    if (!latest) {
-      console.log('No Claude Code sessions found under ~/.claude/projects.');
-      return;
-    }
-    sessions = [latest];
+  const data = await analyzeSessions(opts);
+  if (cmd === 'list') return opts.json ? console.log(JSON.stringify(data.sessions, null, 2)) : printList(data);
+  if (opts.json) {
+    const { digests, config, ...rest } = data;
+    return console.log(JSON.stringify(rest, null, 2));
   }
 
-  const table = await loadPricingTable();
-  const billingMode = detectBillingMode();
-  const receipts = sessions.map((s) => ({ ...buildReceipt(s, table), billingMode }));
+  mkdirSync(HOME, { recursive: true });
+  if (cmd === 'receipt') {
+    const needle = (sub ?? 'latest').toLowerCase();
+    const s = needle === 'latest' ? data.sessions[0] : data.sessions.find((x) => x.sessionId.startsWith(needle) || x.title.toLowerCase().includes(needle));
+    if (!s) throw new Error(`no session matching "${sub}" - try "burner list"`);
+    const file = path.join(HOME, `receipt-${s.sessionId.slice(0, 8)}.html`);
+    writeFileSync(file, renderReceipt(s, data.categories), 'utf-8');
+    console.log('  receipt -> ' + file);
+    if (opts.open) openUrl(file);
+    return;
+  }
 
-  if (asJson) {
-    console.log(JSON.stringify(receipts, null, 2));
+  if (cmd === 'report') {
+    for (const s of data.sessions) writeFileSync(path.join(HOME, `receipt-${s.sessionId.slice(0, 8)}.html`), renderReceipt(s, data.categories), 'utf-8');
+    const file = path.join(HOME, 'report.html');
+    writeFileSync(file, renderReport(data, { served: false }), 'utf-8');
+    const untagged = data.sessions.filter((s) => s.category === UNTAGGED.id).length;
+    console.log(`  report -> ${file}  (${data.sessions.length} sessions, ${untagged} untagged)`);
+    if (opts.open) openUrl(file);
     return;
   }
 
-  const outFile = renderReceipts(receipts);
-  console.log(`Receipt written to ${outFile}`);
-  openInBrowser(outFile);
+  console.log(HELP);
+  process.exitCode = 1;
 }
 
 main().catch((err) => {
-  console.error('burner-cc failed:', err.message);
+  console.error('  x ' + err.message);
+  if (process.env.DEBUG) console.error(err.stack);
   process.exitCode = 1;
 });

package/src/config.js

@@ -0,0 +1,222 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parseYaml, stringifyYaml } from './yaml.js';
+
+export const HOME = process.env.BURNER_HOME ?? path.join(os.homedir(), '.burner');
+export const CLAUDE_HOME = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude');
+export const FILES = {
+  config: path.join(HOME, 'config.yaml'),
+  pricing: path.join(HOME, 'pricing.yaml'),
+  tags: path.join(HOME, 'tags.json'),
+  assignments: path.join(HOME, 'assignments.json'),
+  pricingCache: path.join(HOME, 'cache', 'litellm-pricing.json'),
+  model: path.join(HOME, 'model', 'intent-nb.json'),
+};
+
+// What people use Claude Code for, by intent rather than by tool mechanics.
+// Order matters only for display.
+export const DEFAULT_CATEGORIES = [
+  { id: 'coding', label: 'Coding', color: '#2563eb', description: 'Building or changing something: code, scripts, apps, automations, files' },
+  { id: 'debugging', label: 'Debugging', color: '#dc2626', description: 'Figuring out why something is broken and fixing it' },
+  { id: 'planning', label: 'Planning', color: '#059669', description: 'Deciding what to build or do: strategy, specs, designs, roadmaps, breakdowns' },
+  { id: 'research', label: 'Research', color: '#475569', description: 'Finding out how something works: exploring files, docs, the web, options' },
+  { id: 'writing', label: 'Writing', color: '#b45309', description: 'Docs, emails, reports, slides, copy, summaries' },
+  { id: 'analysis', label: 'Analysis', color: '#0d9488', description: 'Working with data, numbers, metrics, spreadsheets, charts' },
+  { id: 'review', label: 'Review', color: '#c2410c', description: 'Checking someone\'s work: code, documents, plans, feedback' },
+  { id: 'learning', label: 'Learning', color: '#64748b', description: 'Questions and explanations, no real work product' },
+  { id: 'other', label: 'Other', color: '#94a3b8', description: 'Anything that does not fit above' },
+];
+
+// Ids from earlier versions, mapped to the current set.
+export const LEGACY_CATEGORY_IDS = { feature: 'coding', refactor: 'coding', testing: 'coding', devops: 'coding', bugfix: 'debugging', docs: 'writing', data: 'analysis' };
+export const mapLegacyCategory = (id) => LEGACY_CATEGORY_IDS[id] ?? id;
+
+export const THEMES = ['paper', 'thermal', 'matrix', 'dark'];
+export const RANGES = ['all', '7', '30', '90', 'custom'];
+const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+export const UNTAGGED = { id: 'untagged', label: 'Untagged', color: '#a8a29e', description: 'No tag yet' };
+
+// Tagging levels, lowest to highest — mirrors Claude Code's effort slider.
+export const TAGGING_LEVELS = [
+  { id: 'off', label: 'Off', description: 'Never tag. Sessions stay untagged unless the project has a default. Burner removes the global /burner-tag skill and hooks from ~/.claude.' },
+  { id: 'manual', label: 'Manual', description: 'Only when you run /burner-tag. Burner keeps the skill installed globally; no CLAUDE.md reminder.' },
+  { id: 'session', label: 'Session end', description: 'Tag when a session ends: SessionEnd hook + your Anthropic model id (below), or /burner-tag via CLAUDE.md if no model id. Burner updates ~/.claude when you move the slider.' },
+  { id: 'task', label: 'Every task', description: 'Claude tags after each distinct task (/burner-tag with --task). Burner adds a CLAUDE.md block and keeps the skill installed.' },
+];
+
+export function defaultConfig() {
+  return {
+    version: 1,
+    categories: DEFAULT_CATEGORIES.map((c) => ({ ...c })),
+    projects: [],
+    tagging: {
+      level: 'manual',
+      learned: true,
+      endModel: '',
+    },
+    ui: { theme: 'paper', range: 'all', customFrom: '', customTo: '' },
+  };
+}
+
+function readText(file) {
+  try {
+    return readFileSync(file, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+function writeAtomic(file, text) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, text, 'utf-8');
+  renameSync(tmp, file);
+}
+
+const CONFIG_HEADER = '# burner config — edited from the Settings page (burner serve). Safe to hand-edit.\n';
+
+function normalizeConfig(raw) {
+  const base = defaultConfig();
+  const cfg = { ...base, ...(raw ?? {}) };
+  if (Array.isArray(cfg.categories) && cfg.categories.some((x) => LEGACY_CATEGORY_IDS[x?.id]) && !cfg.categories.some((x) => x?.id === 'coding')) cfg.categories = null;
+  cfg.categories = Array.isArray(cfg.categories) && cfg.categories.length
+    ? cfg.categories.filter((c) => c?.id).map((c) => ({ id: String(c.id), label: c.label ?? c.id, color: c.color ?? '#888888', description: c.description ?? '' }))
+    : base.categories;
+  cfg.projects = Array.isArray(cfg.projects)
+    ? cfg.projects.filter((p) => p?.name).map((p) => ({
+        name: String(p.name),
+        paths: (p.paths ?? []).map(String),
+        categories: [...new Set((p.categories ?? []).map(String).map(mapLegacyCategory))],
+        defaultCategory: p.defaultCategory ? mapLegacyCategory(p.defaultCategory) : null,
+      }))
+    : [];
+  cfg.tagging = { ...base.tagging, ...(cfg.tagging ?? {}) };
+  delete cfg.tagging.auto;
+  if (cfg.tagging.level === 'auto') cfg.tagging.level = 'manual';
+  cfg.tagging.endModel = String(cfg.tagging.endModel ?? '').trim();
+  const ui = cfg.ui ?? {};
+  cfg.ui = {
+    theme: THEMES.includes(ui.theme) ? ui.theme : 'paper',
+    range: RANGES.includes(String(ui.range)) ? String(ui.range) : 'all',
+    customFrom: DAY_RE.test(String(ui.customFrom ?? '')) ? String(ui.customFrom) : '',
+    customTo: DAY_RE.test(String(ui.customTo ?? '')) ? String(ui.customTo) : '',
+  };
+  if (!TAGGING_LEVELS.some((l) => l.id === cfg.tagging.level)) cfg.tagging.level = base.tagging.level;
+  return cfg;
+}
+
+export function loadConfig() {
+  migrateLegacy();
+  const text = readText(FILES.config);
+  if (text == null) return defaultConfig();
+  return normalizeConfig(parseYaml(text));
+}
+
+export function saveConfig(cfg) {
+  const clean = normalizeConfig(cfg);
+  writeAtomic(FILES.config, CONFIG_HEADER + stringifyYaml(clean) + '\n');
+  return clean;
+}
+
+// pricing.yaml: { models: { "<raw model id>": { input, output, cacheWrite5m, cacheWrite1h, cacheRead } } }
+// Rates are USD per million tokens. A model listed here always wins over the fetched table.
+export function loadPricingOverrides() {
+  migrateLegacy();
+  const text = readText(FILES.pricing);
+  if (text == null) return {};
+  const parsed = parseYaml(text);
+  return parsed?.models ?? {};
+}
+
+export function savePricingOverrides(models) {
+  const clean = {};
+  for (const [id, r] of Object.entries(models ?? {})) {
+    if (!r) continue;
+    clean[id] = {};
+    for (const k of ['input', 'output', 'cacheWrite5m', 'cacheWrite1h', 'cacheRead']) clean[id][k] = Number(r[k]) || 0;
+  }
+  writeAtomic(FILES.pricing, '# USD per million tokens. Edited from the Pricing page; models not listed use fetched public rates (Claude) or $0.\n' + stringifyYaml({ models: clean }) + '\n');
+  return clean;
+}
+
+export function readJson(file, fallback) {
+  const text = readText(file);
+  if (text == null) return fallback;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(file, value) {
+  writeAtomic(file, JSON.stringify(value, null, 2));
+}
+
+let migrated = false;
+// One-time import from the old ~/.ti-burner layout.
+function migrateLegacy() {
+  if (migrated) return;
+  migrated = true;
+  const legacy = path.join(os.homedir(), '.ti-burner');
+  if (!existsSync(legacy) || HOME === legacy) return;
+  const overrides = readJson(path.join(legacy, 'overrides.json'), null);
+  if (overrides && !existsSync(FILES.tags)) {
+    const map = { 'Feature Work': 'coding', 'Bug Fix': 'debugging', Research: 'research', Planning: 'planning', Meetings: 'other', Documentation: 'writing', 'Data Analysis': 'analysis', 'Q&A': 'learning', Other: 'other' };
+    const tags = {};
+    for (const [id, cat] of Object.entries(overrides)) {
+      tags[id] = { category: map[cat] ?? 'other', source: 'manual', at: new Date().toISOString(), segments: [] };
+    }
+    writeJson(FILES.tags, tags);
+  }
+  const custom = readJson(path.join(legacy, 'custom-pricing.json'), null);
+  if (custom && !existsSync(FILES.pricing)) {
+    const models = {};
+    for (const [id, r] of Object.entries(custom)) {
+      const rid = id.replace(/ \(billed-unpriced\)$/, '');
+      const rates = ['input', 'output', 'cacheWrite5m', 'cacheWrite1h', 'cacheRead'].map((k) => Number(r?.[k]) || 0);
+      if (rates.some((v) => v > 0)) models[rid] = r;
+    }
+    if (Object.keys(models).length) savePricingOverrides(models);
+  }
+}
+
+function normPath(p) {
+  let s = path.resolve(p).replace(/[\\/]+$/, '');
+  if (process.platform === 'win32' || /^[a-z]:/i.test(s)) s = s.toLowerCase().replace(/\//g, '\\');
+  return s;
+}
+
+function isUnder(child, parent) {
+  if (child === parent) return true;
+  const sep = parent.includes('\\') ? '\\' : '/';
+  return child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+}
+
+// The project a working directory belongs to: the configured project whose
+// path is the longest prefix of cwd, else an implicit project named after
+// the directory.
+export function resolveProject(cwd, cfg) {
+  if (!cwd) return { name: 'unknown', implicit: true, categories: [], defaultCategory: null };
+  const target = normPath(cwd);
+  let best = null;
+  let bestLen = -1;
+  for (const p of cfg.projects) {
+    for (const dir of p.paths) {
+      const n = normPath(dir);
+      if (isUnder(target, n) && n.length > bestLen) {
+        best = p;
+        bestLen = n.length;
+      }
+    }
+  }
+  if (best) return { ...best, implicit: false };
+  const home = normPath(os.homedir());
+  const name = target === home ? '~' : path.basename(cwd) || cwd;
+  return { name, implicit: true, categories: [], defaultCategory: null };
+}
+
+export function categoryIds(cfg) {
+  return cfg.categories.map((c) => c.id);
+}