@unpolarize/code-sessions 0.1.0 → 0.3.0

package/dist/cli.js

@@ -4,13 +4,16 @@ import {
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
   cmdStatus,
+  cmdUsage,
   envelopeFile,
   handleHookInput,
   insightsFile,
@@ -20,7 +23,7 @@ import {
   parseFlags,
   readStdin,
   startDaemon
-} from "./chunk-ZJG2DWAK.js";
+} from "./chunk-ON3CPW4C.js";
 
 // src/analytics/command.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -231,6 +234,9 @@ async function main(argv) {
         })
       );
       break;
+    case "install-skills":
+      emit(cmdInstallSkills(typeof flags.agent === "string" ? { agent: flags.agent } : {}));
+      break;
     case "backfill":
       emit(
         await cmdBackfill(cfg, {
@@ -251,6 +257,9 @@ async function main(argv) {
     case "index":
       emit(cmdIndex(cfg));
       break;
+    case "usage":
+      emit(cmdUsage(cfg, { json: flags.json === true }));
+      break;
     case "query":
       emit(
         cmdQuery(cfg, {
@@ -264,6 +273,17 @@ async function main(argv) {
       emit(cmdSearch(cfg, { query: q, ...typeof flags.limit === "string" ? { limit: Number(flags.limit) } : {} }));
       break;
     }
+    case "fork": {
+      const sid = argv.slice(1).find((a) => !a.startsWith("--")) ?? "";
+      emit(
+        cmdFork(cfg, {
+          sessionId: sid,
+          atTurn: typeof flags.at === "string" ? Number(flags.at) : NaN,
+          ...typeof flags.id === "string" ? { newId: flags.id } : {}
+        })
+      );
+      break;
+    }
     case "hook": {
       try {
         const input = await readStdin();

package/dist/index.js

@@ -9,25 +9,35 @@ import {
   StateStore,
   THRESHOLDS,
   applyHygiene,
+  buildClaudeSkill,
+  buildLabelSkillBody,
   buildMetricPayload,
   buildPrompt,
+  buildPromptFile,
   buildTracePayload,
   claudeRunner,
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
   cmdStatus,
+  cmdUsage,
+  codebuildSessionsRoot,
   codexSessionsRoot,
   computeEnvelope,
   defaultConfig,
+  deriveIntent,
+  deriveProjects,
   deriveSignals,
   deriveTags,
+  discoverCodebuildSessions,
   discoverCodexSessions,
   discoverGrokSessions,
   envelopeFile,
@@ -35,12 +45,14 @@ import {
   exportSession,
   exportStore,
   findTranscript,
+  forkSession,
   grokRunner,
   grokSessionsRoot,
   guessTopic,
   handleHookInput,
   insightsFile,
   installHooks,
+  installSkills,
   isSessionEndEvent,
   isoNano,
   labelSession,
@@ -52,6 +64,7 @@ import {
   monthOf,
   ollamaRunner,
   overridesFromFlags,
+  parseCodebuildSession,
   parseCodexSession,
   parseFlags,
   parseGrokSession,
@@ -59,6 +72,7 @@ import {
   parseLabelJson,
   postOtlp,
   priceFor,
+  projectIdFromPath,
   rawBlobFile,
   readEntries,
   readNewLines,
@@ -78,7 +92,7 @@ import {
   writeBlobFile,
   writeImportedSession,
   writeTurnFile
-} from "./chunk-ZJG2DWAK.js";
+} from "./chunk-ON3CPW4C.js";
 export {
   CaptureEngine,
   DEFAULT_HOOK_EVENTS,
@@ -90,25 +104,35 @@ export {
   StateStore,
   THRESHOLDS,
   applyHygiene,
+  buildClaudeSkill,
+  buildLabelSkillBody,
   buildMetricPayload,
   buildPrompt,
+  buildPromptFile,
   buildTracePayload,
   claudeRunner,
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
   cmdStatus,
+  cmdUsage,
+  codebuildSessionsRoot,
   codexSessionsRoot,
   computeEnvelope,
   defaultConfig,
+  deriveIntent,
+  deriveProjects,
   deriveSignals,
   deriveTags,
+  discoverCodebuildSessions,
   discoverCodexSessions,
   discoverGrokSessions,
   envelopeFile,
@@ -116,12 +140,14 @@ export {
   exportSession,
   exportStore,
   findTranscript,
+  forkSession,
   grokRunner,
   grokSessionsRoot,
   guessTopic,
   handleHookInput,
   insightsFile,
   installHooks,
+  installSkills,
   isSessionEndEvent,
   isoNano,
   labelSession,
@@ -133,6 +159,7 @@ export {
   monthOf,
   ollamaRunner,
   overridesFromFlags,
+  parseCodebuildSession,
   parseCodexSession,
   parseFlags,
   parseGrokSession,
@@ -140,6 +167,7 @@ export {
   parseLabelJson,
   postOtlp,
   priceFor,
+  projectIdFromPath,
   rawBlobFile,
   readEntries,
   readNewLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unpolarize/code-sessions",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Headless, event-driven cross-agent session capture agent (daemon + CLI)",
   "license": "MIT",
   "type": "module",
@@ -8,14 +8,24 @@
     "code-sessions": "./bin/code-sessions.mjs"
   },
   "main": "./dist/index.js",
-  "files": ["dist", "src", "bin"],
-  "publishConfig": { "access": "public" },
-  "repository": { "type": "git", "url": "git+https://github.com/unpolarize/code-sessions.git", "directory": "packages/agent" },
+  "files": [
+    "dist",
+    "src",
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unpolarize/code-sessions.git",
+    "directory": "packages/agent"
+  },
   "scripts": {
     "build": "tsup src/index.ts src/cli.ts --format esm --clean --out-dir dist"
   },
   "dependencies": {
-    "@unpolarize/code-sessions-schema": "^0.1.0",
+    "@unpolarize/code-sessions-schema": "^0.3.0",
     "zod": "^3.23.8"
   }
 }

package/src/adapters/adapters.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, it } from 'vitest';
 import { sessionDir, turnFile, envelopeFile } from '../store/paths';
 import { makeConfig, withTempDir } from '../test/tmp';
 import { discoverCodexSessions, parseCodexSession } from './codex';
+import { discoverCodebuildSessions, parseCodebuildSession } from './codebuild';
 import { discoverGrokSessions, parseGrokSession } from './grok';
 import { writeImportedSession } from './import';
 
@@ -98,6 +99,41 @@ describe('codex adapter', () => {
   });
 });
 
+function seedCodebuild(root: string): void {
+  mkdirSync(root, { recursive: true });
+  writeFileSync(
+    join(root, 'cb-1.jsonl'),
+    [
+      '{"type":"meta","meta":{"id":"cb-1","backend":"claude","title":"Plan MVP","cwd":"/Users/x/projects/foo"}}',
+      '{"type":"update","update":{"kind":"system_init","backendSessionId":"native-1"}}',
+      '{"type":"user","text":"add a feature"}',
+      '{"type":"update","update":{"kind":"agent_message_chunk","content":{"type":"text","text":"sure, "}}}',
+      '{"type":"update","update":{"kind":"agent_message_chunk","content":{"type":"text","text":"editing"}}}',
+      '{"type":"update","update":{"kind":"tool_call","toolCall":{"toolCallId":"t1","title":"Edit","rawInput":{"file_path":"a.ts"}}}}',
+      '{"type":"update","update":{"kind":"result","stopReason":"success","usage":{"inputTokens":1000,"outputTokens":40,"costUsd":0.25}}}',
+    ].join('\n'),
+  );
+}
+
+describe('codebuild adapter', () => {
+  it('folds CB stream into user/assistant turns with usage', () => {
+    withTempDir((root) => {
+      seedCodebuild(root);
+      const found = discoverCodebuildSessions(root);
+      expect(found).toHaveLength(1);
+      const imported = parseCodebuildSession(found[0]!, 'test-host')!;
+      expect(imported.agent).toBe('claude-code'); // backend=claude -> claude-code
+      expect(imported.sessionId).toBe('cb-1');
+      expect(imported.meta.title).toBe('Plan MVP');
+      expect(imported.turns.map((t) => t.role)).toEqual(['user', 'assistant']);
+      expect(imported.turns[1]!.text).toBe('sure, editing'); // chunks concatenated
+      expect(imported.turns[1]!.tool_calls[0]).toMatchObject({ name: 'Edit' });
+      expect(imported.turns[1]!.usage.input_tokens).toBe(1000);
+      expect(imported.turns[1]!.telemetry?.cost_usd).toBe(0.25);
+    });
+  });
+});
+
 describe('writeImportedSession', () => {
   it('writes per-turn files + envelope for an imported session', () => {
     withTempDir((store) => {

package/src/adapters/codebuild.ts

@@ -0,0 +1,188 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  SCHEMA_VERSIONS,
+  type AgentKind,
+  type ClaudeSessionMeta,
+  type ToolCall,
+  type Turn,
+} from '@unpolarize/code-sessions-schema';
+import type { ImportedSession } from './import';
+
+/**
+ * Code Build VSCode (CB) adapter. CB stores each chat at
+ * ~/.codebuild/sessions/<uuid>.jsonl as a stream of:
+ *   {type:"meta", meta:{id, backend, title, cwd}}
+ *   {type:"user", text}
+ *   {type:"update", update:{kind:"agent_message_chunk", content:{type:"text",text}}}
+ *   {type:"update", update:{kind:"tool_call", toolCall:{title, rawInput}}}
+ *   {type:"update", update:{kind:"usage"|"result", usage:{...}}}
+ * Events carry no per-line timestamp; synthesized from file mtime + ordinal.
+ *
+ * Importing CB sessions into the CS store is how "CB context management uses CS":
+ * every CB turn becomes discoverable in the shared sessions store + index, and a
+ * CB switch/fork can be expressed as a CS forkSession on the persisted session.
+ */
+
+export function codebuildSessionsRoot(): string {
+  return join(homedir(), '.codebuild', 'sessions');
+}
+
+export interface CodebuildSessionInfo {
+  sessionId: string;
+  path: string;
+}
+
+export function discoverCodebuildSessions(root = codebuildSessionsRoot()): CodebuildSessionInfo[] {
+  if (!existsSync(root)) return [];
+  let files: string[];
+  try {
+    files = readdirSync(root).filter((f) => f.endsWith('.jsonl'));
+  } catch {
+    return [];
+  }
+  return files.map((f) => ({ sessionId: f.replace(/\.jsonl$/, ''), path: join(root, f) }));
+}
+
+function backendToAgent(backend: unknown): AgentKind {
+  if (backend === 'claude') return 'claude-code';
+  if (backend === 'grok') return 'grok';
+  if (backend === 'codex') return 'codex';
+  return 'unknown';
+}
+
+interface Pending {
+  text: string;
+  tools: ToolCall[];
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cost_usd: number;
+}
+
+export function parseCodebuildSession(info: CodebuildSessionInfo, host: string): ImportedSession | null {
+  let raw = '';
+  try {
+    raw = readFileSync(info.path, 'utf8');
+  } catch {
+    return null;
+  }
+  const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+  const baseMs = statMtime(info.path);
+
+  let agent: AgentKind = 'unknown';
+  let sessionId = info.sessionId;
+  let title: string | undefined;
+  let cwd: string | undefined;
+
+  const turns: Turn[] = [];
+  let pending: Pending | null = null;
+  let idx = 0;
+
+  const flush = (): void => {
+    if (!pending) return;
+    const p = pending;
+    pending = null;
+    const turn = mkTurn(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 = (): Pending => {
+    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: any;
+    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(mkTurn(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: ClaudeSessionMeta = {
+    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 statMtime(p: string): number {
+  try {
+    return statSync(p).mtimeMs;
+  } catch {
+    return Date.parse('2020-01-01T00:00:00Z');
+  }
+}
+
+function mkTurn(
+  sessionId: string,
+  host: string,
+  agent: AgentKind,
+  index: number,
+  baseMs: number,
+  role: Turn['role'],
+  text: string,
+  tool_calls: ToolCall[],
+): Turn {
+  return {
+    schema: SCHEMA_VERSIONS.turn,
+    session_id: sessionId,
+    host,
+    agent,
+    turn_index: index,
+    ts: new Date(baseMs + index * 1000).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,
+  };
+}

package/src/adapters/index.ts

@@ -1,3 +1,4 @@
 export * from './import';
 export * from './grok';
 export * from './codex';
+export * from './codebuild';

package/src/cli.ts

@@ -4,13 +4,16 @@ import {
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
   cmdStatus,
+  cmdUsage,
   startDaemon,
   type CommandResult,
 } from './commands';
@@ -45,11 +48,14 @@ export async function main(argv: string[]): Promise<void> {
         }),
       );
       break;
+    case 'install-skills':
+      emit(cmdInstallSkills(typeof flags.agent === 'string' ? { agent: flags.agent as 'claude' | 'codex' | 'grok' | 'all' } : {}));
+      break;
     case 'backfill':
       emit(
         await cmdBackfill(cfg, {
           ...(typeof flags.projects === 'string' ? { projectsDir: flags.projects } : {}),
-          ...(typeof flags.agent === 'string' ? { agent: flags.agent as 'claude' | 'grok' | 'codex' | 'all' } : {}),
+          ...(typeof flags.agent === 'string' ? { agent: flags.agent as 'claude' | 'grok' | 'codex' | 'codebuild' | 'all' } : {}),
         }),
       );
       break;
@@ -65,6 +71,9 @@ export async function main(argv: string[]): Promise<void> {
     case 'index':
       emit(cmdIndex(cfg));
       break;
+    case 'usage':
+      emit(cmdUsage(cfg, { json: flags.json === true }));
+      break;
     case 'query':
       emit(
         cmdQuery(cfg, {
@@ -78,6 +87,17 @@ export async function main(argv: string[]): Promise<void> {
       emit(cmdSearch(cfg, { query: q, ...(typeof flags.limit === 'string' ? { limit: Number(flags.limit) } : {}) }));
       break;
     }
+    case 'fork': {
+      const sid = argv.slice(1).find((a) => !a.startsWith('--')) ?? '';
+      emit(
+        cmdFork(cfg, {
+          sessionId: sid,
+          atTurn: typeof flags.at === 'string' ? Number(flags.at) : NaN,
+          ...(typeof flags.id === 'string' ? { newId: flags.id } : {}),
+        }),
+      );
+      break;
+    }
     case 'hook': {
       // Never fail the agent: swallow everything, always exit 0.
       try {

package/src/cliargs.ts

@@ -51,13 +51,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

package/src/commands.ts

@@ -12,9 +12,12 @@ import { installHooks } from './hooks/install';
 import { exportSession, exportStore } from './telemetry/exporter';
 import { discoverGrokSessions, parseGrokSession } from './adapters/grok';
 import { discoverCodexSessions, parseCodexSession } from './adapters/codex';
+import { discoverCodebuildSessions, parseCodebuildSession } from './adapters/codebuild';
 import { writeImportedSession } from './adapters/import';
 import { SessionIndex, type SessionIndexRow } from './index_store/db';
 import { syncIndex } from './index_store/sync';
+import { installSkills, type SkillAgent } from './skills/install';
+import { forkSession } from './fork';
 
 export interface CommandResult {
   code: number;
@@ -80,7 +83,7 @@ export function cmdStatus(cfg: CodeSessionsConfig): CommandResult {
   return { code: 0, output: lines.join('\n') };
 }
 
-export type BackfillAgent = 'claude' | 'grok' | 'codex' | 'all';
+export type BackfillAgent = 'claude' | 'grok' | 'codex' | 'codebuild' | 'all';
 
 export async function cmdBackfill(
   cfg: CodeSessionsConfig,
@@ -132,6 +135,21 @@ export async function cmdBackfill(
     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`);
@@ -192,6 +210,55 @@ export async function cmdExport(
   };
 }
 
+export function cmdFork(
+  cfg: CodeSessionsConfig,
+  opts: { sessionId: string; atTurn: number; newId?: string },
+): CommandResult {
+  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} → ${res.newSessionId} (${res.turns} turns) at ${res.sessionDir}`,
+    };
+  } catch (e) {
+    return { code: 1, output: `fork failed: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+
+/** Aggregated usage from the CS index (totals/byAgent/byDay/byProject/topByCost). */
+export function cmdUsage(cfg: CodeSessionsConfig, opts: { json?: boolean } = {}): CommandResult {
+  syncIndex(cfg); // ensure the index reflects the current store
+  const index = new SessionIndex(cfg.indexPath);
+  try {
+    const u = index.usageSummary();
+    if (opts.json) return { code: 0, output: JSON.stringify(u) };
+    const lines = [
+      `# usage — ${u.totals.sessions} sessions · ${u.totals.input_tokens.toLocaleString()} in / ${u.totals.output_tokens.toLocaleString()} out · $${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();
+  }
+}
+
+export function cmdInstallSkills(opts: { agent?: SkillAgent } = {}): CommandResult {
+  const res = installSkills(opts.agent ? { agent: opts.agent } : {});
+  return { code: 0, output: `Installed cs-label-session skill:\n  ${res.installed.join('\n  ')}` };
+}
+
 export function cmdIndex(cfg: CodeSessionsConfig): CommandResult {
   const stats = syncIndex(cfg);
   return {
@@ -205,8 +272,9 @@ function fmtRow(r: SessionIndexRow): string {
   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 || '·').padEnd(8).slice(0, 8);
+  const title = (r.topic || r.title || r.session_id).slice(0, 44);
+  return `${date}  ${agent}  ${intent}  ${tok}  ${cost}  ${title}`;
 }
 
 export function cmdQuery(