@unpolarize/code-sessions 0.1.0

package/src/analytics/rollup.ts

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from 'node:fs';
+import {
+  safeParseInsights,
+  safeParseSession,
+  type Insights,
+  type SessionEnvelope,
+} from '@unpolarize/code-sessions-schema';
+import { envelopeFile, insightsFile } from '../store/paths';
+import { listSessionDirs, type SessionRef } from '../store/scan';
+
+export interface LoadedSession {
+  ref: SessionRef;
+  envelope?: SessionEnvelope;
+  insights?: Insights;
+}
+
+export function loadSession(ref: SessionRef): LoadedSession {
+  const out: LoadedSession = { ref };
+  const envPath = envelopeFile(ref.dir);
+  if (existsSync(envPath)) {
+    try {
+      const parsed = safeParseSession(JSON.parse(readFileSync(envPath, 'utf8')));
+      if (parsed.success) out.envelope = parsed.data;
+    } catch {
+      /* ignore */
+    }
+  }
+  const insPath = insightsFile(ref.dir);
+  if (existsSync(insPath)) {
+    try {
+      const parsed = safeParseInsights(JSON.parse(readFileSync(insPath, 'utf8')));
+      if (parsed.success) out.insights = parsed.data;
+    } catch {
+      /* ignore */
+    }
+  }
+  return out;
+}
+
+export interface AnalyticsReport {
+  generated_at: string;
+  sessions: number;
+  hosts: Record<string, number>;
+  totals: { input_tokens: number; output_tokens: number; cost_usd: number };
+  byMonth: Record<string, { sessions: number; cost_usd: number }>;
+  topTopics: { topic: string; count: number }[];
+  topTags: { tag: string; count: number }[];
+  signalCounts: Record<string, number>;
+  similar: { tag: string; sessions: string[] }[];
+}
+
+function topN(counts: Map<string, number>, n: number): { count: number; key: string }[] {
+  return [...counts.entries()]
+    .map(([key, count]) => ({ key, count }))
+    .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key))
+    .slice(0, n);
+}
+
+/** Crunch all stored sessions into a single analytics report (the "backend brain", server-free). */
+export function computeReport(storeDir: string, now: string): AnalyticsReport {
+  const refs = listSessionDirs(storeDir);
+  const loaded = refs.map(loadSession);
+
+  const hosts: Record<string, number> = {};
+  const byMonth: Record<string, { sessions: number; cost_usd: number }> = {};
+  const totals = { input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+  const topicCounts = new Map<string, number>();
+  const tagCounts = new Map<string, number>();
+  const tagToSessions = new Map<string, string[]>();
+  const signalCounts: Record<string, number> = {};
+
+  for (const { ref, envelope, insights } of loaded) {
+    hosts[ref.host] = (hosts[ref.host] ?? 0) + 1;
+    const month = (byMonth[ref.month] ??= { sessions: 0, cost_usd: 0 });
+    month.sessions++;
+    if (envelope) {
+      totals.input_tokens += envelope.totals.input_tokens;
+      totals.output_tokens += envelope.totals.output_tokens;
+      totals.cost_usd += envelope.totals.cost_usd;
+      month.cost_usd += envelope.totals.cost_usd;
+    }
+    if (insights) {
+      if (insights.topic) topicCounts.set(insights.topic, (topicCounts.get(insights.topic) ?? 0) + 1);
+      for (const tag of insights.tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+        (tagToSessions.get(tag) ?? tagToSessions.set(tag, []).get(tag)!).push(ref.sessionId);
+      }
+      for (const sig of insights.signals) {
+        signalCounts[sig.kind] = (signalCounts[sig.kind] ?? 0) + 1;
+      }
+    }
+  }
+
+  totals.cost_usd = Math.round(totals.cost_usd * 1e6) / 1e6;
+  for (const m of Object.values(byMonth)) m.cost_usd = Math.round(m.cost_usd * 1e6) / 1e6;
+
+  const similar = [...tagToSessions.entries()]
+    .filter(([, s]) => s.length >= 2)
+    .map(([tag, sessions]) => ({ tag, sessions: [...new Set(sessions)] }))
+    .sort((a, b) => b.sessions.length - a.sessions.length)
+    .slice(0, 10);
+
+  return {
+    generated_at: now,
+    sessions: loaded.length,
+    hosts,
+    totals,
+    byMonth,
+    topTopics: topN(topicCounts, 10).map(({ key, count }) => ({ topic: key, count })),
+    topTags: topN(tagCounts, 15).map(({ key, count }) => ({ tag: key, count })),
+    signalCounts,
+    similar,
+  };
+}

package/src/analytics/site.ts

@@ -0,0 +1,41 @@
+import type { AnalyticsReport } from './rollup';
+
+function esc(s: string): string {
+  return s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]!);
+}
+
+/** Render a minimal, dependency-free static HTML dashboard from the report. */
+export function renderSite(report: AnalyticsReport): string {
+  const rows = (pairs: [string, string | number][]): string =>
+    pairs.map(([k, v]) => `<tr><td>${esc(k)}</td><td>${esc(String(v))}</td></tr>`).join('');
+
+  const topics = report.topTopics.map((t) => `<li>${esc(t.topic)} — ${t.count}</li>`).join('');
+  const tags = report.topTags.map((t) => `<span class="tag">${esc(t.tag)} (${t.count})</span>`).join(' ');
+  const signals = Object.entries(report.signalCounts)
+    .map(([k, v]) => `<li>${esc(k)}: ${v}</li>`)
+    .join('');
+
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>code-sessions — analytics</title>
+<style>
+  body{font:14px/1.5 system-ui,sans-serif;margin:2rem auto;max-width:720px;color:#111}
+  h1{margin-bottom:.2rem} .muted{color:#666}
+  table{border-collapse:collapse;margin:1rem 0} td{padding:.2rem .8rem;border-bottom:1px solid #eee}
+  .tag{display:inline-block;background:#eef;border-radius:4px;padding:.1rem .4rem;margin:.1rem}
+  ul{margin:.3rem 0}
+</style></head><body>
+<h1>code-sessions</h1>
+<div class="muted">analytics · generated ${esc(report.generated_at)}</div>
+<table>${rows([
+    ['Sessions', report.sessions],
+    ['Input tokens', report.totals.input_tokens],
+    ['Output tokens', report.totals.output_tokens],
+    ['Estimated cost (USD)', report.totals.cost_usd.toFixed(2)],
+  ])}</table>
+<h2>Top topics</h2><ul>${topics || '<li class="muted">none</li>'}</ul>
+<h2>Top tags</h2><div>${tags || '<span class="muted">none</span>'}</div>
+<h2>Signals</h2><ul>${signals || '<li class="muted">none</li>'}</ul>
+</body></html>
+`;
+}

package/src/capture.test.ts

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { CaptureEngine } from './capture';
+import { StateStore } from './state';
+import { envelopeFile, sessionDir, turnFile } from './store/paths';
+import { makeConfig, withTempDir } from './test/tmp';
+
+const LINES = [
+  '{"type":"user","sessionId":"sess-1","cwd":"/proj","gitBranch":"main","timestamp":"2026-06-20T08:00:00Z","message":{"role":"user","content":"hi"}}',
+  '{"type":"assistant","timestamp":"2026-06-20T08:00:05Z","message":{"role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"hello"},{"type":"tool_use","id":"t1","name":"Read","input":{"file_path":"a"}}],"usage":{"input_tokens":1000,"output_tokens":20}}}',
+];
+
+function writeTranscript(dir: string, lines: string[]): string {
+  const p = join(dir, 'sess-1.jsonl');
+  writeFileSync(p, lines.map((l) => `${l}\n`).join(''));
+  return p;
+}
+
+describe('CaptureEngine', () => {
+  it('captures turns into immutable per-turn files + envelope', () => {
+    withTempDir((root) => {
+      const store = join(root, 'store');
+      const src = join(root, 'src');
+      mkdirSync(src, { recursive: true });
+      const cfg = makeConfig(store);
+      const engine = new CaptureEngine(cfg, new StateStore(join(store, 'state.json')));
+      const transcript = writeTranscript(src, LINES);
+
+      const res = engine.captureSession('sess-1', transcript);
+      expect(res.newTurns).toBe(2);
+      expect(res.month).toBe('2026-06');
+
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      expect(existsSync(turnFile(dir, 0))).toBe(true);
+      expect(existsSync(turnFile(dir, 1))).toBe(true);
+      expect(existsSync(envelopeFile(dir))).toBe(true);
+      expect(res.envelope!.turn_count).toBe(2);
+      expect(res.envelope!.model).toBe('claude-opus-4-8');
+      expect(res.envelope!.tool_call_count).toBe(1);
+      expect(res.envelope!.totals.cost_usd).toBeGreaterThan(0);
+    });
+  });
+
+  it('is incremental: a second call only captures appended turns', () => {
+    withTempDir((root) => {
+      const store = join(root, 'store');
+      const src = join(root, 'src');
+      mkdirSync(src, { recursive: true });
+      const cfg = makeConfig(store);
+      const state = new StateStore(join(store, 'state.json'));
+      const engine = new CaptureEngine(cfg, state);
+      const transcript = writeTranscript(src, LINES);
+
+      const r1 = engine.captureSession('sess-1', transcript);
+      expect(r1.newTurns).toBe(2);
+
+      // append one more assistant turn
+      writeFileSync(
+        transcript,
+        LINES.map((l) => `${l}\n`).join('') +
+          '{"type":"assistant","timestamp":"2026-06-20T08:01:00Z","message":{"role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"done"}],"usage":{"input_tokens":50,"output_tokens":5}}}\n',
+      );
+
+      const r2 = engine.captureSession('sess-1', transcript);
+      expect(r2.newTurns).toBe(1);
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      expect(existsSync(turnFile(dir, 2))).toBe(true);
+      expect(r2.envelope!.turn_count).toBe(3);
+    });
+  });
+
+  it('is restart-safe: a fresh engine resumes from persisted offset', () => {
+    withTempDir((root) => {
+      const store = join(root, 'store');
+      const src = join(root, 'src');
+      mkdirSync(src, { recursive: true });
+      const cfg = makeConfig(store);
+      const statePath = join(store, 'state.json');
+      const transcript = writeTranscript(src, LINES);
+
+      new CaptureEngine(cfg, new StateStore(statePath)).captureSession('sess-1', transcript);
+      // simulate restart with a brand-new engine + state loaded from disk
+      const r = new CaptureEngine(cfg, new StateStore(statePath)).captureSession('sess-1', transcript);
+      expect(r.newTurns).toBe(0); // nothing new; no duplicate turns
+    });
+  });
+
+  it('scrubs secrets during capture', () => {
+    withTempDir((root) => {
+      const store = join(root, 'store');
+      const src = join(root, 'src');
+      mkdirSync(src, { recursive: true });
+      const cfg = makeConfig(store);
+      const engine = new CaptureEngine(cfg, new StateStore(join(store, 'state.json')));
+      const line =
+        '{"type":"user","sessionId":"sess-2","timestamp":"2026-06-20T08:00:00Z","message":{"role":"user","content":"my key ghp_1234567890abcdefghijklmnopqrstuvwxyzABCD ok"}}';
+      const transcript = writeTranscript(src, [line]);
+      const res = engine.captureSession('sess-2', transcript);
+      expect(res.redactions).toBeGreaterThan(0);
+    });
+  });
+});

package/src/capture.ts

@@ -0,0 +1,121 @@
+import {
+  buildTurn,
+  extractClaudeSessionMeta,
+  normalizeClaudeEvent,
+  type ClaudeSessionMeta,
+  type SessionEnvelope,
+  type Turn,
+} from '@unpolarize/code-sessions-schema';
+import type { CodeSessionsConfig } from './config';
+import { applyHygiene } from './hygiene';
+import { estimateCostUsd } from './pricing';
+import type { StateStore } from './state';
+import { sessionDir } from './store/paths';
+import { rebuildEnvelope, writeBlobFile, writeTurnFile } from './store/writer';
+import { readNewLines } from './tail';
+import { monthOf } from './store/paths';
+
+export interface CaptureResult {
+  sessionId: string;
+  sessionDir: string;
+  month: string;
+  newTurns: number;
+  writtenPaths: string[];
+  redactions: number;
+  envelope?: SessionEnvelope;
+}
+
+/**
+ * The capture engine: given a session id + its native transcript path, consume
+ * newly-appended JSONL, normalize + apply hygiene + cost, write immutable
+ * per-turn files, and rebuild the derived envelope. Restart-safe via StateStore
+ * (byte offset + next turn index persisted).
+ */
+export class CaptureEngine {
+  constructor(
+    private readonly config: CodeSessionsConfig,
+    private readonly state: StateStore,
+  ) {}
+
+  captureSession(sessionId: string, transcriptPath: string): CaptureResult {
+    const st = this.state.ensure(sessionId, transcriptPath);
+    const tail = readNewLines(transcriptPath, st.offset);
+
+    const meta = extractClaudeSessionMeta(tail.records);
+    const month = st.month ?? monthOf(meta.started_at ?? firstTs(tail.records));
+    const dir = sessionDir(this.config.storeDir, this.config.host, month, sessionId);
+
+    const writtenPaths: string[] = [];
+    let nextIndex = st.nextTurnIndex;
+    let redactions = 0;
+
+    for (const rec of tail.records) {
+      const norm = normalizeClaudeEvent(rec);
+      if (!norm) continue;
+      let turn: Turn = buildTurn(norm, {
+        session_id: sessionId,
+        host: this.config.host,
+        agent: this.config.agent,
+        turn_index: nextIndex,
+      });
+      // attach cost telemetry for billable (assistant) turns
+      const cost = estimateCostUsd(turn.usage, meta.model);
+      if (cost > 0) turn = { ...turn, telemetry: { cost_usd: cost } };
+
+      const hy = applyHygiene(turn, this.config.hygiene);
+      redactions += hy.redactions.reduce((a, m) => a + m.count, 0);
+      if (hy.blob) writtenPaths.push(writeBlobFile(dir, hy.blob.sha, hy.blob.content));
+
+      const res = writeTurnFile(dir, hy.turn);
+      if (res.written) {
+        writtenPaths.push(res.path);
+        nextIndex++;
+      }
+    }
+
+    // advance state regardless (offset moves past consumed bytes even if all metadata)
+    this.state.update(sessionId, {
+      transcriptPath,
+      offset: tail.newOffset,
+      nextTurnIndex: nextIndex,
+      month,
+      startedAt: st.startedAt ?? meta.started_at,
+      lastTs: meta.ended_at ?? st.lastTs,
+    });
+
+    const newTurns = nextIndex - st.nextTurnIndex;
+    const result: CaptureResult = {
+      sessionId,
+      sessionDir: dir,
+      month,
+      newTurns,
+      writtenPaths,
+      redactions,
+    };
+    if (newTurns > 0 || writtenPaths.length > 0) {
+      result.envelope = rebuildEnvelope(
+        this.config.storeDir,
+        this.config.host,
+        month,
+        sessionId,
+        meta,
+        {
+          session_id: sessionId,
+          host: this.config.host,
+          agent: this.config.agent,
+          native_uuid: sessionId,
+        },
+      );
+    }
+    return result;
+  }
+}
+
+function firstTs(records: unknown[]): string | undefined {
+  for (const r of records) {
+    if (r && typeof r === 'object' && typeof (r as { timestamp?: unknown }).timestamp === 'string') {
+      return (r as { timestamp: string }).timestamp;
+    }
+  }
+  return undefined;
+}

package/src/cli.ts

@@ -0,0 +1,118 @@
+import { loadConfig } from './config';
+import { HELP, overridesFromFlags, parseFlags } from './cliargs';
+import {
+  cmdBackfill,
+  cmdDoctor,
+  cmdExport,
+  cmdIndex,
+  cmdInit,
+  cmdInstallHooks,
+  cmdQuery,
+  cmdReindex,
+  cmdSearch,
+  cmdStatus,
+  startDaemon,
+  type CommandResult,
+} from './commands';
+import { cmdAnalytics } from './analytics/command';
+import { handleHookInput, readStdin } from './hooks/shim';
+
+function emit(res: CommandResult): never {
+  if (res.output) process.stdout.write(`${res.output}\n`);
+  process.exit(res.code);
+}
+
+export async function main(argv: string[]): Promise<void> {
+  const command = argv[0];
+  const flags = parseFlags(argv.slice(1));
+  const cfg = loadConfig(overridesFromFlags(flags));
+
+  switch (command) {
+    case 'init':
+      emit(cmdInit(cfg));
+      break;
+    case 'status':
+      emit(cmdStatus(cfg));
+      break;
+    case 'doctor':
+      emit(cmdDoctor(cfg));
+      break;
+    case 'install-hooks':
+      emit(
+        cmdInstallHooks(cfg, {
+          ...(typeof flags.settings === 'string' ? { settingsPath: flags.settings } : {}),
+          ...(typeof flags.command === 'string' ? { command: flags.command } : {}),
+        }),
+      );
+      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' } : {}),
+        }),
+      );
+      break;
+    case 'reindex':
+      emit(await cmdReindex(cfg, typeof flags.since === 'string' ? { since: flags.since } : {}));
+      break;
+    case 'analytics':
+      emit(await cmdAnalytics(cfg));
+      break;
+    case 'export':
+      emit(await cmdExport(cfg, typeof flags.since === 'string' ? { since: flags.since } : {}));
+      break;
+    case 'index':
+      emit(cmdIndex(cfg));
+      break;
+    case 'query':
+      emit(
+        cmdQuery(cfg, {
+          ...(typeof flags.limit === 'string' ? { limit: Number(flags.limit) } : {}),
+          ...(typeof flags.agent === 'string' ? { agent: flags.agent } : {}),
+        }),
+      );
+      break;
+    case 'search': {
+      const q = argv.slice(1).find((a) => !a.startsWith('--')) ?? '';
+      emit(cmdSearch(cfg, { query: q, ...(typeof flags.limit === 'string' ? { limit: Number(flags.limit) } : {}) }));
+      break;
+    }
+    case 'hook': {
+      // Never fail the agent: swallow everything, always exit 0.
+      try {
+        const input = await readStdin();
+        await handleHookInput(cfg.socketPath, input);
+      } catch {
+        /* ignore */
+      }
+      process.exit(0);
+      break;
+    }
+    case 'start': {
+      const daemon = await startDaemon(cfg);
+      process.stdout.write(`code-sessions daemon listening on ${cfg.socketPath}\n`);
+      const stop = async (): Promise<void> => {
+        await daemon.stop();
+        process.exit(0);
+      };
+      process.on('SIGINT', stop);
+      process.on('SIGTERM', stop);
+      break; // keep the event loop alive
+    }
+    case 'help':
+    case '--help':
+    case undefined:
+      process.stdout.write(HELP);
+      process.exit(command ? 0 : 1);
+      break;
+    default:
+      process.stderr.write(`Unknown command: ${command}\n\n${HELP}`);
+      process.exit(1);
+  }
+}
+
+main(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}\n`);
+  process.exit(1);
+});

package/src/cliargs.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { overridesFromFlags, parseFlags } from './cliargs';
+
+describe('parseFlags', () => {
+  it('parses --key value, --key=value, and boolean flags', () => {
+    const f = parseFlags(['--store', '/s', '--provider=ollama', '--push', '--since', '2026-06']);
+    expect(f).toEqual({ store: '/s', provider: 'ollama', push: true, since: '2026-06' });
+  });
+});
+
+describe('overridesFromFlags', () => {
+  it('maps flags onto config overrides', () => {
+    const o = overridesFromFlags({
+      store: '/s',
+      host: 'box',
+      remote: 'git@x:y.git',
+      push: true,
+      provider: 'claude',
+      mode: 'on-stop',
+      model: 'opus',
+    });
+    expect(o.storeDir).toBe('/s');
+    expect(o.host).toBe('box');
+    expect(o.git).toEqual({ remote: 'git@x:y.git', autoPush: true });
+    expect(o.insights).toEqual({ provider: 'claude', mode: 'on-stop', model: 'opus' });
+  });
+
+  it('omits unset groups', () => {
+    expect(overridesFromFlags({ store: '/s' })).toEqual({ storeDir: '/s' });
+  });
+});

package/src/cliargs.ts

@@ -0,0 +1,77 @@
+import type { DeepPartial, CodeSessionsConfig, InsightsProvider, InsightsMode } from './config';
+
+export type Flags = Record<string, string | boolean>;
+
+/** Minimal flag parser: --key value, --key=value, and bare --flag booleans. */
+export function parseFlags(args: string[]): Flags {
+  const flags: Flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    if (!a.startsWith('--')) continue;
+    const body = a.slice(2);
+    const eq = body.indexOf('=');
+    if (eq >= 0) {
+      flags[body.slice(0, eq)] = body.slice(eq + 1);
+    } else {
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags[body] = next;
+        i++;
+      } else {
+        flags[body] = true;
+      }
+    }
+  }
+  return flags;
+}
+
+export function overridesFromFlags(flags: Flags): DeepPartial<CodeSessionsConfig> {
+  const o: DeepPartial<CodeSessionsConfig> = {};
+  if (typeof flags.store === 'string') o.storeDir = flags.store;
+  if (typeof flags.host === 'string') o.host = flags.host;
+  if (typeof flags.remote === 'string') o.git = { remote: flags.remote };
+  if (flags.push === true) o.git = { ...(o.git ?? {}), autoPush: true };
+  const insights: DeepPartial<CodeSessionsConfig['insights']> = {};
+  if (typeof flags.provider === 'string') insights.provider = flags.provider as InsightsProvider;
+  if (typeof flags.mode === 'string') insights.mode = flags.mode as InsightsMode;
+  if (typeof flags.model === 'string') insights.model = flags.model;
+  if (Object.keys(insights).length > 0) o.insights = insights;
+  const telemetry: DeepPartial<CodeSessionsConfig['telemetry']> = {};
+  if (typeof flags.endpoint === 'string') telemetry.endpoint = flags.endpoint;
+  if (flags['no-telemetry'] === true || flags['telemetry'] === false) telemetry.enabled = false;
+  if (Object.keys(telemetry).length > 0) o.telemetry = telemetry;
+  return o;
+}
+
+export const HELP = `code-sessions — headless cross-agent session capture
+
+Usage: code-sessions <command> [flags]
+
+Commands:
+  init            Initialize the git-backed store (~/.sessions)
+  start           Run the capture daemon (foreground)
+  install-hooks   Install Claude Code hooks that feed the daemon
+  hook            (internal) forward a hook payload from stdin to the daemon
+  backfill        Import existing transcripts into the store [--agent claude|grok|codex|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]
+  search          Full-text search session turns  <text> [--limit N]
+  analytics       Compute MVP-2 rollups + digest into analytics/
+  status          Show daemon/store status
+  doctor          Environment checks
+
+Flags:
+  --store <dir>        store dir (default ~/.sessions)
+  --host <name>        logical host id
+  --remote <url>       git remote for the store
+  --push               push after commit
+  --provider <p>       insights provider: none|fake|claude|grok|ollama
+  --mode <m>           insights mode: off|on-stop|per-turn
+  --model <m>          provider model
+  --since <YYYY-MM>    reindex/export: only sessions since month
+  --endpoint <url>     OTLP/HTTP collector base (default http://localhost:4318)
+  --no-telemetry       disable OTLP export
+  --settings <path>    install-hooks: target settings.json
+`;