@unpolarize/code-sessions 0.1.0 → 0.3.0

package/dist/{chunk-ZJG2DWAK.js → chunk-ON3CPW4C.js}

@@ -133,13 +133,16 @@ Commands:
   init            Initialize the git-backed store (~/.sessions)
   start           Run the capture daemon (foreground)
   install-hooks   Install Claude Code hooks that feed the daemon
+  install-skills  Install the cs-label-session skill into agents [--agent claude|codex|grok|all]
   hook            (internal) forward a hook payload from stdin to the daemon
-  backfill        Import existing transcripts into the store [--agent claude|grok|codex|all]
+  backfill        Import existing transcripts into the store [--agent claude|grok|codex|codebuild|all]
   reindex         (Re)derive insights for stored sessions  [--since YYYY-MM]
   export          Export stored sessions as OTLP to a collector  [--since YYYY-MM]
   index           (Re)build the internal SQLite index from the git store
   query           List recent sessions from the index  [--limit N] [--agent X]
+  usage           Aggregated token/cost usage (totals/by-agent/by-day)  [--json]
   search          Full-text search session turns  <text> [--limit N]
+  fork            Fork a session at a turn ("git for sessions")  <session-id> --at N [--id X]
   analytics       Compute MVP-2 rollups + digest into analytics/
   status          Show daemon/store status
   doctor          Environment checks
@@ -973,6 +976,45 @@ function deriveTags(turns) {
   for (const t of turns) for (const c of t.tool_calls) tags.add(c.name);
   return [...tags].slice(0, 12);
 }
+function projectIdFromPath(p) {
+  const segs = p.split("/").filter(Boolean);
+  const i = segs.indexOf("projects");
+  if (i >= 0 && segs[i + 1] === "ai" && segs[i + 2]) return `ai/${segs[i + 2]}`;
+  if (i >= 0 && segs[i + 1]) return segs[i + 1];
+  if (segs.includes("docs")) return "docs";
+  return null;
+}
+function deriveProjects(turns) {
+  const set = /* @__PURE__ */ new Set();
+  for (const t of turns) {
+    for (const c of t.tool_calls) {
+      const fp = c.input?.file_path ?? c.input?.path;
+      if (typeof fp === "string") {
+        const id = projectIdFromPath(fp);
+        if (id) set.add(id);
+      }
+    }
+  }
+  return [...set].sort().slice(0, 12);
+}
+var INTENT_PATTERNS = [
+  ["bugfix", /\b(fix|bug|broken|error|crash|regression|failing|stack ?trace)\b/i],
+  ["feature", /\b(add|implement|build|create|feature|support|introduce|new )\b/i],
+  ["refactor", /\b(refactor|clean ?up|simplify|rename|restructure|extract|dedupe)\b/i],
+  ["research", /\b(research|investigate|explore|compare|evaluate|find out|how (do|does|to)|why)\b/i],
+  ["docs", /\b(document|docs|readme|write[ -]?up|notes|comment)\b/i],
+  ["review", /\b(review|audit|critique|check|inspect)\b/i],
+  ["ops", /\b(deploy|release|publish|install|configure|ci\/?cd|pipeline|infra)\b/i]
+];
+function deriveIntent(turns) {
+  const firstUser = turns.find((t) => t.role === "user" && t.text.trim().length > 0);
+  if (!firstUser) return void 0;
+  const text = firstUser.text;
+  for (const [intent, re] of INTENT_PATTERNS) {
+    if (re.test(text)) return intent;
+  }
+  return "other";
+}
 
 // src/insights/provider.ts
 var FakeProvider = class {
@@ -980,10 +1022,13 @@ var FakeProvider = class {
   async label(req) {
     const result = {
       tags: deriveTags(req.turns),
+      projects: deriveProjects(req.turns),
       signals: []
     };
     const topic = guessTopic(req.turns);
     if (topic) result.topic = topic;
+    const intent = deriveIntent(req.turns);
+    if (intent) result.intent = intent;
     const assistantText = req.turns.find((t) => t.role === "assistant")?.text;
     if (assistantText) result.summary = assistantText.slice(0, 160);
     return result;
@@ -992,7 +1037,7 @@ var FakeProvider = class {
 
 // src/insights/llm.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { SIGNAL_KINDS } from "@unpolarize/code-sessions-schema";
+import { INTENTS, SIGNAL_KINDS } from "@unpolarize/code-sessions-schema";
 var MAX_HEAD = 40;
 var MAX_TAIL = 10;
 var MAX_TURN_CHARS = 400;
@@ -1006,8 +1051,8 @@ function buildPrompt(req) {
   }).join("\n");
   return [
     "You label a coding-agent session. Respond with ONLY a JSON object, no prose:",
-    '{"topic": string, "tags": string[], "summary": string, "signals": [{"kind": one of ' + SIGNAL_KINDS.join("|") + ', "severity": "info"|"warn"|"critical", "note": string}]}',
-    "topic: 3-6 words. tags: tools/themes. summary: <=1 sentence. signals: only notable ones.",
+    '{"topic": string, "intent": one of ' + INTENTS.join("|") + ', "tags": string[], "projects": string[], "summary": string, "signals": [{"kind": one of ' + SIGNAL_KINDS.join("|") + ', "severity": "info"|"warn"|"critical", "note": string}]}',
+    "topic: 3-6 words. intent: what the user wanted. tags: tools/themes. projects: repo/dir names touched. summary: <=1 sentence. signals: only notable ones.",
     "",
     "Transcript:",
     transcript
@@ -1017,19 +1062,23 @@ var KIND_SET = new Set(SIGNAL_KINDS);
 function parseLabelJson(out) {
   const start = out.indexOf("{");
   const end = out.lastIndexOf("}");
-  if (start < 0 || end <= start) return { tags: [], signals: [] };
+  if (start < 0 || end <= start) return { tags: [], projects: [], signals: [] };
   let obj;
   try {
     obj = JSON.parse(out.slice(start, end + 1));
   } catch {
-    return { tags: [], signals: [] };
+    return { tags: [], projects: [], signals: [] };
   }
   const result = {
     tags: Array.isArray(obj.tags) ? obj.tags.filter((t) => typeof t === "string") : [],
+    projects: Array.isArray(obj.projects) ? obj.projects.filter((t) => typeof t === "string") : [],
     signals: coerceSignals(obj.signals)
   };
   if (typeof obj.topic === "string") result.topic = obj.topic;
   if (typeof obj.summary === "string") result.summary = obj.summary;
+  if (typeof obj.intent === "string" && INTENTS.includes(obj.intent)) {
+    result.intent = obj.intent;
+  }
   return result;
 }
 function coerceSignals(raw) {
@@ -1130,13 +1179,15 @@ async function labelSession(sessionDir2, identity, provider, opts = {}) {
   const turns = readTurns(sessionDir2);
   if (turns.length === 0) return void 0;
   const heuristicSignals = deriveSignals(turns);
-  let provided = { tags: [], signals: [] };
+  let provided = { tags: [], projects: [], signals: [] };
   try {
     provided = await provider.label({ sessionId: identity.sessionId, host: identity.host, turns });
   } catch {
   }
   const topic = provided.topic ?? guessTopic(turns);
+  const intent = provided.intent ?? deriveIntent(turns);
   const tags = [.../* @__PURE__ */ new Set([...provided.tags, ...deriveTags(turns)])].slice(0, 16);
+  const projects = [.../* @__PURE__ */ new Set([...provided.projects, ...deriveProjects(turns)])].slice(0, 16);
   const signals = dedupeSignals([...heuristicSignals, ...provided.signals]);
   const insights = {
     schema: SCHEMA_VERSIONS2.insights,
@@ -1145,15 +1196,17 @@ async function labelSession(sessionDir2, identity, provider, opts = {}) {
     generated_at: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(),
     provider: provider.name,
     tags,
+    projects,
     signals
   };
   if (topic) insights.topic = topic;
+  if (intent) insights.intent = intent;
   if (provided.summary) insights.summary = provided.summary;
   writeJsonAtomic2(insightsFile(sessionDir2), insights);
-  updateEnvelopeLabels(sessionDir2, topic, tags);
+  updateEnvelopeLabels(sessionDir2, { topic, intent, projects });
   return insights;
 }
-function updateEnvelopeLabels(sessionDir2, topic, tags) {
+function updateEnvelopeLabels(sessionDir2, l) {
   const path = envelopeFile(sessionDir2);
   if (!existsSync7(path)) return;
   let env;
@@ -1162,7 +1215,13 @@ function updateEnvelopeLabels(sessionDir2, topic, tags) {
   } catch {
     return;
   }
-  env.labels = [.../* @__PURE__ */ new Set([...topic ? [topic] : [], ...tags])].slice(0, 16);
+  env.labels = [
+    .../* @__PURE__ */ new Set([
+      ...l.intent ? [`intent:${l.intent}`] : [],
+      ...l.topic ? [l.topic] : [],
+      ...l.projects.map((p) => `project:${p}`)
+    ])
+  ].slice(0, 16);
   writeJsonAtomic2(path, env);
 }
 async function reindexStore(cfg, provider, opts = {}) {
@@ -1703,8 +1762,144 @@ function parseCodexSession(info, host) {
   return { host, sessionId, agent: "codex", turns, meta };
 }
 
+// src/adapters/codebuild.ts
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
+import {
+  SCHEMA_VERSIONS as SCHEMA_VERSIONS5
+} from "@unpolarize/code-sessions-schema";
+function codebuildSessionsRoot() {
+  return join8(homedir4(), ".codebuild", "sessions");
+}
+function discoverCodebuildSessions(root = codebuildSessionsRoot()) {
+  if (!existsSync12(root)) return [];
+  let files;
+  try {
+    files = readdirSync4(root).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  return files.map((f) => ({ sessionId: f.replace(/\.jsonl$/, ""), path: join8(root, f) }));
+}
+function backendToAgent(backend) {
+  if (backend === "claude") return "claude-code";
+  if (backend === "grok") return "grok";
+  if (backend === "codex") return "codex";
+  return "unknown";
+}
+function parseCodebuildSession(info, host) {
+  let raw = "";
+  try {
+    raw = readFileSync10(info.path, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+  const baseMs = statMtime2(info.path);
+  let agent = "unknown";
+  let sessionId = info.sessionId;
+  let title;
+  let cwd;
+  const turns = [];
+  let pending = null;
+  let idx = 0;
+  const flush = () => {
+    if (!pending) return;
+    const p = pending;
+    pending = null;
+    const turn = mkTurn2(sessionId, host, agent, idx++, baseMs, "assistant", p.text, p.tools);
+    turn.usage = {
+      input_tokens: p.input_tokens,
+      output_tokens: p.output_tokens,
+      cache_read_tokens: p.cache_read_tokens,
+      cache_write_tokens: 0
+    };
+    if (p.cost_usd > 0) turn.telemetry = { cost_usd: p.cost_usd };
+    turns.push(turn);
+  };
+  const ensurePending = () => {
+    if (!pending) pending = { text: "", tools: [], input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cost_usd: 0 };
+    return pending;
+  };
+  for (const line of lines) {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (ev.type === "meta" && ev.meta) {
+      agent = backendToAgent(ev.meta.backend);
+      if (typeof ev.meta.id === "string") sessionId = ev.meta.id;
+      if (typeof ev.meta.title === "string") title = ev.meta.title;
+      if (typeof ev.meta.cwd === "string") cwd = ev.meta.cwd;
+      continue;
+    }
+    if (ev.type === "user" && typeof ev.text === "string") {
+      flush();
+      turns.push(mkTurn2(sessionId, host, agent, idx++, baseMs, "user", ev.text, []));
+      continue;
+    }
+    if (ev.type === "update" && ev.update) {
+      const u = ev.update;
+      if (u.kind === "agent_message_chunk") {
+        const t = u.content?.text;
+        if (typeof t === "string") ensurePending().text += t;
+      } else if (u.kind === "tool_call" && u.toolCall) {
+        const p = ensurePending();
+        p.tools.push({ name: String(u.toolCall.title ?? u.toolCall.kind ?? "tool"), input: u.toolCall.rawInput });
+      } else if (u.kind === "usage" && u.usage) {
+        const p = ensurePending();
+        p.input_tokens += Number(u.usage.inputTokens) || 0;
+        p.output_tokens += Number(u.usage.outputTokens) || 0;
+        p.cache_read_tokens += Number(u.usage.cacheReadTokens) || 0;
+      } else if (u.kind === "result" && u.usage) {
+        const p = ensurePending();
+        p.input_tokens += Number(u.usage.inputTokens) || 0;
+        p.output_tokens += Number(u.usage.outputTokens) || 0;
+        p.cost_usd += Number(u.usage.costUsd) || 0;
+        flush();
+      }
+    }
+  }
+  flush();
+  if (turns.length === 0) return null;
+  const meta = {
+    session_id: sessionId,
+    started_at: turns[0].ts,
+    ended_at: turns[turns.length - 1].ts
+  };
+  if (cwd) meta.project_path = cwd;
+  if (title) meta.title = title;
+  return { host, sessionId, agent, turns, meta };
+}
+function statMtime2(p) {
+  try {
+    return statSync2(p).mtimeMs;
+  } catch {
+    return Date.parse("2020-01-01T00:00:00Z");
+  }
+}
+function mkTurn2(sessionId, host, agent, index, baseMs, role, text, tool_calls) {
+  return {
+    schema: SCHEMA_VERSIONS5.turn,
+    session_id: sessionId,
+    host,
+    agent,
+    turn_index: index,
+    ts: new Date(baseMs + index * 1e3).toISOString(),
+    role,
+    text,
+    tool_calls,
+    usage: { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null
+  };
+}
+
 // src/adapters/import.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname5 } from "path";
 var NATIVE_FORMAT = {
   "claude-code": "claude-jsonl",
@@ -1735,9 +1930,9 @@ function writeImportedSession(cfg, s) {
   });
   env.native_ref.format = NATIVE_FORMAT[s.agent] ?? "unknown";
   const envPath = envelopeFile(dir);
-  if (existsSync12(envPath)) {
+  if (existsSync13(envPath)) {
     try {
-      const prev = JSON.parse(readFileSync10(envPath, "utf8"));
+      const prev = JSON.parse(readFileSync11(envPath, "utf8"));
       if (prev.labels?.length) env.labels = prev.labels;
     } catch {
     }
@@ -1752,12 +1947,15 @@ import { createRequire } from "module";
 import { dirname as dirname6 } from "path";
 var nodeRequire = createRequire(import.meta.url);
 var { DatabaseSync } = nodeRequire("node:sqlite");
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 function toMs(iso) {
   if (!iso) return null;
   const v = Date.parse(iso);
   return Number.isNaN(v) ? null : v;
 }
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
 var SessionIndex = class {
   db;
   constructor(path) {
@@ -1768,7 +1966,8 @@ var SessionIndex = class {
   }
   migrate() {
     const row = this.db.prepare("PRAGMA user_version").get();
-    if ((row?.user_version ?? 0) < 1) {
+    const cur = row?.user_version ?? 0;
+    if (cur < 1) {
       this.db.exec(`
         CREATE TABLE IF NOT EXISTS session (
           session_id TEXT PRIMARY KEY,
@@ -1786,6 +1985,8 @@ var SessionIndex = class {
           title TEXT,
           labels_json TEXT NOT NULL DEFAULT '[]',
           topic TEXT,
+          intent TEXT,
+          projects_json TEXT NOT NULL DEFAULT '[]',
           source_path TEXT NOT NULL,
           mtime_ms INTEGER NOT NULL DEFAULT 0,
           size_bytes INTEGER NOT NULL DEFAULT 0,
@@ -1809,13 +2010,23 @@ var SessionIndex = class {
         CREATE TABLE IF NOT EXISTS insight (
           session_id TEXT PRIMARY KEY REFERENCES session(session_id) ON DELETE CASCADE,
           topic TEXT,
+          intent TEXT,
           tags_json TEXT NOT NULL DEFAULT '[]',
+          projects_json TEXT NOT NULL DEFAULT '[]',
           signals_json TEXT NOT NULL DEFAULT '[]',
           provider TEXT,
           generated_at TEXT
         );
       `);
       this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    } else if (cur < 2) {
+      this.db.exec(`
+        ALTER TABLE session ADD COLUMN intent TEXT;
+        ALTER TABLE session ADD COLUMN projects_json TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE insight ADD COLUMN intent TEXT;
+        ALTER TABLE insight ADD COLUMN projects_json TEXT NOT NULL DEFAULT '[]';
+        PRAGMA user_version = ${SCHEMA_VERSION};
+      `);
     }
   }
   /** session_id -> {mtime_ms, size_bytes} for incremental sync invalidation. */
@@ -1829,15 +2040,16 @@ var SessionIndex = class {
     this.db.prepare(
       `INSERT INTO session (session_id, host, agent, project_path, model, started_at, ended_at,
            turn_count, tool_call_count, input_tokens, output_tokens, cost_usd, title, labels_json,
-           topic, source_path, mtime_ms, size_bytes, indexed_at)
-         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+           topic, intent, projects_json, source_path, mtime_ms, size_bytes, indexed_at)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
          ON CONFLICT(session_id) DO UPDATE SET
            host=excluded.host, agent=excluded.agent, project_path=excluded.project_path,
            model=excluded.model, started_at=excluded.started_at, ended_at=excluded.ended_at,
            turn_count=excluded.turn_count, tool_call_count=excluded.tool_call_count,
            input_tokens=excluded.input_tokens, output_tokens=excluded.output_tokens,
            cost_usd=excluded.cost_usd, title=excluded.title, labels_json=excluded.labels_json,
-           topic=excluded.topic, source_path=excluded.source_path, mtime_ms=excluded.mtime_ms,
+           topic=excluded.topic, intent=excluded.intent, projects_json=excluded.projects_json,
+           source_path=excluded.source_path, mtime_ms=excluded.mtime_ms,
            size_bytes=excluded.size_bytes, indexed_at=excluded.indexed_at`
     ).run(
       env.session_id,
@@ -1855,6 +2067,8 @@ var SessionIndex = class {
       env.title ?? null,
       JSON.stringify(env.labels ?? []),
       src.topic ?? null,
+      src.intent ?? null,
+      JSON.stringify(src.projects ?? []),
       src.source_path,
       src.mtime_ms,
       src.size_bytes,
@@ -1884,12 +2098,14 @@ var SessionIndex = class {
   }
   upsertInsight(ins) {
     this.db.prepare(
-      `INSERT OR REPLACE INTO insight (session_id, topic, tags_json, signals_json, provider, generated_at)
-         VALUES (?,?,?,?,?,?)`
+      `INSERT OR REPLACE INTO insight (session_id, topic, intent, tags_json, projects_json, signals_json, provider, generated_at)
+         VALUES (?,?,?,?,?,?,?,?)`
     ).run(
       ins.session_id,
       ins.topic ?? null,
+      ins.intent ?? null,
       JSON.stringify(ins.tags ?? []),
+      JSON.stringify(ins.projects ?? []),
       JSON.stringify(ins.signals ?? []),
       ins.provider,
       ins.generated_at
@@ -1917,6 +2133,8 @@ var SessionIndex = class {
       title: r.title ?? null,
       labels: safeJson(r.labels_json),
       topic: r.topic ?? null,
+      intent: r.intent ?? null,
+      projects: safeJson(r.projects_json),
       source_path: r.source_path
     };
   }
@@ -1939,6 +2157,48 @@ var SessionIndex = class {
     ).all(like, like, limit);
     return rows.map((r) => this.rowToIndex(r));
   }
+  /** Aggregated usage for a Usage panel: totals, by agent, by day, by project, top cost. */
+  usageSummary(opts = {}) {
+    const rows = this.db.prepare(
+      "SELECT session_id, agent, started_at, input_tokens, output_tokens, cost_usd, projects_json, topic, title FROM session"
+    ).all();
+    const totals = { sessions: rows.length, input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+    const byAgent = {};
+    const byDay = {};
+    const byProject = {};
+    const add = (m, key, r) => {
+      const b = m[key] ??= { sessions: 0, input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+      b.sessions++;
+      b.input_tokens += r.input_tokens;
+      b.output_tokens += r.output_tokens;
+      b.cost_usd += r.cost_usd;
+    };
+    for (const r of rows) {
+      totals.input_tokens += r.input_tokens;
+      totals.output_tokens += r.output_tokens;
+      totals.cost_usd += r.cost_usd;
+      add(byAgent, r.agent || "unknown", r);
+      if (r.started_at) add(byDay, new Date(r.started_at).toISOString().slice(0, 10), r);
+      for (const p of safeJson(r.projects_json)) add(byProject, p, r);
+    }
+    totals.cost_usd = round6(totals.cost_usd);
+    for (const m of [byAgent, byDay, byProject]) for (const b of Object.values(m)) b.cost_usd = round6(b.cost_usd);
+    const days = opts.days ?? 30;
+    const recentDays = Object.entries(byDay).sort((a, b) => a[0] < b[0] ? 1 : -1).slice(0, days).map(([day, b]) => ({ day, ...b }));
+    const topByCost = rows.map((r) => ({
+      session_id: r.session_id,
+      agent: r.agent,
+      cost_usd: round6(r.cost_usd),
+      label: r.topic || r.title || r.session_id
+    })).sort((a, b) => b.cost_usd - a.cost_usd).slice(0, opts.topN ?? 10);
+    return {
+      totals,
+      byAgent,
+      byDay: recentDays,
+      byProject,
+      topByCost
+    };
+  }
   stats() {
     const s = this.db.prepare("SELECT COUNT(*) c, COALESCE(SUM(cost_usd),0) cost FROM session").get();
     const t = this.db.prepare("SELECT COUNT(*) c FROM turn").get();
@@ -1962,7 +2222,7 @@ function safeJson(s) {
 }
 
 // src/index_store/sync.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
 import { safeParseInsights, safeParseSession as safeParseSession2 } from "@unpolarize/code-sessions-schema";
 function syncIndex(cfg, opts = {}) {
   const index = opts.index ?? new SessionIndex(cfg.indexPath);
@@ -1976,8 +2236,8 @@ function syncIndex(cfg, opts = {}) {
     let unchanged = 0;
     for (const ref of refs) {
       const envPath = envelopeFile(ref.dir);
-      if (!existsSync13(envPath)) continue;
-      const st = statSync2(envPath);
+      if (!existsSync14(envPath)) continue;
+      const st = statSync3(envPath);
       const mtime_ms = Math.floor(st.mtimeMs);
       const size_bytes = st.size;
       seen.add(ref.sessionId);
@@ -1986,17 +2246,21 @@ function syncIndex(cfg, opts = {}) {
         unchanged++;
         continue;
       }
-      const parsed = safeParseSession2(JSON.parse(readFileSync11(envPath, "utf8")));
+      const parsed = safeParseSession2(JSON.parse(readFileSync12(envPath, "utf8")));
       if (!parsed.success) continue;
       const env = parsed.data;
       let topic;
+      let intent;
+      let projects = [];
       const insPath = insightsFile(ref.dir);
       let insights = void 0;
-      if (existsSync13(insPath)) {
-        const pi = safeParseInsights(JSON.parse(readFileSync11(insPath, "utf8")));
+      if (existsSync14(insPath)) {
+        const pi = safeParseInsights(JSON.parse(readFileSync12(insPath, "utf8")));
         if (pi.success) {
           insights = pi.data;
           topic = pi.data.topic;
+          intent = pi.data.intent;
+          projects = pi.data.projects ?? [];
         }
       }
       index.upsertSession(env, {
@@ -2004,7 +2268,9 @@ function syncIndex(cfg, opts = {}) {
         mtime_ms,
         size_bytes,
         indexed_at: now,
-        ...topic ? { topic } : {}
+        projects,
+        ...topic ? { topic } : {},
+        ...intent ? { intent } : {}
       });
       index.replaceTurns(env.session_id, readTurns(ref.dir));
       if (insights) index.upsertInsight(insights);
@@ -2018,9 +2284,155 @@ function syncIndex(cfg, opts = {}) {
   }
 }
 
+// src/skills/templates.ts
+import { INTENTS as INTENTS2, SIGNAL_KINDS as SIGNAL_KINDS2 } from "@unpolarize/code-sessions-schema";
+function buildLabelSkillBody() {
+  return `You are labeling a coding-agent session for the code-sessions (CS) store.
+
+Read the provided session transcript and emit ONLY a single JSON object \u2014 no prose, no code fence:
+
+\`\`\`json
+{
+  "topic": "3-6 word summary of what the session was about",
+  "intent": "one of: ${INTENTS2.join(" | ")}",
+  "tags": ["short", "themes", "or", "tool", "names"],
+  "projects": ["repo-or-dir-names-touched"],
+  "signals": [
+    { "kind": "one of: ${SIGNAL_KINDS2.join(" | ")}", "severity": "info|warn|critical", "note": "why" }
+  ],
+  "summary": "one sentence"
+}
+\`\`\`
+
+Guidance:
+- **intent** = what the user wanted (a feature, a bug fixed, a refactor, research, docs, ops, a review, a chore).
+- **projects** = the projects/repos the session actually edited (from file paths it wrote to), not everything mentioned.
+- **signals** = only notable ones: stuck loops, error-recovery, unusually high cost, very long sessions, tool-heavy stretches, strong negative/positive affect.
+- Keep it terse and machine-parseable. Output the JSON and nothing else.`;
+}
+function buildClaudeSkill() {
+  return `---
+name: cs-label-session
+description: Label a coding session (topic, intent, tags, projects touched, signals) as JSON for the code-sessions store. Use when asked to classify or summarize a session.
+---
+
+${buildLabelSkillBody()}
+`;
+}
+function buildPromptFile() {
+  return `# cs-label-session
+
+${buildLabelSkillBody()}
+`;
+}
+
+// src/skills/install.ts
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname7, join as join9 } from "path";
+function targetsFor(agent, home) {
+  const out = [];
+  const want = (a) => agent === "all" || agent === a;
+  if (want("claude")) {
+    out.push({
+      agent: "claude",
+      path: join9(home, ".claude", "skills", "cs-label-session", "SKILL.md"),
+      content: buildClaudeSkill()
+    });
+  }
+  if (want("codex")) {
+    out.push({
+      agent: "codex",
+      path: join9(home, ".codex", "prompts", "cs-label-session.md"),
+      content: buildPromptFile()
+    });
+  }
+  if (want("grok")) {
+    out.push({
+      agent: "grok",
+      path: join9(home, ".grok", "prompts", "cs-label-session.md"),
+      content: buildPromptFile()
+    });
+  }
+  return out;
+}
+function installSkills(opts = {}) {
+  const home = opts.home ?? homedir5();
+  const installed = [];
+  for (const t of targetsFor(opts.agent ?? "all", home)) {
+    mkdirSync8(dirname7(t.path), { recursive: true });
+    writeFileSync7(t.path, t.content);
+    installed.push(t.path);
+  }
+  return { installed };
+}
+
+// src/fork.ts
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync9, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname8 } from "path";
+import {
+  safeParseSession as safeParseSession3
+} from "@unpolarize/code-sessions-schema";
+function locateSession(storeDir, sessionId) {
+  const ref = listSessionDirs(storeDir).find((r) => r.sessionId === sessionId);
+  return ref ? { dir: ref.dir } : void 0;
+}
+function loadEnvelope2(dir) {
+  const p = envelopeFile(dir);
+  if (!existsSync15(p)) return void 0;
+  const parsed = safeParseSession3(JSON.parse(readFileSync13(p, "utf8")));
+  return parsed.success ? parsed.data : void 0;
+}
+function writeJsonAtomic4(path, value) {
+  mkdirSync9(dirname8(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync8(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync5(tmp, path);
+}
+function forkSession(cfg, opts) {
+  const located = locateSession(cfg.storeDir, opts.sessionId);
+  if (!located) throw new Error(`session not found in store: ${opts.sessionId}`);
+  const srcEnv = loadEnvelope2(located.dir);
+  const allTurns = readTurns(located.dir);
+  const prefix = allTurns.filter((t) => t.turn_index <= opts.atTurn);
+  if (prefix.length === 0) throw new Error(`no turns at or before index ${opts.atTurn}`);
+  const newId = opts.newSessionId ?? randomUUID();
+  const agent = opts.agent ?? srcEnv?.agent ?? "claude-code";
+  const month = monthOf(srcEnv?.started_at ?? prefix[0]?.ts);
+  const dir = sessionDir(cfg.storeDir, cfg.host, month, newId);
+  const newTurns = prefix.map((t) => ({
+    ...t,
+    session_id: newId,
+    host: cfg.host,
+    agent
+  }));
+  for (const t of newTurns) writeTurnFile(dir, t);
+  const env = computeEnvelope(
+    newTurns,
+    {
+      ...srcEnv?.model ? { model: srcEnv.model } : {},
+      ...srcEnv?.project_path ? { project_path: srcEnv.project_path } : {},
+      ...srcEnv?.title ? { title: `fork: ${srcEnv.title}` } : {}
+    },
+    { session_id: newId, host: cfg.host, agent, native_uuid: newId }
+  );
+  env.forked_from = { session_id: opts.sessionId, turn_index: opts.atTurn };
+  env.native_ref.format = "fork";
+  writeJsonAtomic4(envelopeFile(dir), env);
+  return {
+    newSessionId: newId,
+    sessionDir: dir,
+    turns: newTurns.length,
+    forkedFrom: env.forked_from
+  };
+}
+
 // src/commands.ts
-import { existsSync as existsSync14, writeFileSync as writeFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync16, writeFileSync as writeFileSync9 } from "fs";
+import { join as join10 } from "path";
 function gitStoreFor(cfg) {
   return new GitStore(cfg.storeDir, {
     ...cfg.git.remote ? { remote: cfg.git.remote } : {},
@@ -2030,13 +2442,13 @@ function gitStoreFor(cfg) {
 function listClaudeTranscripts(projectsDir, maxDepth = 3) {
   const out = [];
   const walk = (dir, depth) => {
-    if (depth > maxDepth || !existsSync14(dir)) return;
+    if (depth > maxDepth || !existsSync16(dir)) return;
     for (const e of readEntries(dir)) {
       const name = String(e.name);
       if (e.isFile() && name.endsWith(".jsonl")) {
-        out.push({ sessionId: name.replace(/\.jsonl$/, ""), path: join8(dir, name) });
+        out.push({ sessionId: name.replace(/\.jsonl$/, ""), path: join10(dir, name) });
       } else if (e.isDirectory()) {
-        walk(join8(dir, name), depth + 1);
+        walk(join10(dir, name), depth + 1);
       }
     }
   };
@@ -2046,9 +2458,9 @@ function listClaudeTranscripts(projectsDir, maxDepth = 3) {
 function cmdInit(cfg) {
   const git = gitStoreFor(cfg);
   git.init();
-  const configPath = join8(cfg.storeDir, "config.json");
-  if (!existsSync14(configPath)) {
-    writeFileSync7(
+  const configPath = join10(cfg.storeDir, "config.json");
+  if (!existsSync16(configPath)) {
+    writeFileSync9(
       configPath,
       `${JSON.stringify({ insights: cfg.insights, batch: cfg.batch, hygiene: cfg.hygiene }, null, 2)}
 `
@@ -2061,7 +2473,7 @@ function cmdStatus(cfg) {
   const state = new StateStore(cfg.statePath);
   const sessions = Object.keys(state.all());
   const stored = listSessionDirs(cfg.storeDir);
-  const socketUp = existsSync14(cfg.socketPath);
+  const socketUp = existsSync16(cfg.socketPath);
   const lines = [
     `store:      ${cfg.storeDir}`,
     `host:       ${cfg.host}`,
@@ -2116,6 +2528,20 @@ async function cmdBackfill(cfg, opts = {}) {
     turns += t;
     parts.push(`codex: ${n} sessions / ${t} turns`);
   }
+  if (agent === "codebuild" || agent === "all") {
+    const found = discoverCodebuildSessions();
+    let n = 0;
+    let t = 0;
+    for (const info of found) {
+      const imported = parseCodebuildSession(info, cfg.host);
+      if (!imported) continue;
+      t += writeImportedSession(cfg, imported).turns;
+      n++;
+    }
+    sessions += n;
+    turns += t;
+    parts.push(`codebuild: ${n} sessions / ${t} turns`);
+  }
   const git = gitStoreFor(cfg);
   git.init();
   git.commit(`backfill (${agent}): ${sessions} sessions`);
@@ -2130,7 +2556,7 @@ async function cmdReindex(cfg, opts = {}) {
 }
 function cmdInstallHooks(cfg, opts = {}) {
   const home = cfg.claudeProjectsDir.replace(/\/projects\/?$/, "");
-  const settingsPath = opts.settingsPath ?? join8(home, "settings.json");
+  const settingsPath = opts.settingsPath ?? join10(home, "settings.json");
   const command = opts.command ?? "code-sessions hook";
   const res = installHooks(settingsPath, command);
   return {
@@ -2140,10 +2566,10 @@ function cmdInstallHooks(cfg, opts = {}) {
 }
 function cmdDoctor(cfg) {
   const checks = [
-    ["store dir exists", existsSync14(cfg.storeDir)],
-    ["store is git repo", existsSync14(join8(cfg.storeDir, ".git"))],
-    ["daemon socket present", existsSync14(cfg.socketPath)],
-    ["claude projects dir", existsSync14(cfg.claudeProjectsDir)]
+    ["store dir exists", existsSync16(cfg.storeDir)],
+    ["store is git repo", existsSync16(join10(cfg.storeDir, ".git"))],
+    ["daemon socket present", existsSync16(cfg.socketPath)],
+    ["claude projects dir", existsSync16(cfg.claudeProjectsDir)]
   ];
   const lines = checks.map(([name, ok]) => `${ok ? "\u2713" : "\u2717"} ${name}`);
   const code = checks.every(([, ok]) => ok) ? 0 : 1;
@@ -2159,6 +2585,49 @@ async function cmdExport(cfg, opts = {}) {
     output: `Exported ${res.exported}/${res.total} session(s) to ${cfg.telemetry.endpoint} (${res.failed} failed)`
   };
 }
+function cmdFork(cfg, opts) {
+  if (!opts.sessionId || Number.isNaN(opts.atTurn)) {
+    return { code: 1, output: "usage: code-sessions fork <session-id> --at <turn> [--id <new-id>]" };
+  }
+  try {
+    const res = forkSession(cfg, {
+      sessionId: opts.sessionId,
+      atTurn: opts.atTurn,
+      ...opts.newId ? { newSessionId: opts.newId } : {}
+    });
+    const git = gitStoreFor(cfg);
+    if (git.isRepo()) git.commit(`fork ${opts.sessionId}@${opts.atTurn} -> ${res.newSessionId}`);
+    return {
+      code: 0,
+      output: `Forked ${opts.sessionId} at turn ${opts.atTurn} \u2192 ${res.newSessionId} (${res.turns} turns) at ${res.sessionDir}`
+    };
+  } catch (e) {
+    return { code: 1, output: `fork failed: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+function cmdUsage(cfg, opts = {}) {
+  syncIndex(cfg);
+  const index = new SessionIndex(cfg.indexPath);
+  try {
+    const u = index.usageSummary();
+    if (opts.json) return { code: 0, output: JSON.stringify(u) };
+    const lines = [
+      `# usage \u2014 ${u.totals.sessions} sessions \xB7 ${u.totals.input_tokens.toLocaleString()} in / ${u.totals.output_tokens.toLocaleString()} out \xB7 $${u.totals.cost_usd.toFixed(2)}`,
+      "by agent:",
+      ...Object.entries(u.byAgent).map(([a, b]) => `  ${a.padEnd(12)} ${b.sessions} sess  $${b.cost_usd.toFixed(2)}`),
+      "top sessions by cost:",
+      ...u.topByCost.slice(0, 5).map((t) => `  $${t.cost_usd.toFixed(2).padStart(8)}  ${t.agent.padEnd(12)} ${t.label.slice(0, 50)}`)
+    ];
+    return { code: 0, output: lines.join("\n") };
+  } finally {
+    index.close();
+  }
+}
+function cmdInstallSkills(opts = {}) {
+  const res = installSkills(opts.agent ? { agent: opts.agent } : {});
+  return { code: 0, output: `Installed cs-label-session skill:
+  ${res.installed.join("\n  ")}` };
+}
 function cmdIndex(cfg) {
   const stats = syncIndex(cfg);
   return {
@@ -2171,8 +2640,9 @@ function fmtRow(r) {
   const agent = (r.agent || "?").padEnd(11).slice(0, 11);
   const tok = String(r.input_tokens + r.output_tokens).padStart(8);
   const cost = `$${r.cost_usd.toFixed(2)}`.padStart(8);
-  const title = (r.topic || r.title || r.session_id).slice(0, 48);
-  return `${date}  ${agent}  ${tok}  ${cost}  ${title}`;
+  const intent = (r.intent || "\xB7").padEnd(8).slice(0, 8);
+  const title = (r.topic || r.title || r.session_id).slice(0, 44);
+  return `${date}  ${agent}  ${intent}  ${tok}  ${cost}  ${title}`;
 }
 function cmdQuery(cfg, opts = {}) {
   const index = new SessionIndex(cfg.indexPath);
@@ -2218,9 +2688,9 @@ async function startDaemon(cfg) {
 }
 
 // src/hooks/shim.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 async function handleHookInput(socketPath, rawInput) {
-  if (!existsSync15(socketPath)) return { ok: false, error: "daemon not running" };
+  if (!existsSync17(socketPath)) return { ok: false, error: "daemon not running" };
   let parsed;
   try {
     parsed = JSON.parse(rawInput);
@@ -2276,6 +2746,9 @@ export {
   deriveSignals,
   guessTopic,
   deriveTags,
+  projectIdFromPath,
+  deriveProjects,
+  deriveIntent,
   FakeProvider,
   buildPrompt,
   parseLabelJson,
@@ -2301,9 +2774,17 @@ export {
   codexSessionsRoot,
   discoverCodexSessions,
   parseCodexSession,
+  codebuildSessionsRoot,
+  discoverCodebuildSessions,
+  parseCodebuildSession,
   writeImportedSession,
   SessionIndex,
   syncIndex,
+  buildLabelSkillBody,
+  buildClaudeSkill,
+  buildPromptFile,
+  installSkills,
+  forkSession,
   listClaudeTranscripts,
   cmdInit,
   cmdStatus,
@@ -2312,6 +2793,9 @@ export {
   cmdInstallHooks,
   cmdDoctor,
   cmdExport,
+  cmdFork,
+  cmdUsage,
+  cmdInstallSkills,
   cmdIndex,
   cmdQuery,
   cmdSearch,