@titan-design/session-graph 0.6.0 → 0.8.0

package/dist/index.js

@@ -129,6 +129,124 @@ function addColumnIfMissing(db, table, column, type) {
   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 = `
@@ -318,6 +436,8 @@ var DERIVED_TABLES = [
   "subagent",
   ...AUDIT_TABLES,
   FACET_TABLE,
+  ...ORIGIN_TABLES,
+  EPISODE_TABLE,
   "session_model_usage",
   "session",
   "fact",
@@ -336,7 +456,8 @@ var MIGRATIONS = [
     db.exec(NORMALIZED_DDL);
     backfillClaudeAliases(db);
   } },
-  { version: 4, name: AUDIT_MIGRATION_NAME, up: applyAuditSchema }
+  { version: 4, name: AUDIT_MIGRATION_NAME, up: applyAuditSchema },
+  { version: 5, name: ORIGIN_MIGRATION_NAME, up: applyOriginSchema }
 ];
 
 // src/graph.ts
@@ -617,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);
@@ -791,15 +912,153 @@ import { promises as fs } from "fs";
 import { contentHash, resumePoint } from "@titan-design/locator";
 import { TranscriptParseError as TranscriptParseError2, extractTranscript as extractTranscript2 } from "@titan-design/session-read";
 
+// src/outcomes.ts
+var NO_PR_OUTCOMES = Object.freeze({ requested: 0, applied: 0, failed: false });
+var PRS_NEEDING_OUTCOME = `
+  SELECT pr_ref, repo, number FROM pr
+  WHERE repo IS NOT NULL AND number IS NOT NULL AND (outcome_checked_at IS NULL OR state IS NOT 'merged')
+  ORDER BY pr_ref`;
+var APPLY_OUTCOME = `
+  UPDATE pr SET
+    state = CASE WHEN state = 'merged' THEN state ELSE COALESCE(lower(@state), state) END,
+    merged_at = COALESCE(@mergedAt, merged_at),
+    closed_at = COALESCE(@closedAt, closed_at),
+    review_rounds = COALESCE(@reviewRounds, review_rounds),
+    outcome_checked_at = @checkedAt
+  WHERE pr_ref = @prRef`;
+function prsNeedingOutcome(graph) {
+  const rows = graph.db.prepare(PRS_NEEDING_OUTCOME).all();
+  return rows.map((r) => ({ prRef: r.pr_ref, repo: r.repo, number: r.number }));
+}
+async function enrichPrs(graph, resolver) {
+  if (!resolver) return NO_PR_OUTCOMES;
+  const prs = prsNeedingOutcome(graph);
+  if (prs.length === 0) return NO_PR_OUTCOMES;
+  try {
+    const resolved = await resolver(prs);
+    return { requested: prs.length, applied: write(graph, resolved, (/* @__PURE__ */ new Date()).toISOString()), failed: false };
+  } catch (err) {
+    return { requested: prs.length, applied: 0, failed: true, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function write(graph, resolved, checkedAt) {
+  const apply = graph.db.prepare(APPLY_OUTCOME);
+  return graph.db.transaction(() => {
+    let applied = 0;
+    for (const [prRef, fields] of resolved) {
+      if (!fields) continue;
+      applied += apply.run({
+        prRef,
+        checkedAt,
+        state: fields.state ?? null,
+        mergedAt: fields.mergedAt ?? null,
+        closedAt: fields.closedAt ?? null,
+        reviewRounds: fields.reviewRounds ?? null
+      }).changes;
+    }
+    return applied;
+  })();
+}
+
+// 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";
 var NO_ENRICHMENT = Object.freeze({ requested: 0, applied: 0, failed: false });
 var UPSERT_TASK = `
-  INSERT INTO task (task_ref, task_id, initiative, title, status) VALUES (@taskRef, @taskId, @initiative, @title, @status)
+  INSERT INTO task (task_ref, task_id, initiative, title, status, estimate) VALUES (@taskRef, @taskId, @initiative, @title, @status, @estimate)
   ON CONFLICT (task_ref) DO UPDATE SET
     initiative = COALESCE(excluded.initiative, initiative),
     title      = COALESCE(excluded.title, title),
-    status     = COALESCE(excluded.status, status)`;
+    status     = COALESCE(excluded.status, status),
+    estimate   = COALESCE(excluded.estimate, estimate)`;
 function allTaskIds(graph) {
   return graph.db.prepare("SELECT task_id FROM task").all().map((r) => r.task_id);
 }
@@ -808,12 +1067,12 @@ async function enrichTasks(graph, resolver, taskIds) {
   if (!resolver) return NO_ENRICHMENT;
   try {
     const resolved = await resolver(unique);
-    return { requested: unique.length, applied: write(graph, resolved), failed: false };
+    return { requested: unique.length, applied: write2(graph, resolved), failed: false };
   } catch (err) {
     return { requested: unique.length, applied: 0, failed: true, error: err instanceof Error ? err.message : String(err) };
   }
 }
-function write(graph, resolved) {
+function write2(graph, resolved) {
   const upsert = graph.db.prepare(UPSERT_TASK);
   return graph.db.transaction(() => {
     let applied = 0;
@@ -824,7 +1083,8 @@ function write(graph, resolved) {
         taskId,
         initiative: fields.initiative ?? null,
         title: fields.title ?? null,
-        status: fields.status ?? null
+        status: fields.status ?? null,
+        estimate: fields.estimate ?? null
       }).changes;
     }
     return applied;
@@ -874,7 +1134,7 @@ async function indexTranscript(graph, transcript, options = {}) {
   }
 }
 async function refreshCorpus(graph, transcripts, options = {}) {
-  const { resolveTasks, full, facetLimit, ...perTranscript } = options;
+  const { resolveTasks, resolveOrigins: originResolver, resolvePrs, full, facetLimit, ...perTranscript } = options;
   const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };
   const touched = [];
   let facts = 0;
@@ -887,11 +1147,13 @@ async function refreshCorpus(graph, transcripts, options = {}) {
   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 prs = await enrichPrs(graph, resolvePrs);
   const tasks = await enrichTasks(graph, resolveTasks, allTaskIds(graph));
   const markedMissing = await markMissing(graph, transcripts);
   const facetSummary = { facetsBackfilled: facets.backfilled, facetBacklog: facets.backlog };
-  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, markedMissing, ...facetSummary };
+  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, origins, prs, markedMissing, ...facetSummary };
 }
 async function markMissing(graph, discovered) {
   const present = new Set(discovered.map((t) => t.displayPath));
@@ -916,6 +1178,57 @@ async function exists(absolutePath) {
   }
 }
 
+// src/episodes.ts
+var DELETE_EPISODES = `DELETE FROM ${EPISODE_TABLE} WHERE session_id = ? AND heuristic = ?`;
+var INSERT_EPISODE = `
+  INSERT INTO ${EPISODE_TABLE} (session_id, episode_index, heuristic, heuristic_version, started_at, ended_at,
+    start_offset, end_offset, opened_by, assignment_offset, first_deliverable_offset, first_deliverable_signal, first_status_offset)
+  VALUES (@sessionId, @episodeIndex, @heuristic, @heuristicVersion, @startedAt, @endedAt,
+    @startOffset, @endOffset, @openedBy, @assignmentOffset, @firstDeliverableOffset, @firstDeliverableSignal, @firstStatusOffset)`;
+function replaceEpisodes(graph, sessionId, heuristic, rows) {
+  const remove = graph.db.prepare(DELETE_EPISODES);
+  const insert = graph.db.prepare(INSERT_EPISODE);
+  return graph.db.transaction(() => {
+    remove.run(sessionId, heuristic);
+    for (const row of rows) insert.run(episodeParams(sessionId, heuristic, row));
+    return rows.length;
+  })();
+}
+function episodeParams(sessionId, heuristic, row) {
+  return {
+    sessionId,
+    heuristic,
+    episodeIndex: row.episodeIndex,
+    heuristicVersion: row.heuristicVersion,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    startOffset: row.startOffset,
+    endOffset: row.endOffset,
+    openedBy: row.openedBy,
+    assignmentOffset: row.assignmentOffset ?? null,
+    firstDeliverableOffset: row.firstDeliverableOffset ?? null,
+    firstDeliverableSignal: row.firstDeliverableSignal ?? null,
+    firstStatusOffset: row.firstStatusOffset ?? null
+  };
+}
+
+// src/prices.ts
+function syncPrices(graph, rows, options) {
+  const insert = graph.db.prepare(
+    `INSERT INTO price (model, effective_from, table_version, input_usd_mtok, cache_read_usd_mtok,
+       cache_write_5m_usd_mtok, cache_write_1h_usd_mtok, output_usd_mtok, source)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const source = options.source ?? null;
+  graph.db.transaction(() => {
+    graph.db.exec("DELETE FROM price");
+    for (const r of rows) {
+      insert.run(r.modelPrefix, r.effectiveFrom, options.tableVersion, r.input, r.cacheRead, r.cacheWrite5m, r.cacheWrite1h, r.output, source);
+    }
+  })();
+  return rows.length;
+}
+
 // src/normalized-index.ts
 import { randomUUID } from "crypto";
 import { stat } from "fs/promises";
@@ -1132,27 +1445,40 @@ export {
   DEFAULT_FACET_LIMIT,
   DERIVED_TABLES,
   DOMAIN_DDL,
+  EPISODE_TABLE,
   FACET_TABLE,
   KIT,
   MIGRATIONS,
   NO_ENRICHMENT,
+  NO_ORIGINS,
+  NO_PR_OUTCOMES,
+  ORIGIN_DDL,
+  ORIGIN_MIGRATION_NAME,
+  ORIGIN_TABLES,
+  ORIGIN_VIEWS,
   allSessionIds,
   allTaskIds,
   applyAudit,
   applyDelta,
   backfillFacets,
+  enrichPrs,
   enrichTasks,
   indexCodexSource,
   indexTranscript,
   normalizedSessions,
   normalizedUsage,
   openSessionGraph,
+  prsNeedingOutcome,
   purgeTranscript,
   readIndexedText,
   reconcile,
   refreshCorpus,
+  replaceEpisodes,
   resetIndex,
   resolveConversationAlias,
-  rollupSessions
+  resolveOrigins,
+  rollupSessions,
+  sessionsNeedingOrigin,
+  syncPrices
 };
 //# sourceMappingURL=index.js.map