@fml-inc/panopticon 0.1.0

package/dist/chunk-SEXU2WYG.js

@@ -0,0 +1,788 @@
+import {
+  getDb
+} from "./chunk-DZ5HJFB4.js";
+
+// src/sync/reader.ts
+function parseJson(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var HOOK_EVENTS_SQL = `
+  SELECT h.id, h.session_id, h.sync_id, h.event_type, h.timestamp_ms, h.cwd, h.repository,
+         h.tool_name, decompress(h.payload) as payload,
+         h.user_prompt, h.file_path, h.command, h.tool_result,
+         s.target
+  FROM hook_events h
+  LEFT JOIN sessions s ON s.session_id = h.session_id
+  WHERE h.id > ?
+  ORDER BY h.id
+  LIMIT ?
+`;
+function readHookEvents(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(HOOK_EVENTS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    hookId: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    eventType: r.event_type,
+    timestampMs: r.timestamp_ms,
+    cwd: r.cwd,
+    repository: r.repository,
+    toolName: r.tool_name,
+    payload: parseJson(r.payload),
+    userPrompt: r.user_prompt,
+    filePath: r.file_path,
+    command: r.command,
+    toolResult: r.tool_result,
+    target: r.target
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].hookId : afterId;
+  return { rows, maxId };
+}
+var HOOK_COVERED_BODIES = [
+  // Claude Code
+  "claude_code.user_prompt",
+  "claude_code.tool_decision",
+  "claude_code.tool_result",
+  // Gemini CLI
+  "gemini_cli.user_prompt",
+  "gemini_cli.tool_call",
+  "gemini_cli.hook_call"
+];
+var ALL_LOGS_SQL = `
+  SELECT id, sync_id, timestamp_ns, body, attributes, resource_attributes,
+         severity_text, session_id, prompt_id, trace_id, span_id
+  FROM otel_logs
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function mapOtelRows(rawRows) {
+  return rawRows.map((r) => ({
+    id: r.id,
+    syncId: r.sync_id,
+    timestampNs: r.timestamp_ns,
+    body: r.body,
+    attributes: parseJson(r.attributes),
+    resourceAttributes: parseJson(r.resource_attributes),
+    severityText: r.severity_text,
+    sessionId: r.session_id,
+    promptId: r.prompt_id,
+    traceId: r.trace_id,
+    spanId: r.span_id
+  }));
+}
+function readOtelLogs(afterId, limit, hooksInstalled) {
+  const db = getDb();
+  if (!hooksInstalled) {
+    const rawRows2 = db.prepare(ALL_LOGS_SQL).all(afterId, limit);
+    const rows2 = mapOtelRows(rawRows2);
+    const maxId = rows2.length > 0 ? rows2[rows2.length - 1].id : afterId;
+    return { rows: rows2, maxId };
+  }
+  const scanMaxId = db.prepare(
+    "SELECT MAX(id) as m FROM (SELECT id FROM otel_logs WHERE id > ? ORDER BY id LIMIT ?)"
+  ).get(afterId, limit).m;
+  if (scanMaxId == null) return { rows: [], maxId: afterId };
+  const rawRows = db.prepare(
+    `SELECT id, sync_id, timestamp_ns, body, attributes, resource_attributes,
+              severity_text, session_id, prompt_id, trace_id, span_id
+       FROM otel_logs
+       WHERE id > ? AND id <= ?
+         AND body NOT IN (${HOOK_COVERED_BODIES.map(() => "?").join(", ")})
+       ORDER BY id`
+  ).all(afterId, scanMaxId, ...HOOK_COVERED_BODIES);
+  const rows = mapOtelRows(rawRows);
+  return { rows, maxId: scanMaxId };
+}
+var METRICS_SQL = `
+  SELECT id, sync_id, timestamp_ns, name, value, metric_type, unit,
+         attributes, resource_attributes, session_id
+  FROM otel_metrics
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readMetrics(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(METRICS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    syncId: r.sync_id,
+    timestampNs: r.timestamp_ns,
+    name: r.name,
+    value: r.value,
+    metricType: r.metric_type,
+    unit: r.unit,
+    attributes: parseJson(r.attributes),
+    resourceAttributes: parseJson(r.resource_attributes),
+    sessionId: r.session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var SCANNER_TURNS_SQL = `
+  SELECT t.id, t.session_id, t.sync_id, t.source, t.turn_index, t.timestamp_ms,
+         t.model, t.role, t.content_preview,
+         t.input_tokens, t.output_tokens, t.cache_read_tokens,
+         t.cache_creation_tokens, t.reasoning_tokens,
+         s.cli_version
+  FROM scanner_turns t
+  LEFT JOIN sessions s ON s.session_id = t.session_id
+  WHERE t.id > ?
+  ORDER BY t.id
+  LIMIT ?
+`;
+function readScannerTurns(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(SCANNER_TURNS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    source: r.source,
+    turnIndex: r.turn_index,
+    timestampMs: r.timestamp_ms,
+    model: r.model,
+    role: r.role,
+    contentPreview: r.content_preview,
+    inputTokens: r.input_tokens,
+    outputTokens: r.output_tokens,
+    cacheReadTokens: r.cache_read_tokens,
+    cacheCreationTokens: r.cache_creation_tokens,
+    reasoningTokens: r.reasoning_tokens,
+    cliVersion: r.cli_version
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var SCANNER_EVENTS_SQL = `
+  SELECT id, session_id, sync_id, source, event_type, timestamp_ms,
+         tool_name, tool_input, tool_output, content, metadata
+  FROM scanner_events
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readScannerEvents(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(SCANNER_EVENTS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    source: r.source,
+    eventType: r.event_type,
+    timestampMs: r.timestamp_ms,
+    toolName: r.tool_name,
+    toolInput: r.tool_input,
+    toolOutput: r.tool_output,
+    content: r.content,
+    metadata: parseJson(r.metadata)
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var SPANS_SQL = `
+  SELECT id, trace_id, span_id, parent_span_id, name, kind,
+         start_time_ns, end_time_ns, status_code, status_message,
+         attributes, resource_attributes, session_id
+  FROM otel_spans
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readOtelSpans(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(SPANS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    traceId: r.trace_id,
+    spanId: r.span_id,
+    parentSpanId: r.parent_span_id,
+    name: r.name,
+    kind: r.kind,
+    startTimeNs: r.start_time_ns,
+    endTimeNs: r.end_time_ns,
+    statusCode: r.status_code,
+    statusMessage: r.status_message,
+    attributes: parseJson(r.attributes),
+    resourceAttributes: parseJson(r.resource_attributes),
+    sessionId: r.session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function parseJsonArray(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parseJsonObject(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+var USER_CONFIG_SQL = `
+  SELECT id, device_name, snapshot_at_ms, content_hash,
+         permissions, enabled_plugins, hooks, commands, rules, skills
+  FROM user_config_snapshots
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readUserConfigSnapshots(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(USER_CONFIG_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    deviceName: r.device_name,
+    snapshotAtMs: r.snapshot_at_ms,
+    contentHash: r.content_hash,
+    permissions: parseJsonObject(r.permissions),
+    enabledPlugins: parseJsonArray(r.enabled_plugins),
+    hooks: parseJsonArray(r.hooks),
+    commands: parseJsonArray(r.commands),
+    rules: parseJsonArray(r.rules),
+    skills: parseJsonArray(r.skills)
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var REPO_CONFIG_SQL = `
+  SELECT id, repository, cwd, session_id, snapshot_at_ms, content_hash,
+         hooks, mcp_servers, commands, agents, rules,
+         local_hooks, local_mcp_servers, local_permissions,
+         local_is_gitignored, instructions
+  FROM repo_config_snapshots
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readRepoConfigSnapshots(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(REPO_CONFIG_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    repository: r.repository,
+    cwd: r.cwd,
+    sessionId: r.session_id,
+    snapshotAtMs: r.snapshot_at_ms,
+    contentHash: r.content_hash,
+    hooks: parseJsonArray(r.hooks),
+    mcpServers: parseJsonArray(r.mcp_servers),
+    commands: parseJsonArray(r.commands),
+    agents: parseJsonArray(r.agents),
+    rules: parseJsonArray(r.rules),
+    localHooks: parseJsonArray(r.local_hooks),
+    localMcpServers: parseJsonArray(r.local_mcp_servers),
+    localPermissions: parseJsonObject(r.local_permissions),
+    localIsGitignored: r.local_is_gitignored === 1,
+    instructions: parseJsonArray(r.instructions)
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var MESSAGES_SQL = `
+  SELECT id, 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
+  FROM messages
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readMessages(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(MESSAGES_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    ordinal: r.ordinal,
+    role: r.role,
+    content: r.content,
+    timestampMs: r.timestamp_ms,
+    hasThinking: r.has_thinking === 1,
+    hasToolUse: r.has_tool_use === 1,
+    contentLength: r.content_length,
+    isSystem: r.is_system === 1,
+    model: r.model,
+    tokenUsage: r.token_usage,
+    contextTokens: r.context_tokens,
+    outputTokens: r.output_tokens,
+    hasContextTokens: r.has_context_tokens === 1,
+    hasOutputTokens: r.has_output_tokens === 1
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var TOOL_CALLS_SQL = `
+  SELECT id, message_id, session_id, sync_id, tool_name, category, tool_use_id,
+         input_json, skill_name, result_content_length, result_content,
+         subagent_session_id
+  FROM tool_calls
+  WHERE id > ?
+  ORDER BY id
+  LIMIT ?
+`;
+function readToolCalls(afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(TOOL_CALLS_SQL).all(afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    messageId: r.message_id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    toolName: r.tool_name,
+    category: r.category,
+    toolUseId: r.tool_use_id,
+    inputJson: r.input_json,
+    skillName: r.skill_name,
+    resultContentLength: r.result_content_length,
+    resultContent: r.result_content,
+    subagentSessionId: r.subagent_session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var SESSIONS_SQL = `
+  SELECT session_id, target, started_at_ms, ended_at_ms, cwd, first_prompt,
+         permission_mode, agent_version,
+         total_input_tokens, total_output_tokens, total_cache_read_tokens,
+         total_cache_creation_tokens, total_reasoning_tokens, turn_count,
+         models, summary, tool_counts, hook_tool_counts, event_type_counts, hook_event_type_counts, sync_seq,
+         project, machine, message_count, user_message_count,
+         parent_session_id, relationship_type, is_automated, created_at
+  FROM sessions
+  WHERE sync_seq > ?
+  ORDER BY sync_seq
+  LIMIT ?
+`;
+function readSessions(afterSeq, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(SESSIONS_SQL).all(afterSeq, limit);
+  if (rawRows.length === 0) return { rows: [], maxId: afterSeq };
+  const sessionIds = rawRows.map((r) => r.session_id);
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const repoRows = db.prepare(
+    `SELECT session_id, repository, first_seen_ms, git_user_name, git_user_email, branch
+       FROM session_repositories
+       WHERE session_id IN (${placeholders})`
+  ).all(...sessionIds);
+  const cwdRows = db.prepare(
+    `SELECT session_id, cwd, first_seen_ms
+       FROM session_cwds
+       WHERE session_id IN (${placeholders})`
+  ).all(...sessionIds);
+  const reposBySession = /* @__PURE__ */ new Map();
+  for (const r of repoRows) {
+    const list = reposBySession.get(r.session_id) ?? [];
+    list.push({
+      repository: r.repository,
+      firstSeenMs: r.first_seen_ms,
+      gitUserName: r.git_user_name,
+      gitUserEmail: r.git_user_email,
+      branch: r.branch
+    });
+    reposBySession.set(r.session_id, list);
+  }
+  const cwdsBySession = /* @__PURE__ */ new Map();
+  for (const r of cwdRows) {
+    const list = cwdsBySession.get(r.session_id) ?? [];
+    list.push({ cwd: r.cwd, firstSeenMs: r.first_seen_ms });
+    cwdsBySession.set(r.session_id, list);
+  }
+  const rows = rawRows.map((r) => ({
+    sessionId: r.session_id,
+    target: r.target,
+    startedAtMs: r.started_at_ms,
+    endedAtMs: r.ended_at_ms,
+    cwd: r.cwd,
+    firstPrompt: r.first_prompt,
+    permissionMode: r.permission_mode,
+    agentVersion: r.agent_version,
+    totalInputTokens: r.total_input_tokens,
+    totalOutputTokens: r.total_output_tokens,
+    totalCacheReadTokens: r.total_cache_read_tokens,
+    totalCacheCreationTokens: r.total_cache_creation_tokens,
+    totalReasoningTokens: r.total_reasoning_tokens,
+    turnCount: r.turn_count,
+    models: r.models,
+    summary: r.summary,
+    toolCounts: parseJsonObject(r.tool_counts),
+    hookToolCounts: parseJsonObject(r.hook_tool_counts),
+    eventTypeCounts: parseJsonObject(r.event_type_counts),
+    hookEventTypeCounts: parseJsonObject(r.hook_event_type_counts),
+    project: r.project,
+    machine: r.machine,
+    messageCount: r.message_count,
+    userMessageCount: r.user_message_count,
+    parentSessionId: r.parent_session_id,
+    relationshipType: r.relationship_type,
+    isAutomated: r.is_automated === 1,
+    createdAt: r.created_at,
+    repositories: reposBySession.get(r.session_id) ?? [],
+    cwds: cwdsBySession.get(r.session_id) ?? []
+  }));
+  const maxId = rawRows[rawRows.length - 1].sync_seq;
+  return { rows, maxId };
+}
+function readSessionMessages(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, 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
+       FROM messages
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    ordinal: r.ordinal,
+    role: r.role,
+    content: r.content,
+    timestampMs: r.timestamp_ms,
+    hasThinking: r.has_thinking === 1,
+    hasToolUse: r.has_tool_use === 1,
+    contentLength: r.content_length,
+    isSystem: r.is_system === 1,
+    model: r.model,
+    tokenUsage: r.token_usage,
+    contextTokens: r.context_tokens,
+    outputTokens: r.output_tokens,
+    hasContextTokens: r.has_context_tokens === 1,
+    hasOutputTokens: r.has_output_tokens === 1
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionToolCalls(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, message_id, session_id, sync_id, tool_name, category, tool_use_id,
+              input_json, skill_name, result_content_length, result_content,
+              subagent_session_id
+       FROM tool_calls
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    messageId: r.message_id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    toolName: r.tool_name,
+    category: r.category,
+    toolUseId: r.tool_use_id,
+    inputJson: r.input_json,
+    skillName: r.skill_name,
+    resultContentLength: r.result_content_length,
+    resultContent: r.result_content,
+    subagentSessionId: r.subagent_session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionScannerTurns(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT t.id, t.session_id, t.sync_id, t.source, t.turn_index, t.timestamp_ms,
+              t.model, t.role, t.content_preview,
+              t.input_tokens, t.output_tokens, t.cache_read_tokens,
+              t.cache_creation_tokens, t.reasoning_tokens,
+              s.cli_version
+       FROM scanner_turns t
+       LEFT JOIN sessions s ON s.session_id = t.session_id
+       WHERE t.session_id = ? AND t.id > ?
+       ORDER BY t.id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    source: r.source,
+    turnIndex: r.turn_index,
+    timestampMs: r.timestamp_ms,
+    model: r.model,
+    role: r.role,
+    contentPreview: r.content_preview,
+    inputTokens: r.input_tokens,
+    outputTokens: r.output_tokens,
+    cacheReadTokens: r.cache_read_tokens,
+    cacheCreationTokens: r.cache_creation_tokens,
+    reasoningTokens: r.reasoning_tokens,
+    cliVersion: r.cli_version
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionScannerEvents(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, session_id, sync_id, source, event_type, timestamp_ms,
+              tool_name, tool_input, tool_output, content, metadata
+       FROM scanner_events
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    source: r.source,
+    eventType: r.event_type,
+    timestampMs: r.timestamp_ms,
+    toolName: r.tool_name,
+    toolInput: r.tool_input,
+    toolOutput: r.tool_output,
+    content: r.content,
+    metadata: parseJson(r.metadata)
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionHookEvents(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT h.id, h.session_id, h.sync_id, h.event_type, h.timestamp_ms, h.cwd, h.repository,
+              h.tool_name, decompress(h.payload) as payload,
+              h.user_prompt, h.file_path, h.command, h.tool_result,
+              s.target
+       FROM hook_events h
+       LEFT JOIN sessions s ON s.session_id = h.session_id
+       WHERE h.session_id = ? AND h.id > ?
+       ORDER BY h.id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    hookId: r.id,
+    sessionId: r.session_id,
+    syncId: r.sync_id,
+    eventType: r.event_type,
+    timestampMs: r.timestamp_ms,
+    cwd: r.cwd,
+    repository: r.repository,
+    toolName: r.tool_name,
+    payload: parseJson(r.payload),
+    userPrompt: r.user_prompt,
+    filePath: r.file_path,
+    command: r.command,
+    toolResult: r.tool_result,
+    target: r.target
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].hookId : afterId;
+  return { rows, maxId };
+}
+function readSessionOtelLogs(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, sync_id, timestamp_ns, body, attributes, resource_attributes,
+              severity_text, session_id, prompt_id, trace_id, span_id
+       FROM otel_logs
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = mapOtelRows(rawRows);
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionOtelMetrics(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, sync_id, timestamp_ns, name, value, metric_type, unit,
+              attributes, resource_attributes, session_id
+       FROM otel_metrics
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    syncId: r.sync_id,
+    timestampNs: r.timestamp_ns,
+    name: r.name,
+    value: r.value,
+    metricType: r.metric_type,
+    unit: r.unit,
+    attributes: parseJson(r.attributes),
+    resourceAttributes: parseJson(r.resource_attributes),
+    sessionId: r.session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+function readSessionOtelSpans(sessionId, afterId, limit) {
+  const db = getDb();
+  const rawRows = db.prepare(
+    `SELECT id, trace_id, span_id, parent_span_id, name, kind,
+              start_time_ns, end_time_ns, status_code, status_message,
+              attributes, resource_attributes, session_id
+       FROM otel_spans
+       WHERE session_id = ? AND id > ?
+       ORDER BY id
+       LIMIT ?`
+  ).all(sessionId, afterId, limit);
+  const rows = rawRows.map((r) => ({
+    id: r.id,
+    traceId: r.trace_id,
+    spanId: r.span_id,
+    parentSpanId: r.parent_span_id,
+    name: r.name,
+    kind: r.kind,
+    startTimeNs: r.start_time_ns,
+    endTimeNs: r.end_time_ns,
+    statusCode: r.status_code,
+    statusMessage: r.status_message,
+    attributes: parseJson(r.attributes),
+    resourceAttributes: parseJson(r.resource_attributes),
+    sessionId: r.session_id
+  }));
+  const maxId = rows.length > 0 ? rows[rows.length - 1].id : afterId;
+  return { rows, maxId };
+}
+var SESSION_READERS = {
+  messages: readSessionMessages,
+  tool_calls: readSessionToolCalls,
+  scanner_turns: readSessionScannerTurns,
+  scanner_events: readSessionScannerEvents,
+  hook_events: readSessionHookEvents,
+  otel_logs: readSessionOtelLogs,
+  otel_metrics: readSessionOtelMetrics,
+  otel_spans: readSessionOtelSpans
+};
+
+// src/sync/registry.ts
+var TABLE_SYNC_REGISTRY = [
+  // ── Session-linked tables (filtered by repo attribution) ─────────────────
+  {
+    table: "sessions",
+    logNoun: "sessions",
+    read: (afterId, limit) => readSessions(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "messages",
+    logNoun: "messages",
+    read: (afterId, limit) => readMessages(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "tool_calls",
+    logNoun: "tool calls",
+    read: (afterId, limit) => readToolCalls(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "scanner_turns",
+    logNoun: "turns",
+    read: (afterId, limit) => readScannerTurns(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "scanner_events",
+    logNoun: "events",
+    read: (afterId, limit) => readScannerEvents(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "hook_events",
+    logNoun: "events",
+    read: (afterId, limit) => readHookEvents(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "otel_logs",
+    logNoun: "logs",
+    read: (afterId, limit) => readOtelLogs(afterId, limit, false),
+    sessionLinked: true
+  },
+  {
+    table: "otel_metrics",
+    logNoun: "metrics",
+    read: (afterId, limit) => readMetrics(afterId, limit),
+    sessionLinked: true
+  },
+  {
+    table: "otel_spans",
+    logNoun: "spans",
+    read: (afterId, limit) => readOtelSpans(afterId, limit),
+    sessionLinked: true
+  },
+  // ── Non-session tables (always synced) ────────────────────────────────────
+  {
+    table: "user_config_snapshots",
+    logNoun: "snapshots",
+    read: (afterId, limit) => readUserConfigSnapshots(afterId, limit),
+    sessionLinked: false
+  },
+  {
+    table: "repo_config_snapshots",
+    logNoun: "snapshots",
+    read: (afterId, limit) => readRepoConfigSnapshots(afterId, limit),
+    sessionLinked: false
+  }
+];
+
+// src/sync/watermark.ts
+function watermarkKey(table, targetName) {
+  return `${table}:${targetName}`;
+}
+function readWatermark(key) {
+  const db = getDb();
+  const row = db.prepare("SELECT value FROM watermarks WHERE key = ?").get(key);
+  return row?.value ?? 0;
+}
+function writeWatermark(key, value) {
+  const db = getDb();
+  db.prepare(
+    "INSERT INTO watermarks (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(key, value);
+}
+function resetWatermarks(targetName) {
+  const db = getDb();
+  if (targetName) {
+    const stmt = db.prepare("DELETE FROM watermarks WHERE key = ?");
+    for (const desc of TABLE_SYNC_REGISTRY) {
+      stmt.run(watermarkKey(desc.table, targetName));
+    }
+    db.prepare("DELETE FROM target_session_sync WHERE target = ?").run(
+      targetName
+    );
+  } else {
+    db.prepare("DELETE FROM watermarks").run();
+    db.prepare("DELETE FROM target_session_sync").run();
+  }
+}
+
+export {
+  SESSION_READERS,
+  TABLE_SYNC_REGISTRY,
+  watermarkKey,
+  readWatermark,
+  writeWatermark,
+  resetWatermarks
+};
+//# sourceMappingURL=chunk-SEXU2WYG.js.map