@unpolarize/code-sessions 0.1.0

package/src/commands.test.ts

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { cmdBackfill, cmdDoctor, cmdInit, cmdInstallHooks, cmdReindex, cmdStatus, listClaudeTranscripts } from './commands';
+import { insightsFile, sessionDir } from './store/paths';
+import { makeConfig, withTempDir, withTempDirAsync } from './test/tmp';
+
+const LINES = [
+  '{"type":"user","sessionId":"sess-1","cwd":"/proj","timestamp":"2026-06-20T08:00:00Z","message":{"role":"user","content":"Fix the bug in foo.ts"}}',
+  '{"type":"assistant","timestamp":"2026-06-20T08:00:05Z","message":{"role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"ok"},{"type":"tool_use","id":"t","name":"Edit","input":{}}],"usage":{"input_tokens":100,"output_tokens":10}}}',
+];
+
+function seedProjects(root: string): string {
+  const projects = join(root, 'projects', 'encoded');
+  mkdirSync(projects, { recursive: true });
+  writeFileSync(join(projects, 'sess-1.jsonl'), LINES.map((l) => `${l}\n`).join(''));
+  return join(root, 'projects');
+}
+
+describe('listClaudeTranscripts', () => {
+  it('finds session files recursively', () => {
+    withTempDir((root) => {
+      const projectsDir = seedProjects(root);
+      const found = listClaudeTranscripts(projectsDir);
+      expect(found).toHaveLength(1);
+      expect(found[0]!.sessionId).toBe('sess-1');
+    });
+  });
+});
+
+describe('cmdInit', () => {
+  it('initializes the store repo and config', () => {
+    withTempDir((root) => {
+      const store = join(root, 'store');
+      const res = cmdInit(makeConfig(store));
+      expect(res.code).toBe(0);
+      expect(existsSync(join(store, '.git'))).toBe(true);
+      expect(existsSync(join(store, 'config.json'))).toBe(true);
+    });
+  });
+});
+
+describe('cmdBackfill', () => {
+  it('imports existing transcripts into the store', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const projectsDir = seedProjects(root);
+      const res = await cmdBackfill(makeConfig(store), { projectsDir });
+      expect(res.code).toBe(0);
+      expect(res.output).toMatch(/Backfilled 1 session/);
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      expect(existsSync(dir)).toBe(true);
+    });
+  });
+});
+
+describe('cmdReindex', () => {
+  it('derives insights for backfilled sessions', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const projectsDir = seedProjects(root);
+      const cfg = makeConfig(store, { insights: { provider: 'fake' } });
+      await cmdBackfill(cfg, { projectsDir });
+      const res = await cmdReindex(cfg);
+      expect(res.output).toMatch(/Reindexed 1 session.*provider=fake/);
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      expect(existsSync(insightsFile(dir))).toBe(true);
+    });
+  });
+});
+
+describe('cmdInstallHooks', () => {
+  it('writes hooks into a target settings file', () => {
+    withTempDir((root) => {
+      const settingsPath = join(root, 'settings.json');
+      const res = cmdInstallHooks(makeConfig(join(root, 'store')), { settingsPath });
+      expect(res.code).toBe(0);
+      const written = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      expect(written.hooks.Stop[0].hooks[0].command).toBe('code-sessions hook');
+    });
+  });
+});
+
+describe('cmdStatus / cmdDoctor', () => {
+  it('status reports store + provider config', () => {
+    withTempDir((root) => {
+      const res = cmdStatus(makeConfig(join(root, 'store'), { insights: { provider: 'fake' } }));
+      expect(res.output).toMatch(/insights:\s+fake/);
+    });
+  });
+
+  it('doctor returns non-zero when store is missing', () => {
+    withTempDir((root) => {
+      const res = cmdDoctor(makeConfig(join(root, 'absent')));
+      expect(res.code).toBe(1);
+      expect(res.output).toMatch(/✗ store dir exists/);
+    });
+  });
+});

package/src/commands.ts

@@ -0,0 +1,266 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { CodeSessionsConfig } from './config';
+import { CaptureEngine } from './capture';
+import { Daemon } from './daemon';
+import { FakeProvider } from './insights/provider';
+import { labelSession, makeProvider, reindexStore } from './insights/labeler';
+import { StateStore } from './state';
+import { GitStore } from './store/git';
+import { listSessionDirs, readEntries } from './store/scan';
+import { installHooks } from './hooks/install';
+import { exportSession, exportStore } from './telemetry/exporter';
+import { discoverGrokSessions, parseGrokSession } from './adapters/grok';
+import { discoverCodexSessions, parseCodexSession } from './adapters/codex';
+import { writeImportedSession } from './adapters/import';
+import { SessionIndex, type SessionIndexRow } from './index_store/db';
+import { syncIndex } from './index_store/sync';
+
+export interface CommandResult {
+  code: number;
+  output: string;
+}
+
+function gitStoreFor(cfg: CodeSessionsConfig): GitStore {
+  return new GitStore(cfg.storeDir, {
+    ...(cfg.git.remote ? { remote: cfg.git.remote } : {}),
+    autoPush: cfg.git.autoPush,
+  });
+}
+
+/** Collect every Claude transcript (<sessionId>.jsonl) under a projects dir. */
+export function listClaudeTranscripts(
+  projectsDir: string,
+  maxDepth = 3,
+): { sessionId: string; path: string }[] {
+  const out: { sessionId: string; path: string }[] = [];
+  const walk = (dir: string, depth: number): void => {
+    if (depth > maxDepth || !existsSync(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: join(dir, name) });
+      } else if (e.isDirectory()) {
+        walk(join(dir, name), depth + 1);
+      }
+    }
+  };
+  walk(projectsDir, 0);
+  return out;
+}
+
+export function cmdInit(cfg: CodeSessionsConfig): CommandResult {
+  const git = gitStoreFor(cfg);
+  git.init();
+  const configPath = join(cfg.storeDir, 'config.json');
+  if (!existsSync(configPath)) {
+    writeFileSync(
+      configPath,
+      `${JSON.stringify({ insights: cfg.insights, batch: cfg.batch, hygiene: cfg.hygiene }, null, 2)}\n`,
+    );
+  }
+  git.commit('init store');
+  return { code: 0, output: `Initialized store at ${cfg.storeDir}` };
+}
+
+export function cmdStatus(cfg: CodeSessionsConfig): CommandResult {
+  const state = new StateStore(cfg.statePath);
+  const sessions = Object.keys(state.all());
+  const stored = listSessionDirs(cfg.storeDir);
+  const socketUp = existsSync(cfg.socketPath);
+  const lines = [
+    `store:      ${cfg.storeDir}`,
+    `host:       ${cfg.host}`,
+    `daemon:     ${socketUp ? 'running (socket present)' : 'not running'}`,
+    `tracked:    ${sessions.length} session(s) in state`,
+    `stored:     ${stored.length} session(s) in store`,
+    `insights:   ${cfg.insights.provider} / ${cfg.insights.mode}`,
+    `remote:     ${cfg.git.remote ?? '(none)'}  autoPush=${cfg.git.autoPush}`,
+  ];
+  return { code: 0, output: lines.join('\n') };
+}
+
+export type BackfillAgent = 'claude' | 'grok' | 'codex' | 'all';
+
+export async function cmdBackfill(
+  cfg: CodeSessionsConfig,
+  opts: { projectsDir?: string; agent?: BackfillAgent } = {},
+): Promise<CommandResult> {
+  const agent = opts.agent ?? 'claude';
+  const parts: string[] = [];
+  let sessions = 0;
+  let turns = 0;
+
+  if (agent === 'claude' || agent === 'all') {
+    const projectsDir = opts.projectsDir ?? cfg.claudeProjectsDir;
+    const transcripts = listClaudeTranscripts(projectsDir);
+    const engine = new CaptureEngine(cfg, new StateStore(cfg.statePath));
+    let t = 0;
+    for (const tr of transcripts) t += engine.captureSession(tr.sessionId, tr.path).newTurns;
+    sessions += transcripts.length;
+    turns += t;
+    parts.push(`claude: ${transcripts.length} sessions / ${t} turns`);
+  }
+
+  if (agent === 'grok' || agent === 'all') {
+    const found = discoverGrokSessions();
+    let n = 0;
+    let t = 0;
+    for (const info of found) {
+      const imported = parseGrokSession(info, cfg.host);
+      if (!imported) continue;
+      t += writeImportedSession(cfg, imported).turns;
+      n++;
+    }
+    sessions += n;
+    turns += t;
+    parts.push(`grok: ${n} sessions / ${t} turns`);
+  }
+
+  if (agent === 'codex' || agent === 'all') {
+    const found = discoverCodexSessions();
+    let n = 0;
+    let t = 0;
+    for (const info of found) {
+      const imported = parseCodexSession(info, cfg.host);
+      if (!imported) continue;
+      t += writeImportedSession(cfg, imported).turns;
+      n++;
+    }
+    sessions += n;
+    turns += t;
+    parts.push(`codex: ${n} sessions / ${t} turns`);
+  }
+
+  const git = gitStoreFor(cfg);
+  git.init();
+  git.commit(`backfill (${agent}): ${sessions} sessions`);
+  return { code: 0, output: `Backfilled ${sessions} session(s), ${turns} turn(s) — ${parts.join(', ')}` };
+}
+
+export async function cmdReindex(
+  cfg: CodeSessionsConfig,
+  opts: { since?: string } = {},
+): Promise<CommandResult> {
+  const provider = makeProvider(cfg) ?? new FakeProvider();
+  const res = await reindexStore(cfg, provider, opts.since ? { sinceMonth: opts.since } : {});
+  const git = gitStoreFor(cfg);
+  if (git.isRepo()) git.sync(`insights reindex (${res.count})`);
+  return { code: 0, output: `Reindexed ${res.count} session(s) with provider=${provider.name}` };
+}
+
+export function cmdInstallHooks(
+  cfg: CodeSessionsConfig,
+  opts: { settingsPath?: string; command?: string } = {},
+): CommandResult {
+  const home = cfg.claudeProjectsDir.replace(/\/projects\/?$/, '');
+  const settingsPath = opts.settingsPath ?? join(home, 'settings.json');
+  const command = opts.command ?? 'code-sessions hook';
+  const res = installHooks(settingsPath, command);
+  return {
+    code: 0,
+    output:
+      res.added.length > 0
+        ? `Installed hooks (${res.added.join(', ')}) → ${settingsPath}`
+        : `Hooks already present → ${settingsPath}`,
+  };
+}
+
+export function cmdDoctor(cfg: CodeSessionsConfig): CommandResult {
+  const checks: [string, boolean][] = [
+    ['store dir exists', existsSync(cfg.storeDir)],
+    ['store is git repo', existsSync(join(cfg.storeDir, '.git'))],
+    ['daemon socket present', existsSync(cfg.socketPath)],
+    ['claude projects dir', existsSync(cfg.claudeProjectsDir)],
+  ];
+  const lines = checks.map(([name, ok]) => `${ok ? '✓' : '✗'} ${name}`);
+  const code = checks.every(([, ok]) => ok) ? 0 : 1;
+  return { code, output: lines.join('\n') };
+}
+
+export async function cmdExport(
+  cfg: CodeSessionsConfig,
+  opts: { since?: string } = {},
+): Promise<CommandResult> {
+  if (!cfg.telemetry.enabled) {
+    return { code: 0, output: 'Telemetry export disabled (telemetry.enabled=false)' };
+  }
+  const res = await exportStore(cfg, opts.since ? { sinceMonth: opts.since } : {});
+  return {
+    code: 0,
+    output: `Exported ${res.exported}/${res.total} session(s) to ${cfg.telemetry.endpoint} (${res.failed} failed)`,
+  };
+}
+
+export function cmdIndex(cfg: CodeSessionsConfig): CommandResult {
+  const stats = syncIndex(cfg);
+  return {
+    code: 0,
+    output: `Indexed ${stats.indexed} new/changed, ${stats.unchanged} unchanged, ${stats.removed} removed → ${cfg.indexPath}`,
+  };
+}
+
+function fmtRow(r: SessionIndexRow): string {
+  const date = r.started_at ? new Date(r.started_at).toISOString().slice(0, 16).replace('T', ' ') : '—'.padEnd(16);
+  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}`;
+}
+
+export function cmdQuery(
+  cfg: CodeSessionsConfig,
+  opts: { limit?: number; agent?: string } = {},
+): CommandResult {
+  const index = new SessionIndex(cfg.indexPath);
+  try {
+    const rows = index.listRecent(opts.limit ?? 25, opts.agent);
+    const s = index.stats();
+    const header = `# ${s.sessions} sessions, ${s.turns} turns, $${s.cost_usd.toFixed(2)} — ${Object.entries(s.byAgent).map(([a, n]) => `${a}:${n}`).join(' ')}`;
+    return { code: 0, output: [header, ...rows.map(fmtRow)].join('\n') };
+  } finally {
+    index.close();
+  }
+}
+
+export function cmdSearch(
+  cfg: CodeSessionsConfig,
+  opts: { query: string; limit?: number },
+): CommandResult {
+  if (!opts.query) return { code: 1, output: 'usage: code-sessions search <text> [--limit N]' };
+  const index = new SessionIndex(cfg.indexPath);
+  try {
+    const rows = index.searchTurns(opts.query, opts.limit ?? 25);
+    return {
+      code: 0,
+      output: rows.length ? [`# ${rows.length} match(es) for "${opts.query}"`, ...rows.map(fmtRow)].join('\n') : `No matches for "${opts.query}"`,
+    };
+  } finally {
+    index.close();
+  }
+}
+
+/** Long-running: start the daemon, wire insights + telemetry on session-end. */
+export async function startDaemon(cfg: CodeSessionsConfig): Promise<Daemon> {
+  const provider = makeProvider(cfg);
+  const wantInsights = provider && cfg.insights.mode !== 'off';
+  const wantTelemetry = cfg.telemetry.enabled;
+
+  const deps =
+    wantInsights || wantTelemetry
+      ? {
+          onSessionEnd: async (sessionId: string, sessionDir: string) => {
+            if (wantInsights && provider) {
+              await labelSession(sessionDir, { sessionId, host: cfg.host }, provider);
+            }
+            if (wantTelemetry) {
+              await exportSession(cfg, sessionDir);
+            }
+          },
+        }
+      : {};
+  const daemon = new Daemon(cfg, deps);
+  await daemon.start();
+  return daemon;
+}

package/src/config.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { defaultConfig, resolveConfig } from './config';
+
+describe('config', () => {
+  it('builds sane defaults under a home dir', () => {
+    const c = defaultConfig('/home/x', 'box');
+    expect(c.host).toBe('box');
+    expect(c.storeDir).toBe('/home/x/.sessions');
+    expect(c.runtimeDir).toBe('/home/x/.sessions/.daemon');
+    expect(c.socketPath).toBe('/home/x/.sessions/.daemon/daemon.sock');
+    expect(c.statePath).toBe('/home/x/.sessions/.daemon/state.json');
+    expect(c.claudeProjectsDir).toBe('/home/x/.claude/projects');
+    expect(c.insights.provider).toBe('none');
+  });
+
+  it('deep-merges overrides without dropping sibling keys', () => {
+    const base = defaultConfig('/home/x', 'box');
+    const merged = resolveConfig(base, {
+      host: 'other',
+      batch: { maxTurns: 1 },
+      insights: { provider: 'ollama', model: 'llama3' },
+    });
+    expect(merged.host).toBe('other');
+    expect(merged.batch.maxTurns).toBe(1);
+    expect(merged.batch.maxIntervalMs).toBe(base.batch.maxIntervalMs); // sibling preserved
+    expect(merged.insights.provider).toBe('ollama');
+    expect(merged.insights.mode).toBe('off'); // sibling preserved
+  });
+
+  it('re-derives runtime paths when storeDir is overridden', () => {
+    const merged = resolveConfig(defaultConfig('/home/x', 'box'), { storeDir: '/tmp/store' });
+    expect(merged.runtimeDir).toBe('/tmp/store/.daemon');
+    expect(merged.socketPath).toBe('/tmp/store/.daemon/daemon.sock');
+    expect(merged.statePath).toBe('/tmp/store/.daemon/state.json');
+  });
+});

package/src/config.ts

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+import type { AgentKind } from '@unpolarize/code-sessions-schema';
+
+export type InsightsProvider = 'none' | 'fake' | 'claude' | 'grok' | 'ollama';
+export type InsightsMode = 'off' | 'on-stop' | 'per-turn';
+
+export interface CodeSessionsConfig {
+  /** logical host id; keys store paths so two machines never collide */
+  host: string;
+  agent: AgentKind;
+  /** root of the git-backed store, e.g. ~/.sessions */
+  storeDir: string;
+  /** gitignored dir under storeDir for daemon runtime files (socket, state) */
+  runtimeDir: string;
+  /** unix socket the daemon listens on for hook events */
+  socketPath: string;
+  /** daemon bookkeeping state file */
+  statePath: string;
+  /** SQLite index (projection of the git store) for fast queries */
+  indexPath: string;
+  /** where Claude Code writes its native JSONL transcripts */
+  claudeProjectsDir: string;
+  batch: {
+    /** flush after this many buffered turns */
+    maxTurns: number;
+    /** flush at least this often (ms) */
+    maxIntervalMs: number;
+  };
+  hygiene: {
+    /** externalize a turn's text once it exceeds this many bytes */
+    maxTurnBytes: number;
+    scrubSecrets: boolean;
+  };
+  git: {
+    /** remote URL for the store; when set the daemon pushes after commit */
+    remote?: string;
+    autoCommit: boolean;
+    autoPush: boolean;
+  };
+  insights: {
+    provider: InsightsProvider;
+    mode: InsightsMode;
+    /** model/tag passed to the provider (e.g. ollama model name) */
+    model?: string;
+  };
+  telemetry: {
+    /** export captured sessions as OTLP to a collector */
+    enabled: boolean;
+    /** OTLP/HTTP base URL (paths /v1/traces, /v1/metrics are appended) */
+    endpoint: string;
+    serviceName: string;
+    timeoutMs: number;
+  };
+}
+
+export function defaultConfig(home = homedir(), host = hostname()): CodeSessionsConfig {
+  const storeDir = join(home, '.sessions');
+  const runtimeDir = join(storeDir, '.daemon');
+  return {
+    host,
+    agent: 'claude-code',
+    storeDir,
+    runtimeDir,
+    socketPath: join(runtimeDir, 'daemon.sock'),
+    statePath: join(runtimeDir, 'state.json'),
+    indexPath: join(runtimeDir, 'index.db'),
+    claudeProjectsDir: join(home, '.claude', 'projects'),
+    batch: { maxTurns: 8, maxIntervalMs: 5000 },
+    hygiene: { maxTurnBytes: 64 * 1024, scrubSecrets: true },
+    git: { autoCommit: true, autoPush: false },
+    insights: { provider: 'none', mode: 'off' },
+    telemetry: {
+      enabled: true,
+      endpoint: 'http://localhost:4318',
+      serviceName: 'code-sessions',
+      timeoutMs: 2000,
+    },
+  };
+}
+
+/**
+ * Deep-merge a partial override onto a base config (pure; no IO). Runtime paths
+ * (runtimeDir/socketPath/statePath) are re-derived from storeDir unless the
+ * override sets them explicitly, so changing storeDir keeps them consistent.
+ */
+export function resolveConfig(
+  base: CodeSessionsConfig,
+  override: DeepPartial<CodeSessionsConfig> = {},
+): CodeSessionsConfig {
+  const merged: CodeSessionsConfig = {
+    ...base,
+    ...stripUndefined(override),
+    batch: { ...base.batch, ...stripUndefined(override.batch) },
+    hygiene: { ...base.hygiene, ...stripUndefined(override.hygiene) },
+    git: { ...base.git, ...stripUndefined(override.git) },
+    insights: { ...base.insights, ...stripUndefined(override.insights) },
+    telemetry: { ...base.telemetry, ...stripUndefined(override.telemetry) },
+  };
+  if (override.storeDir && override.runtimeDir === undefined) {
+    merged.runtimeDir = join(merged.storeDir, '.daemon');
+  }
+  if (merged.socketPath === base.socketPath && override.socketPath === undefined) {
+    merged.socketPath = join(merged.runtimeDir, 'daemon.sock');
+  }
+  if (merged.statePath === base.statePath && override.statePath === undefined) {
+    merged.statePath = join(merged.runtimeDir, 'state.json');
+  }
+  if (merged.indexPath === base.indexPath && override.indexPath === undefined) {
+    merged.indexPath = join(merged.runtimeDir, 'index.db');
+  }
+  return merged;
+}
+
+/** Load config from defaults <- ~/.sessions/config.json <- env <- explicit overrides. */
+export function loadConfig(override: DeepPartial<CodeSessionsConfig> = {}): CodeSessionsConfig {
+  let cfg = defaultConfig();
+  const configPath = join(cfg.storeDir, 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const fileCfg = JSON.parse(readFileSync(configPath, 'utf8')) as DeepPartial<CodeSessionsConfig>;
+      cfg = resolveConfig(cfg, fileCfg);
+    } catch {
+      // ignore malformed config; defaults win
+    }
+  }
+  cfg = resolveConfig(cfg, envOverrides());
+  cfg = resolveConfig(cfg, override);
+  return cfg;
+}
+
+function envOverrides(): DeepPartial<CodeSessionsConfig> {
+  const o: DeepPartial<CodeSessionsConfig> = {};
+  const env = process.env;
+  if (env.CODE_SESSIONS_STORE) o.storeDir = env.CODE_SESSIONS_STORE;
+  if (env.CODE_SESSIONS_HOST) o.host = env.CODE_SESSIONS_HOST;
+  if (env.CODE_SESSIONS_REMOTE) o.git = { remote: env.CODE_SESSIONS_REMOTE };
+  if (env.CODE_SESSIONS_INSIGHTS_PROVIDER)
+    o.insights = { provider: env.CODE_SESSIONS_INSIGHTS_PROVIDER as InsightsProvider };
+  if (env.OTEL_EXPORTER_OTLP_ENDPOINT) o.telemetry = { endpoint: env.OTEL_EXPORTER_OTLP_ENDPOINT };
+  if (env.CODE_SESSIONS_TELEMETRY === '0' || env.CODE_SESSIONS_TELEMETRY === 'false')
+    o.telemetry = { ...(o.telemetry ?? {}), enabled: false };
+  return o;
+}
+
+function stripUndefined<T extends object>(obj: T | undefined): Partial<T> {
+  if (!obj) return {};
+  const out: Partial<T> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined) (out as Record<string, unknown>)[k] = v;
+  }
+  return out;
+}
+
+export type DeepPartial<T> = {
+  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};

package/src/daemon.test.ts

@@ -0,0 +1,130 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { Daemon, findTranscript } from './daemon';
+import { sendEvent } from './ipc';
+import { 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"}],"usage":{"input_tokens":1000,"output_tokens":20}}}',
+];
+
+function writeTranscript(dir: string): string {
+  mkdirSync(dir, { recursive: true });
+  const p = join(dir, 'sess-1.jsonl');
+  writeFileSync(p, LINES.map((l) => `${l}\n`).join(''));
+  return p;
+}
+
+function gitLogCount(repo: string): number {
+  const r = spawnSync('git', ['-C', repo, 'log', '--oneline'], { encoding: 'utf8' });
+  if (r.status !== 0) return 0;
+  return r.stdout.trim().split('\n').filter(Boolean).length;
+}
+
+describe('findTranscript', () => {
+  it('locates a session file by id under the projects dir', () => {
+    withTempDir((root) => {
+      const proj = join(root, 'projects', 'encoded-proj');
+      mkdirSync(proj, { recursive: true });
+      writeFileSync(join(proj, 'abc-123.jsonl'), '{}');
+      expect(findTranscript(join(root, 'projects'), 'abc-123')).toBe(join(proj, 'abc-123.jsonl'));
+      expect(findTranscript(join(root, 'projects'), 'missing')).toBeUndefined();
+    });
+  });
+});
+
+describe('Daemon', () => {
+  it('captures via handleEvent and commits on flush', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const transcript = writeTranscript(join(root, 'src'));
+      const d = new Daemon(makeConfig(store, { batch: { maxTurns: 1 } }));
+      await d.start();
+      const ack = await d.handleEvent({
+        event: 'PostToolUse',
+        session_id: 'sess-1',
+        transcript_path: transcript,
+      });
+      expect(ack.ok).toBe(true);
+      expect(ack.newTurns).toBe(2);
+      expect(ack.flushed).toBe(true); // maxTurns=1 forces a flush
+      await d.stop();
+
+      const dir = sessionDir(store, 'test-host', '2026-06', 'sess-1');
+      expect(existsSync(turnFile(dir, 0))).toBe(true);
+      expect(gitLogCount(store)).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  it('accepts events over the unix socket', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const transcript = writeTranscript(join(root, 'src'));
+      const socketPath = join(root, 'd.sock');
+      const d = new Daemon(makeConfig(store, { socketPath, batch: { maxTurns: 1 } }));
+      await d.start();
+      try {
+        const ack = await sendEvent(socketPath, {
+          event: 'PostToolUse',
+          session_id: 'sess-1',
+          transcript_path: transcript,
+        });
+        expect(ack.ok).toBe(true);
+        expect(ack.newTurns).toBe(2);
+      } finally {
+        await d.stop();
+      }
+    });
+  });
+
+  it('reports an error when the transcript cannot be found', async () => {
+    await withTempDirAsync(async (root) => {
+      const d = new Daemon(makeConfig(join(root, 'store')));
+      await d.start();
+      try {
+        const ack = await d.handleEvent({
+          event: 'PostToolUse',
+          session_id: 'nope',
+          transcript_path: '/does/not/exist.jsonl',
+        });
+        expect(ack.ok).toBe(false);
+        expect(ack.error).toMatch(/not found/);
+      } finally {
+        await d.stop();
+      }
+    });
+  });
+
+  it('invokes the onSessionEnd hook on Stop', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const transcript = writeTranscript(join(root, 'src'));
+      const onSessionEnd = vi.fn();
+      const d = new Daemon(makeConfig(store), { onSessionEnd });
+      await d.start();
+      await d.handleEvent({ event: 'Stop', session_id: 'sess-1', transcript_path: transcript });
+      await d.stop();
+      expect(onSessionEnd).toHaveBeenCalledOnce();
+      expect(onSessionEnd).toHaveBeenCalledWith(
+        'sess-1',
+        sessionDir(store, 'test-host', '2026-06', 'sess-1'),
+      );
+    });
+  });
+});
+
+// async temp-dir helper (mirror of withTempDir but awaits fn)
+async function withTempDirAsync<T>(fn: (dir: string) => Promise<T>): Promise<T> {
+  const { mkdtempSync, rmSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const dir = mkdtempSync(join(tmpdir(), 'cs-d-'));
+  try {
+    return await fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}