@unpolarize/code-sessions 0.1.0

package/dist/chunk-ZJG2DWAK.js

@@ -0,0 +1,2321 @@
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir, hostname } from "os";
+import { join } from "path";
+function defaultConfig(home = homedir(), host = hostname()) {
+  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: 5e3 },
+    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: 2e3
+    }
+  };
+}
+function resolveConfig(base, override = {}) {
+  const merged = {
+    ...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 === void 0) {
+    merged.runtimeDir = join(merged.storeDir, ".daemon");
+  }
+  if (merged.socketPath === base.socketPath && override.socketPath === void 0) {
+    merged.socketPath = join(merged.runtimeDir, "daemon.sock");
+  }
+  if (merged.statePath === base.statePath && override.statePath === void 0) {
+    merged.statePath = join(merged.runtimeDir, "state.json");
+  }
+  if (merged.indexPath === base.indexPath && override.indexPath === void 0) {
+    merged.indexPath = join(merged.runtimeDir, "index.db");
+  }
+  return merged;
+}
+function loadConfig(override = {}) {
+  let cfg = defaultConfig();
+  const configPath = join(cfg.storeDir, "config.json");
+  if (existsSync(configPath)) {
+    try {
+      const fileCfg = JSON.parse(readFileSync(configPath, "utf8"));
+      cfg = resolveConfig(cfg, fileCfg);
+    } catch {
+    }
+  }
+  cfg = resolveConfig(cfg, envOverrides());
+  cfg = resolveConfig(cfg, override);
+  return cfg;
+}
+function envOverrides() {
+  const o = {};
+  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 };
+  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(obj) {
+  if (!obj) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
+// src/cliargs.ts
+function parseFlags(args) {
+  const 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 !== void 0 && !next.startsWith("--")) {
+        flags[body] = next;
+        i++;
+      } else {
+        flags[body] = true;
+      }
+    }
+  }
+  return flags;
+}
+function overridesFromFlags(flags) {
+  const o = {};
+  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 = {};
+  if (typeof flags.provider === "string") insights.provider = flags.provider;
+  if (typeof flags.mode === "string") insights.mode = flags.mode;
+  if (typeof flags.model === "string") insights.model = flags.model;
+  if (Object.keys(insights).length > 0) o.insights = insights;
+  const 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;
+}
+var HELP = `code-sessions \u2014 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
+`;
+
+// src/hygiene.ts
+import { createHash } from "crypto";
+var PATTERNS = [
+  { kind: "aws-access-key", re: /\bAKIA[0-9A-Z]{16}\b/g },
+  { kind: "github-token", re: /\bgh[posru]_[A-Za-z0-9]{36,255}\b/g },
+  { kind: "openai-key", re: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g },
+  { kind: "anthropic-key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+  { kind: "slack-token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g },
+  { kind: "google-api-key", re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+  { kind: "private-key-block", re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g },
+  { kind: "bearer-token", re: /\bBearer\s+[A-Za-z0-9._-]{20,}\b/g },
+  { kind: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g }
+];
+function scrubSecrets(text) {
+  let out = text;
+  const matches = [];
+  for (const { kind, re } of PATTERNS) {
+    let count = 0;
+    out = out.replace(re, () => {
+      count++;
+      return `[REDACTED:${kind}]`;
+    });
+    if (count > 0) matches.push({ kind, count });
+  }
+  return { text: out, matches };
+}
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+var PREVIEW_CHARS = 280;
+function applyHygiene(turn, opts) {
+  let text = turn.text;
+  let scrubbed = turn.scrubbed;
+  let raw = turn.raw;
+  const redactions = [];
+  if (opts.scrubSecrets) {
+    const res = scrubSecrets(text);
+    if (res.matches.length > 0) {
+      text = res.text;
+      scrubbed = true;
+      raw = void 0;
+      redactions.push(...res.matches);
+    }
+  }
+  let blob;
+  let rawRef = turn.raw_ref;
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes > opts.maxTurnBytes) {
+    const sha = sha256(text);
+    blob = { sha, content: text };
+    rawRef = sha;
+    raw = void 0;
+    const preview = text.slice(0, PREVIEW_CHARS);
+    text = `${preview}
+\u2026[externalized ${bytes}B \u2192 raw/${sha}]`;
+  }
+  const next = {
+    ...turn,
+    text,
+    scrubbed,
+    raw_ref: rawRef,
+    ...raw === void 0 ? { raw: void 0 } : { raw }
+  };
+  return { turn: next, ...blob ? { blob } : {}, redactions };
+}
+
+// src/pricing.ts
+var PRICES = {
+  "claude-opus-4-8": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 }
+};
+var DEFAULT_PRICE = PRICES["claude-sonnet"];
+function priceFor(model) {
+  if (!model) return DEFAULT_PRICE;
+  const lower = model.toLowerCase();
+  for (const key of Object.keys(PRICES)) {
+    if (lower.includes(key)) return PRICES[key];
+  }
+  if (lower.includes("opus")) return PRICES["claude-opus"];
+  if (lower.includes("sonnet")) return PRICES["claude-sonnet"];
+  if (lower.includes("haiku")) return PRICES["claude-haiku"];
+  return DEFAULT_PRICE;
+}
+function estimateCostUsd(usage, model) {
+  const p = priceFor(model);
+  const dollars = (usage.input_tokens * p.input + usage.output_tokens * p.output + usage.cache_read_tokens * p.cacheRead + usage.cache_write_tokens * p.cacheWrite) / 1e6;
+  return Math.round(dollars * 1e6) / 1e6;
+}
+
+// src/store/paths.ts
+import { join as join2 } from "path";
+function monthOf(ts) {
+  if (ts) {
+    const m = /^(\d{4})-(\d{2})/.exec(ts);
+    if (m) return `${m[1]}-${m[2]}`;
+  }
+  return "unknown";
+}
+function sessionDir(storeDir, host, month, sessionId) {
+  return join2(storeDir, "hosts", host, month, sessionId);
+}
+function turnFile(dir, index) {
+  return join2(dir, "turns", `${String(index).padStart(6, "0")}.json`);
+}
+function envelopeFile(dir) {
+  return join2(dir, "session.json");
+}
+function insightsFile(dir) {
+  return join2(dir, "insights", "labels.json");
+}
+function telemetryFile(dir) {
+  return join2(dir, "telemetry", "otel.jsonl");
+}
+function rawBlobFile(dir, sha) {
+  return join2(dir, "raw", sha);
+}
+
+// src/store/writer.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import {
+  SCHEMA_VERSIONS
+} from "@unpolarize/code-sessions-schema";
+function ensureDir(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+function writeJsonAtomic(filePath, value) {
+  ensureDir(filePath);
+  const tmp = `${filePath}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync(tmp, filePath);
+}
+function writeTurnFile(dir, turn) {
+  const path = turnFile(dir, turn.turn_index);
+  if (existsSync2(path)) return { path, written: false };
+  ensureDir(path);
+  writeFileSync(path, `${JSON.stringify(turn, null, 2)}
+`);
+  return { path, written: true };
+}
+function writeBlobFile(dir, sha, content) {
+  const path = rawBlobFile(dir, sha);
+  if (!existsSync2(path)) {
+    ensureDir(path);
+    writeFileSync(path, content);
+  }
+  return path;
+}
+function readTurns(dir) {
+  const turnsDir = `${dir}/turns`;
+  if (!existsSync2(turnsDir)) return [];
+  return readdirSync(turnsDir).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp")).sort().map((f) => JSON.parse(readFileSync2(`${turnsDir}/${f}`, "utf8")));
+}
+function computeEnvelope(turns, meta, identity, existing) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cost = 0;
+  let toolCalls = 0;
+  for (const t of turns) {
+    inputTokens += t.usage.input_tokens;
+    outputTokens += t.usage.output_tokens;
+    toolCalls += t.tool_calls.length;
+    cost += t.telemetry?.cost_usd ?? 0;
+  }
+  const first = turns[0];
+  const last = turns[turns.length - 1];
+  const env = {
+    schema: SCHEMA_VERSIONS.session,
+    session_id: identity.session_id,
+    host: identity.host,
+    agent: identity.agent,
+    project_path: meta.project_path ?? existing?.project_path ?? "",
+    turn_count: turns.length,
+    tool_call_count: toolCalls,
+    totals: {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cost_usd: Math.round(cost * 1e6) / 1e6
+    },
+    labels: existing?.labels ?? [],
+    native_ref: { format: "claude-jsonl", uuid: identity.native_uuid }
+  };
+  const branch = meta.git_branch ?? existing?.git_branch;
+  if (branch) env.git_branch = branch;
+  const model = meta.model ?? existing?.model;
+  if (model) env.model = model;
+  const startedAt = meta.started_at ?? first?.ts ?? existing?.started_at;
+  if (startedAt) env.started_at = startedAt;
+  const endedAt = meta.ended_at ?? last?.ts ?? existing?.ended_at;
+  if (endedAt) env.ended_at = endedAt;
+  const title = meta.title ?? existing?.title;
+  if (title) env.title = title;
+  return env;
+}
+function rebuildEnvelope(storeDir, host, month, sessionId, meta, identity) {
+  const dir = sessionDir(storeDir, host, month, sessionId);
+  const turns = readTurns(dir);
+  const envPath = envelopeFile(dir);
+  let existing;
+  if (existsSync2(envPath)) {
+    try {
+      existing = JSON.parse(readFileSync2(envPath, "utf8"));
+    } catch {
+    }
+  }
+  const env = computeEnvelope(turns, meta, identity, existing);
+  writeJsonAtomic(envPath, env);
+  return env;
+}
+
+// src/tail.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+function readNewLines(filePath, fromOffset) {
+  const empty = { records: [], rawLines: [], newOffset: fromOffset, parseErrors: 0 };
+  if (!existsSync3(filePath)) return empty;
+  const buf = readFileSync3(filePath);
+  if (fromOffset >= buf.length) return { ...empty, newOffset: buf.length };
+  const slice = buf.subarray(fromOffset);
+  const lastNewline = slice.lastIndexOf(10);
+  if (lastNewline < 0) return empty;
+  const complete = slice.subarray(0, lastNewline + 1).toString("utf8");
+  const consumedBytes = Buffer.byteLength(complete, "utf8");
+  const records = [];
+  const rawLines = [];
+  let parseErrors = 0;
+  for (const line of complete.split("\n")) {
+    if (line.trim().length === 0) continue;
+    rawLines.push(line);
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      parseErrors++;
+    }
+  }
+  return { records, rawLines, newOffset: fromOffset + consumedBytes, parseErrors };
+}
+
+// src/capture.ts
+import {
+  buildTurn,
+  extractClaudeSessionMeta,
+  normalizeClaudeEvent
+} from "@unpolarize/code-sessions-schema";
+var CaptureEngine = class {
+  constructor(config, state) {
+    this.config = config;
+    this.state = state;
+  }
+  config;
+  state;
+  captureSession(sessionId, transcriptPath) {
+    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 = [];
+    let nextIndex = st.nextTurnIndex;
+    let redactions = 0;
+    for (const rec of tail.records) {
+      const norm = normalizeClaudeEvent(rec);
+      if (!norm) continue;
+      let turn = buildTurn(norm, {
+        session_id: sessionId,
+        host: this.config.host,
+        agent: this.config.agent,
+        turn_index: nextIndex
+      });
+      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++;
+      }
+    }
+    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 = {
+      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) {
+  for (const r of records) {
+    if (r && typeof r === "object" && typeof r.timestamp === "string") {
+      return r.timestamp;
+    }
+  }
+  return void 0;
+}
+
+// src/ipc.ts
+import { connect } from "net";
+var LIFECYCLE_END = /* @__PURE__ */ new Set(["Stop", "SubagentStop", "SessionEnd"]);
+function isSessionEndEvent(event) {
+  return LIFECYCLE_END.has(event);
+}
+function parseHookEvent(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const event = r.event ?? r.hook_event_name ?? r.hookEventName;
+  const session_id = r.session_id ?? r.sessionId;
+  if (!event || !session_id) return null;
+  const out = { event, session_id };
+  const tp = r.transcript_path ?? r.transcriptPath;
+  if (typeof tp === "string") out.transcript_path = tp;
+  if (typeof r.cwd === "string") out.cwd = r.cwd;
+  return out;
+}
+function sendEvent(socketPath, event, timeoutMs = 4e3) {
+  return new Promise((resolve) => {
+    const sock = connect(socketPath);
+    let buf = "";
+    let settled = false;
+    const done = (ack) => {
+      if (settled) return;
+      settled = true;
+      sock.destroy();
+      resolve(ack);
+    };
+    sock.setTimeout(timeoutMs);
+    sock.on("connect", () => sock.write(`${JSON.stringify(event)}
+`));
+    sock.on("data", (d) => {
+      buf += d.toString("utf8");
+      const nl = buf.indexOf("\n");
+      if (nl >= 0) {
+        try {
+          done(JSON.parse(buf.slice(0, nl)));
+        } catch {
+          done({ ok: false, error: "bad ack" });
+        }
+      }
+    });
+    sock.on("timeout", () => done({ ok: false, error: "timeout" }));
+    sock.on("error", (e) => done({ ok: false, error: e.message }));
+  });
+}
+
+// src/state.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var StateStore = class {
+  constructor(path) {
+    this.path = path;
+    this.data = this.read();
+  }
+  path;
+  data;
+  read() {
+    if (existsSync4(this.path)) {
+      try {
+        const parsed = JSON.parse(readFileSync4(this.path, "utf8"));
+        if (parsed && parsed.version === 1 && parsed.sessions) return parsed;
+      } catch {
+      }
+    }
+    return { version: 1, sessions: {} };
+  }
+  /** Atomic write: tmp file + rename. */
+  flush() {
+    mkdirSync2(dirname2(this.path), { recursive: true });
+    const tmp = `${this.path}.tmp`;
+    writeFileSync2(tmp, JSON.stringify(this.data, null, 2));
+    renameSync2(tmp, this.path);
+  }
+  get(sessionId) {
+    return this.data.sessions[sessionId];
+  }
+  /** Get existing state or initialize a fresh one for this transcript. */
+  ensure(sessionId, transcriptPath) {
+    let s = this.data.sessions[sessionId];
+    if (!s) {
+      s = { transcriptPath, offset: 0, nextTurnIndex: 0 };
+      this.data.sessions[sessionId] = s;
+      this.flush();
+    } else if (transcriptPath && s.transcriptPath !== transcriptPath) {
+      s.transcriptPath = transcriptPath;
+      this.flush();
+    }
+    return s;
+  }
+  update(sessionId, patch) {
+    const s = this.data.sessions[sessionId] ?? {
+      transcriptPath: "",
+      offset: 0,
+      nextTurnIndex: 0
+    };
+    const next = { ...s, ...patch };
+    this.data.sessions[sessionId] = next;
+    this.flush();
+    return next;
+  }
+  all() {
+    return this.data.sessions;
+  }
+};
+
+// src/store/git.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+var FALLBACK_IDENTITY = ["-c", "user.name=code-sessions", "-c", "user.email=agent@code-sessions"];
+var GITIGNORE = `# code-sessions store \u2014 runtime + local-only artifacts
+.daemon/
+*.tmp
+# large externalized blobs stay local in MVP-1 (LFS/object-store in MVP-2)
+raw/
+`;
+var GITATTRIBUTES = `# append-only manifests merge by union so concurrent appends both survive
+*.jsonl merge=union
+telemetry/*.jsonl merge=union
+`;
+var GitStore = class {
+  constructor(dir, opts = {}) {
+    this.dir = dir;
+    this.opts = opts;
+  }
+  dir;
+  opts;
+  run(args, extraEnv) {
+    const res = spawnSync("git", ["-C", this.dir, ...args], {
+      encoding: "utf8",
+      env: { ...process.env, ...extraEnv }
+    });
+    return {
+      ok: res.status === 0,
+      stdout: (res.stdout ?? "").trim(),
+      stderr: (res.stderr ?? "").trim(),
+      code: res.status ?? -1
+    };
+  }
+  isRepo() {
+    return existsSync5(join3(this.dir, ".git"));
+  }
+  /** Initialize the store repo (idempotent): git init, scaffolding files, remote. */
+  init() {
+    if (!this.isRepo()) {
+      const r = spawnSync("git", ["init", "-b", "main", this.dir], { encoding: "utf8" });
+      if (r.status !== 0) throw new Error(`git init failed: ${r.stderr}`);
+    }
+    const giPath = join3(this.dir, ".gitignore");
+    if (!existsSync5(giPath)) writeFileSync3(giPath, GITIGNORE);
+    const gaPath = join3(this.dir, ".gitattributes");
+    if (!existsSync5(gaPath)) writeFileSync3(gaPath, GITATTRIBUTES);
+    if (this.opts.remote) this.ensureRemote(this.opts.remote);
+  }
+  ensureRemote(remote) {
+    const existing = this.run(["remote", "get-url", "origin"]);
+    if (existing.ok) {
+      if (existing.stdout !== remote) this.run(["remote", "set-url", "origin", remote]);
+    } else {
+      this.run(["remote", "add", "origin", remote]);
+    }
+  }
+  hasChanges() {
+    const r = this.run(["status", "--porcelain"]);
+    return r.stdout.length > 0;
+  }
+  /** Stage everything and commit. Returns committed:false when the tree is clean. */
+  commit(message) {
+    this.run(["add", "-A"]);
+    if (!this.hasChanges() && !this.hasStaged()) {
+      return { committed: false, reason: "nothing to commit" };
+    }
+    let r = this.run(["commit", "-m", message]);
+    if (!r.ok && /Please tell me who you are|user\.email|empty ident/i.test(r.stderr)) {
+      r = this.run([...FALLBACK_IDENTITY, "commit", "-m", message]);
+    }
+    if (!r.ok) {
+      if (/nothing to commit/i.test(r.stdout + r.stderr)) {
+        return { committed: false, reason: "nothing to commit" };
+      }
+      return { committed: false, reason: r.stderr || r.stdout };
+    }
+    const sha = this.run(["rev-parse", "HEAD"]).stdout;
+    return { committed: true, sha };
+  }
+  hasStaged() {
+    const r = this.run(["diff", "--cached", "--quiet"]);
+    return r.code === 1;
+  }
+  currentBranch() {
+    return this.run(["rev-parse", "--abbrev-ref", "HEAD"]).stdout || "main";
+  }
+  /** Rebase local commits on top of the remote (clean by construction for host-keyed paths). */
+  pull() {
+    return this.run(["pull", "--rebase", "--autostash", "origin", this.currentBranch()]);
+  }
+  push() {
+    return this.run(["push", "-u", "origin", this.currentBranch()]);
+  }
+  /** Convenience: commit, and when a remote+autoPush are configured, pull --rebase then push. */
+  sync(message) {
+    const commit = this.commit(message);
+    if (!commit.committed) return { commit, pushed: false };
+    if (!this.opts.remote || !this.opts.autoPush) return { commit, pushed: false };
+    this.pull();
+    const p = this.push();
+    return { commit, pushed: p.ok, ...p.ok ? {} : { pushError: p.stderr } };
+  }
+};
+
+// src/store/scan.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+function readEntries(dir) {
+  try {
+    return readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function subdirs(dir) {
+  return readEntries(dir).filter((e) => e.isDirectory()).map((e) => String(e.name));
+}
+function listSessionDirs(storeDir, opts = {}) {
+  const hostsRoot = join4(storeDir, "hosts");
+  const out = [];
+  for (const host of subdirs(hostsRoot)) {
+    for (const month of subdirs(join4(hostsRoot, host))) {
+      if (opts.sinceMonth && month < opts.sinceMonth) continue;
+      for (const sessionId of subdirs(join4(hostsRoot, host, month))) {
+        out.push({ host, month, sessionId, dir: join4(hostsRoot, host, month, sessionId) });
+      }
+    }
+  }
+  return out;
+}
+
+// src/daemon.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, rmSync } from "fs";
+import { createServer } from "net";
+import { join as join5 } from "path";
+function findTranscript(projectsDir, sessionId, maxDepth = 3) {
+  const target = `${sessionId}.jsonl`;
+  const walk = (dir, depth) => {
+    if (depth > maxDepth || !existsSync6(dir)) return void 0;
+    const entries = readEntries(dir);
+    for (const e of entries) {
+      if (e.isFile() && String(e.name) === target) return join5(dir, String(e.name));
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        const found = walk(join5(dir, String(e.name)), depth + 1);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  };
+  return walk(projectsDir, 0);
+}
+var Daemon = class {
+  constructor(cfg, deps = {}) {
+    this.cfg = cfg;
+    this.state = deps.state ?? new StateStore(cfg.statePath);
+    this.capture = deps.capture ?? new CaptureEngine(cfg, this.state);
+    if (cfg.git.autoCommit) {
+      this.git = deps.git ?? new GitStore(cfg.storeDir, {
+        ...cfg.git.remote ? { remote: cfg.git.remote } : {},
+        autoPush: cfg.git.autoPush
+      });
+    }
+    if (deps.onSessionEnd) this.onSessionEnd = deps.onSessionEnd;
+  }
+  cfg;
+  server;
+  capture;
+  state;
+  git;
+  onSessionEnd;
+  dirty = false;
+  pendingTurns = 0;
+  commitTimer;
+  running = false;
+  stats = { events: 0, turns: 0, commits: 0 };
+  sessions = /* @__PURE__ */ new Set();
+  async start() {
+    mkdirSync3(this.cfg.storeDir, { recursive: true });
+    mkdirSync3(this.cfg.runtimeDir, { recursive: true });
+    this.git?.init();
+    if (existsSync6(this.cfg.socketPath)) rmSync(this.cfg.socketPath);
+    await new Promise((resolve, reject) => {
+      const server = createServer((sock) => this.onConnection(sock));
+      server.on("error", reject);
+      server.listen(this.cfg.socketPath, () => {
+        this.running = true;
+        resolve();
+      });
+      this.server = server;
+    });
+  }
+  onConnection(sock) {
+    let buf = "";
+    sock.on("data", async (chunk) => {
+      buf += chunk.toString("utf8");
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (!line.trim()) continue;
+        let ack;
+        try {
+          const evt = parseHookEvent(JSON.parse(line));
+          ack = evt ? await this.handleEvent(evt) : { ok: false, error: "invalid event" };
+        } catch {
+          ack = { ok: false, error: "parse error" };
+        }
+        if (!sock.destroyed) sock.write(`${JSON.stringify(ack)}
+`);
+      }
+    });
+    sock.on("error", () => {
+    });
+  }
+  /** Process a single hook event: capture, then decide whether to flush a commit. */
+  async handleEvent(evt) {
+    this.stats.events++;
+    const transcript = evt.transcript_path && existsSync6(evt.transcript_path) ? evt.transcript_path : findTranscript(this.cfg.claudeProjectsDir, evt.session_id);
+    if (!transcript) return { ok: false, error: "transcript not found" };
+    const res = this.capture.captureSession(evt.session_id, transcript);
+    this.sessions.add(evt.session_id);
+    if (res.newTurns > 0 || res.writtenPaths.length > 0) {
+      this.dirty = true;
+      this.pendingTurns += res.newTurns;
+      this.stats.turns += res.newTurns;
+    }
+    const end = isSessionEndEvent(evt.event);
+    let flushed = false;
+    if (end && this.onSessionEnd) {
+      await this.onSessionEnd(evt.session_id, res.sessionDir);
+      this.dirty = true;
+    }
+    if (end || this.pendingTurns >= this.cfg.batch.maxTurns) {
+      flushed = this.flush(`capture ${evt.session_id}`);
+    } else {
+      this.scheduleFlush();
+    }
+    return { ok: true, newTurns: res.newTurns, flushed };
+  }
+  scheduleFlush() {
+    if (this.commitTimer) return;
+    this.commitTimer = setTimeout(() => {
+      this.commitTimer = void 0;
+      this.flush("batch interval");
+    }, this.cfg.batch.maxIntervalMs);
+    this.commitTimer.unref?.();
+  }
+  /** Commit (and push when configured) all buffered store changes. Returns whether a commit landed. */
+  flush(message) {
+    if (this.commitTimer) {
+      clearTimeout(this.commitTimer);
+      this.commitTimer = void 0;
+    }
+    if (!this.dirty || !this.git) {
+      this.dirty = false;
+      this.pendingTurns = 0;
+      return false;
+    }
+    const r = this.git.sync(message);
+    this.dirty = false;
+    this.pendingTurns = 0;
+    if (r.commit.committed) this.stats.commits++;
+    return r.commit.committed;
+  }
+  status() {
+    return {
+      running: this.running,
+      socketPath: this.cfg.socketPath,
+      storeDir: this.cfg.storeDir,
+      events: this.stats.events,
+      turns: this.stats.turns,
+      commits: this.stats.commits,
+      sessions: [...this.sessions]
+    };
+  }
+  async stop() {
+    if (this.commitTimer) {
+      clearTimeout(this.commitTimer);
+      this.commitTimer = void 0;
+    }
+    this.flush("daemon shutdown");
+    if (this.server) {
+      await new Promise((resolve) => this.server.close(() => resolve()));
+      this.server = void 0;
+    }
+    if (existsSync6(this.cfg.socketPath)) {
+      try {
+        rmSync(this.cfg.socketPath);
+      } catch {
+      }
+    }
+    this.running = false;
+  }
+};
+
+// src/insights/heuristics.ts
+var THRESHOLDS = {
+  stuckRepeat: 3,
+  // N consecutive identical assistant/tool actions
+  highCostUsd: 0.5,
+  longSessionTurns: 80,
+  toolHeavyRatio: 1.5
+};
+var ERROR_RE = /(error|exception|traceback|failed|fatal|panic)/i;
+function actionKey(t) {
+  if (t.tool_calls.length > 0) {
+    return `tool:${t.tool_calls.map((c) => `${c.name}(${JSON.stringify(c.input ?? null)})`).join(",")}`;
+  }
+  return `${t.role}:${t.text.slice(0, 120)}`;
+}
+function deriveSignals(turns) {
+  const signals = [];
+  let runKey = "";
+  let runLen = 0;
+  let runStart = 0;
+  let flaggedStuck = false;
+  for (let i = 0; i < turns.length; i++) {
+    const key = actionKey(turns[i]);
+    if (key === runKey) {
+      runLen++;
+    } else {
+      runKey = key;
+      runLen = 1;
+      runStart = i;
+    }
+    if (runLen >= THRESHOLDS.stuckRepeat && !flaggedStuck) {
+      signals.push({
+        kind: "stuck-loop",
+        severity: "warn",
+        turn_index: turns[runStart].turn_index,
+        note: `repeated action \xD7${runLen}`
+      });
+      flaggedStuck = true;
+    }
+  }
+  for (const t of turns) {
+    if (ERROR_RE.test(t.text)) {
+      signals.push({ kind: "error-recovery", severity: "info", turn_index: t.turn_index });
+      break;
+    }
+  }
+  for (const t of turns) {
+    const cost = t.telemetry?.cost_usd ?? 0;
+    if (cost >= THRESHOLDS.highCostUsd) {
+      signals.push({
+        kind: "high-cost-turn",
+        severity: "warn",
+        turn_index: t.turn_index,
+        note: `$${cost.toFixed(2)}`
+      });
+      break;
+    }
+  }
+  if (turns.length >= THRESHOLDS.longSessionTurns) {
+    signals.push({ kind: "long-session", severity: "info", note: `${turns.length} turns` });
+  }
+  const toolCalls = turns.reduce((a, t) => a + t.tool_calls.length, 0);
+  if (turns.length > 0 && toolCalls / turns.length >= THRESHOLDS.toolHeavyRatio) {
+    signals.push({
+      kind: "tool-heavy",
+      severity: "info",
+      note: `${toolCalls} tool calls / ${turns.length} turns`
+    });
+  }
+  return signals;
+}
+function guessTopic(turns) {
+  const firstUser = turns.find((t) => t.role === "user" && t.text.trim().length > 0);
+  if (!firstUser) return void 0;
+  const words = firstUser.text.trim().split(/\s+/).slice(0, 8).join(" ");
+  return words.length > 0 ? words : void 0;
+}
+function deriveTags(turns) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const t of turns) for (const c of t.tool_calls) tags.add(c.name);
+  return [...tags].slice(0, 12);
+}
+
+// src/insights/provider.ts
+var FakeProvider = class {
+  name = "fake";
+  async label(req) {
+    const result = {
+      tags: deriveTags(req.turns),
+      signals: []
+    };
+    const topic = guessTopic(req.turns);
+    if (topic) result.topic = topic;
+    const assistantText = req.turns.find((t) => t.role === "assistant")?.text;
+    if (assistantText) result.summary = assistantText.slice(0, 160);
+    return result;
+  }
+};
+
+// src/insights/llm.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { SIGNAL_KINDS } from "@unpolarize/code-sessions-schema";
+var MAX_HEAD = 40;
+var MAX_TAIL = 10;
+var MAX_TURN_CHARS = 400;
+function buildPrompt(req) {
+  const turns = req.turns;
+  const picked = turns.length > MAX_HEAD + MAX_TAIL ? [...turns.slice(0, MAX_HEAD), { role: "\u2026", text: `(${turns.length - MAX_HEAD - MAX_TAIL} turns elided)`, tool_calls: [] }, ...turns.slice(-MAX_TAIL)] : turns;
+  const transcript = picked.map((t) => {
+    const tools = t.tool_calls?.map((c) => c.name).join(",");
+    const head = tools ? `[${t.role} tools:${tools}]` : `[${t.role}]`;
+    return `${head} ${String(t.text).slice(0, MAX_TURN_CHARS)}`;
+  }).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.",
+    "",
+    "Transcript:",
+    transcript
+  ].join("\n");
+}
+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: [] };
+  let obj;
+  try {
+    obj = JSON.parse(out.slice(start, end + 1));
+  } catch {
+    return { tags: [], signals: [] };
+  }
+  const result = {
+    tags: Array.isArray(obj.tags) ? obj.tags.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;
+  return result;
+}
+function coerceSignals(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const s of raw) {
+    if (!s || typeof s !== "object") continue;
+    const o = s;
+    if (typeof o.kind !== "string" || !KIND_SET.has(o.kind)) continue;
+    const sig = {
+      kind: o.kind,
+      severity: o.severity === "warn" || o.severity === "critical" ? o.severity : "info"
+    };
+    if (typeof o.note === "string") sig.note = o.note;
+    if (typeof o.turn_index === "number") sig.turn_index = o.turn_index;
+    out.push(sig);
+  }
+  return out;
+}
+var LlmProvider = class {
+  constructor(name, runner) {
+    this.name = name;
+    this.runner = runner;
+  }
+  name;
+  runner;
+  async label(req) {
+    const out = await this.runner(buildPrompt(req));
+    return parseLabelJson(out);
+  }
+};
+function spawnText(cmd, args, input) {
+  const res = spawnSync2(cmd, args, {
+    encoding: "utf8",
+    input,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  if (res.error) throw new Error(`${cmd} failed: ${res.error.message}`);
+  if (res.status !== 0) throw new Error(`${cmd} exited ${res.status}: ${(res.stderr ?? "").slice(0, 200)}`);
+  return res.stdout ?? "";
+}
+var claudeRunner = (model) => async (prompt) => spawnText("claude", model ? ["-p", "--model", model, prompt] : ["-p", prompt]);
+var grokRunner = (model) => async (prompt) => spawnText("grok", model ? ["--model", model, "-p", prompt] : ["-p", prompt]);
+var ollamaRunner = (model = "llama3.1", host = "http://localhost:11434") => async (prompt) => {
+  const res = await fetch(`${host}/api/generate`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ model, prompt, stream: false })
+  });
+  if (!res.ok) throw new Error(`ollama ${res.status}`);
+  const data = await res.json();
+  return data.response ?? "";
+};
+
+// src/insights/labeler.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3 } from "path";
+import {
+  SCHEMA_VERSIONS as SCHEMA_VERSIONS2,
+  parseSession
+} from "@unpolarize/code-sessions-schema";
+function writeJsonAtomic2(path, value) {
+  mkdirSync4(dirname3(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync4(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync3(tmp, path);
+}
+function dedupeSignals(signals) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of signals) {
+    const key = `${s.kind}:${s.turn_index ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(s);
+  }
+  return out;
+}
+function makeProvider(cfg) {
+  const { provider, model } = cfg.insights;
+  switch (provider) {
+    case "none":
+      return null;
+    case "fake":
+      return new FakeProvider();
+    case "claude":
+      return new LlmProvider("claude", claudeRunner(model));
+    case "grok":
+      return new LlmProvider("grok", grokRunner(model));
+    case "ollama":
+      return new LlmProvider("ollama", ollamaRunner(model));
+    default:
+      return null;
+  }
+}
+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: [] };
+  try {
+    provided = await provider.label({ sessionId: identity.sessionId, host: identity.host, turns });
+  } catch {
+  }
+  const topic = provided.topic ?? guessTopic(turns);
+  const tags = [.../* @__PURE__ */ new Set([...provided.tags, ...deriveTags(turns)])].slice(0, 16);
+  const signals = dedupeSignals([...heuristicSignals, ...provided.signals]);
+  const insights = {
+    schema: SCHEMA_VERSIONS2.insights,
+    session_id: identity.sessionId,
+    host: identity.host,
+    generated_at: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    provider: provider.name,
+    tags,
+    signals
+  };
+  if (topic) insights.topic = topic;
+  if (provided.summary) insights.summary = provided.summary;
+  writeJsonAtomic2(insightsFile(sessionDir2), insights);
+  updateEnvelopeLabels(sessionDir2, topic, tags);
+  return insights;
+}
+function updateEnvelopeLabels(sessionDir2, topic, tags) {
+  const path = envelopeFile(sessionDir2);
+  if (!existsSync7(path)) return;
+  let env;
+  try {
+    env = parseSession(JSON.parse(readFileSync5(path, "utf8")));
+  } catch {
+    return;
+  }
+  env.labels = [.../* @__PURE__ */ new Set([...topic ? [topic] : [], ...tags])].slice(0, 16);
+  writeJsonAtomic2(path, env);
+}
+async function reindexStore(cfg, provider, opts = {}) {
+  const refs = listSessionDirs(cfg.storeDir, opts.sinceMonth ? { sinceMonth: opts.sinceMonth } : {});
+  const labeled = [];
+  for (const ref of refs) {
+    const labelOpts = opts.now ? { now: opts.now } : {};
+    const res = await labelSession(ref.dir, { sessionId: ref.sessionId, host: ref.host }, provider, labelOpts);
+    if (res) labeled.push(ref.sessionId);
+  }
+  return { count: labeled.length, sessions: labeled };
+}
+
+// src/hooks/install.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4 } from "path";
+var DEFAULT_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop"
+];
+function groupHasCommand(groups, command) {
+  return groups.some((g) => g.hooks?.some((h) => h.command === command));
+}
+function mergeHooks(settings, command, events = DEFAULT_HOOK_EVENTS) {
+  const next = { ...settings, hooks: { ...settings.hooks ?? {} } };
+  const hooks = next.hooks;
+  const added = [];
+  for (const event of events) {
+    const groups = hooks[event] ? [...hooks[event]] : [];
+    if (groupHasCommand(groups, command)) {
+      hooks[event] = groups;
+      continue;
+    }
+    groups.push({ matcher: "", hooks: [{ type: "command", command }] });
+    hooks[event] = groups;
+    added.push(event);
+  }
+  return { settings: next, added };
+}
+function installHooks(settingsPath, command, events = DEFAULT_HOOK_EVENTS) {
+  let settings = {};
+  if (existsSync8(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
+    } catch {
+      settings = {};
+    }
+  }
+  const { settings: merged, added } = mergeHooks(settings, command, events);
+  mkdirSync5(dirname4(settingsPath), { recursive: true });
+  writeFileSync5(settingsPath, `${JSON.stringify(merged, null, 2)}
+`);
+  return { settingsPath, command, added };
+}
+
+// src/telemetry/otlp.ts
+import { createHash as createHash2 } from "crypto";
+function attr(key, value) {
+  if (typeof value === "boolean") return { key, value: { boolValue: value } };
+  if (typeof value === "string") return { key, value: { stringValue: value } };
+  return Number.isInteger(value) ? { key, value: { intValue: value } } : { key, value: { doubleValue: value } };
+}
+function hexId(input, bytes) {
+  return createHash2("sha256").update(input).digest("hex").slice(0, bytes * 2);
+}
+function isoNano(ts) {
+  if (!ts) return "0";
+  const ms = Date.parse(ts);
+  return Number.isNaN(ms) ? "0" : `${ms}000000`;
+}
+var SCOPE = { name: "code-sessions", version: "0.1.0" };
+function resource(serviceName, host) {
+  return {
+    attributes: [
+      attr("service.name", serviceName),
+      attr("host.name", host),
+      attr("telemetry.sdk.name", "code-sessions"),
+      attr("telemetry.sdk.language", "nodejs")
+    ]
+  };
+}
+function sumUsage(turns) {
+  const u = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  for (const t of turns) {
+    u.input += t.usage.input_tokens;
+    u.output += t.usage.output_tokens;
+    u.cacheRead += t.usage.cache_read_tokens;
+    u.cacheWrite += t.usage.cache_write_tokens;
+    u.cost += t.telemetry?.cost_usd ?? 0;
+  }
+  return u;
+}
+function buildTracePayload(session, turns, serviceName) {
+  const traceId = hexId(session.session_id, 16);
+  const rootId = hexId(`${session.session_id}:root`, 8);
+  const totals = sumUsage(turns);
+  const rootSpan = {
+    traceId,
+    spanId: rootId,
+    name: `session ${session.title ?? session.session_id}`,
+    kind: 1,
+    startTimeUnixNano: isoNano(session.started_at),
+    endTimeUnixNano: isoNano(session.ended_at ?? session.started_at),
+    attributes: [
+      attr("session.id", session.session_id),
+      attr("gen_ai.system", session.agent),
+      ...session.model ? [attr("gen_ai.request.model", session.model)] : [],
+      attr("session.turn_count", session.turn_count),
+      attr("gen_ai.usage.input_tokens", totals.input),
+      attr("gen_ai.usage.output_tokens", totals.output),
+      attr("code_sessions.cost_usd", Math.round(totals.cost * 1e6) / 1e6),
+      ...session.project_path ? [attr("project.path", session.project_path)] : []
+    ],
+    status: {}
+  };
+  const turnSpans = turns.map((t) => ({
+    traceId,
+    spanId: hexId(`${session.session_id}:${t.turn_index}`, 8),
+    parentSpanId: rootId,
+    name: `turn ${t.turn_index} ${t.role}`,
+    kind: 1,
+    startTimeUnixNano: isoNano(t.ts),
+    endTimeUnixNano: isoNano(t.ts),
+    attributes: [
+      attr("turn.index", t.turn_index),
+      attr("gen_ai.role", t.role),
+      attr("gen_ai.usage.input_tokens", t.usage.input_tokens),
+      attr("gen_ai.usage.output_tokens", t.usage.output_tokens),
+      attr("code_sessions.tool_count", t.tool_calls.length),
+      attr("code_sessions.cost_usd", t.telemetry?.cost_usd ?? 0)
+    ],
+    status: {}
+  }));
+  return {
+    resourceSpans: [
+      {
+        resource: resource(serviceName, session.host),
+        scopeSpans: [{ scope: SCOPE, spans: [rootSpan, ...turnSpans] }]
+      }
+    ]
+  };
+}
+function buildMetricPayload(session, turns, serviceName) {
+  const totals = sumUsage(turns);
+  const time = isoNano(session.ended_at ?? session.started_at);
+  const base = [attr("session.id", session.session_id), attr("gen_ai.system", session.agent)];
+  const tokenPoint = (type, value) => ({
+    asInt: value,
+    timeUnixNano: time,
+    attributes: [...base, attr("gen_ai.token.type", type)]
+  });
+  return {
+    resourceMetrics: [
+      {
+        resource: resource(serviceName, session.host),
+        scopeMetrics: [
+          {
+            scope: SCOPE,
+            metrics: [
+              {
+                name: "code_sessions.tokens",
+                unit: "{token}",
+                sum: {
+                  aggregationTemporality: 2,
+                  isMonotonic: true,
+                  dataPoints: [
+                    tokenPoint("input", totals.input),
+                    tokenPoint("output", totals.output),
+                    tokenPoint("cache_read", totals.cacheRead),
+                    tokenPoint("cache_write", totals.cacheWrite)
+                  ]
+                }
+              },
+              {
+                name: "code_sessions.cost_usd",
+                unit: "USD",
+                gauge: {
+                  dataPoints: [
+                    { asDouble: Math.round(totals.cost * 1e6) / 1e6, timeUnixNano: time, attributes: base }
+                  ]
+                }
+              },
+              {
+                name: "code_sessions.turns",
+                unit: "{turn}",
+                sum: {
+                  aggregationTemporality: 2,
+                  isMonotonic: true,
+                  dataPoints: [{ asInt: turns.length, timeUnixNano: time, attributes: base }]
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}
+async function postOtlp(endpoint, signalPath, payload, timeoutMs) {
+  const url = `${endpoint.replace(/\/$/, "")}${signalPath}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    return { ok: res.ok, status: res.status };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/telemetry/exporter.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { safeParseSession } from "@unpolarize/code-sessions-schema";
+function loadEnvelope(sessionDir2) {
+  const path = envelopeFile(sessionDir2);
+  if (!existsSync9(path)) return void 0;
+  try {
+    const parsed = safeParseSession(JSON.parse(readFileSync7(path, "utf8")));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function exportSession(cfg, sessionDir2) {
+  if (!cfg.telemetry.enabled) return { ok: false, skipped: true, reason: "telemetry disabled" };
+  const envelope = loadEnvelope(sessionDir2);
+  if (!envelope) return { ok: false, reason: "no envelope" };
+  const turns = readTurns(sessionDir2);
+  const { endpoint, serviceName, timeoutMs } = cfg.telemetry;
+  const traces = await postOtlp(endpoint, "/v1/traces", buildTracePayload(envelope, turns, serviceName), timeoutMs);
+  const metrics = await postOtlp(endpoint, "/v1/metrics", buildMetricPayload(envelope, turns, serviceName), timeoutMs);
+  return { ok: traces.ok && metrics.ok, traces, metrics };
+}
+async function exportStore(cfg, opts = {}) {
+  const refs = listSessionDirs(cfg.storeDir, opts.sinceMonth ? { sinceMonth: opts.sinceMonth } : {});
+  let exported = 0;
+  let failed = 0;
+  for (const ref of refs) {
+    const res = await exportSession(cfg, ref.dir);
+    if (res.ok) exported++;
+    else if (!res.skipped) failed++;
+  }
+  return { total: refs.length, exported, failed };
+}
+
+// src/adapters/grok.ts
+import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join6 } from "path";
+import {
+  SCHEMA_VERSIONS as SCHEMA_VERSIONS3
+} from "@unpolarize/code-sessions-schema";
+function grokSessionsRoot() {
+  return join6(homedir2(), ".grok", "sessions");
+}
+function safeDirs(dir) {
+  try {
+    return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function discoverGrokSessions(root = grokSessionsRoot()) {
+  if (!existsSync10(root)) return [];
+  const out = [];
+  for (const enc of safeDirs(root)) {
+    let cwd = enc;
+    try {
+      cwd = decodeURIComponent(enc);
+    } catch {
+    }
+    for (const uuid of safeDirs(join6(root, enc))) {
+      const dir = join6(root, enc, uuid);
+      const chatPath = join6(dir, "chat_history.jsonl");
+      const summaryPath = join6(dir, "summary.json");
+      if (existsSync10(chatPath)) out.push({ sessionId: uuid, chatPath, summaryPath, cwd });
+    }
+  }
+  return out;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => typeof b === "string" ? b : b && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : "").filter(Boolean).join("\n\n");
+  }
+  return "";
+}
+function parseArgs(s) {
+  if (typeof s !== "string") return s;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+function parseGrokSession(info, host) {
+  let summary = {};
+  if (existsSync10(info.summaryPath)) {
+    try {
+      summary = JSON.parse(readFileSync8(info.summaryPath, "utf8"));
+    } catch {
+    }
+  }
+  if (summary.session_kind === "claude_import") return null;
+  const baseMs = Date.parse(summary.created_at ?? "") || statMtime(info.chatPath);
+  const lines = readFileSync8(info.chatPath, "utf8").split("\n").filter((l) => l.trim().length > 0);
+  const turns = [];
+  let idx = 0;
+  let model = summary.current_model_id;
+  for (const line of lines) {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const ts = new Date(baseMs + idx * 1e3).toISOString();
+    if (ev.type === "user") {
+      turns.push(mkTurn(info.sessionId, host, idx++, ts, "user", extractText(ev.content), []));
+    } else if (ev.type === "assistant") {
+      if (typeof ev.model_id === "string") model = ev.model_id;
+      const tools = Array.isArray(ev.tool_calls) ? ev.tool_calls.filter((t) => t && typeof t.name === "string").map((t) => ({ name: t.name, input: parseArgs(t.arguments), ...t.id ? { id: t.id } : {} })) : [];
+      turns.push(mkTurn(info.sessionId, host, idx++, ts, "assistant", extractText(ev.content), tools));
+    } else if (ev.type === "tool_result") {
+      turns.push(mkTurn(info.sessionId, host, idx++, ts, "tool", extractText(ev.content), []));
+    }
+  }
+  if (turns.length === 0) return null;
+  const startedAt = new Date(baseMs).toISOString();
+  const endedAt = turns[turns.length - 1].ts;
+  const meta = {
+    session_id: info.sessionId,
+    project_path: summary.info?.cwd ?? info.cwd,
+    started_at: startedAt,
+    ended_at: endedAt
+  };
+  if (model) meta.model = model;
+  const title = summary.generated_title?.trim() || summary.session_summary?.trim();
+  if (title) meta.title = title;
+  return { host, sessionId: info.sessionId, agent: "grok", turns, meta };
+}
+function statMtime(p) {
+  try {
+    return statSync(p).mtimeMs;
+  } catch {
+    return Date.parse("2020-01-01T00:00:00Z");
+  }
+}
+function mkTurn(sessionId, host, index, ts, role, text, tool_calls) {
+  return {
+    schema: SCHEMA_VERSIONS3.turn,
+    session_id: sessionId,
+    host,
+    agent: "grok",
+    turn_index: index,
+    ts,
+    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/codex.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
+import {
+  SCHEMA_VERSIONS as SCHEMA_VERSIONS4
+} from "@unpolarize/code-sessions-schema";
+var UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+function codexSessionsRoot() {
+  return join7(homedir3(), ".codex", "sessions");
+}
+function discoverCodexSessions(root = codexSessionsRoot()) {
+  if (!existsSync11(root)) return [];
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > 6) return;
+    for (const e of readEntries(dir)) {
+      const name = String(e.name);
+      const full = join7(dir, name);
+      if (e.isDirectory()) walk(full, depth + 1);
+      else if (e.isFile() && name.endsWith(".jsonl")) {
+        const m = UUID_RE.exec(name);
+        out.push({ sessionId: m ? m[1] : name.replace(/\.jsonl$/, ""), path: full });
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => {
+      if (typeof b === "string") return b;
+      if (b && typeof b === "object") {
+        const o = b;
+        if (typeof o.text === "string") return o.text;
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  if (content && typeof content === "object" && typeof content.text === "string") {
+    return content.text;
+  }
+  return "";
+}
+function normalizeCodexLine(ev) {
+  const p = ev?.payload && typeof ev.payload === "object" ? ev.payload : ev;
+  const ptype = p?.type;
+  if (ev?.type === "event_msg") {
+    if (ptype === "user_message" && typeof p.message === "string") {
+      return { role: "user", text: p.message, tool_calls: [] };
+    }
+    if (ptype === "agent_message" && typeof p.message === "string") {
+      return { role: "assistant", text: p.message, tool_calls: [] };
+    }
+    return null;
+  }
+  if (ev?.type === "response_item") {
+    if (ptype === "function_call" || ptype === "local_shell_call" || ptype === "tool_call") {
+      const name = typeof p.name === "string" ? p.name : ptype === "local_shell_call" ? "shell" : "tool";
+      let input = p.arguments ?? p.input ?? p.action;
+      if (typeof input === "string") {
+        try {
+          input = JSON.parse(input);
+        } catch {
+        }
+      }
+      return { role: "assistant", text: "", tool_calls: [{ name, input }] };
+    }
+    if (ptype === "function_call_output" || ptype === "tool_result") {
+      return { role: "tool", text: textFromContent(p.output ?? p.content), tool_calls: [] };
+    }
+    return null;
+  }
+  return null;
+}
+function readTokenCount(ev) {
+  if (ev?.type !== "event_msg" || ev?.payload?.type !== "token_count") return null;
+  const u = ev.payload.info?.total_token_usage ?? ev.payload.info;
+  if (!u || typeof u !== "object") return null;
+  return {
+    input_tokens: Number(u.input_tokens) || 0,
+    output_tokens: Number(u.output_tokens) || 0,
+    cache_read_tokens: Number(u.cached_input_tokens ?? u.cache_read_tokens) || 0
+  };
+}
+function lineTs(ev, fallback) {
+  const t = ev?.timestamp ?? ev?.ts;
+  if (typeof t === "string" && !Number.isNaN(Date.parse(t))) return t;
+  return fallback;
+}
+function parseCodexSession(info, host) {
+  const lines = readFileSync9(info.path, "utf8").split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length === 0) return null;
+  let model;
+  let cwd;
+  let sessionId = info.sessionId;
+  let baseTs = "2020-01-01T00:00:00Z";
+  let latestUsage = null;
+  let lastAssistantIdx = -1;
+  const turns = [];
+  let idx = 0;
+  for (const line of lines) {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (ev?.type === "session_meta") {
+      const src = ev.payload && typeof ev.payload === "object" ? ev.payload : ev;
+      if (typeof src.model === "string") model = src.model;
+      if (typeof src.cwd === "string") cwd = src.cwd;
+      if (typeof src.id === "string") sessionId = UUID_RE.exec(src.id)?.[1] ?? sessionId;
+      const t = src.timestamp ?? ev.timestamp;
+      if (typeof t === "string" && !Number.isNaN(Date.parse(t))) baseTs = t;
+      continue;
+    }
+    if (ev?.type === "turn_context" && typeof ev.payload?.cwd === "string" && !cwd) {
+      cwd = ev.payload.cwd;
+    }
+    const usage = readTokenCount(ev);
+    if (usage) {
+      latestUsage = usage;
+      continue;
+    }
+    const norm = normalizeCodexLine(ev);
+    if (!norm) continue;
+    const ts = lineTs(ev, new Date(Date.parse(baseTs) + idx * 1e3).toISOString());
+    if (norm.role === "assistant") lastAssistantIdx = turns.length;
+    turns.push({
+      schema: SCHEMA_VERSIONS4.turn,
+      session_id: sessionId,
+      host,
+      agent: "codex",
+      turn_index: idx++,
+      ts,
+      role: norm.role,
+      text: norm.text,
+      tool_calls: norm.tool_calls,
+      usage: { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0 },
+      scrubbed: false,
+      raw_ref: null
+    });
+  }
+  if (turns.length === 0) return null;
+  if (latestUsage && lastAssistantIdx >= 0) {
+    turns[lastAssistantIdx].usage = {
+      input_tokens: latestUsage.input_tokens,
+      output_tokens: latestUsage.output_tokens,
+      cache_read_tokens: latestUsage.cache_read_tokens,
+      cache_write_tokens: 0
+    };
+  }
+  const meta = {
+    session_id: sessionId,
+    started_at: turns[0].ts,
+    ended_at: turns[turns.length - 1].ts
+  };
+  if (model) meta.model = model;
+  if (cwd) meta.project_path = cwd;
+  return { host, sessionId, agent: "codex", turns, meta };
+}
+
+// src/adapters/import.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5 } from "path";
+var NATIVE_FORMAT = {
+  "claude-code": "claude-jsonl",
+  grok: "grok-jsonl",
+  codex: "codex-rollout",
+  unknown: "unknown"
+};
+function writeJsonAtomic3(path, value) {
+  mkdirSync6(dirname5(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync6(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync4(tmp, path);
+}
+function writeImportedSession(cfg, s) {
+  const month = monthOf(s.meta.started_at ?? s.turns[0]?.ts);
+  const dir = sessionDir(cfg.storeDir, s.host, month, s.sessionId);
+  for (const turn of s.turns) {
+    const hy = applyHygiene(turn, cfg.hygiene);
+    if (hy.blob) writeBlobFile(dir, hy.blob.sha, hy.blob.content);
+    writeTurnFile(dir, hy.turn);
+  }
+  const env = computeEnvelope(s.turns, s.meta, {
+    session_id: s.sessionId,
+    host: s.host,
+    agent: s.agent,
+    native_uuid: s.sessionId
+  });
+  env.native_ref.format = NATIVE_FORMAT[s.agent] ?? "unknown";
+  const envPath = envelopeFile(dir);
+  if (existsSync12(envPath)) {
+    try {
+      const prev = JSON.parse(readFileSync10(envPath, "utf8"));
+      if (prev.labels?.length) env.labels = prev.labels;
+    } catch {
+    }
+  }
+  writeJsonAtomic3(envPath, env);
+  return { sessionId: s.sessionId, sessionDir: dir, turns: s.turns.length, envelope: env };
+}
+
+// src/index_store/db.ts
+import { mkdirSync as mkdirSync7 } from "fs";
+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;
+function toMs(iso) {
+  if (!iso) return null;
+  const v = Date.parse(iso);
+  return Number.isNaN(v) ? null : v;
+}
+var SessionIndex = class {
+  db;
+  constructor(path) {
+    if (path !== ":memory:") mkdirSync7(dirname6(path), { recursive: true });
+    this.db = new DatabaseSync(path);
+    this.db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
+    this.migrate();
+  }
+  migrate() {
+    const row = this.db.prepare("PRAGMA user_version").get();
+    if ((row?.user_version ?? 0) < 1) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS session (
+          session_id TEXT PRIMARY KEY,
+          host TEXT NOT NULL,
+          agent TEXT NOT NULL,
+          project_path TEXT NOT NULL DEFAULT '',
+          model TEXT,
+          started_at INTEGER,
+          ended_at INTEGER,
+          turn_count INTEGER NOT NULL DEFAULT 0,
+          tool_call_count INTEGER NOT NULL DEFAULT 0,
+          input_tokens INTEGER NOT NULL DEFAULT 0,
+          output_tokens INTEGER NOT NULL DEFAULT 0,
+          cost_usd REAL NOT NULL DEFAULT 0,
+          title TEXT,
+          labels_json TEXT NOT NULL DEFAULT '[]',
+          topic TEXT,
+          source_path TEXT NOT NULL,
+          mtime_ms INTEGER NOT NULL DEFAULT 0,
+          size_bytes INTEGER NOT NULL DEFAULT 0,
+          indexed_at INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_started ON session(started_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_session_agent ON session(agent);
+        CREATE TABLE IF NOT EXISTS turn (
+          turn_uuid TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL REFERENCES session(session_id) ON DELETE CASCADE,
+          turn_index INTEGER NOT NULL,
+          ts INTEGER,
+          role TEXT NOT NULL,
+          text TEXT NOT NULL DEFAULT '',
+          tool_names_csv TEXT NOT NULL DEFAULT '',
+          input_tokens INTEGER NOT NULL DEFAULT 0,
+          output_tokens INTEGER NOT NULL DEFAULT 0,
+          cost_usd REAL NOT NULL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_turn_session ON turn(session_id, turn_index);
+        CREATE TABLE IF NOT EXISTS insight (
+          session_id TEXT PRIMARY KEY REFERENCES session(session_id) ON DELETE CASCADE,
+          topic TEXT,
+          tags_json TEXT NOT NULL DEFAULT '[]',
+          signals_json TEXT NOT NULL DEFAULT '[]',
+          provider TEXT,
+          generated_at TEXT
+        );
+      `);
+      this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    }
+  }
+  /** session_id -> {mtime_ms, size_bytes} for incremental sync invalidation. */
+  knownSources() {
+    const rows = this.db.prepare("SELECT session_id, mtime_ms, size_bytes FROM session").all();
+    const m = /* @__PURE__ */ new Map();
+    for (const r of rows) m.set(r.session_id, { mtime_ms: r.mtime_ms, size_bytes: r.size_bytes });
+    return m;
+  }
+  upsertSession(env, src) {
+    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 (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+         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,
+           size_bytes=excluded.size_bytes, indexed_at=excluded.indexed_at`
+    ).run(
+      env.session_id,
+      env.host,
+      env.agent,
+      env.project_path,
+      env.model ?? null,
+      toMs(env.started_at),
+      toMs(env.ended_at),
+      env.turn_count,
+      env.tool_call_count,
+      env.totals.input_tokens,
+      env.totals.output_tokens,
+      env.totals.cost_usd,
+      env.title ?? null,
+      JSON.stringify(env.labels ?? []),
+      src.topic ?? null,
+      src.source_path,
+      src.mtime_ms,
+      src.size_bytes,
+      src.indexed_at
+    );
+  }
+  replaceTurns(sessionId, turns) {
+    this.db.prepare("DELETE FROM turn WHERE session_id = ?").run(sessionId);
+    const stmt = this.db.prepare(
+      `INSERT OR REPLACE INTO turn (turn_uuid, session_id, turn_index, ts, role, text,
+         tool_names_csv, input_tokens, output_tokens, cost_usd) VALUES (?,?,?,?,?,?,?,?,?,?)`
+    );
+    for (const t of turns) {
+      stmt.run(
+        `${sessionId}#${t.turn_index}`,
+        sessionId,
+        t.turn_index,
+        toMs(t.ts),
+        t.role,
+        t.text.slice(0, 8192),
+        t.tool_calls.map((c) => c.name).join(","),
+        t.usage.input_tokens,
+        t.usage.output_tokens,
+        t.telemetry?.cost_usd ?? 0
+      );
+    }
+  }
+  upsertInsight(ins) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO insight (session_id, topic, tags_json, signals_json, provider, generated_at)
+         VALUES (?,?,?,?,?,?)`
+    ).run(
+      ins.session_id,
+      ins.topic ?? null,
+      JSON.stringify(ins.tags ?? []),
+      JSON.stringify(ins.signals ?? []),
+      ins.provider,
+      ins.generated_at
+    );
+  }
+  deleteSessions(ids) {
+    if (ids.length === 0) return;
+    const stmt = this.db.prepare("DELETE FROM session WHERE session_id = ?");
+    for (const id of ids) stmt.run(id);
+  }
+  rowToIndex(r) {
+    return {
+      session_id: r.session_id,
+      host: r.host,
+      agent: r.agent,
+      project_path: r.project_path,
+      model: r.model ?? null,
+      started_at: r.started_at ?? null,
+      ended_at: r.ended_at ?? null,
+      turn_count: r.turn_count,
+      tool_call_count: r.tool_call_count,
+      input_tokens: r.input_tokens,
+      output_tokens: r.output_tokens,
+      cost_usd: r.cost_usd,
+      title: r.title ?? null,
+      labels: safeJson(r.labels_json),
+      topic: r.topic ?? null,
+      source_path: r.source_path
+    };
+  }
+  listRecent(limit = 50, agent) {
+    const rows = agent ? this.db.prepare("SELECT * FROM session WHERE agent = ? ORDER BY started_at DESC LIMIT ?").all(agent, limit) : this.db.prepare("SELECT * FROM session ORDER BY started_at DESC LIMIT ?").all(limit);
+    return rows.map((r) => this.rowToIndex(r));
+  }
+  getSession(id) {
+    const r = this.db.prepare("SELECT * FROM session WHERE session_id = ?").get(id);
+    return r ? this.rowToIndex(r) : void 0;
+  }
+  /** Full-text-ish search over turn text + session titles. */
+  searchTurns(query, limit = 50) {
+    const like = `%${query}%`;
+    const rows = this.db.prepare(
+      `SELECT DISTINCT s.* FROM session s
+         LEFT JOIN turn t ON t.session_id = s.session_id
+         WHERE t.text LIKE ? OR s.title LIKE ?
+         ORDER BY s.started_at DESC LIMIT ?`
+    ).all(like, like, limit);
+    return rows.map((r) => this.rowToIndex(r));
+  }
+  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();
+    const agents = this.db.prepare("SELECT agent, COUNT(*) c FROM session GROUP BY agent").all();
+    const byAgent = {};
+    for (const a of agents) byAgent[a.agent] = a.c;
+    return { sessions: s.c, turns: t.c, cost_usd: Math.round(s.cost * 1e6) / 1e6, byAgent };
+  }
+  close() {
+    this.db.close();
+  }
+};
+function safeJson(s) {
+  if (typeof s !== "string") return [];
+  try {
+    const v = JSON.parse(s);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+
+// src/index_store/sync.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
+import { safeParseInsights, safeParseSession as safeParseSession2 } from "@unpolarize/code-sessions-schema";
+function syncIndex(cfg, opts = {}) {
+  const index = opts.index ?? new SessionIndex(cfg.indexPath);
+  const ownsIndex = !opts.index;
+  const now = opts.now ?? Date.now();
+  try {
+    const refs = listSessionDirs(cfg.storeDir);
+    const known = index.knownSources();
+    const seen = /* @__PURE__ */ new Set();
+    let indexed = 0;
+    let unchanged = 0;
+    for (const ref of refs) {
+      const envPath = envelopeFile(ref.dir);
+      if (!existsSync13(envPath)) continue;
+      const st = statSync2(envPath);
+      const mtime_ms = Math.floor(st.mtimeMs);
+      const size_bytes = st.size;
+      seen.add(ref.sessionId);
+      const cached = known.get(ref.sessionId);
+      if (cached && cached.mtime_ms === mtime_ms && cached.size_bytes === size_bytes) {
+        unchanged++;
+        continue;
+      }
+      const parsed = safeParseSession2(JSON.parse(readFileSync11(envPath, "utf8")));
+      if (!parsed.success) continue;
+      const env = parsed.data;
+      let topic;
+      const insPath = insightsFile(ref.dir);
+      let insights = void 0;
+      if (existsSync13(insPath)) {
+        const pi = safeParseInsights(JSON.parse(readFileSync11(insPath, "utf8")));
+        if (pi.success) {
+          insights = pi.data;
+          topic = pi.data.topic;
+        }
+      }
+      index.upsertSession(env, {
+        source_path: envPath,
+        mtime_ms,
+        size_bytes,
+        indexed_at: now,
+        ...topic ? { topic } : {}
+      });
+      index.replaceTurns(env.session_id, readTurns(ref.dir));
+      if (insights) index.upsertInsight(insights);
+      indexed++;
+    }
+    const removed = [...known.keys()].filter((id) => !seen.has(id));
+    index.deleteSessions(removed);
+    return { total: refs.length, indexed, unchanged, removed: removed.length };
+  } finally {
+    if (ownsIndex) index.close();
+  }
+}
+
+// src/commands.ts
+import { existsSync as existsSync14, writeFileSync as writeFileSync7 } from "fs";
+import { join as join8 } from "path";
+function gitStoreFor(cfg) {
+  return new GitStore(cfg.storeDir, {
+    ...cfg.git.remote ? { remote: cfg.git.remote } : {},
+    autoPush: cfg.git.autoPush
+  });
+}
+function listClaudeTranscripts(projectsDir, maxDepth = 3) {
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > maxDepth || !existsSync14(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) });
+      } else if (e.isDirectory()) {
+        walk(join8(dir, name), depth + 1);
+      }
+    }
+  };
+  walk(projectsDir, 0);
+  return out;
+}
+function cmdInit(cfg) {
+  const git = gitStoreFor(cfg);
+  git.init();
+  const configPath = join8(cfg.storeDir, "config.json");
+  if (!existsSync14(configPath)) {
+    writeFileSync7(
+      configPath,
+      `${JSON.stringify({ insights: cfg.insights, batch: cfg.batch, hygiene: cfg.hygiene }, null, 2)}
+`
+    );
+  }
+  git.commit("init store");
+  return { code: 0, output: `Initialized store at ${cfg.storeDir}` };
+}
+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 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") };
+}
+async function cmdBackfill(cfg, opts = {}) {
+  const agent = opts.agent ?? "claude";
+  const parts = [];
+  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) \u2014 ${parts.join(", ")}` };
+}
+async function cmdReindex(cfg, opts = {}) {
+  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}` };
+}
+function cmdInstallHooks(cfg, opts = {}) {
+  const home = cfg.claudeProjectsDir.replace(/\/projects\/?$/, "");
+  const settingsPath = opts.settingsPath ?? join8(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(", ")}) \u2192 ${settingsPath}` : `Hooks already present \u2192 ${settingsPath}`
+  };
+}
+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)]
+  ];
+  const lines = checks.map(([name, ok]) => `${ok ? "\u2713" : "\u2717"} ${name}`);
+  const code = checks.every(([, ok]) => ok) ? 0 : 1;
+  return { code, output: lines.join("\n") };
+}
+async function cmdExport(cfg, opts = {}) {
+  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)`
+  };
+}
+function cmdIndex(cfg) {
+  const stats = syncIndex(cfg);
+  return {
+    code: 0,
+    output: `Indexed ${stats.indexed} new/changed, ${stats.unchanged} unchanged, ${stats.removed} removed \u2192 ${cfg.indexPath}`
+  };
+}
+function fmtRow(r) {
+  const date = r.started_at ? new Date(r.started_at).toISOString().slice(0, 16).replace("T", " ") : "\u2014".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}`;
+}
+function cmdQuery(cfg, opts = {}) {
+  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)} \u2014 ${Object.entries(s.byAgent).map(([a, n]) => `${a}:${n}`).join(" ")}`;
+    return { code: 0, output: [header, ...rows.map(fmtRow)].join("\n") };
+  } finally {
+    index.close();
+  }
+}
+function cmdSearch(cfg, opts) {
+  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();
+  }
+}
+async function startDaemon(cfg) {
+  const provider = makeProvider(cfg);
+  const wantInsights = provider && cfg.insights.mode !== "off";
+  const wantTelemetry = cfg.telemetry.enabled;
+  const deps = wantInsights || wantTelemetry ? {
+    onSessionEnd: async (sessionId, sessionDir2) => {
+      if (wantInsights && provider) {
+        await labelSession(sessionDir2, { sessionId, host: cfg.host }, provider);
+      }
+      if (wantTelemetry) {
+        await exportSession(cfg, sessionDir2);
+      }
+    }
+  } : {};
+  const daemon = new Daemon(cfg, deps);
+  await daemon.start();
+  return daemon;
+}
+
+// src/hooks/shim.ts
+import { existsSync as existsSync15 } from "fs";
+async function handleHookInput(socketPath, rawInput) {
+  if (!existsSync15(socketPath)) return { ok: false, error: "daemon not running" };
+  let parsed;
+  try {
+    parsed = JSON.parse(rawInput);
+  } catch {
+    return { ok: false, error: "invalid hook json" };
+  }
+  const evt = parseHookEvent(parsed);
+  if (!evt) return { ok: false, error: "unrecognized hook payload" };
+  return sendEvent(socketPath, evt);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+export {
+  defaultConfig,
+  resolveConfig,
+  loadConfig,
+  parseFlags,
+  overridesFromFlags,
+  HELP,
+  scrubSecrets,
+  sha256,
+  applyHygiene,
+  priceFor,
+  estimateCostUsd,
+  monthOf,
+  sessionDir,
+  turnFile,
+  envelopeFile,
+  insightsFile,
+  telemetryFile,
+  rawBlobFile,
+  writeTurnFile,
+  writeBlobFile,
+  readTurns,
+  computeEnvelope,
+  rebuildEnvelope,
+  readNewLines,
+  CaptureEngine,
+  isSessionEndEvent,
+  parseHookEvent,
+  sendEvent,
+  StateStore,
+  GitStore,
+  readEntries,
+  listSessionDirs,
+  findTranscript,
+  Daemon,
+  THRESHOLDS,
+  deriveSignals,
+  guessTopic,
+  deriveTags,
+  FakeProvider,
+  buildPrompt,
+  parseLabelJson,
+  LlmProvider,
+  claudeRunner,
+  grokRunner,
+  ollamaRunner,
+  makeProvider,
+  labelSession,
+  reindexStore,
+  DEFAULT_HOOK_EVENTS,
+  mergeHooks,
+  installHooks,
+  isoNano,
+  buildTracePayload,
+  buildMetricPayload,
+  postOtlp,
+  exportSession,
+  exportStore,
+  grokSessionsRoot,
+  discoverGrokSessions,
+  parseGrokSession,
+  codexSessionsRoot,
+  discoverCodexSessions,
+  parseCodexSession,
+  writeImportedSession,
+  SessionIndex,
+  syncIndex,
+  listClaudeTranscripts,
+  cmdInit,
+  cmdStatus,
+  cmdBackfill,
+  cmdReindex,
+  cmdInstallHooks,
+  cmdDoctor,
+  cmdExport,
+  cmdIndex,
+  cmdQuery,
+  cmdSearch,
+  startDaemon,
+  handleHookInput,
+  readStdin
+};