@titan-design/session-graph 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,6 +1,252 @@
 // src/graph.ts
 import { EdgeTable, SpanFtsTables, WatermarkTable, openDatabase, runMigrations } from "@titan-design/store-sqlite";
 
+// src/audit-schema.ts
+var AUDIT_MIGRATION_NAME = "audit tables";
+var AUDIT_TABLES = [
+  "request",
+  "tool_call",
+  "inbound",
+  "context_block",
+  "compaction",
+  "queue_op",
+  "session_signal",
+  "cost_state_observation"
+];
+var FACET_TABLE = "transcript_facet";
+var AUDIT_DDL = `
+  CREATE TABLE IF NOT EXISTS request (
+    transcript_id   INTEGER NOT NULL,
+    request_id      TEXT    NOT NULL,
+    byte_offset     INTEGER NOT NULL,          -- first line seen for this request
+    session_id      TEXT    NOT NULL,
+    message_id      TEXT,
+    ts              TEXT    NOT NULL,
+    model           TEXT    NOT NULL,
+    input_tokens          INTEGER NOT NULL DEFAULT 0,
+    cache_read_tokens     INTEGER NOT NULL DEFAULT 0,
+    cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+    cache_creation_5m     INTEGER NOT NULL DEFAULT 0,
+    cache_creation_1h     INTEGER NOT NULL DEFAULT 0,
+    output_tokens         INTEGER NOT NULL DEFAULT 0,
+    thinking_tokens       INTEGER NOT NULL DEFAULT 0,
+    context_tokens        INTEGER NOT NULL DEFAULT 0,   -- input + cache_read + cache_creation
+    service_tier    TEXT,
+    is_sidechain    INTEGER NOT NULL DEFAULT 0,
+    -- rollup-owned, recomputed for touched sessions:
+    seq_in_session  INTEGER,
+    gap_ms          INTEGER,                   -- since previous request in the session
+    ctx_delta       INTEGER,                   -- context_tokens - (prev.context_tokens + prev.output_tokens)
+    wake_cause      TEXT,
+    wake_delivery   TEXT,
+    wake_detail     TEXT,                      -- tool name, channel sender, or NULL
+    wake_tool_family TEXT,
+    wake_mcp_server TEXT,
+    wake_offset     INTEGER,                   -- byte_offset of the inbound row
+    PRIMARY KEY (transcript_id, request_id)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_request_session_ts ON request(session_id, ts);
+  CREATE INDEX IF NOT EXISTS idx_request_ts ON request(ts);
+  CREATE INDEX IF NOT EXISTS idx_request_id ON request(request_id);
+
+  CREATE TABLE IF NOT EXISTS tool_call (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL, block_index INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, tool_use_id TEXT NOT NULL,
+    name TEXT NOT NULL, family TEXT NOT NULL, mcp_server TEXT, input_chars INTEGER NOT NULL,
+    PRIMARY KEY (transcript_id, byte_offset, block_index)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_tool_call_use ON tool_call(tool_use_id);
+
+  CREATE TABLE IF NOT EXISTS inbound (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL, block_index INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL,
+    cause TEXT NOT NULL, delivery TEXT NOT NULL, detail TEXT,
+    origin_server TEXT, from_name TEXT, msg_id TEXT, tool_use_id TEXT,
+    is_error INTEGER NOT NULL DEFAULT 0, content_hash TEXT NOT NULL, chars INTEGER NOT NULL,
+    queued_ms INTEGER,                          -- rollup-owned
+    PRIMARY KEY (transcript_id, byte_offset, block_index)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_inbound_session ON inbound(session_id, byte_offset);
+
+  CREATE TABLE IF NOT EXISTS context_block (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL, block_index INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, source TEXT NOT NULL,
+    tool_use_id TEXT, attachment_type TEXT, chars INTEGER NOT NULL, is_media INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (transcript_id, byte_offset, block_index)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_context_block_session ON context_block(session_id, source);
+
+  CREATE TABLE IF NOT EXISTS compaction (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, trigger TEXT,
+    pre_tokens INTEGER, post_tokens INTEGER, dropped_tokens INTEGER, duration_ms INTEGER,
+    mid_loop INTEGER,                           -- rollup-owned: previous inbound was a tool_result
+    PRIMARY KEY (transcript_id, byte_offset)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE IF NOT EXISTS queue_op (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, operation TEXT NOT NULL,
+    content_hash TEXT, origin_server TEXT,
+    PRIMARY KEY (transcript_id, byte_offset)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_queue_op_hash ON queue_op(session_id, content_hash);
+
+  CREATE TABLE IF NOT EXISTS session_signal (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL, block_index INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, signal TEXT NOT NULL, detail TEXT, tool_use_id TEXT,
+    -- one Bash block can emit up to three signals (commit, push, pr_create); the signal name disambiguates them
+    PRIMARY KEY (transcript_id, byte_offset, block_index, signal)
+  ) WITHOUT ROWID;
+  CREATE INDEX IF NOT EXISTS idx_signal_session ON session_signal(session_id, ts);
+
+  CREATE TABLE IF NOT EXISTS cost_state_observation (
+    transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL,
+    session_id TEXT NOT NULL, ts TEXT, total_cost_usd REAL NOT NULL, model_usage TEXT NOT NULL,
+    PRIMARY KEY (transcript_id, byte_offset)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE IF NOT EXISTS transcript_facet (
+    transcript_id INTEGER NOT NULL, facet TEXT NOT NULL,
+    version INTEGER NOT NULL, indexed_to INTEGER NOT NULL,
+    PRIMARY KEY (transcript_id, facet)
+  ) WITHOUT ROWID;
+`;
+var AUDIT_COLUMNS = [
+  ["session", "account", "TEXT"],
+  ["turn", "wake_cause", "TEXT"],
+  ["task", "estimate", "REAL"],
+  ["pr", "review_rounds", "INTEGER"],
+  ["pr", "closed_at", "TEXT"],
+  ["pr", "outcome_checked_at", "TEXT"]
+];
+function applyAuditSchema(db) {
+  db.exec(AUDIT_DDL);
+  for (const [table, column, type] of AUDIT_COLUMNS) addColumnIfMissing(db, table, column, type);
+}
+function addColumnIfMissing(db, table, column, type) {
+  const present = db.prepare("SELECT 1 FROM pragma_table_info(?) WHERE name = ?").get(table, column);
+  if (!present) db.exec(`ALTER TABLE "${table}" ADD COLUMN "${column}" ${type}`);
+}
+
+// src/audit-schema-v5.ts
+var ORIGIN_MIGRATION_NAME = "origin, episodes, prices";
+var ORIGIN_TABLES = ["session_origin", "session_external_event"];
+var EPISODE_TABLE = "episode";
+var ORIGIN_DDL = `
+  CREATE TABLE IF NOT EXISTS session_origin (        -- not derived from transcripts
+    session_id TEXT PRIMARY KEY,
+    origin_system TEXT NOT NULL,                     -- 'agent-chat'
+    agent_id TEXT, agent_name TEXT, parent_name TEXT, parent_session_id TEXT,
+    profile TEXT, model_alias TEXT, surface TEXT, isolation TEXT, depth INTEGER,
+    origin_kind TEXT,                                -- spawned | adopted | inherited | human
+    config_dir TEXT, spawn_cwd TEXT, spawned_at TEXT,
+    brief_chars INTEGER, brief_excerpt TEXT, brief_path TEXT, launch_args TEXT,
+    resolved_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_origin_parent ON session_origin(parent_session_id);
+
+  CREATE TABLE IF NOT EXISTS session_external_event ( -- teleport, handoff, retire, exit
+    session_id TEXT NOT NULL, ts TEXT NOT NULL, origin_system TEXT NOT NULL,
+    kind TEXT NOT NULL, detail TEXT,
+    PRIMARY KEY (session_id, ts, kind)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE IF NOT EXISTS episode (               -- provisional, see section 9
+    session_id TEXT NOT NULL, episode_index INTEGER NOT NULL,
+    heuristic TEXT NOT NULL, heuristic_version INTEGER NOT NULL,
+    started_at TEXT NOT NULL, ended_at TEXT NOT NULL,
+    start_offset INTEGER NOT NULL, end_offset INTEGER NOT NULL,
+    opened_by TEXT NOT NULL,                         -- brief | channel_followup | idle_gap | compaction
+    assignment_offset INTEGER, first_deliverable_offset INTEGER, first_deliverable_signal TEXT,
+    first_status_offset INTEGER,
+    PRIMARY KEY (session_id, heuristic, episode_index)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE IF NOT EXISTS price (
+    model TEXT NOT NULL, effective_from TEXT NOT NULL, table_version INTEGER NOT NULL,
+    input_usd_mtok REAL NOT NULL, cache_read_usd_mtok REAL NOT NULL,
+    cache_write_5m_usd_mtok REAL NOT NULL, cache_write_1h_usd_mtok REAL NOT NULL,
+    output_usd_mtok REAL NOT NULL, source TEXT,
+    PRIMARY KEY (model, effective_from)
+  ) WITHOUT ROWID;
+`;
+var REQUEST_COLUMNS = `transcript_id, request_id, byte_offset, session_id, message_id, ts, model,
+    input_tokens, cache_read_tokens, cache_creation_tokens, cache_creation_5m, cache_creation_1h,
+    output_tokens, thinking_tokens, context_tokens, service_tier, is_sidechain,
+    seq_in_session, gap_ms, ctx_delta, wake_cause, wake_delivery, wake_detail,
+    wake_tool_family, wake_mcp_server, wake_offset`;
+var REQUEST_DEDUP = `
+  CREATE VIEW IF NOT EXISTS request_dedup AS
+  SELECT ${REQUEST_COLUMNS} FROM (
+    SELECT r.*, ROW_NUMBER() OVER (PARTITION BY r.request_id ORDER BY r.ts, r.transcript_id) AS copy_rank
+    FROM request r
+  ) WHERE copy_rank = 1;
+`;
+var REQUEST_COST = `
+  CREATE VIEW IF NOT EXISTS request_cost AS
+  WITH candidate AS (
+    SELECT d.request_id, p.model AS price_model, p.effective_from AS price_effective_from,
+      p.input_usd_mtok, p.cache_read_usd_mtok, p.cache_write_5m_usd_mtok, p.cache_write_1h_usd_mtok, p.output_usd_mtok,
+      ROW_NUMBER() OVER (PARTITION BY d.request_id ORDER BY length(p.model) DESC, p.effective_from DESC) AS match_rank
+    FROM request_dedup d
+    JOIN price p ON substr(d.model, 1, length(p.model)) = p.model AND p.effective_from <= d.ts
+  ), component AS (
+    SELECT d.*, c.price_model, c.price_effective_from, c.price_model IS NOT NULL AS priced,
+      COALESCE(d.input_tokens * c.input_usd_mtok, 0) / 1e6 AS input_cost_usd,
+      COALESCE(d.cache_read_tokens * c.cache_read_usd_mtok, 0) / 1e6 AS cache_read_cost_usd,
+      COALESCE(CASE WHEN d.cache_creation_5m + d.cache_creation_1h = 0 THEN d.cache_creation_tokens ELSE d.cache_creation_5m END
+        * c.cache_write_5m_usd_mtok, 0) / 1e6 AS cache_write_5m_cost_usd,
+      COALESCE(d.cache_creation_1h * c.cache_write_1h_usd_mtok, 0) / 1e6 AS cache_write_1h_cost_usd,
+      COALESCE(d.output_tokens * c.output_usd_mtok, 0) / 1e6 AS output_cost_usd
+    FROM request_dedup d
+    LEFT JOIN candidate c ON c.request_id = d.request_id AND c.match_rank = 1
+  )
+  SELECT *,
+    input_cost_usd + cache_read_cost_usd + cache_write_5m_cost_usd + cache_write_1h_cost_usd + output_cost_usd AS cost_usd,
+    (cache_read_tokens < 0.2 * context_tokens AND cache_creation_tokens >= 20000) AS is_cold,
+    CASE WHEN context_tokens < 50000 THEN '<50k' WHEN context_tokens < 100000 THEN '50-100k'
+      WHEN context_tokens < 200000 THEN '100-200k' ELSE '200k+' END AS context_band,
+    CASE WHEN gap_ms IS NULL THEN NULL WHEN gap_ms < 300000 THEN '<5m'
+      WHEN gap_ms < 3600000 THEN '5-60m' ELSE '>60m' END AS gap_band
+  FROM component;
+`;
+var ASSISTANT_OUTPUT = "'assistant_text', 'assistant_thinking', 'assistant_tool_input'";
+var CONTEXT_CONTRIBUTION = `
+  CREATE VIEW IF NOT EXISTS context_contribution AS
+  WITH stream AS (
+    SELECT transcript_id, byte_offset, 0 AS lane, block_index, NULL AS request_id FROM context_block
+    UNION ALL
+    SELECT transcript_id, byte_offset, -1 AS lane, 0, request_id FROM request
+  ), ordered AS (
+    SELECT *, COUNT(request_id) OVER (PARTITION BY transcript_id ORDER BY byte_offset, lane, block_index ROWS UNBOUNDED PRECEDING) AS requests_before
+    FROM stream
+  ), owner AS (
+    SELECT b.transcript_id, b.byte_offset, b.block_index, r.request_id
+    FROM ordered b JOIN ordered r ON r.transcript_id = b.transcript_id AND r.lane = -1 AND r.requests_before = b.requests_before + 1
+    WHERE b.lane = 0
+  ), tool AS (
+    SELECT tool_use_id, name, family, mcp_server,
+      ROW_NUMBER() OVER (PARTITION BY tool_use_id ORDER BY transcript_id, byte_offset, block_index) AS copy_rank
+    FROM tool_call
+  )
+  SELECT cb.transcript_id, cb.byte_offset, cb.block_index, cb.session_id, cb.ts, cb.source,
+    cb.tool_use_id, cb.attachment_type, cb.chars, cb.is_media, o.request_id, d.ctx_delta,
+    CASE WHEN cb.source IN (${ASSISTANT_OUTPUT}) THEN NULL
+      ELSE d.ctx_delta * cb.chars * 1.0 / NULLIF(SUM(CASE WHEN cb.source IN (${ASSISTANT_OUTPUT}) THEN 0 ELSE cb.chars END)
+        OVER (PARTITION BY o.transcript_id, o.request_id), 0) END AS est_tokens,
+    t.name AS tool_name, t.family AS tool_family, t.mcp_server
+  FROM context_block cb
+  JOIN owner o USING (transcript_id, byte_offset, block_index)
+  JOIN request_dedup d ON d.transcript_id = o.transcript_id AND d.request_id = o.request_id
+  LEFT JOIN tool t ON t.tool_use_id = cb.tool_use_id AND t.copy_rank = 1;
+`;
+var ORIGIN_VIEWS = [REQUEST_DEDUP, REQUEST_COST, CONTEXT_CONTRIBUTION];
+function applyOriginSchema(db) {
+  db.exec(ORIGIN_DDL);
+  for (const view of ORIGIN_VIEWS) db.exec(view);
+}
+
 // src/normalized-schema.ts
 import { conversationRef } from "@titan-design/agent-protocol";
 var NORMALIZED_DDL = `
@@ -188,6 +434,10 @@ var DERIVED_TABLES = [
   "human_edit",
   "file_checkpoint",
   "subagent",
+  ...AUDIT_TABLES,
+  FACET_TABLE,
+  ...ORIGIN_TABLES,
+  EPISODE_TABLE,
   "session_model_usage",
   "session",
   "fact",
@@ -205,7 +455,9 @@ var MIGRATIONS = [
   { version: 3, name: "normalized conversations and source evidence", up: (db) => {
     db.exec(NORMALIZED_DDL);
     backfillClaudeAliases(db);
-  } }
+  } },
+  { version: 4, name: AUDIT_MIGRATION_NAME, up: applyAuditSchema },
+  { version: 5, name: ORIGIN_MIGRATION_NAME, up: applyOriginSchema }
 ];
 
 // src/graph.ts
@@ -230,16 +482,152 @@ function allSessionIds(graph) {
   return graph.db.prepare("SELECT session_id FROM session").all().map((r) => r.session_id);
 }
 
+// src/audit-apply.ts
+var UPSERT_REQUEST = `
+  INSERT INTO request (transcript_id, request_id, byte_offset, session_id, message_id, ts, model,
+    input_tokens, cache_read_tokens, cache_creation_tokens, cache_creation_5m, cache_creation_1h,
+    output_tokens, thinking_tokens, context_tokens, service_tier, is_sidechain)
+  VALUES (@transcriptId, @requestId, @byteOffset, @sessionId, @messageId, @ts, @model,
+    @inputTokens, @cacheReadTokens, @cacheCreationTokens, @cacheCreation5mTokens, @cacheCreation1hTokens,
+    @outputTokens, @thinkingTokens, @inputTokens + @cacheReadTokens + @cacheCreationTokens, @serviceTier, @isSidechain)
+  ON CONFLICT (transcript_id, request_id) DO UPDATE SET
+    session_id   = CASE WHEN excluded.byte_offset < byte_offset THEN excluded.session_id ELSE session_id END,
+    message_id   = CASE WHEN excluded.byte_offset < byte_offset THEN excluded.message_id ELSE message_id END,
+    model        = CASE WHEN excluded.byte_offset < byte_offset THEN excluded.model ELSE model END,
+    service_tier = CASE WHEN excluded.byte_offset < byte_offset THEN excluded.service_tier ELSE service_tier END,
+    is_sidechain = CASE WHEN excluded.byte_offset < byte_offset THEN excluded.is_sidechain ELSE is_sidechain END,
+    byte_offset  = MIN(byte_offset, excluded.byte_offset),
+    ts           = MIN(ts, excluded.ts),
+    input_tokens          = MAX(input_tokens, excluded.input_tokens),
+    cache_read_tokens     = MAX(cache_read_tokens, excluded.cache_read_tokens),
+    cache_creation_tokens = MAX(cache_creation_tokens, excluded.cache_creation_tokens),
+    cache_creation_5m     = MAX(cache_creation_5m, excluded.cache_creation_5m),
+    cache_creation_1h     = MAX(cache_creation_1h, excluded.cache_creation_1h),
+    output_tokens         = MAX(output_tokens, excluded.output_tokens),
+    thinking_tokens       = MAX(thinking_tokens, excluded.thinking_tokens),
+    context_tokens        = MAX(input_tokens, excluded.input_tokens) + MAX(cache_read_tokens, excluded.cache_read_tokens)
+                          + MAX(cache_creation_tokens, excluded.cache_creation_tokens)`;
+var INSERTS = {
+  toolCalls: `INSERT INTO tool_call (transcript_id, byte_offset, block_index, session_id, ts, tool_use_id, name, family, mcp_server, input_chars)
+    VALUES (@transcriptId, @byteOffset, @blockIndex, @sessionId, @ts, @toolUseId, @name, @family, @mcpServer, @inputChars)
+    ON CONFLICT DO NOTHING`,
+  inbound: `INSERT INTO inbound (transcript_id, byte_offset, block_index, session_id, ts, cause, delivery, detail, origin_server, from_name, msg_id, tool_use_id, is_error, content_hash, chars)
+    VALUES (@transcriptId, @byteOffset, @blockIndex, @sessionId, @ts, @cause, @delivery, @detail, @originServer, @fromName, @msgId, @toolUseId, @isError, @contentHash, @chars)
+    ON CONFLICT DO NOTHING`,
+  contextBlocks: `INSERT INTO context_block (transcript_id, byte_offset, block_index, session_id, ts, source, tool_use_id, attachment_type, chars, is_media)
+    VALUES (@transcriptId, @byteOffset, @blockIndex, @sessionId, @ts, @source, @toolUseId, @attachmentType, @chars, @isMedia)
+    ON CONFLICT DO NOTHING`,
+  compactions: `INSERT INTO compaction (transcript_id, byte_offset, session_id, ts, trigger, pre_tokens, post_tokens, dropped_tokens, duration_ms)
+    VALUES (@transcriptId, @byteOffset, @sessionId, @ts, @trigger, @preTokens, @postTokens, @droppedTokens, @durationMs)
+    ON CONFLICT DO NOTHING`,
+  queueOps: `INSERT INTO queue_op (transcript_id, byte_offset, session_id, ts, operation, content_hash, origin_server)
+    VALUES (@transcriptId, @byteOffset, @sessionId, @ts, @operation, @contentHash, @originServer)
+    ON CONFLICT DO NOTHING`,
+  signals: `INSERT INTO session_signal (transcript_id, byte_offset, block_index, session_id, ts, signal, detail, tool_use_id)
+    VALUES (@transcriptId, @byteOffset, @blockIndex, @sessionId, @ts, @signal, @detail, @toolUseId)
+    ON CONFLICT DO NOTHING`,
+  costStates: `INSERT INTO cost_state_observation (transcript_id, byte_offset, session_id, ts, total_cost_usd, model_usage)
+    VALUES (@transcriptId, @byteOffset, @sessionId, @ts, @totalCostUsd, @modelUsageJson)
+    ON CONFLICT DO NOTHING`
+};
+function applyAudit(db, transcriptId, delta) {
+  run(db, UPSERT_REQUEST, transcriptId, delta.requests);
+  for (const [list, sql] of Object.entries(INSERTS)) {
+    run(db, sql, transcriptId, delta[list]);
+  }
+}
+function run(db, sql, transcriptId, events) {
+  if (events.length === 0) return;
+  const statement = db.prepare(sql);
+  const names = [...new Set([...sql.matchAll(/@(\w+)/g)].map((m) => m[1]))];
+  for (const event of events) statement.run(bind(names, { ...event, transcriptId }));
+}
+function bind(names, row) {
+  return Object.fromEntries(names.map((name) => {
+    const value = row[name] ?? null;
+    return [name, typeof value === "boolean" ? Number(value) : value];
+  }));
+}
+
+// src/facet.ts
+import { EXTRACT_VERSION, TranscriptParseError, extractTranscript } from "@titan-design/session-read";
+var AUDIT_FACET = "audit";
+var DEFAULT_FACET_LIMIT = 40;
+async function backfillFacets(graph, transcripts, options = {}) {
+  const version = options.version ?? EXTRACT_VERSION;
+  const stale = staleTranscripts(graph, transcripts, version);
+  const visit = stale.slice(0, options.limit ?? DEFAULT_FACET_LIMIT);
+  const sessionIds = /* @__PURE__ */ new Set();
+  let backfilled = 0;
+  for (const candidate of visit) {
+    const touched = await backfillOne(graph, candidate, version);
+    if (!touched) continue;
+    backfilled += 1;
+    for (const id of touched) sessionIds.add(id);
+  }
+  return { backfilled, backlog: stale.length - visit.length, sessionIds: [...sessionIds] };
+}
+function staleTranscripts(graph, transcripts, version) {
+  const byPath = new Map(transcripts.map((t) => [t.displayPath, t]));
+  const versions = facetVersions(graph.db);
+  const stale = [];
+  for (const row of graph.transcripts.list()) {
+    const transcript = byPath.get(row.sourceKey);
+    if (!transcript || row.status !== "ok" || (versions.get(row.sourceId) ?? -1) >= version) continue;
+    stale.push({ row, transcript });
+  }
+  return stale.sort((a, b) => (b.row.fileMtime ?? "").localeCompare(a.row.fileMtime ?? ""));
+}
+function facetVersions(db) {
+  const rows = db.prepare(`SELECT transcript_id, version FROM ${FACET_TABLE} WHERE facet = ?`).all(AUDIT_FACET);
+  return new Map(rows.map((r) => [r.transcript_id, r.version]));
+}
+async function backfillOne(graph, { row, transcript }, version) {
+  let delta;
+  try {
+    delta = await extractTranscript(transcript.absolutePath, { untilByteOffset: row.lastOffset, subagentId: transcript.subagentId });
+  } catch (err) {
+    const status = unreadableStatus(err);
+    if (!status) throw err;
+    graph.transcripts.markStatus(row.sourceKey, status, err instanceof Error ? err.message : String(err));
+    return null;
+  }
+  graph.db.transaction(() => {
+    for (const table of AUDIT_TABLES) graph.db.prepare(`DELETE FROM "${table}" WHERE transcript_id = ?`).run(row.sourceId);
+    applyAudit(graph.db, row.sourceId, delta);
+    writeFacet(graph.db, row.sourceId, version, delta.lastByteOffset);
+  })();
+  return delta.sessions.map((s) => s.sessionId);
+}
+function unreadableStatus(err) {
+  if (err instanceof TranscriptParseError) return "quarantined";
+  if (err?.code === "ENOENT") return "missing";
+  return null;
+}
+function writeFacet(db, transcriptId, version, indexedTo) {
+  db.prepare(`
+    INSERT INTO ${FACET_TABLE} (transcript_id, facet, version, indexed_to) VALUES (?, ?, ?, ?)
+    ON CONFLICT (transcript_id, facet) DO UPDATE SET version = excluded.version, indexed_to = excluded.indexed_to`).run(transcriptId, AUDIT_FACET, version, indexedTo);
+}
+function advanceFacet(db, transcriptId, fromByteOffset, indexedTo, version = EXTRACT_VERSION) {
+  if (fromByteOffset === 0) {
+    writeFacet(db, transcriptId, version, indexedTo);
+    return;
+  }
+  db.prepare(`UPDATE ${FACET_TABLE} SET indexed_to = ? WHERE transcript_id = ? AND facet = ? AND version = ?`).run(indexedTo, transcriptId, AUDIT_FACET, version);
+}
+
 // src/apply.ts
 import { sessionRef } from "@titan-design/session-read";
-function applyDelta(graph, transcriptId, delta) {
+function applyDelta(graph, transcriptId, delta, source = {}) {
   graph.db.transaction(() => {
     applyFacts(graph.db, transcriptId, delta);
-    applySessions(graph.db, transcriptId, delta);
+    applySessions(graph.db, transcriptId, delta, source.account ?? null);
     backfillClaudeAliases(graph.db, delta.sessions.map((s) => s.sessionId));
     applyAssets(graph.db, delta);
     applyPhases(graph.db, transcriptId, delta);
     applyLinkedRows(graph, transcriptId, delta);
+    applyAudit(graph.db, transcriptId, delta);
   })();
 }
 var INSERT_FACT = `
@@ -255,8 +643,8 @@ function applyFacts(db, transcriptId, delta) {
   }
 }
 var UPSERT_SESSION = `
-  INSERT INTO session (session_id, transcript_id, started_at, ended_at, start_type, cwd, git_branch, ai_title, seed_prompt, cli_version, turn_count, commit_count, push_count)
-  VALUES (@sessionId, @transcriptId, @startedAt, @endedAt, @startType, @cwd, @gitBranch, @aiTitle, @seedPrompt, @cliVersion, @turnDelta, @commitDelta, @pushDelta)
+  INSERT INTO session (session_id, transcript_id, started_at, ended_at, start_type, cwd, git_branch, ai_title, seed_prompt, cli_version, account, turn_count, commit_count, push_count)
+  VALUES (@sessionId, @transcriptId, @startedAt, @endedAt, @startType, @cwd, @gitBranch, @aiTitle, @seedPrompt, @cliVersion, @account, @turnDelta, @commitDelta, @pushDelta)
   ON CONFLICT (session_id) DO UPDATE SET
     started_at  = MIN(COALESCE(started_at, excluded.started_at), COALESCE(excluded.started_at, started_at)),
     ended_at    = MAX(COALESCE(ended_at, excluded.ended_at), COALESCE(excluded.ended_at, ended_at)),
@@ -270,22 +658,13 @@ var UPSERT_SESSION = `
     ai_title    = COALESCE(excluded.ai_title, ai_title),
     seed_prompt = COALESCE(seed_prompt, excluded.seed_prompt),
     cli_version = COALESCE(excluded.cli_version, cli_version),
+    account     = COALESCE(excluded.account, account),
     turn_count   = turn_count + excluded.turn_count,
     commit_count = commit_count + excluded.commit_count,
     push_count   = push_count + excluded.push_count`;
-var UPSERT_USAGE = `
-  INSERT INTO session_model_usage (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, thinking_tokens, request_count)
-  VALUES (@sessionId, @model, @inputTokens, @outputTokens, @cacheReadTokens, @cacheCreationTokens, @thinkingTokens, @requestCount)
-  ON CONFLICT (session_id, model) DO UPDATE SET
-    input_tokens = input_tokens + excluded.input_tokens, output_tokens = output_tokens + excluded.output_tokens,
-    cache_read_tokens = cache_read_tokens + excluded.cache_read_tokens,
-    cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,
-    thinking_tokens = thinking_tokens + excluded.thinking_tokens, request_count = request_count + excluded.request_count`;
-function applySessions(db, transcriptId, delta) {
+function applySessions(db, transcriptId, delta, account) {
   const upsertSession = db.prepare(UPSERT_SESSION);
-  for (const s of delta.sessions) upsertSession.run({ ...s, transcriptId });
-  const upsertUsage = db.prepare(UPSERT_USAGE);
-  for (const u of delta.usage) upsertUsage.run(u);
+  for (const s of delta.sessions) upsertSession.run({ ...s, transcriptId, account });
 }
 var ASSET_UPSERTS = {
   prs: `INSERT INTO pr (pr_ref, number, repo, title, url) VALUES (@prRef, @number, @repo, @title, @url)
@@ -359,7 +738,7 @@ function factIdFor(db, transcriptId, byteOffset) {
 
 // src/purge.ts
 import { sessionRef as sessionRef2 } from "@titan-design/session-read";
-var SESSION_SCOPED = ["turn", "permission_phase", "human_edit", "file_checkpoint", "subagent", "session_model_usage"];
+var SESSION_SCOPED = ["turn", "permission_phase", "human_edit", "file_checkpoint", "subagent", "session_model_usage", EPISODE_TABLE];
 function purgeTranscript(graph, transcriptId) {
   graph.db.transaction(() => {
     const owned = graph.db.prepare("SELECT session_id FROM session WHERE transcript_id = ?").all(transcriptId);
@@ -368,11 +747,97 @@ function purgeTranscript(graph, transcriptId) {
       graph.db.prepare(`DELETE FROM "${table}" WHERE session_id IN (SELECT session_id FROM session WHERE transcript_id = ?)`).run(transcriptId);
     }
     graph.db.prepare(`DELETE FROM "${KIT.edge}" WHERE fact_id IN (SELECT fact_id FROM fact WHERE transcript_id = ?)`).run(transcriptId);
+    for (const table of [...AUDIT_TABLES, FACET_TABLE]) {
+      graph.db.prepare(`DELETE FROM "${table}" WHERE transcript_id = ?`).run(transcriptId);
+    }
     graph.db.prepare("DELETE FROM fact WHERE transcript_id = ?").run(transcriptId);
     graph.db.prepare("DELETE FROM session WHERE transcript_id = ?").run(transcriptId);
   })();
 }
 
+// src/audit-rollup.ts
+var IN_BATCH = "SELECT value FROM json_each(@sessionIds)";
+var REQUEST_ORDER = `
+  WITH ordered AS (
+    SELECT transcript_id, request_id, ts, context_tokens,
+      ROW_NUMBER() OVER w - 1 AS seq,
+      LAG(ts) OVER w AS prev_ts,
+      LAG(context_tokens) OVER w AS prev_context,
+      LAG(output_tokens) OVER w AS prev_output
+    FROM request WHERE session_id IN (${IN_BATCH})
+    WINDOW w AS (PARTITION BY session_id ORDER BY ts, byte_offset, transcript_id, request_id)
+  )
+  UPDATE request SET seq_in_session = ordered.seq,
+    gap_ms = CAST(ROUND((julianday(ordered.ts) - julianday(ordered.prev_ts)) * 86400000) AS INTEGER),
+    ctx_delta = ordered.context_tokens - (ordered.prev_context + ordered.prev_output)
+  FROM ordered WHERE request.transcript_id = ordered.transcript_id AND request.request_id = ordered.request_id`;
+var REQUEST_WAKE = `
+  WITH hit AS (
+    SELECT r.transcript_id, r.request_id,
+      (SELECT MAX(i.byte_offset) FROM inbound i
+        WHERE i.transcript_id = r.transcript_id AND i.session_id = r.session_id AND i.byte_offset < r.byte_offset) AS wake_offset
+    FROM request r WHERE r.session_id IN (${IN_BATCH})
+  ),
+  tools AS (
+    SELECT transcript_id, tool_use_id, name, family, mcp_server,
+      ROW_NUMBER() OVER (PARTITION BY transcript_id, tool_use_id ORDER BY byte_offset, block_index) AS pick
+    FROM tool_call WHERE session_id IN (${IN_BATCH})
+  ),
+  wake AS (
+    SELECT hit.transcript_id, hit.request_id, hit.wake_offset, i.cause, i.delivery, i.detail, i.from_name,
+      t.name AS tool_name, t.family, t.mcp_server
+    FROM hit
+    LEFT JOIN inbound i ON i.transcript_id = hit.transcript_id AND i.byte_offset = hit.wake_offset
+      AND i.block_index = (SELECT MAX(block_index) FROM inbound j WHERE j.transcript_id = hit.transcript_id AND j.byte_offset = hit.wake_offset)
+    LEFT JOIN tools t ON t.transcript_id = i.transcript_id AND t.tool_use_id = i.tool_use_id AND t.pick = 1
+  )
+  UPDATE request SET
+    wake_cause = CASE WHEN wake.cause IS NULL THEN 'session_start'
+      WHEN wake.tool_name = 'AskUserQuestion' THEN 'ask_user_answer' ELSE wake.cause END,
+    wake_delivery = wake.delivery,
+    wake_detail = COALESCE(wake.tool_name, wake.from_name, wake.detail),
+    wake_tool_family = wake.family,
+    wake_mcp_server = wake.mcp_server,
+    wake_offset = wake.wake_offset
+  FROM wake WHERE request.transcript_id = wake.transcript_id AND request.request_id = wake.request_id`;
+var INBOUND_QUEUED = `
+  UPDATE inbound SET queued_ms = (
+    SELECT CAST(ROUND((julianday(inbound.ts) - julianday(q.ts)) * 86400000) AS INTEGER)
+    FROM queue_op q
+    WHERE q.transcript_id = inbound.transcript_id AND q.session_id = inbound.session_id
+      AND q.operation = 'enqueue' AND q.content_hash = inbound.content_hash AND q.byte_offset < inbound.byte_offset
+    ORDER BY q.byte_offset DESC LIMIT 1)
+  WHERE session_id IN (${IN_BATCH})`;
+var COMPACTION_MID_LOOP = `
+  UPDATE compaction SET mid_loop = COALESCE((
+    SELECT i.delivery = 'tool_result' FROM inbound i
+    WHERE i.transcript_id = compaction.transcript_id AND i.session_id = compaction.session_id AND i.byte_offset < compaction.byte_offset
+    ORDER BY i.byte_offset DESC, i.block_index DESC LIMIT 1), 0)
+  WHERE session_id IN (${IN_BATCH})`;
+var TURN_WAKE = `
+  UPDATE turn SET wake_cause = (
+    SELECT i.cause FROM fact f JOIN inbound i ON i.transcript_id = f.transcript_id AND i.byte_offset = f.byte_offset
+    WHERE f.fact_id = turn.fact_id_start ORDER BY i.block_index LIMIT 1)
+  WHERE session_id IN (${IN_BATCH})`;
+var CLEAR_USAGE = `
+  DELETE FROM session_model_usage
+  WHERE session_id IN (${IN_BATCH}) AND session_id IN (SELECT session_id FROM request WHERE session_id IN (${IN_BATCH}))`;
+var RECOMPUTE_USAGE = `
+  WITH ranked AS (
+    SELECT *, ROW_NUMBER() OVER (PARTITION BY session_id, request_id ORDER BY ts, transcript_id) AS pick
+    FROM request WHERE session_id IN (${IN_BATCH})
+  )
+  INSERT INTO session_model_usage (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, thinking_tokens, request_count)
+  SELECT session_id, model, SUM(input_tokens), SUM(output_tokens), SUM(cache_read_tokens), SUM(cache_creation_tokens), SUM(thinking_tokens), COUNT(*)
+  FROM ranked WHERE pick = 1 GROUP BY session_id, model`;
+var STEPS = [REQUEST_ORDER, REQUEST_WAKE, INBOUND_QUEUED, COMPACTION_MID_LOOP, TURN_WAKE, CLEAR_USAGE, RECOMPUTE_USAGE];
+function prepareAuditRollup(db) {
+  const statements = STEPS.map((sql) => db.prepare(sql));
+  return (sessionIds) => {
+    for (const statement of statements) statement.run({ sessionIds });
+  };
+}
+
 // src/rollup.ts
 var BATCH = 400;
 var ROLLUP = `
@@ -409,12 +874,14 @@ function rollupSessions(graph, sessionIds) {
   if (unique.length === 0) return 0;
   const aggregate = graph.db.prepare(ROLLUP);
   const renumber = graph.db.prepare(RENUMBER_TURNS);
+  const audit = prepareAuditRollup(graph.db);
   return graph.db.transaction(() => {
     let updated = 0;
     for (let i = 0; i < unique.length; i += BATCH) {
       const batch = JSON.stringify(unique.slice(i, i + BATCH));
       renumber.run({ sessionIds: batch });
       updated += aggregate.run({ sessionIds: batch }).changes;
+      audit(batch);
     }
     return updated;
   })();
@@ -443,7 +910,96 @@ function reconcile(graph) {
 // src/refresh.ts
 import { promises as fs } from "fs";
 import { contentHash, resumePoint } from "@titan-design/locator";
-import { TranscriptParseError, extractTranscript } from "@titan-design/session-read";
+import { TranscriptParseError as TranscriptParseError2, extractTranscript as extractTranscript2 } from "@titan-design/session-read";
+
+// src/origin.ts
+import { RELATIONS, sessionRef as sessionRef3 } from "@titan-design/session-read";
+var NO_ORIGINS = Object.freeze({ requested: 0, applied: 0, events: 0, failed: false });
+var SESSIONS_NEEDING_ORIGIN = `
+  SELECT s.session_id FROM session s LEFT JOIN session_origin o ON o.session_id = s.session_id
+  WHERE o.session_id IS NULL OR o.resolved_at < s.ended_at
+  ORDER BY s.session_id`;
+var UPSERT_ORIGIN = `
+  INSERT OR REPLACE INTO session_origin (session_id, origin_system, agent_id, agent_name, parent_name, parent_session_id,
+    profile, model_alias, surface, isolation, depth, origin_kind, config_dir, spawn_cwd, spawned_at,
+    brief_chars, brief_excerpt, brief_path, launch_args, resolved_at)
+  VALUES (@sessionId, @originSystem, @agentId, @agentName, @parentName, @parentSessionId,
+    @profile, @modelAlias, @surface, @isolation, @depth, @originKind, @configDir, @spawnCwd, @spawnedAt,
+    @briefChars, @briefExcerpt, @briefPath, @launchArgs, @resolvedAt)`;
+var UPSERT_EVENT = `
+  INSERT INTO session_external_event (session_id, ts, origin_system, kind, detail)
+  VALUES (@sessionId, @ts, COALESCE(@originSystem, (SELECT origin_system FROM session_origin WHERE session_id = @sessionId), 'unknown'), @kind, @detail)
+  ON CONFLICT (session_id, ts, kind) DO UPDATE SET origin_system = excluded.origin_system, detail = excluded.detail`;
+var PROJECT_SUBAGENTS = `
+  INSERT INTO subagent (agent_ref, session_id, child_session_id, agent_type, label, started_at)
+  SELECT 'agent:' || origin_system || ':' || agent_id, parent_session_id, session_id, profile, agent_name, spawned_at
+  FROM session_origin WHERE parent_session_id IS NOT NULL AND agent_id IS NOT NULL
+  ON CONFLICT (agent_ref) DO UPDATE SET session_id = excluded.session_id, child_session_id = excluded.child_session_id,
+    agent_type = excluded.agent_type, label = excluded.label, started_at = COALESCE(excluded.started_at, started_at)`;
+function sessionsNeedingOrigin(graph) {
+  return graph.db.prepare(SESSIONS_NEEDING_ORIGIN).all().map((r) => r.session_id);
+}
+async function resolveOrigins(graph, resolver) {
+  if (!resolver) return NO_ORIGINS;
+  const sessionIds = sessionsNeedingOrigin(graph);
+  try {
+    const resolution = await resolver(sessionIds);
+    const written = writeResolution(graph, resolution, (/* @__PURE__ */ new Date()).toISOString());
+    return { requested: sessionIds.length, ...written, failed: false };
+  } catch (err) {
+    return { requested: sessionIds.length, applied: 0, events: 0, failed: true, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    projectOrigins(graph);
+  }
+}
+function writeResolution(graph, resolution, resolvedAt) {
+  const upsertOrigin = graph.db.prepare(UPSERT_ORIGIN);
+  const upsertEvent = graph.db.prepare(UPSERT_EVENT);
+  return graph.db.transaction(() => {
+    let applied = 0;
+    for (const [sessionId, origin] of Object.entries(resolution.origins)) {
+      applied += upsertOrigin.run(originRow(sessionId, origin, resolvedAt)).changes;
+    }
+    let events = 0;
+    for (const e of resolution.externalEvents ?? []) {
+      events += upsertEvent.run({ sessionId: e.sessionId, ts: e.ts, kind: e.kind, detail: e.detail ?? null, originSystem: e.originSystem ?? null }).changes;
+    }
+    return { applied, events };
+  })();
+}
+function originRow(sessionId, o, resolvedAt) {
+  return {
+    sessionId,
+    originSystem: o.originSystem,
+    resolvedAt,
+    agentId: o.agentId ?? null,
+    agentName: o.agentName ?? null,
+    parentName: o.parentName ?? null,
+    parentSessionId: o.parentSessionId ?? null,
+    profile: o.profile ?? null,
+    modelAlias: o.modelAlias ?? null,
+    surface: o.surface ?? null,
+    isolation: o.isolation ?? null,
+    depth: o.depth ?? null,
+    originKind: o.originKind ?? null,
+    configDir: o.configDir ?? null,
+    spawnCwd: o.spawnCwd ?? null,
+    spawnedAt: o.spawnedAt ?? null,
+    briefChars: o.briefChars ?? null,
+    briefExcerpt: o.briefExcerpt ?? null,
+    briefPath: o.briefPath ?? null,
+    launchArgs: o.launchArgs ?? null
+  };
+}
+function projectOrigins(graph) {
+  const spawned = graph.db.prepare("SELECT session_id, parent_session_id, spawned_at, resolved_at FROM session_origin WHERE parent_session_id IS NOT NULL").all();
+  graph.db.transaction(() => {
+    graph.db.prepare(PROJECT_SUBAGENTS).run();
+    for (const o of spawned) {
+      graph.edges.assert({ sourceRef: sessionRef3(o.parent_session_id), relation: RELATIONS.SPAWNED, targetRef: sessionRef3(o.session_id), tValid: o.spawned_at ?? o.resolved_at });
+    }
+  })();
+}
 
 // src/tasks.ts
 import { taskRef } from "@titan-design/session-read";
@@ -500,14 +1056,15 @@ async function indexTranscript(graph, transcript, options = {}) {
     return { ...base, status: "unchanged", facts: 0 };
   }
   try {
-    const delta = await extractTranscript(transcript.absolutePath, {
+    const delta = await extractTranscript2(transcript.absolutePath, {
       fromByteOffset: point.start,
       priorPrefixHash: point.state === "rewritten" ? null : row.prefixHash,
       subagentId: transcript.subagentId
     });
     const rewound = point.state === "rewritten" || delta.restartedFromZero;
     if (rewound) purgeTranscript(graph, row.sourceId);
-    applyDelta(graph, row.sourceId, delta);
+    applyDelta(graph, row.sourceId, delta, { account: transcript.account });
+    advanceFacet(graph.db, row.sourceId, rewound ? 0 : point.start, delta.lastByteOffset);
     const stat2 = await fs.stat(transcript.absolutePath);
     graph.transcripts.advance(transcript.displayPath, {
       lastOffset: delta.lastByteOffset,
@@ -521,13 +1078,13 @@ async function indexTranscript(graph, transcript, options = {}) {
     const tasks = taskIds.length > 0 ? await enrichTasks(graph, options.resolveTasks, taskIds) : NO_ENRICHMENT;
     return { ...base, sessionIds, tasks, status: rewound ? "rewound" : "indexed", facts: delta.facts.length };
   } catch (err) {
-    if (!(err instanceof TranscriptParseError)) throw err;
+    if (!(err instanceof TranscriptParseError2)) throw err;
     graph.transcripts.markStatus(transcript.displayPath, "quarantined", err.message);
     return { ...base, status: "quarantined", facts: 0, reason: err.message };
   }
 }
 async function refreshCorpus(graph, transcripts, options = {}) {
-  const { resolveTasks, ...perTranscript } = options;
+  const { resolveTasks, resolveOrigins: originResolver, full, facetLimit, ...perTranscript } = options;
   const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };
   const touched = [];
   let facts = 0;
@@ -537,11 +1094,15 @@ async function refreshCorpus(graph, transcripts, options = {}) {
     facts += outcome.facts;
     touched.push(...outcome.sessionIds);
   }
-  const turnsRolledUp = rollupSessions(graph, options.full ? allSessionIds(graph) : touched);
+  const facets = await backfillFacets(graph, transcripts, { limit: facetLimit });
+  touched.push(...facets.sessionIds);
+  const turnsRolledUp = rollupSessions(graph, full ? allSessionIds(graph) : touched);
+  const origins = await resolveOrigins(graph, originResolver);
   const reconciled = reconcile(graph);
   const tasks = await enrichTasks(graph, resolveTasks, allTaskIds(graph));
   const markedMissing = await markMissing(graph, transcripts);
-  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, markedMissing };
+  const facetSummary = { facetsBackfilled: facets.backfilled, facetBacklog: facets.backlog };
+  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, origins, markedMissing, ...facetSummary };
 }
 async function markMissing(graph, discovered) {
   const present = new Set(discovered.map((t) => t.displayPath));
@@ -775,14 +1336,28 @@ function normalizedUsage(graph, ref) {
   return accumulator.summaries();
 }
 export {
+  AUDIT_DDL,
+  AUDIT_FACET,
+  AUDIT_MIGRATION_NAME,
+  AUDIT_TABLES,
+  DEFAULT_FACET_LIMIT,
   DERIVED_TABLES,
   DOMAIN_DDL,
+  EPISODE_TABLE,
+  FACET_TABLE,
   KIT,
   MIGRATIONS,
   NO_ENRICHMENT,
+  NO_ORIGINS,
+  ORIGIN_DDL,
+  ORIGIN_MIGRATION_NAME,
+  ORIGIN_TABLES,
+  ORIGIN_VIEWS,
   allSessionIds,
   allTaskIds,
+  applyAudit,
   applyDelta,
+  backfillFacets,
   enrichTasks,
   indexCodexSource,
   indexTranscript,
@@ -795,6 +1370,8 @@ export {
   refreshCorpus,
   resetIndex,
   resolveConversationAlias,
-  rollupSessions
+  resolveOrigins,
+  rollupSessions,
+  sessionsNeedingOrigin
 };
 //# sourceMappingURL=index.js.map