@fml-inc/panopticon 0.1.0

package/dist/chunk-NXH7AONS.js

@@ -0,0 +1,1120 @@
+import {
+  updateSessionMessageCounts,
+  upsertSession,
+  upsertSessionCwd,
+  upsertSessionRepository
+} from "./chunk-BVOE7A2Z.js";
+import {
+  resolveRepoFromCwd
+} from "./chunk-YVRWVDIA.js";
+import {
+  log
+} from "./chunk-7Q3BJMLG.js";
+import {
+  refreshIfStale
+} from "./chunk-3TZAKV3M.js";
+import {
+  allTargets
+} from "./chunk-QVK6VGCV.js";
+import {
+  SCANNER_DATA_VERSION,
+  SCHEMA_SQL,
+  closeDb,
+  getDb,
+  markResyncComplete,
+  needsResync
+} from "./chunk-DZ5HJFB4.js";
+import {
+  config
+} from "./chunk-K7YUPLES.js";
+
+// src/scanner/reparse.ts
+import fs3 from "fs";
+import { gunzipSync as gunzipSync2 } from "zlib";
+import Database from "better-sqlite3";
+
+// src/scanner/loop.ts
+import fs2 from "fs";
+
+// src/archive/local.ts
+import fs from "fs";
+import path from "path";
+import { gunzipSync, gzipSync } from "zlib";
+var LocalArchiveBackend = class {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  putSync(sessionId, source, content) {
+    const dir = path.join(this.baseDir, sessionId);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${source}.jsonl.gz`);
+    const compressed = gzipSync(content);
+    fs.writeFileSync(filePath, compressed);
+  }
+  getSync(sessionId, source) {
+    const filePath = path.join(this.baseDir, sessionId, `${source}.jsonl.gz`);
+    if (!fs.existsSync(filePath)) return null;
+    const compressed = fs.readFileSync(filePath);
+    return gunzipSync(compressed);
+  }
+  hasSync(sessionId, source) {
+    const filePath = path.join(this.baseDir, sessionId, `${source}.jsonl.gz`);
+    return fs.existsSync(filePath);
+  }
+  list() {
+    const results = [];
+    if (!fs.existsSync(this.baseDir)) return results;
+    for (const sessionId of fs.readdirSync(this.baseDir)) {
+      const sessionDir = path.join(this.baseDir, sessionId);
+      const stat = fs.statSync(sessionDir);
+      if (!stat.isDirectory()) continue;
+      for (const file of fs.readdirSync(sessionDir)) {
+        if (!file.endsWith(".jsonl.gz")) continue;
+        const source = file.replace(/\.jsonl\.gz$/, "");
+        const fileStat = fs.statSync(path.join(sessionDir, file));
+        results.push({
+          sessionId,
+          source,
+          sizeBytes: fileStat.size
+        });
+      }
+    }
+    return results;
+  }
+  stats() {
+    const entries = this.list();
+    return {
+      totalFiles: entries.length,
+      totalBytes: entries.reduce((sum, e) => sum + e.sizeBytes, 0)
+    };
+  }
+};
+
+// src/archive/index.ts
+import path2 from "path";
+var _backend = null;
+function getArchiveBackend() {
+  if (!_backend) {
+    _backend = new LocalArchiveBackend(path2.join(config.dataDir, "archive"));
+  }
+  return _backend;
+}
+
+// src/summary/llm.ts
+import { execFileSync, spawnSync } from "child_process";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/summary/loop.ts
+var MIN_MESSAGES = 3;
+var SUMMARY_THRESHOLD = 20;
+var MAX_PER_CYCLE = 50;
+function buildDeterministicSummary(sessionId) {
+  const db = getDb();
+  const firstUser = db.prepare(
+    "SELECT SUBSTR(content, 1, 200) as content FROM messages WHERE session_id = ? AND role = 'user' AND is_system = 0 ORDER BY ordinal ASC LIMIT 1"
+  ).get(sessionId);
+  const counts = db.prepare(
+    "SELECT COUNT(*) as msg_count, SUM(CASE WHEN role = 'user' AND is_system = 0 THEN 1 ELSE 0 END) as user_count FROM messages WHERE session_id = ?"
+  ).get(sessionId);
+  const tools = db.prepare(
+    "SELECT tool_name, COUNT(*) as cnt FROM tool_calls WHERE session_id = ? GROUP BY tool_name ORDER BY cnt DESC LIMIT 5"
+  ).all(sessionId);
+  const files = db.prepare(
+    "SELECT DISTINCT json_extract(input_json, '$.file_path') as fp FROM tool_calls WHERE session_id = ? AND tool_name IN ('Write', 'Edit') AND input_json IS NOT NULL LIMIT 10"
+  ).all(sessionId);
+  if (!firstUser && counts.msg_count === 0) return null;
+  const parts = [];
+  if (firstUser) parts.push(`Prompt: "${firstUser.content}"`);
+  parts.push(`${counts.msg_count} messages (${counts.user_count} user)`);
+  if (tools.length > 0) {
+    parts.push(
+      `Tools: ${tools.map((t) => `${t.tool_name}(${t.cnt})`).join(", ")}`
+    );
+  }
+  const filePaths = files.map((f) => f.fp).filter(Boolean);
+  if (filePaths.length > 0) {
+    parts.push(`Files: ${filePaths.join(", ")}`);
+  }
+  return parts.join(". ");
+}
+function generateSummariesOnce(log2 = () => {
+}) {
+  const db = getDb();
+  let updated = 0;
+  const sessions = db.prepare(
+    `
+    SELECT s.session_id, s.message_count, s.summary_version, s.ended_at_ms,
+           EXISTS(SELECT 1 FROM session_repositories WHERE session_id = s.session_id) as has_repo
+    FROM sessions s
+    WHERE s.message_count >= ?
+      AND (
+        s.summary IS NULL
+        OR (s.message_count - COALESCE(s.summary_version, 0)) >= ?
+        OR (s.ended_at_ms IS NOT NULL AND s.ended_at_ms > COALESCE(
+          (SELECT MAX(created_at_ms) FROM session_summary_deltas WHERE session_id = s.session_id),
+          0
+        ))
+      )
+    ORDER BY s.started_at_ms DESC
+    LIMIT ?
+  `
+  ).all(MIN_MESSAGES, SUMMARY_THRESHOLD, MAX_PER_CYCLE);
+  for (const sess of sessions) {
+    try {
+      const summary = buildDeterministicSummary(sess.session_id);
+      if (!summary) continue;
+      db.prepare(
+        "UPDATE sessions SET summary = ?, summary_version = ?, sync_dirty = 1, sync_seq = COALESCE(sync_seq, 0) + 1 WHERE session_id = ?"
+      ).run(summary, sess.message_count, sess.session_id);
+      updated++;
+      log2(`Summarized ${sess.session_id} (${sess.message_count} messages)`);
+    } catch (err) {
+      log2(
+        `Summary error for ${sess.session_id}: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  return { updated };
+}
+
+// src/scanner/store.ts
+import path4 from "path";
+function upsertSession2(meta, filePath, source) {
+  let project;
+  if (meta.cwd) {
+    const info = resolveRepoFromCwd(meta.cwd);
+    if (info) {
+      project = info.repo;
+    } else {
+      project = path4.basename(meta.cwd);
+    }
+  }
+  upsertSession({
+    session_id: meta.sessionId,
+    target: source,
+    started_at_ms: meta.startedAtMs,
+    first_prompt: meta.firstPrompt,
+    model: meta.model,
+    cli_version: meta.cliVersion,
+    scanner_file_path: filePath,
+    has_scanner: 1,
+    project,
+    created_at: meta.startedAtMs ?? Date.now(),
+    parent_session_id: meta.parentSessionId,
+    relationship_type: meta.relationshipType ?? (meta.parentSessionId ? "subagent" : void 0)
+  });
+  if (meta.cwd) {
+    upsertSessionCwd(meta.sessionId, meta.cwd, meta.startedAtMs ?? Date.now());
+  }
+  if (meta.cwd) {
+    const info = resolveRepoFromCwd(meta.cwd);
+    if (info) {
+      upsertSessionRepository(
+        meta.sessionId,
+        info.repo,
+        meta.startedAtMs ?? Date.now(),
+        void 0,
+        info.branch
+      );
+    }
+  }
+}
+var INSERT_TURN_SQL = `
+  INSERT OR IGNORE INTO scanner_turns
+    (session_id, source, turn_index, timestamp_ms, model, role,
+     content_preview, input_tokens, output_tokens,
+     cache_read_tokens, cache_creation_tokens, reasoning_tokens)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+function insertTurns(turns, source) {
+  if (turns.length === 0) return;
+  const db = getDb();
+  const stmt = db.prepare(INSERT_TURN_SQL);
+  const tx = db.transaction(() => {
+    for (const t of turns) {
+      stmt.run(
+        t.sessionId,
+        source,
+        t.turnIndex,
+        t.timestampMs,
+        t.model ?? null,
+        t.role,
+        t.contentPreview ?? null,
+        t.inputTokens,
+        t.outputTokens,
+        t.cacheReadTokens,
+        t.cacheCreationTokens,
+        t.reasoningTokens
+      );
+    }
+  });
+  tx();
+}
+var INSERT_EVENT_SQL = `
+  INSERT OR IGNORE INTO scanner_events
+    (session_id, source, event_type, timestamp_ms, tool_name, tool_input, tool_output, content, metadata)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+function insertScannerEvents(events, source) {
+  if (events.length === 0) return;
+  const db = getDb();
+  const stmt = db.prepare(INSERT_EVENT_SQL);
+  const tx = db.transaction(() => {
+    for (const e of events) {
+      stmt.run(
+        e.sessionId,
+        source,
+        e.eventType,
+        e.timestampMs,
+        e.toolName ?? null,
+        e.toolInput ?? null,
+        e.toolOutput ?? null,
+        e.content ?? null,
+        e.metadata ? JSON.stringify(e.metadata) : null
+      );
+    }
+  });
+  tx();
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.eventType !== "tool_call" || !e.toolInput) continue;
+    try {
+      const input = JSON.parse(e.toolInput);
+      const fp = input.file_path ?? input.path;
+      if (typeof fp !== "string" || !path4.isAbsolute(fp)) continue;
+      const dir = path4.dirname(fp);
+      if (seen.has(dir)) continue;
+      seen.add(dir);
+      const info = resolveRepoFromCwd(dir);
+      if (info) {
+        upsertSessionRepository(
+          e.sessionId,
+          info.repo,
+          e.timestampMs,
+          void 0,
+          info.branch
+        );
+      }
+    } catch {
+    }
+  }
+}
+var UPDATE_TOTALS_SQL = `
+  UPDATE sessions SET
+    total_input_tokens = (SELECT COALESCE(SUM(input_tokens), 0) FROM scanner_turns WHERE session_id = ?),
+    total_output_tokens = (SELECT COALESCE(SUM(output_tokens), 0) FROM scanner_turns WHERE session_id = ?),
+    total_cache_read_tokens = (SELECT COALESCE(SUM(cache_read_tokens), 0) FROM scanner_turns WHERE session_id = ?),
+    total_cache_creation_tokens = (SELECT COALESCE(SUM(cache_creation_tokens), 0) FROM scanner_turns WHERE session_id = ?),
+    total_reasoning_tokens = (SELECT COALESCE(SUM(reasoning_tokens), 0) FROM scanner_turns WHERE session_id = ?),
+    turn_count = (SELECT COUNT(*) FROM scanner_turns WHERE session_id = ?)
+  WHERE session_id = ?
+`;
+function updateSessionTotals(sessionId) {
+  const db = getDb();
+  db.prepare(UPDATE_TOTALS_SQL).run(
+    sessionId,
+    sessionId,
+    sessionId,
+    sessionId,
+    sessionId,
+    sessionId,
+    sessionId
+  );
+  const toolRows = db.prepare(
+    `SELECT tool_name, COUNT(*) as cnt FROM tool_calls WHERE session_id = ? GROUP BY tool_name`
+  ).all(sessionId);
+  const eventRows = db.prepare(
+    `SELECT event_type, COUNT(*) as cnt FROM scanner_events WHERE session_id = ? GROUP BY event_type`
+  ).all(sessionId);
+  const toolCounts = {};
+  for (const r of toolRows) toolCounts[r.tool_name] = r.cnt;
+  const eventCounts = {};
+  for (const r of eventRows) {
+    const key = r.event_type.startsWith("progress:") ? r.event_type.slice("progress:".length) : r.event_type;
+    eventCounts[key] = (eventCounts[key] ?? 0) + r.cnt;
+  }
+  if (toolRows.length > 0 || eventRows.length > 0) {
+    db.prepare(
+      `UPDATE sessions
+       SET tool_counts = ?,
+           event_type_counts = ?,
+           sync_seq = COALESCE(sync_seq, 0) + 1
+       WHERE session_id = ?`
+    ).run(JSON.stringify(toolCounts), JSON.stringify(eventCounts), sessionId);
+  }
+  refreshIfStale().catch(() => {
+  });
+}
+function readFileWatermark(filePath) {
+  const db = getDb();
+  const row = db.prepare(
+    "SELECT byte_offset FROM scanner_file_watermarks WHERE file_path = ?"
+  ).get(filePath);
+  return row?.byte_offset ?? 0;
+}
+function writeFileWatermark(filePath, byteOffset) {
+  const db = getDb();
+  db.prepare(
+    `INSERT INTO scanner_file_watermarks (file_path, byte_offset, last_scanned_ms)
+     VALUES (?, ?, ?)
+     ON CONFLICT(file_path) DO UPDATE SET byte_offset = excluded.byte_offset, last_scanned_ms = excluded.last_scanned_ms`
+  ).run(filePath, byteOffset, Date.now());
+}
+function snapshotSyncIds(sessionId) {
+  const db = getDb();
+  const saved = { turns: [], events: [], toolCalls: [] };
+  const forkRows = db.prepare(
+    "SELECT session_id FROM sessions WHERE parent_session_id = ? AND relationship_type = 'fork'"
+  ).all(sessionId);
+  const allIds = [sessionId, ...forkRows.map((r) => r.session_id)];
+  for (const sid of allIds) {
+    const turns = db.prepare(
+      "SELECT session_id, source, turn_index, sync_id FROM scanner_turns WHERE session_id = ?"
+    ).all(sid);
+    for (const t of turns) {
+      saved.turns.push({
+        sessionId: t.session_id,
+        source: t.source,
+        turnIndex: t.turn_index,
+        syncId: t.sync_id
+      });
+    }
+    const events = db.prepare(
+      "SELECT session_id, source, event_type, timestamp_ms, COALESCE(tool_name, '') as tool_name, sync_id FROM scanner_events WHERE session_id = ?"
+    ).all(sid);
+    for (const e of events) {
+      saved.events.push({
+        sessionId: e.session_id,
+        source: e.source,
+        eventType: e.event_type,
+        timestampMs: e.timestamp_ms,
+        toolName: e.tool_name,
+        syncId: e.sync_id
+      });
+    }
+    const tcs = db.prepare(
+      `SELECT tc.session_id, m.ordinal, COALESCE(tc.tool_use_id, '') as tool_use_id,
+                tc.tool_name, tc.sync_id
+         FROM tool_calls tc
+         INNER JOIN messages m ON tc.message_id = m.id
+         WHERE tc.session_id = ?`
+    ).all(sid);
+    for (const tc of tcs) {
+      saved.toolCalls.push({
+        sessionId: tc.session_id,
+        ordinal: tc.ordinal,
+        toolUseId: tc.tool_use_id,
+        toolName: tc.tool_name,
+        syncId: tc.sync_id
+      });
+    }
+  }
+  return saved;
+}
+function resetFileForReparse(filePath, sessionId) {
+  const db = getDb();
+  const saved = sessionId ? snapshotSyncIds(sessionId) : { turns: [], events: [], toolCalls: [] };
+  db.prepare("DELETE FROM scanner_file_watermarks WHERE file_path = ?").run(
+    filePath
+  );
+  if (sessionId) {
+    db.prepare("DELETE FROM scanner_turns WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM scanner_events WHERE session_id = ?").run(
+      sessionId
+    );
+    db.prepare("DELETE FROM tool_calls WHERE session_id = ?").run(sessionId);
+    db.prepare(
+      "DELETE FROM messages_fts WHERE rowid IN (SELECT id FROM messages WHERE session_id = ?)"
+    ).run(sessionId);
+    db.prepare("DELETE FROM messages WHERE session_id = ?").run(sessionId);
+    const forkSessionFilter = "SELECT session_id FROM sessions WHERE parent_session_id = ? AND relationship_type = 'fork'";
+    db.prepare(
+      `DELETE FROM scanner_turns WHERE session_id IN (${forkSessionFilter})`
+    ).run(sessionId);
+    db.prepare(
+      `DELETE FROM scanner_events WHERE session_id IN (${forkSessionFilter})`
+    ).run(sessionId);
+    db.prepare(
+      `DELETE FROM tool_calls WHERE session_id IN (${forkSessionFilter})`
+    ).run(sessionId);
+    db.prepare(
+      `DELETE FROM messages_fts WHERE rowid IN (SELECT id FROM messages WHERE session_id IN (${forkSessionFilter}))`
+    ).run(sessionId);
+    db.prepare(
+      `DELETE FROM messages WHERE session_id IN (${forkSessionFilter})`
+    ).run(sessionId);
+    db.prepare(
+      "DELETE FROM sessions WHERE parent_session_id = ? AND relationship_type = 'fork'"
+    ).run(sessionId);
+  }
+  return saved;
+}
+function restoreSyncIds(saved) {
+  if (!saved.turns.length && !saved.events.length && !saved.toolCalls.length)
+    return;
+  const db = getDb();
+  const tx = db.transaction(() => {
+    if (saved.turns.length > 0) {
+      const stmt = db.prepare(
+        "UPDATE scanner_turns SET sync_id = ? WHERE session_id = ? AND source = ? AND turn_index = ?"
+      );
+      for (const t of saved.turns) {
+        stmt.run(t.syncId, t.sessionId, t.source, t.turnIndex);
+      }
+    }
+    if (saved.events.length > 0) {
+      const stmt = db.prepare(
+        `UPDATE scanner_events SET sync_id = ?
+         WHERE session_id = ? AND source = ? AND event_type = ? AND timestamp_ms = ?
+           AND COALESCE(tool_name, '') = ?`
+      );
+      for (const e of saved.events) {
+        stmt.run(
+          e.syncId,
+          e.sessionId,
+          e.source,
+          e.eventType,
+          e.timestampMs,
+          e.toolName
+        );
+      }
+    }
+    if (saved.toolCalls.length > 0) {
+      const stmt = db.prepare(
+        `UPDATE tool_calls SET sync_id = ?
+         WHERE message_id IN (SELECT id FROM messages WHERE session_id = ? AND ordinal = ?)
+           AND COALESCE(tool_use_id, '') = ?
+           AND tool_name = ?`
+      );
+      for (const tc of saved.toolCalls) {
+        stmt.run(
+          tc.syncId,
+          tc.sessionId,
+          tc.ordinal,
+          tc.toolUseId,
+          tc.toolName
+        );
+      }
+    }
+  });
+  tx();
+}
+function getTurnCount(sessionId, source) {
+  const db = getDb();
+  const row = db.prepare(
+    "SELECT COUNT(*) as count FROM scanner_turns WHERE session_id = ? AND source = ?"
+  ).get(sessionId, source);
+  return row.count;
+}
+function readArchivedSize(filePath) {
+  const db = getDb();
+  const row = db.prepare(
+    "SELECT archived_size FROM scanner_file_watermarks WHERE file_path = ?"
+  ).get(filePath);
+  return row?.archived_size ?? 0;
+}
+function writeArchivedSize(filePath, size) {
+  const db = getDb();
+  db.prepare(
+    "UPDATE scanner_file_watermarks SET archived_size = ? WHERE file_path = ?"
+  ).run(size, filePath);
+}
+function toolUseSummary(toolCalls) {
+  return toolCalls.map((tc) => {
+    let label = "";
+    if (tc.inputJson) {
+      try {
+        const input = JSON.parse(tc.inputJson);
+        label = input.description ?? input.command ?? input.pattern ?? input.file_path ?? input.query ?? input.prompt ?? input.skill ?? "";
+      } catch {
+      }
+    }
+    return label ? `[${tc.toolName}: ${label}]` : `[${tc.toolName}]`;
+  }).join("\n");
+}
+var INSERT_MESSAGE_SQL = `
+  INSERT OR IGNORE INTO messages
+    (session_id, ordinal, role, content, timestamp_ms,
+     has_thinking, has_tool_use, content_length, is_system,
+     model, token_usage, context_tokens, output_tokens,
+     has_context_tokens, has_output_tokens, uuid, parent_uuid)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+var INSERT_TOOL_CALL_SQL = `
+  INSERT INTO tool_calls
+    (message_id, session_id, tool_name, category, tool_use_id,
+     input_json, skill_name, result_content_length, result_content,
+     subagent_session_id, duration_ms)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+function insertMessages(messages, orphanedToolResults) {
+  if (messages.length === 0 && !orphanedToolResults?.size) return;
+  const db = getDb();
+  const toolResultMap = /* @__PURE__ */ new Map();
+  if (orphanedToolResults) {
+    for (const [id, result] of orphanedToolResults) {
+      toolResultMap.set(id, result);
+    }
+  }
+  for (const msg of messages) {
+    for (const [id, result] of msg.toolResults) {
+      toolResultMap.set(id, result);
+    }
+  }
+  const msgStmt = db.prepare(INSERT_MESSAGE_SQL);
+  const tcStmt = db.prepare(INSERT_TOOL_CALL_SQL);
+  const ftsStmt = db.prepare(
+    "INSERT INTO messages_fts(rowid, content) VALUES (?, ?)"
+  );
+  const tx = db.transaction(() => {
+    for (const msg of messages) {
+      let content = msg.content;
+      if (!content && msg.role === "assistant" && msg.toolCalls.length > 0) {
+        content = toolUseSummary(msg.toolCalls);
+      }
+      const result = msgStmt.run(
+        msg.sessionId,
+        msg.ordinal,
+        msg.role,
+        content,
+        msg.timestampMs ?? null,
+        msg.hasThinking ? 1 : 0,
+        msg.hasToolUse ? 1 : 0,
+        msg.contentLength,
+        msg.isSystem ? 1 : 0,
+        msg.model ?? "",
+        msg.tokenUsage ?? "",
+        msg.contextTokens ?? 0,
+        msg.outputTokens ?? 0,
+        msg.hasContextTokens ? 1 : 0,
+        msg.hasOutputTokens ? 1 : 0,
+        msg.uuid ?? null,
+        msg.parentUuid ?? null
+      );
+      if (result.changes === 0) continue;
+      const messageId = result.lastInsertRowid;
+      ftsStmt.run(messageId, content);
+      for (const tc of msg.toolCalls) {
+        const toolResult = toolResultMap.get(tc.toolUseId);
+        const durationMs = tc.timestampMs && toolResult?.timestampMs ? toolResult.timestampMs - tc.timestampMs : null;
+        tcStmt.run(
+          messageId,
+          msg.sessionId,
+          tc.toolName,
+          tc.category,
+          tc.toolUseId,
+          tc.inputJson ?? null,
+          tc.skillName ?? null,
+          toolResult?.contentLength ?? null,
+          toolResult?.contentRaw ?? null,
+          tc.subagentSessionId ?? null,
+          durationMs != null && durationMs >= 0 ? durationMs : null
+        );
+      }
+    }
+    if (toolResultMap.size > 0) {
+      const backfillStmt = db.prepare(
+        `UPDATE tool_calls
+         SET result_content = ?, result_content_length = ?
+         WHERE tool_use_id = ? AND result_content IS NULL`
+      );
+      for (const [toolUseId, result] of toolResultMap) {
+        backfillStmt.run(result.contentRaw, result.contentLength, toolUseId);
+      }
+    }
+  });
+  tx();
+}
+function linkSubagentSessions() {
+  const db = getDb();
+  const result = db.prepare(
+    `UPDATE sessions
+     SET parent_session_id = (
+           SELECT tc.session_id
+           FROM tool_calls tc
+           WHERE tc.subagent_session_id = sessions.session_id
+           LIMIT 1
+         ),
+         relationship_type = 'subagent',
+         sync_seq = COALESCE(sync_seq, 0) + 1
+     WHERE (relationship_type = '' OR relationship_type IS NULL)
+       AND parent_session_id IS NULL
+       AND EXISTS (
+           SELECT 1 FROM tool_calls tc
+           WHERE tc.subagent_session_id = sessions.session_id
+         )`
+  ).run();
+  return result.changes;
+}
+function getMaxOrdinal(sessionId) {
+  const db = getDb();
+  const row = db.prepare(
+    "SELECT MAX(ordinal) as max_ord FROM messages WHERE session_id = ?"
+  ).get(sessionId);
+  return row.max_ord ?? -1;
+}
+
+// src/scanner/loop.ts
+var DEFAULT_IDLE_MS = 6e4;
+var DEFAULT_CATCHUP_MS = 5e3;
+function scanOnce() {
+  getDb();
+  let filesScanned = 0;
+  let newTurns = 0;
+  for (const target of allTargets()) {
+    if (!target.scanner) continue;
+    const source = target.id;
+    for (const { filePath } of target.scanner.discover()) {
+      let offset = readFileWatermark(filePath);
+      let result = target.scanner.parseFile(filePath, offset);
+      if (!result) continue;
+      let savedSyncIds;
+      if (result.needsFullReparse && offset > 0) {
+        savedSyncIds = resetFileForReparse(filePath, result.meta?.sessionId);
+        offset = 0;
+        result = target.scanner.parseFile(filePath, 0);
+        if (!result) continue;
+        log.scanner.info(`Reparsing ${filePath} from start (fork detected)`);
+      }
+      filesScanned++;
+      if (offset > 0 && result.meta?.sessionId && !result.absoluteIndices) {
+        const existingCount = getTurnCount(result.meta.sessionId, source);
+        if (existingCount > 0) {
+          reindexTurns(result, existingCount);
+        }
+        if (result.messages.length > 0) {
+          const maxOrd = getMaxOrdinal(result.meta.sessionId);
+          reindexMessages(result, maxOrd + 1);
+        }
+      }
+      if (!result.meta?.sessionId) {
+        writeFileWatermark(filePath, result.newByteOffset);
+        continue;
+      }
+      const sessionId = result.meta.sessionId;
+      const fileMeta = result.meta;
+      const fileResult = result;
+      const db = getDb();
+      db.transaction(() => {
+        upsertSession2(fileMeta, filePath, source);
+        if (fileResult.turns.length > 0) {
+          insertTurns(fileResult.turns, source);
+          updateSessionTotals(sessionId);
+        }
+        if (fileResult.events.length > 0) {
+          insertScannerEvents(fileResult.events, source);
+        }
+        if (fileResult.messages.length > 0 || fileResult.orphanedToolResults?.size) {
+          insertMessages(fileResult.messages, fileResult.orphanedToolResults);
+          updateSessionMessageCounts(sessionId);
+        }
+        writeFileWatermark(filePath, fileResult.newByteOffset);
+      })();
+      newTurns += result.turns.length;
+      if (result.forks) {
+        for (const fork of result.forks) {
+          if (!fork.meta?.sessionId) continue;
+          const forkSessionId = fork.meta.sessionId;
+          const forkMeta = fork.meta;
+          db.transaction(() => {
+            upsertSession2(forkMeta, filePath, source);
+            if (fork.turns.length > 0) {
+              insertTurns(fork.turns, source);
+              updateSessionTotals(forkSessionId);
+            }
+            if (fork.events.length > 0) {
+              insertScannerEvents(fork.events, source);
+            }
+            if (fork.messages.length > 0 || fork.orphanedToolResults?.size) {
+              insertMessages(fork.messages, fork.orphanedToolResults);
+              updateSessionMessageCounts(forkSessionId);
+            }
+          })();
+          newTurns += fork.turns.length;
+        }
+      }
+      if (savedSyncIds) {
+        restoreSyncIds(savedSyncIds);
+      }
+      try {
+        const fileSize = fs2.statSync(filePath).size;
+        const archivedSize = readArchivedSize(filePath);
+        if (fileSize > archivedSize) {
+          const rawContent = fs2.readFileSync(filePath);
+          getArchiveBackend().putSync(
+            result.meta.sessionId,
+            source,
+            rawContent
+          );
+          writeArchivedSize(filePath, fileSize);
+        }
+      } catch (archiveErr) {
+        log.scanner.warn(
+          `Archive error for ${filePath}: ${archiveErr instanceof Error ? archiveErr.message : archiveErr}`
+        );
+      }
+    }
+  }
+  if (filesScanned > 0) {
+    const linked = linkSubagentSessions();
+    if (linked > 0) {
+      log.scanner.info(
+        `Linked ${linked} subagent session${linked > 1 ? "s" : ""}`
+      );
+    }
+    log.scanner.info(`Scanned ${filesScanned} files, ${newTurns} new turns`);
+  }
+  return { filesScanned, newTurns };
+}
+function reindexTurns(result, startIndex) {
+  for (let i = 0; i < result.turns.length; i++) {
+    result.turns[i].turnIndex = startIndex + i;
+  }
+}
+function reindexMessages(result, startOrdinal) {
+  for (let i = 0; i < result.messages.length; i++) {
+    result.messages[i].ordinal = startOrdinal + i;
+  }
+}
+function createScannerLoop(opts) {
+  const idleMs = opts.idleIntervalMs ?? DEFAULT_IDLE_MS;
+  const catchUpMs = opts.catchUpIntervalMs ?? DEFAULT_CATCHUP_MS;
+  let timer = null;
+  let stopping = false;
+  let reparseChecked = false;
+  let ready = false;
+  function scheduleNext(hadWork) {
+    if (stopping) return;
+    const delay = hadWork ? catchUpMs : idleMs;
+    timer = setTimeout(() => tick(), delay);
+    if (!opts.keepAlive && timer.unref) {
+      timer.unref();
+    }
+  }
+  function tick() {
+    if (stopping) return;
+    if (!reparseChecked) {
+      reparseChecked = true;
+      if (needsResync()) {
+        log.scanner.info("Data version outdated \u2014 running atomic reparse...");
+        import("./reparse-636YZCE3.js").then(({ reparseAll: reparseAll2 }) => {
+          try {
+            const result = reparseAll2((msg) => log.scanner.info(msg));
+            if (result.success) {
+              markResyncComplete();
+            } else {
+              log.scanner.error(
+                `Reparse failed: ${result.error ?? "unknown"}`
+              );
+            }
+          } catch (err) {
+            log.scanner.error(
+              `Reparse error: ${err instanceof Error ? err.message : err}`
+            );
+          }
+          scheduleNext(true);
+        }).catch((err) => {
+          log.scanner.error(
+            `Reparse import error: ${err instanceof Error ? err.message : err}`
+          );
+          scheduleNext(false);
+        });
+        return;
+      }
+      markResyncComplete();
+    }
+    let hadWork = false;
+    try {
+      const { newTurns } = scanOnce();
+      hadWork = newTurns > 0;
+      if (!ready) {
+        ready = true;
+        opts.onReady?.();
+      }
+      if (!hadWork && ready) {
+        try {
+          generateSummariesOnce((msg) => log.scanner.info(msg));
+        } catch (err) {
+          log.scanner.error(
+            `Session summary error: ${err instanceof Error ? err.message : err}`
+          );
+        }
+      }
+    } catch (err) {
+      log.scanner.error(
+        `Scan error: ${err instanceof Error ? err.message : err}`
+      );
+    }
+    if (!stopping) {
+      scheduleNext(hadWork);
+    }
+  }
+  return {
+    start() {
+      if (timer) return;
+      stopping = false;
+      log.scanner.info("Starting scanner");
+      tick();
+    },
+    stop() {
+      stopping = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+        log.scanner.info("Stopped scanner");
+      }
+    }
+  };
+}
+
+// src/scanner/reparse.ts
+var PRESERVED_TABLES = [
+  "hook_events",
+  "otel_logs",
+  "otel_metrics",
+  "otel_spans",
+  "watermarks",
+  "target_session_sync",
+  "model_pricing",
+  "user_config_snapshots",
+  "repo_config_snapshots"
+];
+var SESSION_MERGE_COLUMNS = [
+  "has_hooks",
+  "has_otel",
+  "otel_input_tokens",
+  "otel_output_tokens",
+  "otel_cache_read_tokens",
+  "otel_cache_creation_tokens",
+  "summary",
+  "summary_version",
+  "permission_mode",
+  "is_automated",
+  "created_at"
+];
+function removeTempFiles(tempPath) {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      fs3.unlinkSync(tempPath + suffix);
+    } catch {
+    }
+  }
+}
+function removeWAL(dbPath) {
+  for (const suffix of ["-wal", "-shm"]) {
+    try {
+      fs3.unlinkSync(dbPath + suffix);
+    } catch {
+    }
+  }
+}
+function initTempDb(tempPath) {
+  const db = new Database(tempPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  db.function(
+    "decompress",
+    (blob) => blob ? gunzipSync2(blob).toString() : null
+  );
+  db.exec(SCHEMA_SQL);
+  return db;
+}
+function reparseAll(log2 = () => {
+}) {
+  const origPath = config.dbPath;
+  const tempPath = `${origPath}-reparse`;
+  removeTempFiles(tempPath);
+  log2("Starting atomic reparse...");
+  let tempDb;
+  try {
+    tempDb = initTempDb(tempPath);
+    tempDb.close();
+  } catch (err) {
+    removeTempFiles(tempPath);
+    return {
+      success: false,
+      filesScanned: 0,
+      newTurns: 0,
+      error: `Failed to create temp DB: ${err}`
+    };
+  }
+  let oldSessionCount = 0;
+  try {
+    const oldDb = new Database(origPath);
+    oldSessionCount = oldDb.prepare("SELECT COUNT(*) as c FROM sessions").get().c;
+    oldDb.close();
+  } catch {
+  }
+  closeDb();
+  const savedDbPath = config.dbPath;
+  config.dbPath = tempPath;
+  let filesScanned = 0;
+  let newTurns = 0;
+  try {
+    const result = scanOnce();
+    filesScanned = result.filesScanned;
+    newTurns = result.newTurns;
+  } catch (err) {
+    config.dbPath = savedDbPath;
+    closeDb();
+    getDb();
+    removeTempFiles(tempPath);
+    return {
+      success: false,
+      filesScanned: 0,
+      newTurns: 0,
+      error: `Scan into temp DB failed: ${err}`
+    };
+  }
+  const db = getDb();
+  const tempSessionCount = db.prepare("SELECT COUNT(*) as c FROM sessions").get().c;
+  closeDb();
+  config.dbPath = savedDbPath;
+  if (tempSessionCount === 0 && oldSessionCount > 0) {
+    log2(
+      `Reparse aborted: temp DB has 0 sessions but old DB has ${oldSessionCount}`
+    );
+    getDb();
+    removeTempFiles(tempPath);
+    return {
+      success: false,
+      filesScanned,
+      newTurns,
+      error: `Aborted: 0 sessions in reparse vs ${oldSessionCount} in old DB`
+    };
+  }
+  log2("Copying preserved data from old database...");
+  try {
+    tempDb = new Database(tempPath);
+    tempDb.pragma("journal_mode = WAL");
+    tempDb.function(
+      "decompress",
+      (blob) => blob ? gunzipSync2(blob).toString() : null
+    );
+    const escapedPath = origPath.replace(/'/g, "''");
+    tempDb.exec(`ATTACH DATABASE '${escapedPath}' AS old_db`);
+    const tx = tempDb.transaction(() => {
+      for (const table of PRESERVED_TABLES) {
+        try {
+          tempDb.exec(
+            `INSERT OR IGNORE INTO main.${table} SELECT * FROM old_db.${table}`
+          );
+        } catch (e) {
+          log2(`  Skipping ${table}: ${e instanceof Error ? e.message : e}`);
+        }
+      }
+      try {
+        tempDb.exec(
+          "INSERT INTO main.hook_events_fts(rowid, payload) SELECT id, decompress(payload) FROM main.hook_events"
+        );
+      } catch (e) {
+        log2(`  hook_events_fts rebuild: ${e instanceof Error ? e.message : e}`);
+      }
+      const setClauses = SESSION_MERGE_COLUMNS.map(
+        (col) => `${col} = old_db.sessions.${col}`
+      ).join(", ");
+      try {
+        tempDb.exec(`
+          UPDATE main.sessions SET ${setClauses}
+          FROM old_db.sessions
+          WHERE main.sessions.session_id = old_db.sessions.session_id
+        `);
+      } catch (e) {
+        log2(`  Session merge: ${e instanceof Error ? e.message : e}`);
+      }
+      try {
+        tempDb.exec(
+          "INSERT OR IGNORE INTO main.session_repositories SELECT * FROM old_db.session_repositories"
+        );
+      } catch (e) {
+        log2(`  session_repositories: ${e instanceof Error ? e.message : e}`);
+      }
+      try {
+        tempDb.exec(
+          "INSERT OR IGNORE INTO main.session_cwds SELECT * FROM old_db.session_cwds"
+        );
+      } catch (e) {
+        log2(`  session_cwds: ${e instanceof Error ? e.message : e}`);
+      }
+      try {
+        tempDb.exec(`
+          UPDATE main.scanner_turns SET sync_id = old_db.scanner_turns.sync_id
+          FROM old_db.scanner_turns
+          WHERE main.scanner_turns.session_id = old_db.scanner_turns.session_id
+            AND main.scanner_turns.source = old_db.scanner_turns.source
+            AND main.scanner_turns.turn_index = old_db.scanner_turns.turn_index
+        `);
+      } catch (e) {
+        log2(`  scanner_turns sync_id: ${e instanceof Error ? e.message : e}`);
+      }
+      try {
+        tempDb.exec(`
+          UPDATE main.scanner_events SET sync_id = old_db.scanner_events.sync_id
+          FROM old_db.scanner_events
+          WHERE main.scanner_events.session_id = old_db.scanner_events.session_id
+            AND main.scanner_events.source = old_db.scanner_events.source
+            AND main.scanner_events.event_type = old_db.scanner_events.event_type
+            AND main.scanner_events.timestamp_ms = old_db.scanner_events.timestamp_ms
+            AND COALESCE(main.scanner_events.tool_name, '') = COALESCE(old_db.scanner_events.tool_name, '')
+        `);
+      } catch (e) {
+        log2(`  scanner_events sync_id: ${e instanceof Error ? e.message : e}`);
+      }
+      try {
+        tempDb.exec(`
+          UPDATE main.tool_calls SET sync_id = old_tc.sync_id
+          FROM old_db.tool_calls old_tc
+          INNER JOIN old_db.messages old_m ON old_tc.message_id = old_m.id
+          INNER JOIN main.messages new_m ON new_m.session_id = old_m.session_id AND new_m.ordinal = old_m.ordinal
+          WHERE main.tool_calls.message_id = new_m.id
+            AND COALESCE(main.tool_calls.tool_use_id, '') = COALESCE(old_tc.tool_use_id, '')
+            AND main.tool_calls.tool_name = old_tc.tool_name
+        `);
+      } catch (e) {
+        log2(`  tool_calls sync_id: ${e instanceof Error ? e.message : e}`);
+      }
+    });
+    tx();
+    tempDb.exec("DETACH DATABASE old_db");
+    tempDb.pragma(`user_version = ${SCANNER_DATA_VERSION}`);
+    tempDb.close();
+  } catch (err) {
+    log2(`Failed to copy preserved data: ${err}`);
+    getDb();
+    removeTempFiles(tempPath);
+    return {
+      success: false,
+      filesScanned,
+      newTurns,
+      error: `Copy preserved data failed: ${err}`
+    };
+  }
+  log2("Swapping database files...");
+  try {
+    removeWAL(origPath);
+    fs3.renameSync(tempPath, origPath);
+    removeWAL(tempPath);
+  } catch (err) {
+    log2(`File swap failed: ${err}`);
+    getDb();
+    removeTempFiles(tempPath);
+    return {
+      success: false,
+      filesScanned,
+      newTurns,
+      error: `Atomic swap failed: ${err}`
+    };
+  }
+  getDb();
+  log2(
+    `Reparse complete: ${filesScanned} files, ${newTurns} turns, ${tempSessionCount} sessions`
+  );
+  return { success: true, filesScanned, newTurns };
+}
+
+export {
+  reparseAll,
+  createScannerLoop
+};
+//# sourceMappingURL=chunk-NXH7AONS.js.map