burner-cc 0.3.0 → 0.3.2

package/README.md

@@ -2,84 +2,93 @@
 
 # burner
 
-What your Claude Code sessions cost, and what they were for. Itemized receipts, projects that span several directories, and intent tagging that doesn't guess from tool counts.
+What your Claude Code sessions cost, and what they were for — itemized receipts, projects, intent tagging, and a local analytics app.
 
-Zero dependencies. Reads `~/.claude/projects/` — nothing leaves your machine except the public price list fetch.
+Zero runtime dependencies. Reads `~/.claude/projects/` on your machine. Only network use by default is refreshing public model prices (optional).
+
+## Install
 
 ```bash
-npx burner-cc            # or: node bin/burner.js
+npm install -g burner-cc
+# commands: burner  (alias entry: burner-cc)
 ```
 
-Opens a local app at `http://127.0.0.1:4777` — the report, per-session receipts, and **Settings** (projects, categories, pricing, tagging).
-
-## Commands
+Or without installing:
 
 ```bash
-burner                          # web app: report + settings
-burner report                   # static ~/.burner/report.html (+ receipts)
-burner list                     # terminal table
-burner receipt [id|title]       # one receipt (default: latest)
+npx burner-cc
+```
+
+**Node 18+** required.
 
-burner install                  # install /burner-tag globally, apply tagging level
-burner tag <category> [--task] [--reason TEXT] [--session ID]
-burner pricing refresh          # fetch fresh prices now
-burner model train [--swe-chat] [--data FILE.jsonl]
+## Quick start
 
---project NAME  --from YYYY-MM-DD  --to YYYY-MM-DD  --json  --offline
+```bash
+burner                 # opens http://127.0.0.1:4777 (report + Settings)
+burner serve           # same; --port N, --no-open
+burner install         # global /burner-tag skill + tagging level from ~/.burner/config.yaml
 ```
 
-## Categories
+Settings covers **projects**, **categories**, **pricing** (pin/refresh per model), and **tagging** (slider, train your intent model).
 
-Intent, not mechanics — reading code to fix a bug is a bug fix:
+## Commands
 
-`coding` · `debugging` · `planning` · `research` · `writing` · `analysis` · `review` · `learning` · `other`
+```bash
+burner list [--json] [--project NAME] [--from YYYY-MM-DD] [--to YYYY-MM-DD]
+burner receipt [session-id|title]     # one receipt HTML under ~/.burner/
+burner report [--no-open]               # static report.html + receipt-*.html
 
-Edit them on Settings → Categories. A session's category comes from, in order:
+burner tag <category> [--session ID] [--reason TEXT] [--task]
+burner tag --clear [--session ID]
+burner install | uninstall | status
 
-1. **A tag** — from `/burner-tag`, or the receipt's category picker
-2. **Its project's default category** (or the project's only allowed category)
-3. **The learned model**, once trained on your tags and only when confident
-4. Otherwise **untagged**. There are no folder-name or tool-ratio rules.
+burner pricing refresh
+burner model train [--data FILE.jsonl] [--swe-chat] [--prior]
+```
 
-## Projects
+`burner tag` is what `/burner-tag` runs. After `npm i -g burner-cc`, hooks and the skill use the `burner` command on your PATH.
 
-A project groups one or more directories; any session started under one of them belongs to it (longest match wins). Each project can restrict which categories apply and set a default. Configure on Settings → Projects — it's stored in `~/.burner/config.yaml`, which you never have to open.
+## Categories
 
-## Tagging levels
+Intent, not tool counts — e.g. reading files to fix a bug is **debugging**, not research.
 
-Like Claude Code's effort slider (Settings → Tagging):
+Default ids: `coding` · `debugging` · `planning` · `research` · `writing` · `analysis` · `review` · `learning` · `other` (editable in Settings).
 
-| Level | What happens |
-|---|---|
-| Off | No skill, nothing injected |
-| Manual | `/burner-tag` is available in every project |
-| Session end | A block in `~/.claude/CLAUDE.md` asks Claude to tag once when the work is done (~100 output tokens) |
-| Every task | Claude tags each finished task, so one session can split across categories by cost |
+Resolution order:
 
-### Learned model
+1. Tag (`/burner-tag`, receipt picker, session-end model, or CLI)
+2. Project default category
+3. **Your trained model** (optional; only if enabled and confidence ≥ 60%)
+4. Otherwise **untagged** — no folder-name or tool-ratio guessing
 
-`burner model train` fits a small naive-Bayes classifier on prompt words + tool steps from sessions *you* tagged. `--swe-chat` adds intent-labeled prompts from real Claude Code sessions from [SALT-NLP/SWE-chat](https://huggingface.co/datasets/SALT-NLP/SWE-chat) (gated: accept its terms and set `HF_TOKEN`). `--data` takes any `{"text", "category"}` JSONL.
+## Tagging levels (Settings)
 
-## Tokens
+| Level | Behavior |
+|--------|----------|
+| Off | Removes global skill / hooks |
+| Manual | `/burner-tag` only; skill stays installed |
+| Session end | SessionEnd hook tags with your **local** trained model (no API, no CLAUDE.md) |
 
-Claude Code writes one API response as several lines (one per streamed block) with growing `output_tokens`. Burner keeps the final line per request ID, drops requests a continued session re-logs from its parent, and bills subagent transcripts to their parent session. Totals include all four billed buckets: fresh input, cache write (5m/1h), cache read, output. On real sessions this lands within a few percent of Claude Code's own `/cost`; the gap is background calls (titles, compaction) Claude Code doesn't write to the transcript.
+Moving the tagging slider updates `~/.claude` automatically. Use **Train from my tags** in Settings for a local naive-Bayes model (`~/.burner/model/intent-nb.json`). Training is pure Node — no GPU or Python. CLI `burner model train` does the same; `--prior` / `--swe-chat` are optional extras.
 
-## Pricing
+## Tokens & pricing
 
-- **Claude models** — public list prices from [LiteLLM's price table](https://github.com/BerriAI/litellm), refreshed daily (bundled snapshot when offline). Bedrock/Vertex/dated ids are normalized.
-- **Everything else** (gateway, on-prem, local models behind the Claude Code harness) — **$0 until you set a price**. Settings → Pricing shows each model, offers the public price when one exists, and saves overrides to `~/.burner/pricing.yaml`.
+- One API request → several transcript lines; burner bills the **last** chunk per `requestId`, dedupes continued sessions, rolls subagents into the parent.
+- Totals: fresh input, cache write (5m/1h), cache read, output.
+- **Claude** models: public LiteLLM price list (daily refresh, offline snapshot fallback).
+- **Other** models (gateway, on-prem, local): **$0** until you set a price in Settings.
 
 ## Files
 
-| Path | |
-|---|---|
-| `~/.burner/config.yaml` | projects, categories, tagging level, theme |
-| `~/.burner/pricing.yaml` | your price overrides (USD / 1M tokens) |
+| Path | Purpose |
+|------|---------|
+| `~/.burner/config.yaml` | projects, categories, tagging, UI theme/range |
+| `~/.burner/pricing.yaml` | your USD/1M overrides |
 | `~/.burner/tags.json` | session tags |
-| `~/.burner/model/intent-nb.json` | learned model |
-| `~/.burner/cache/litellm-pricing.json` | price cache |
-| `~/.claude/skills/burner-tag/` | the global skill (`burner install`) |
+| `~/.burner/assignments.json` | per-session project overrides |
+| `~/.burner/model/intent-nb.json` | your trained intent model |
+| `~/.claude/skills/burner-tag/` | global skill (`burner install`) |
 
-Old `~/.ti-burner` overrides and custom prices are imported on first run. `BURNER_HOME` and `CLAUDE_CONFIG_DIR` relocate both sides.
+`BURNER_HOME` and `CLAUDE_CONFIG_DIR` override `~/.burner` and `~/.claude`. Legacy `~/.ti-burner` data is migrated on first run.
 
-*not official billing*
+*Not official Anthropic billing.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "burner-cc",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "What your Claude Code sessions cost, and what they were for — itemized receipts, projects, intent tagging.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -25,7 +25,7 @@ const HELP = `
     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 uninstall                remove the skill and SessionEnd hook
     burner status
 
   Pricing & model
@@ -119,13 +119,13 @@ async function main() {
   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 || '?'})`);
+    if (st.legacyClaudeMd) console.log('  legacy CLAUDE.md burner block: still present (run install to strip)');
+    if (st.sessionEndHook) console.log('  SessionEnd hook: on (local auto-tag)');
     return;
   }
   if (cmd === 'uninstall') {
     uninstall();
-    return console.log('  removed skill and CLAUDE.md block');
+    return console.log('  removed skill, hook, and legacy CLAUDE.md block');
   }
   if (cmd === 'status') {
     const cfg = loadConfig();

package/src/config.js

@@ -40,9 +40,8 @@ export const UNTAGGED = { id: 'untagged', label: 'Untagged', color: '#a8a29e', d
 // 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.' },
+  { id: 'manual', label: 'Manual', description: 'Only when you run /burner-tag. Burner keeps the skill installed globally.' },
+  { id: 'session', label: 'Session end', description: 'SessionEnd hook tags using your trained local model (and project default). No API calls and no CLAUDE.md edits.' },
 ];
 
 export function defaultConfig() {
@@ -53,7 +52,6 @@ export function defaultConfig() {
     tagging: {
       level: 'manual',
       learned: true,
-      endModel: '',
     },
     ui: { theme: 'paper', range: 'all', customFrom: '', customTo: '' },
   };
@@ -94,7 +92,8 @@ function normalizeConfig(raw) {
   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();
+  if (cfg.tagging.level === 'task') cfg.tagging.level = 'manual';
+  delete cfg.tagging.endModel;
   const ui = cfg.ui ?? {};
   cfg.ui = {
     theme: THEMES.includes(ui.theme) ? ui.theme : 'paper',

package/src/install.js

@@ -1,9 +1,10 @@
 // Wires burner into Claude Code globally (~/.claude), never per-repo:
 //   skills/<SKILL_NAME>/SKILL.md  — the tag skill, available in every project
-//   CLAUDE.md block               — "Session end" / "Every task" levels tell Claude to use it
+//   SessionEnd hook               — session level: local auto-tag (no API, no CLAUDE.md)
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { CLAUDE_HOME } from './config.js';
 
@@ -51,7 +52,7 @@ export function skillSetupPrompt() {
   return `Set up burner session tagging on this machine (global, not per-repo):
 1. Run in a terminal: ${cmd}${dev}
    (After npm i -g burner-cc, the same command is just: burner install)
-2. That writes ${path.join(home, 'skills', SKILL_NAME, 'SKILL.md')} and applies the tagging level from ~/.burner/config.yaml (CLAUDE.md block and/or SessionEnd hook).
+2. That writes ${path.join(home, 'skills', SKILL_NAME, 'SKILL.md')} and applies the tagging level from ~/.burner/config.yaml (SessionEnd hook when level is session).
 3. Re-run install after you change categories or tagging level on the Settings page.
 Do not edit project repos for this — only files under ${home}.`;
 }
@@ -60,7 +61,7 @@ export function skillMarkdown(cfg) {
   const cats = cfg.categories.map((c) => `- \`${c.id}\` — ${c.description || c.label}`).join('\n');
   return `---
 name: ${SKILL_NAME}
-description: Tag the current Claude Code session with what it was used for (coding, debugging, planning, research, writing, …) for burner usage analytics. Use when the user runs /${SKILL_NAME} or asks to tag/categorize this session, and when the burner block in CLAUDE.md asks you to tag at the end of a session or task.
+description: Tag the current Claude Code session with what it was used for (coding, debugging, planning, research, writing, …) for burner usage analytics. Use when the user runs /${SKILL_NAME} or asks to tag/categorize this session.
 ---
 
 # ${SKILL_NAME}
@@ -81,22 +82,6 @@ ${burnerShell('tag')} <category> --session "\${CLAUDE_SESSION_ID}" --reason "<un
 `;
 }
 
-function claudeMdBlock(level) {
-  if (level === 'session') {
-    return `${START}
-## burner
-When you've finished the work the user asked for in this session — before your final summary — use the \`${SKILL_NAME}\` skill once to tag the session. Tag again only if the session's main purpose changed. Keep it silent.
-${END}`;
-  }
-  if (level === 'task') {
-    return `${START}
-## burner
-Each time you finish a distinct task the user asked for, use the \`${SKILL_NAME}\` skill with \`--task\` to tag that task before replying. One tag per task, silent.
-${END}`;
-  }
-  return null;
-}
-
 function readJsonFile(file) {
   if (!existsSync(file)) return {};
   try {
@@ -106,19 +91,36 @@ function readJsonFile(file) {
   }
 }
 
+/** Claude Code command hook (exec form): node + burner.js, no shell/PATH/.cmd shims. */
+export function sessionEndHookEntry() {
+  return {
+    type: 'command',
+    command: process.execPath,
+    args: [BIN, 'hook', 'session-end'],
+    timeout: 60,
+  };
+}
+
 function isOurHook(h) {
-  return typeof h?.command === 'string' && h.command.includes('burner') && h.command.includes('hook session-end');
+  if (h?.type !== 'command') return false;
+  const args = h.args;
+  if (Array.isArray(args) && args.includes('hook') && args[args.length - 1] === 'session-end') return true;
+  return typeof h.command === 'string' && h.command.includes('hook session-end');
 }
 
 function ensureSessionEndHook() {
   const { settings: file } = paths();
   let settings;
   try { settings = readJsonFile(file); } catch { settings = {}; }
-  const cmd = burnerShell('hook session-end');
-  const groups = [...(settings.hooks?.SessionEnd ?? [])];
-  if (groups.some((g) => (g.hooks ?? []).some(isOurHook))) return;
-  groups.push({ hooks: [{ type: 'command', command: cmd }] });
-  settings.hooks = { ...(settings.hooks ?? {}), SessionEnd: groups };
+  const entry = sessionEndHookEntry();
+  const hooks = settings.hooks ?? {};
+  const before = JSON.stringify(settings);
+  let groups = (hooks.SessionEnd ?? [])
+    .map((g) => ({ ...g, hooks: (g.hooks ?? []).filter((h) => !isOurHook(h)) }))
+    .filter((g) => g.hooks.length);
+  groups.push({ hooks: [entry] });
+  settings.hooks = { ...hooks, SessionEnd: groups };
+  if (JSON.stringify(settings) === before) return;
   mkdirSync(path.dirname(file), { recursive: true });
   writeFileSync(file, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }
@@ -142,18 +144,15 @@ function removeSessionEndHook() {
   writeFileSync(file, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }
 
-function setClaudeMd(level) {
+/** Remove legacy burner blocks from ~/.claude/CLAUDE.md (we no longer install them). */
+export function stripBurnerClaudeMd() {
   const { claudeMd } = paths();
-  const current = existsSync(claudeMd) ? readFileSync(claudeMd, 'utf-8') : '';
+  if (!existsSync(claudeMd)) return;
+  const current = readFileSync(claudeMd, 'utf-8');
   const re = new RegExp(`\\n?${START}[\\s\\S]*?${END}\\n?`, 'g');
-  let next = current.replace(re, '\n').replace(/\s+$/, '');
-  const block = claudeMdBlock(level);
-  if (block) next = (next ? next + '\n\n' : '') + block;
-  next = next ? next + '\n' : '';
+  const next = current.replace(re, '\n').replace(/\s+$/, '');
   if (next.trim() === current.trim()) return;
-  if (!next.trim() && !existsSync(claudeMd)) return;
-  mkdirSync(path.dirname(claudeMd), { recursive: true });
-  writeFileSync(claudeMd, next, 'utf-8');
+  writeFileSync(claudeMd, next ? next + '\n' : '', 'utf-8');
 }
 
 export function installSkill(cfg) {
@@ -166,40 +165,34 @@ export function installSkill(cfg) {
 // Applies the tagging level from config to ~/.claude. Idempotent.
 export function applyTagging(cfg) {
   const level = cfg.tagging?.level ?? 'manual';
-  const endModel = String(cfg.tagging?.endModel ?? '').trim();
   if (level === 'off') {
     const p = paths();
     if (existsSync(p.skillDir)) rmSync(p.skillDir, { recursive: true, force: true });
   } else {
     installSkill(cfg);
   }
+  stripBurnerClaudeMd();
   removeSessionEndHook();
-  if (level === 'session' && endModel) {
-    ensureSessionEndHook();
-    setClaudeMd('off');
-  } else {
-    setClaudeMd(level === 'off' ? 'off' : level);
-  }
+  if (level === 'session') ensureSessionEndHook();
   return installStatus(cfg);
 }
 
 export function uninstall() {
   const p = paths();
   if (existsSync(p.skillDir)) rmSync(p.skillDir, { recursive: true, force: true });
-  setClaudeMd('off');
+  stripBurnerClaudeMd();
   removeSessionEndHook();
 }
 
 export function installStatus(cfg = null) {
   const p = paths();
-  const md = existsSync(p.claudeMd) ? readFileSync(p.claudeMd, 'utf-8') : '';
-  const block = md.match(new RegExp(`${START}[\\s\\S]*?${END}`))?.[0] ?? '';
   let hookInstalled = false;
   try {
     const settings = readJsonFile(p.settings);
     hookInstalled = (settings.hooks?.SessionEnd ?? []).some((g) => (g.hooks ?? []).some(isOurHook));
   } catch { /* no settings */ }
-  const endModel = String(cfg?.tagging?.endModel ?? '').trim();
+  const md = existsSync(p.claudeMd) ? readFileSync(p.claudeMd, 'utf-8') : '';
+  const legacyClaudeMd = !!md.match(new RegExp(`${START}[\\s\\S]*?${END}`));
   return {
     skillName: SKILL_NAME,
     skillInstalled: existsSync(p.skillFile),
@@ -207,9 +200,8 @@ export function installStatus(cfg = null) {
     skillInstallCmd: burnerShell('install'),
     skillInstallCmdNpm: `${NPM_CLI} install`,
     devCheckout: isDevCheckout(),
-    claudeMdLevel: block.includes('--task') ? 'task' : block ? 'session' : null,
+    legacyClaudeMd,
     sessionEndHook: hookInstalled,
-    endModel,
     claudeHome: CLAUDE_HOME,
   };
 }

package/src/receipt.js

@@ -62,7 +62,7 @@ const TAGLINES = [
   'burned so you don\'t have to guess',
   'classified and costed',
 ];
-const SOURCE_LABEL = { skill: 'TAGGED BY CLAUDE', manual: 'TAGGED BY YOU', 'end-model': 'SESSION-END MODEL', learned: 'LEARNED GUESS', project: 'PROJECT DEFAULT', none: 'NOT TAGGED' };
+const SOURCE_LABEL = { skill: 'TAGGED BY CLAUDE', manual: 'TAGGED BY YOU', 'end-model': 'SESSION-END (legacy)', 'session-end': 'SESSION-END AUTO', learned: 'LEARNED GUESS', project: 'PROJECT DEFAULT', none: 'NOT TAGGED' };
 
 function money(n, unpriced) {
   if (unpriced) return '—';

package/src/report.js

@@ -596,7 +596,7 @@ ${logoTextUri ? `<img class="page-brand" src="${logoTextUri}" alt="Burner" />` :
     <h3>Tokens</h3>
     <p>Claude Code logs one API response as several transcript lines (one per streamed content block) with growing <code>output_tokens</code>. Burner keeps only the final line per request ID, and drops requests a continued session re-logs from its parent. Totals include all four billed buckets: fresh input, cache write, cache read, output. Subagent transcripts are billed to their parent session.</p>
     <h3>Categories</h3>
-    <p>A session's category comes from, in order: a tag (<code>/burner-tag</code>, the report UI, session-end model hook, or CLI), its project's default category, then the <strong>learned model</strong> if trained and confident (≥60%). Otherwise it stays <em>untagged</em>.</p>
+    <p>A session's category comes from, in order: a tag (<code>/burner-tag</code>, the report UI, SessionEnd auto-tag, or CLI), its project's default category, then the <strong>learned model</strong> if trained and confident (≥60%). Otherwise it stays <em>untagged</em>.</p>
     <p><strong>Learned model</strong> — optional on-device classifier (multinomial naive Bayes) trained on your tagged sessions; guesses only when nothing else applied. <strong>/burner-tag skill</strong> — global skill under <code>~/.claude/skills/burner-tag</code>; run <code>burner install</code> (Settings → Tagging has copy blocks). <strong>Session end</strong> — with a model id on Settings, a SessionEnd hook asks that Anthropic model what the session was for; without a model id, the main agent tags via the skill before wrapping up.</p>
     <p>Token totals follow the same idea as <a href="https://ccusage.com/guide/cost-modes" target="_blank" rel="noopener">ccusage</a>: one row per <code>requestId</code> (last streamed chunk), 5m/1h cache write split when present, global dedup for continued sessions. Burner always calculates from tokens (like ccusage <code>--mode calculate</code>); Claude Code's <code>cost-state</code> line is shown on the receipt for comparison when available.</p>
     <h3>Projects</h3>

package/src/settings-page.js

@@ -598,9 +598,8 @@ function taggingSetupPills(level, ins, tagging, learned){
     pills.appendChild(h('span', {class:'badge dimmed', text:'skill removed'}));
   } else {
     pills.appendChild(h('span', {class:'badge' + (ins.skillInstalled ? ' ok' : ''), text:'/' + (ins.skillName || 'burner-tag') + (ins.skillInstalled ? ' \u2713' : ' \u2717')}));
-    var md = ins.claudeMdLevel ? ('CLAUDE.md ' + ins.claudeMdLevel) : 'CLAUDE.md off';
-    if (level === 'session' && ins.sessionEndHook) md = 'SessionEnd hook \u2713';
-    pills.appendChild(h('span', {class:'badge' + ((ins.claudeMdLevel || ins.sessionEndHook) ? ' ok' : ' dimmed'), text: md}));
+    var hookLbl = level === 'session' ? (ins.sessionEndHook ? 'SessionEnd hook \u2713' : 'SessionEnd hook \u2717') : 'SessionEnd off';
+    pills.appendChild(h('span', {class:'badge' + (level === 'session' && ins.sessionEndHook ? ' ok' : (level === 'session' ? '' : ' dimmed')), text: hookLbl}));
   }
   pills.appendChild(h('span', {class:'dim small', style:'margin-left:4px', text:'|'}));
   var L = learned;
@@ -633,7 +632,6 @@ function rTagging(){
     var lv = levels[i].id;
     desc.textContent = levels[i].description;
     Array.prototype.forEach.call(ticks.children, function(s, j){ s.className = j === i ? 'sel' : ''; });
-    sessionCard.style.display = lv === 'session' ? '' : 'none';
   }
   slider.addEventListener('input', function(){ syncLevelUi(Number(slider.value)); });
   slider.addEventListener('change', function(){
@@ -647,28 +645,20 @@ function rTagging(){
   levelCard.appendChild(setupPills);
   wrap.appendChild(levelCard);
 
-  var sessionCard = h('div', {class:'card', style: t.level === 'session' ? '' : 'display:none'});
-  sessionCard.appendChild(h('h3', {text:'Session-end chat model (optional)'}));
-  sessionCard.appendChild(h('p', {class:'note', text:'At Session end level: set an Anthropic model id to tag via a SessionEnd hook, or leave blank to have the main agent tag with /burner-tag before wrapping up.'}));
-  var endIn = h('input', {type:'text', placeholder:'e.g. claude-haiku-4-5', value: t.endModel || ''});
-  endIn.addEventListener('change', function(){
-    save(api('PUT', '/api/config', {tagging:{endModel: endIn.value.trim()}}), 'Claude setup updated');
-  });
-  var endField = h('div', {class:'field'});
-  endField.appendChild(h('label', {text:'Model id'}));
-  endField.appendChild(endIn);
-  sessionCard.appendChild(endField);
-  sessionCard.appendChild(h('p', {class:'dim small', style:'margin-top:8px', text: ins.sessionEndHook ? 'Hook installed' + (ins.endModel ? ' for ' + ins.endModel : '') + ' · needs ANTHROPIC_API_KEY' : 'Saving a model id installs the SessionEnd hook automatically.'}));
-  wrap.appendChild(sessionCard);
+  var sessionNote = h('div', {class:'card'});
+  sessionNote.appendChild(h('h3', {text:'Session end auto-tag'}));
+  sessionNote.appendChild(h('p', {class:'note', text:'Uses your trained local model (train below) and project defaults. Runs in the SessionEnd hook — no Anthropic API, no edits to CLAUDE.md.'}));
+  sessionNote.appendChild(h('p', {class:'dim small', text: ins.sessionEndHook ? 'Hook installed in ~/.claude/settings.json' : 'Move the slider to Session end to install the hook.'}));
+  wrap.appendChild(sessionNote);
 
   var skillCard = h('div', {class:'card'});
   skillCard.appendChild(h('h3', {text:'Troubleshooting / manual install'}));
-  skillCard.appendChild(h('p', {class:'note', text:'Moving the tagging slider or saving session-end model updates ~/.claude for you. Use this only if /burner-tag is missing or hooks look wrong.'}));
+  skillCard.appendChild(h('p', {class:'note', text:'Moving the tagging slider updates ~/.claude for you. Use this only if /burner-tag is missing or hooks look wrong.'}));
   skillCard.appendChild(h('div', {class:'card-section', style:'margin-top:0;padding-top:0;border:none'}, [
     h('h4', {text:'Status'}),
     h('div', {text:'/' + ins.skillName + ' ' + (ins.skillInstalled ? '\u2713' : '\u2717')}),
     ins.skillPath ? h('div', {class:'dim small', text:ins.skillPath}) : null,
-    h('div', {class:'dim small', text:'CLAUDE.md: ' + (ins.claudeMdLevel || 'none')})]));
+    ins.legacyClaudeMd ? h('div', {class:'dim small', text:'Legacy CLAUDE.md burner block still present — run Sync to remove'}) : null]));
   var installCmd = ins.skillInstallCmdNpm || 'burner install';
   if (ins.devCheckout && ins.skillInstallCmd && ins.skillInstallCmd !== installCmd) {
     installCmd = installCmd + '\\n' + ins.skillInstallCmd;

package/src/tag-end.js

@@ -1,11 +1,18 @@
-// SessionEnd hook: ask a small/fast model what the session was for, then tag it.
+// SessionEnd hook: tag from local signals only (learned model, project default). No API calls.
 
-import { readFileSync } from 'node:fs';
 import { discoverSessions } from './discover.js';
 import { parseTranscript } from './parse.js';
-import { loadConfig } from './config.js';
+import { loadConfig, UNTAGGED } from './config.js';
 import { loadTags, setTag, resolveSessionProject } from './tags.js';
-import { allowedCategories, buildDigest } from './classifier.js';
+import {
+  allowedCategories,
+  buildDigest,
+  loadLearned,
+  predictLearned,
+  resolveCategory,
+} from './classifier.js';
+
+const SESSION_END_CONFIDENCE = 0.45;
 
 export async function readHookPayload() {
   try {
@@ -19,53 +26,11 @@ export async function readHookPayload() {
   }
 }
 
-function pickCategory(text, allowed) {
-  const t = String(text ?? '').toLowerCase();
-  for (const id of allowed) {
-    if (t === id || t.includes(id)) return id;
-  }
-  const word = t.match(/[a-z][a-z0-9_-]*/)?.[0];
-  if (word && allowed.includes(word)) return word;
-  return null;
-}
-
-async function classifyWithModel(digest, categories, model) {
-  const key = process.env.ANTHROPIC_API_KEY;
-  if (!key) throw new Error('ANTHROPIC_API_KEY is not set (needed for session-end tagging)');
-  const lines = categories.map((c) => `${c.id}: ${c.description || c.label}`).join('\n');
-  const prompts = (digest.prompts ?? []).slice(0, 6).map((p, i) => `${i + 1}. ${p}`).join('\n');
-  const tools = (digest.tools ?? []).slice(0, 8).map(([s, n]) => `${s} x${n}`).join(', ');
-  const user = `Pick exactly one category id for this Claude Code session.
-
-Categories (reply with only the id):
-${lines}
-
-Session title: ${digest.title ?? '—'}
-Project: ${digest.project ?? '—'}
-User prompts:
-${prompts || '(none)'}
-Tools used: ${tools || '(none)'}`;
-
-  const res = await fetch('https://api.anthropic.com/v1/messages', {
-    method: 'POST',
-    headers: {
-      'x-api-key': key,
-      'anthropic-version': '2023-06-01',
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify({ model, max_tokens: 40, messages: [{ role: 'user', content: user }] }),
-    signal: AbortSignal.timeout(45_000),
-  });
-  if (!res.ok) throw new Error(`Anthropic API ${res.status}: ${(await res.text()).slice(0, 300)}`);
-  const data = await res.json();
-  const text = data.content?.find((b) => b.type === 'text')?.text ?? '';
-  return text.trim();
-}
-
-export async function tagSessionAtEnd({ sessionId, model } = {}) {
+export async function tagSessionAtEnd({ sessionId } = {}) {
   const cfg = loadConfig();
-  const endModel = (model ?? cfg.tagging?.endModel ?? '').trim();
-  if (!endModel) return { ok: false, skipped: true, reason: 'no endModel configured' };
+  if ((cfg.tagging?.level ?? 'manual') !== 'session') {
+    return { ok: false, skipped: true, reason: 'tagging level is not session' };
+  }
 
   const id = sessionId ?? process.env.CLAUDE_SESSION_ID;
   if (!id || id.includes('${')) return { ok: false, skipped: true, reason: 'no session id' };
@@ -84,11 +49,25 @@ export async function tagSessionAtEnd({ sessionId, model } = {}) {
   const allowed = allowedCategories(project, cfg);
   const allowedIds = allowed.map((c) => c.id);
   const digest = buildDigest(parsed, { title: s.customTitle ?? parsed.digest.aiTitle, projectName: project.name });
+  const learned = loadLearned();
 
-  const answer = await classifyWithModel(digest, allowed, endModel);
-  const category = pickCategory(answer.split(/\r?\n/)[0], allowedIds);
-  if (!category) return { ok: false, error: `model answer not a category: ${answer.slice(0, 80)}` };
+  let resolved = resolveCategory({ tag: existing, project, cfg, digest, learned });
+  if (resolved.category === UNTAGGED.id && learned) {
+    const p = predictLearned(learned, digest, allowedIds);
+    if (p && p.confidence >= SESSION_END_CONFIDENCE) {
+      resolved = { category: p.category, source: 'session-end', confidence: p.confidence };
+    }
+  }
 
-  setTag(s.sessionId, { category, source: 'end-model', reason: answer.slice(0, 80) });
-  return { ok: true, sessionId: s.sessionId, category, model: endModel };
+  if (resolved.category === UNTAGGED.id || resolved.source === 'none') {
+    return { ok: true, skipped: true, reason: 'no confident category' };
+  }
+
+  setTag(s.sessionId, {
+    category: resolved.category,
+    source: 'session-end',
+    reason: resolved.source === 'project' ? 'project default' : `auto (${resolved.source})`,
+    confidence: resolved.confidence ?? null,
+  });
+  return { ok: true, sessionId: s.sessionId, category: resolved.category, source: resolved.source };
 }