@titan-design/session-graph 0.12.1 → 0.13.1

package/README.md

@@ -9,10 +9,12 @@ Tier 2 of the titan-platform DAG. Depends on `session-read`, `store-sqlite`,
 `cluster`, `locator`, and `agent-protocol`. Extracted from active-work's session index (AW-23, TP-6).
 
 ```ts
+import os from "node:os";
+import path from "node:path";
 import { discoverTranscripts } from "@titan-design/session-read";
 import { openSessionGraph, refreshCorpus } from "@titan-design/session-graph";
 
-const graph = openSessionGraph("~/.local/state/miner/index.sqlite3");
+const graph = openSessionGraph(path.join(os.homedir(), ".local/state/miner/index.sqlite3"));
 const summary = await refreshCorpus(graph, await discoverTranscripts());
 // summary.indexed, summary.unchanged, summary.rewound, summary.quarantined, summary.missing,
 // summary.facetsBackfilled, summary.facetBacklog
@@ -174,8 +176,14 @@ with its transcript. `pr_ref` stays null until a later pass resolves it.
 `resetIndex` drops `pr` rows and forge review rows with everything else, so `commit_times`,
 `review_rounds_gh` and the forge reviews return only when a resolver answers again.
 
-Everything except `transcript` is derivable, which is what makes the schema safe to evolve
-by drop-and-rederive.
+Not everything can be rebuilt from transcripts. Original sources can be pruned, so schema
+migrations must preserve `fact` and `session` rows rather than assuming a replay is possible.
+`resetIndex` clears the tables in `DERIVED_TABLES`, including `fact` and `session`. That is a
+deliberate reset, not a migration step. It keeps the `transcript` watermark table (rewound, not
+deleted), `price` and `session_state`, which nothing derives from transcripts, and `conversation`
+and `conversation_alias`, which are derived from `session` rows or sources but are not in
+`DERIVED_TABLES`. `session_origin` and `session_external_event` are not derived from transcripts
+either: `resetIndex` clears them and the next pass refills them from their own sources.
 
 
 ## Injected context
@@ -277,6 +285,8 @@ empty tables, so existing rows are untouched.
 - `request_dedup` collapses fan-out copies of a request to the earliest one. Every cost
   query reads it, never `request`. `request_cost` prices each row by longest model prefix
   and latest `effective_from`; an unmatched model reads `priced = 0` and costs 0.
+  A price row matches only when the model id equals its prefix or continues with `[..]` or
+  `-YYYYMMDD` (optionally followed by `[..]`), so `claude-opus-5` never prices `claude-opus-5-9`.
   `context_contribution` attributes each request's context growth to the blocks before it.
 
 Migration 6, `episode transcript ids`, adds nullable `start_transcript_id` and

package/dist/index.d.ts

@@ -20,6 +20,8 @@ interface OpenSessionGraphOptions {
      * the graph must already carry every migration this package declares.
      */
     readonly?: boolean;
+    /** Keep the `normalized_*` tables the Codex path reads and writes. Off by default: a graph holds none unless asked. Ignored when read-only. */
+    normalized?: boolean;
 }
 declare class SessionGraphNotMigratedError extends Error {
     readonly missing: readonly string[];
@@ -46,9 +48,12 @@ declare const KIT: {
  * Locators are `(transcript_id, byte_offset, byte_length)`; `fact_id` rows
  * resolve through the facts table's unique `(transcript_id, byte_offset)`.
  */
-declare const DOMAIN_DDL = "\n  CREATE TABLE IF NOT EXISTS fact (\n    fact_id       INTEGER PRIMARY KEY,\n    transcript_id INTEGER NOT NULL,\n    byte_offset   INTEGER NOT NULL,\n    byte_length   INTEGER NOT NULL,\n    event_type    TEXT NOT NULL,\n    ts            TEXT NOT NULL,\n    seq           INTEGER NOT NULL,\n    session_id    TEXT NOT NULL,\n    prompt_id     TEXT,\n    tool_use_id   TEXT,\n    t_indexed     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),\n    UNIQUE (transcript_id, byte_offset)\n  );\n  CREATE INDEX IF NOT EXISTS idx_fact_session_ts ON fact(session_id, ts);\n  CREATE INDEX IF NOT EXISTS idx_fact_prompt ON fact(prompt_id);\n  CREATE INDEX IF NOT EXISTS idx_fact_tool_use ON fact(tool_use_id);\n\n  CREATE TABLE IF NOT EXISTS session (\n    session_id    TEXT PRIMARY KEY,\n    transcript_id INTEGER,\n    started_at    TEXT,\n    ended_at      TEXT,\n    start_type    TEXT,\n    cwd           TEXT,\n    git_branch    TEXT,\n    ai_title      TEXT,\n    seed_prompt   TEXT,\n    cli_version   TEXT,\n    turn_count    INTEGER NOT NULL DEFAULT 0,\n    commit_count  INTEGER NOT NULL DEFAULT 0,\n    push_count    INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE INDEX IF NOT EXISTS idx_session_started ON session(started_at);\n\n  CREATE TABLE IF NOT EXISTS session_model_usage (\n    session_id            TEXT NOT NULL,\n    model                 TEXT NOT NULL,\n    input_tokens          INTEGER NOT NULL DEFAULT 0,\n    output_tokens         INTEGER NOT NULL DEFAULT 0,\n    cache_read_tokens     INTEGER NOT NULL DEFAULT 0,\n    cache_creation_tokens INTEGER NOT NULL DEFAULT 0,\n    thinking_tokens       INTEGER NOT NULL DEFAULT 0,\n    request_count         INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (session_id, model)\n  );\n\n  CREATE TABLE IF NOT EXISTS turn (\n    prompt_id       TEXT PRIMARY KEY,\n    session_id      TEXT NOT NULL,\n    turn_index      INTEGER NOT NULL,\n    started_at      TEXT NOT NULL,\n    ended_at        TEXT,\n    duration_ms     INTEGER,\n    tool_call_count INTEGER NOT NULL DEFAULT 0,\n    thinking_ms     INTEGER NOT NULL DEFAULT 0,\n    fact_id_start   INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_turn_session ON turn(session_id, turn_index);\n\n  CREATE TABLE IF NOT EXISTS permission_phase (\n    phase_id   INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    from_mode  TEXT,\n    to_mode    TEXT NOT NULL,\n    trigger    TEXT NOT NULL,\n    t_valid    TEXT NOT NULL,\n    t_invalid  TEXT,\n    fact_id    INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_phase_session ON permission_phase(session_id, t_valid);\n\n  CREATE TABLE IF NOT EXISTS human_edit (\n    edit_id    INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    file_path  TEXT NOT NULL,\n    ts         TEXT NOT NULL,\n    fact_id    INTEGER,\n    UNIQUE (session_id, file_path, ts)\n  );\n\n  CREATE TABLE IF NOT EXISTS file_checkpoint (\n    checkpoint_id    INTEGER PRIMARY KEY,\n    session_id       TEXT NOT NULL,\n    file_path        TEXT NOT NULL,\n    backup_file_name TEXT NOT NULL,\n    version          INTEGER NOT NULL,\n    backup_time      TEXT NOT NULL,\n    fact_id          INTEGER,\n    UNIQUE (session_id, file_path, backup_file_name)\n  );\n\n  CREATE TABLE IF NOT EXISTS pr (\n    pr_ref TEXT PRIMARY KEY, number INTEGER, repo TEXT, title TEXT, state TEXT, url TEXT, merged_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS branch (\n    branch_ref TEXT PRIMARY KEY, repo TEXT, name TEXT NOT NULL, base TEXT, created_at TEXT, deleted_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS file (\n    file_ref TEXT PRIMARY KEY, repo TEXT, path TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS task (\n    task_ref TEXT PRIMARY KEY, task_id TEXT NOT NULL, initiative TEXT, title TEXT, status TEXT\n  );\n  CREATE TABLE IF NOT EXISTS subagent (\n    agent_ref        TEXT PRIMARY KEY,\n    session_id       TEXT,\n    child_session_id TEXT,\n    parent_agent_ref TEXT,\n    agent_type       TEXT,\n    label            TEXT,\n    started_at       TEXT,\n    ended_at         TEXT,\n    fact_id          INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_subagent_child ON subagent(child_session_id);\n  CREATE TABLE IF NOT EXISTS artifact (\n    artifact_ref TEXT PRIMARY KEY, kind TEXT, title TEXT, url TEXT, path TEXT, created_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS pr_merge_observation (\n    number INTEGER NOT NULL, repo_hint TEXT, merged_at TEXT NOT NULL,\n    PRIMARY KEY (number, repo_hint, merged_at)\n  );\n  CREATE TABLE IF NOT EXISTS pr_create_observation (\n    tool_use_id TEXT PRIMARY KEY, title TEXT, number INTEGER, repo TEXT, url TEXT\n  );\n";
-/** Every derived table, in an order safe to clear. The watermark table is not derived. */
-declare const DERIVED_TABLES: readonly ["normalized_span", "normalized_event", "normalized_source", "search_span", "edge", "turn", "permission_phase", "human_edit", "file_checkpoint", "subagent", "request", "tool_call", "inbound", "context_block", "compaction", "queue_op", "session_signal", "cost_state_observation", "transcript_facet", "session_origin", "session_external_event", "episode", "session_model_usage", "session", "fact", "pr", "pr_merge_observation", "pr_create_observation", "pr_review", "branch", "file", "task", "artifact"];
+declare const DOMAIN_DDL = "\n  CREATE TABLE IF NOT EXISTS fact (\n    fact_id       INTEGER PRIMARY KEY,\n    transcript_id INTEGER NOT NULL,\n    byte_offset   INTEGER NOT NULL,\n    byte_length   INTEGER NOT NULL,\n    event_type    TEXT NOT NULL,\n    ts            TEXT NOT NULL,\n    seq           INTEGER NOT NULL,\n    session_id    TEXT NOT NULL,\n    prompt_id     TEXT,\n    tool_use_id   TEXT,\n    t_indexed     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),\n    UNIQUE (transcript_id, byte_offset)\n  );\n  CREATE INDEX IF NOT EXISTS idx_fact_session_ts ON fact(session_id, ts);\n  CREATE INDEX IF NOT EXISTS idx_fact_prompt ON fact(prompt_id);\n  CREATE INDEX IF NOT EXISTS idx_fact_tool_use ON fact(tool_use_id);\n\n  CREATE TABLE IF NOT EXISTS session (\n    session_id    TEXT PRIMARY KEY,\n    transcript_id INTEGER,\n    started_at    TEXT,\n    ended_at      TEXT,\n    start_type    TEXT,\n    cwd           TEXT,\n    git_branch    TEXT,\n    ai_title      TEXT,\n    seed_prompt   TEXT,\n    cli_version   TEXT,\n    turn_count    INTEGER NOT NULL DEFAULT 0,\n    commit_count  INTEGER NOT NULL DEFAULT 0,\n    push_count    INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE INDEX IF NOT EXISTS idx_session_started ON session(started_at);\n\n  CREATE TABLE IF NOT EXISTS session_model_usage (\n    session_id            TEXT NOT NULL,\n    model                 TEXT NOT NULL,\n    input_tokens          INTEGER NOT NULL DEFAULT 0,\n    output_tokens         INTEGER NOT NULL DEFAULT 0,\n    cache_read_tokens     INTEGER NOT NULL DEFAULT 0,\n    cache_creation_tokens INTEGER NOT NULL DEFAULT 0,\n    thinking_tokens       INTEGER NOT NULL DEFAULT 0,\n    request_count         INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (session_id, model)\n  );\n\n  CREATE TABLE IF NOT EXISTS turn (\n    prompt_id       TEXT PRIMARY KEY,\n    session_id      TEXT NOT NULL,\n    turn_index      INTEGER NOT NULL,\n    started_at      TEXT NOT NULL,\n    ended_at        TEXT,\n    duration_ms     INTEGER,\n    tool_call_count INTEGER NOT NULL DEFAULT 0,\n    thinking_ms     INTEGER NOT NULL DEFAULT 0,\n    fact_id_start   INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_turn_session ON turn(session_id, turn_index);\n\n  CREATE TABLE IF NOT EXISTS permission_phase (\n    phase_id   INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    from_mode  TEXT,\n    to_mode    TEXT NOT NULL,\n    trigger    TEXT NOT NULL,\n    t_valid    TEXT NOT NULL,\n    t_invalid  TEXT,\n    fact_id    INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_phase_session ON permission_phase(session_id, t_valid);\n\n  CREATE TABLE IF NOT EXISTS human_edit (\n    edit_id    INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    file_path  TEXT NOT NULL,\n    ts         TEXT NOT NULL,\n    fact_id    INTEGER,\n    UNIQUE (session_id, file_path, ts)\n  );\n\n  CREATE TABLE IF NOT EXISTS file_checkpoint (\n    checkpoint_id    INTEGER PRIMARY KEY,\n    session_id       TEXT NOT NULL,\n    file_path        TEXT NOT NULL,\n    backup_file_name TEXT NOT NULL,\n    version          INTEGER NOT NULL,\n    backup_time      TEXT NOT NULL,\n    fact_id          INTEGER,\n    UNIQUE (session_id, file_path, backup_file_name)\n  );\n\n  CREATE TABLE IF NOT EXISTS pr (\n    pr_ref TEXT PRIMARY KEY, number INTEGER, repo TEXT, title TEXT, state TEXT, url TEXT, merged_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS branch (\n    branch_ref TEXT PRIMARY KEY, repo TEXT, name TEXT NOT NULL, base TEXT, created_at TEXT, deleted_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS file (\n    file_ref TEXT PRIMARY KEY, repo TEXT, path TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS task (\n    task_ref TEXT PRIMARY KEY, task_id TEXT NOT NULL, initiative TEXT, title TEXT, status TEXT\n  );\n  CREATE TABLE IF NOT EXISTS subagent (\n    agent_ref        TEXT PRIMARY KEY,\n    session_id       TEXT,\n    child_session_id TEXT,\n    parent_agent_ref TEXT,\n    agent_type       TEXT,\n    label            TEXT,\n    started_at       TEXT,\n    ended_at         TEXT,\n    fact_id          INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_subagent_child ON subagent(child_session_id);\n  CREATE TABLE IF NOT EXISTS pr_merge_observation (\n    number INTEGER NOT NULL, repo_hint TEXT, merged_at TEXT NOT NULL,\n    PRIMARY KEY (number, repo_hint, merged_at)\n  );\n  CREATE TABLE IF NOT EXISTS pr_create_observation (\n    tool_use_id TEXT PRIMARY KEY, title TEXT, number INTEGER, repo TEXT, url TEXT\n  );\n";
+/** Opt-in tables: absent from a graph opened without `normalized: true`. */
+declare const NORMALIZED_TABLES: readonly ["normalized_span", "normalized_event", "normalized_source"];
+/** Derived tables present in this database; the opt-in normalized ones come first so they clear first. */
+declare function derivedTables(db: Db): string[];
+declare const DERIVED_TABLES: readonly ["normalized_span", "normalized_event", "normalized_source", "search_span", "edge", "turn", "permission_phase", "human_edit", "file_checkpoint", "subagent", "request", "tool_call", "inbound", "context_block", "compaction", "queue_op", "session_signal", "cost_state_observation", "transcript_facet", "session_origin", "session_external_event", "episode", "session_model_usage", "session", "fact", "pr", "pr_merge_observation", "pr_create_observation", "pr_review", "branch", "file", "task"];
 declare const MIGRATIONS: Migration[];
 
 /** Recorded in `_migration`; store-sqlite refuses a database whose applied name differs, so never rename it. */
@@ -386,6 +391,10 @@ interface RefreshOptions extends IndexOptions {
     full?: boolean;
     /** Stale audit facets re-extracted per pass (default 40). `Infinity` clears the backlog. */
     facetLimit?: number;
+    /** What a leading `~` in a stored source key means when checking for vanished files. Defaults to the OS home directory. */
+    homeDir?: string;
+    /** Source keys known to exist this pass even when not visited, such as a sealed transcript the caller skipped. */
+    present?: Iterable<string>;
 }
 type TranscriptOutcome = {
     status: "unchanged" | "indexed" | "rewound";
@@ -471,7 +480,7 @@ declare function replaceEpisodes(graph: SessionGraph, sessionId: string, heurist
 
 /** USD per million tokens for one model prefix from one date. Shaped so session-analytics' `PRICE_TABLE` passes straight through. */
 interface PriceInput {
-    /** Matched against `request.model` by longest prefix in `request_cost`. */
+    /** Matched against `request.model` in `request_cost` by longest prefix at an id boundary: the id itself, or followed by -YYYYMMDD or [..]. */
     modelPrefix: string;
     /** ISO date or timestamp; compared as text against `request.ts`. */
     effectiveFrom: string;
@@ -523,7 +532,9 @@ interface IndexedSpan {
     spanId?: number;
 }
 /** One resolver for search and error clustering; never display a raw JSON line. */
-declare function readIndexedText(graph: SessionGraph, span: IndexedSpan): Promise<string | null>;
+declare function readIndexedText(graph: SessionGraph, span: IndexedSpan, options?: {
+    homeDir?: string;
+}): Promise<string | null>;
 interface ConversationSummary {
     sessionId: string;
     harness: string;
@@ -547,7 +558,9 @@ type NormalizedUsageSummary = SessionUsageSummary;
 /** Shared storage-free usage policy keeps graph and direct readers consistent. */
 declare function normalizedUsage(graph: SessionGraph, ref: string): NormalizedUsageSummary[];
 
+/** Re-creates the opt-in tables migration 9 drops from a graph that held none of their rows. */
+declare function ensureNormalizedSchema(db: Db): void;
 /** Ambiguity is explicit; workspace session bodies remain in their original namespace. */
 declare function resolveConversationAlias(db: Db, legacyRef: string): string | null;
 
-export { AUDIT_DDL, AUDIT_FACET, AUDIT_MIGRATION_NAME, AUDIT_TABLES, type BackfillOptions, type BackfillSummary, type ConversationSummary, DEFAULT_FACET_LIMIT, DERIVED_TABLES, DOMAIN_DDL, type DeltaSource, EPISODE_TABLE, type EpisodeRow, type ExternalEvent, FACET_TABLE, type IndexOptions, type IndexedSpan, KIT, MIGRATIONS, NO_ENRICHMENT, NO_ORIGINS, NO_PR_OUTCOMES, NO_TASK_LINK, type NormalizedIndexResult, type NormalizedUsageSummary, ORIGIN_DDL, ORIGIN_MIGRATION_NAME, ORIGIN_TABLES, ORIGIN_TASK_LINK_MIGRATION_NAME, ORIGIN_VIEWS, type OpenSessionGraphOptions, type OriginEnrichment, type OriginResolution, type OriginResolver, type PrEnrichment, type PrKey, type PrResolution, type PrResolver, type PriceInput, REVIEW_DDL, REVIEW_TABLE, REVIEW_VERDICT_MIGRATION_NAME, type ReconcileCounts, type ReconcileResult, type RefreshOptions, type RefreshSummary, type ResolvedOrigin, type ResolvedPr, type ResolvedReview, type ResolvedTask, type ReviewProjection, type ReviewRoundOptions, type ReviewerProfilePredicate, type SessionGraph, SessionGraphNotMigratedError, type SyncPricesOptions, type TaskEnrichment, type TaskLinkSource, type TaskResolution, type TaskResolver, type TranscriptOutcome, allSessionIds, allTaskIds, applyAudit, applyDelta, backfillFacets, countRounds, enrichPrs, enrichTasks, indexCodexSource, indexTranscript, isInjectedCause, isReviewerProfile, isUntypedPrompt, normalizedSessions, normalizedUsage, openSessionGraph, projectReviewRounds, prsNeedingOutcome, purgeTranscript, readIndexedText, reconcile, reconcilePrices, refreshCorpus, replaceEpisodes, resetIndex, resolveConversationAlias, resolveOrigins, rollupSessions, sessionsNeedingOrigin, stripInjected, syncPrices };
+export { AUDIT_DDL, AUDIT_FACET, AUDIT_MIGRATION_NAME, AUDIT_TABLES, type BackfillOptions, type BackfillSummary, type ConversationSummary, DEFAULT_FACET_LIMIT, DERIVED_TABLES, DOMAIN_DDL, type DeltaSource, EPISODE_TABLE, type EpisodeRow, type ExternalEvent, FACET_TABLE, type IndexOptions, type IndexedSpan, KIT, MIGRATIONS, NORMALIZED_TABLES, NO_ENRICHMENT, NO_ORIGINS, NO_PR_OUTCOMES, NO_TASK_LINK, type NormalizedIndexResult, type NormalizedUsageSummary, ORIGIN_DDL, ORIGIN_MIGRATION_NAME, ORIGIN_TABLES, ORIGIN_TASK_LINK_MIGRATION_NAME, ORIGIN_VIEWS, type OpenSessionGraphOptions, type OriginEnrichment, type OriginResolution, type OriginResolver, type PrEnrichment, type PrKey, type PrResolution, type PrResolver, type PriceInput, REVIEW_DDL, REVIEW_TABLE, REVIEW_VERDICT_MIGRATION_NAME, type ReconcileCounts, type ReconcileResult, type RefreshOptions, type RefreshSummary, type ResolvedOrigin, type ResolvedPr, type ResolvedReview, type ResolvedTask, type ReviewProjection, type ReviewRoundOptions, type ReviewerProfilePredicate, type SessionGraph, SessionGraphNotMigratedError, type SyncPricesOptions, type TaskEnrichment, type TaskLinkSource, type TaskResolution, type TaskResolver, type TranscriptOutcome, allSessionIds, allTaskIds, applyAudit, applyDelta, backfillFacets, countRounds, derivedTables, enrichPrs, enrichTasks, ensureNormalizedSchema, indexCodexSource, indexTranscript, isInjectedCause, isReviewerProfile, isUntypedPrompt, normalizedSessions, normalizedUsage, openSessionGraph, projectReviewRounds, prsNeedingOutcome, purgeTranscript, readIndexedText, reconcile, reconcilePrices, refreshCorpus, replaceEpisodes, resetIndex, resolveConversationAlias, resolveOrigins, rollupSessions, sessionsNeedingOrigin, stripInjected, syncPrices };

package/dist/index.js

@@ -1,5 +1,53 @@
 // src/graph.ts
-import { EdgeTable, MIGRATION_TABLE_NAME, SpanFtsTables, WatermarkTable, hasTable, openDatabase, runMigrations } from "@titan-design/store-sqlite";
+import { EdgeTable, MIGRATION_TABLE_NAME, SpanFtsTables, WatermarkTable, hasTable as hasTable2, openDatabase, runMigrations } from "@titan-design/store-sqlite";
+
+// src/normalized-schema.ts
+import { conversationRef } from "@titan-design/agent-protocol";
+var NORMALIZED_DDL = `
+CREATE TABLE IF NOT EXISTS conversation (
+  ref TEXT PRIMARY KEY, harness TEXT NOT NULL, namespace TEXT NOT NULL,
+  native_id TEXT NOT NULL, legacy_session_id TEXT,
+  UNIQUE(harness, namespace, native_id)
+);
+CREATE TABLE IF NOT EXISTS conversation_alias (
+  legacy_ref TEXT NOT NULL, conversation_ref TEXT NOT NULL,
+  PRIMARY KEY(legacy_ref, conversation_ref)
+);
+CREATE TABLE IF NOT EXISTS normalized_source (
+  transcript_id INTEGER PRIMARY KEY, source_id TEXT NOT NULL UNIQUE,
+  conversation_ref TEXT NOT NULL, descriptor TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS normalized_event (
+  transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL,
+  subrecord_index INTEGER NOT NULL, byte_length INTEGER NOT NULL,
+  conversation_ref TEXT NOT NULL, kind TEXT NOT NULL, ts TEXT,
+  turn_ref TEXT, call_ref TEXT, item_ref TEXT, phase TEXT, is_error INTEGER,
+  usage TEXT, metadata TEXT, history_origin TEXT, related_ref TEXT, relationship TEXT,
+  PRIMARY KEY(transcript_id, byte_offset, subrecord_index)
+);
+CREATE INDEX IF NOT EXISTS idx_normalized_event_conversation ON normalized_event(conversation_ref, ts);
+CREATE TABLE IF NOT EXISTS normalized_span (
+  span_id INTEGER PRIMARY KEY, locators TEXT NOT NULL
+);
+`;
+function ensureNormalizedSchema(db) {
+  db.exec(NORMALIZED_DDL);
+}
+function backfillClaudeAliases(db, sessionIds) {
+  const insert = db.prepare("INSERT OR IGNORE INTO conversation(ref,harness,namespace,native_id,legacy_session_id) VALUES (?,?,?,?,?)");
+  const alias = db.prepare("INSERT OR IGNORE INTO conversation_alias VALUES (?,?)");
+  const rows = sessionIds?.map((session_id) => ({ session_id })) ?? db.prepare("SELECT session_id FROM session").all();
+  for (const row of rows) {
+    const ref = conversationRef({ harness: "claude-code", namespace: "legacy", nativeId: row.session_id });
+    insert.run(ref, "claude-code", "legacy", row.session_id, row.session_id);
+    alias.run(`session:${row.session_id}`, ref);
+  }
+}
+function resolveConversationAlias(db, legacyRef) {
+  const rows = db.prepare("SELECT conversation_ref FROM conversation_alias WHERE legacy_ref = ?").all(legacyRef);
+  if (rows.length > 1) throw new Error(`ambiguous conversation alias: ${legacyRef}`);
+  return rows[0]?.conversation_ref ?? null;
+}
 
 // src/audit-schema.ts
 var AUDIT_MIGRATION_NAME = "audit tables";
@@ -293,53 +341,48 @@ function applyReviewVerdictSchema(db) {
   db.exec("UPDATE pr SET outcome_checked_at = NULL");
 }
 
-// src/normalized-schema.ts
-import { conversationRef } from "@titan-design/agent-protocol";
-var NORMALIZED_DDL = `
-CREATE TABLE IF NOT EXISTS conversation (
-  ref TEXT PRIMARY KEY, harness TEXT NOT NULL, namespace TEXT NOT NULL,
-  native_id TEXT NOT NULL, legacy_session_id TEXT,
-  UNIQUE(harness, namespace, native_id)
-);
-CREATE TABLE IF NOT EXISTS conversation_alias (
-  legacy_ref TEXT NOT NULL, conversation_ref TEXT NOT NULL,
-  PRIMARY KEY(legacy_ref, conversation_ref)
-);
-CREATE TABLE IF NOT EXISTS normalized_source (
-  transcript_id INTEGER PRIMARY KEY, source_id TEXT NOT NULL UNIQUE,
-  conversation_ref TEXT NOT NULL, descriptor TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS normalized_event (
-  transcript_id INTEGER NOT NULL, byte_offset INTEGER NOT NULL,
-  subrecord_index INTEGER NOT NULL, byte_length INTEGER NOT NULL,
-  conversation_ref TEXT NOT NULL, kind TEXT NOT NULL, ts TEXT,
-  turn_ref TEXT, call_ref TEXT, item_ref TEXT, phase TEXT, is_error INTEGER,
-  usage TEXT, metadata TEXT, history_origin TEXT, related_ref TEXT, relationship TEXT,
-  PRIMARY KEY(transcript_id, byte_offset, subrecord_index)
-);
-CREATE INDEX IF NOT EXISTS idx_normalized_event_conversation ON normalized_event(conversation_ref, ts);
-CREATE TABLE IF NOT EXISTS normalized_span (
-  span_id INTEGER PRIMARY KEY, locators TEXT NOT NULL
-);
+// src/audit-schema-v10.ts
+var REQUEST_COST_BOUNDARY_MIGRATION_NAME = "request_cost model-id boundary";
+var DIGITS_8 = "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]";
+var REST = "substr(d.model, length(p.model) + 1)";
+var AT_BOUNDARY = `substr(d.model, 1, length(p.model)) = p.model AND (
+      ${REST} = '' OR ${REST} GLOB '[[]*'
+      OR ${REST} GLOB '-${DIGITS_8}' OR ${REST} GLOB '-${DIGITS_8}[[]*]')`;
+var REQUEST_COST2 = `
+  CREATE VIEW 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 ${AT_BOUNDARY} 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;
 `;
-function backfillClaudeAliases(db, sessionIds) {
-  const insert = db.prepare("INSERT OR IGNORE INTO conversation(ref,harness,namespace,native_id,legacy_session_id) VALUES (?,?,?,?,?)");
-  const alias = db.prepare("INSERT OR IGNORE INTO conversation_alias VALUES (?,?)");
-  const rows = sessionIds?.map((session_id) => ({ session_id })) ?? db.prepare("SELECT session_id FROM session").all();
-  for (const row of rows) {
-    const ref = conversationRef({ harness: "claude-code", namespace: "legacy", nativeId: row.session_id });
-    insert.run(ref, "claude-code", "legacy", row.session_id, row.session_id);
-    alias.run(`session:${row.session_id}`, ref);
-  }
-}
-function resolveConversationAlias(db, legacyRef) {
-  const rows = db.prepare("SELECT conversation_ref FROM conversation_alias WHERE legacy_ref = ?").all(legacyRef);
-  if (rows.length > 1) throw new Error(`ambiguous conversation alias: ${legacyRef}`);
-  return rows[0]?.conversation_ref ?? null;
+function applyRequestCostBoundary(db) {
+  db.exec("DROP VIEW IF EXISTS request_cost");
+  db.exec(REQUEST_COST2);
 }
 
 // src/schema.ts
-import { SQL_NOW, kitMigration } from "@titan-design/store-sqlite";
+import { SQL_NOW, hasTable, kitMigration } from "@titan-design/store-sqlite";
 var KIT = { watermark: "transcript", edge: "edge", spanFts: "search" };
 var DOMAIN_DDL = `
   CREATE TABLE IF NOT EXISTS fact (
@@ -458,9 +501,6 @@ var DOMAIN_DDL = `
     fact_id          INTEGER
   );
   CREATE INDEX IF NOT EXISTS idx_subagent_child ON subagent(child_session_id);
-  CREATE TABLE IF NOT EXISTS artifact (
-    artifact_ref TEXT PRIMARY KEY, kind TEXT, title TEXT, url TEXT, path TEXT, created_at TEXT
-  );
   CREATE TABLE IF NOT EXISTS pr_merge_observation (
     number INTEGER NOT NULL, repo_hint TEXT, merged_at TEXT NOT NULL,
     PRIMARY KEY (number, repo_hint, merged_at)
@@ -469,10 +509,9 @@ var DOMAIN_DDL = `
     tool_use_id TEXT PRIMARY KEY, title TEXT, number INTEGER, repo TEXT, url TEXT
   );
 `;
-var DERIVED_TABLES = [
-  "normalized_span",
-  "normalized_event",
-  "normalized_source",
+var NORMALIZED_TABLES = ["normalized_span", "normalized_event", "normalized_source"];
+var ALWAYS_DERIVED = [
+  // Dropped too, not only FTS rows: spans of a deleted or rewritten transcript are never re-streamed and would survive.
   `${KIT.spanFts}_span`,
   KIT.edge,
   "turn",
@@ -493,9 +532,19 @@ var DERIVED_TABLES = [
   REVIEW_TABLE,
   "branch",
   "file",
-  "task",
-  "artifact"
+  "task"
 ];
+function derivedTables(db) {
+  return [...NORMALIZED_TABLES.filter((t) => hasTable(db, t)), ...ALWAYS_DERIVED];
+}
+var DERIVED_TABLES = [...NORMALIZED_TABLES, ...ALWAYS_DERIVED];
+function stopStoringBulkClasses(db) {
+  db.exec("DROP TABLE IF EXISTS artifact");
+  const present = NORMALIZED_TABLES.filter((t) => hasTable(db, t));
+  const empty = present.every((t) => db.prepare(`SELECT 1 FROM ${t} LIMIT 1`).get() === void 0);
+  if (empty) for (const t of present) db.exec(`DROP TABLE ${t}`);
+  db.exec("CREATE TABLE IF NOT EXISTS session_state (session_id TEXT NOT NULL, key TEXT NOT NULL, value TEXT, PRIMARY KEY (session_id, key))");
+}
 var MIGRATIONS = [
   kitMigration(1, { watermark: KIT.watermark, edge: KIT.edge, spanFts: KIT.spanFts }, "kit tables"),
   { version: 2, name: "session graph tables", up: (db) => db.exec(DOMAIN_DDL) },
@@ -507,7 +556,9 @@ var MIGRATIONS = [
   { version: 5, name: ORIGIN_MIGRATION_NAME, up: applyOriginSchema },
   { version: 6, name: EPISODE_TRANSCRIPT_MIGRATION_NAME, up: applyEpisodeTranscriptSchema },
   { version: 7, name: ORIGIN_TASK_LINK_MIGRATION_NAME, up: applyOriginTaskLinkSchema },
-  { version: 8, name: REVIEW_VERDICT_MIGRATION_NAME, up: applyReviewVerdictSchema }
+  { version: 8, name: REVIEW_VERDICT_MIGRATION_NAME, up: applyReviewVerdictSchema },
+  { version: 9, name: "stop storing bulk classes", up: stopStoringBulkClasses },
+  { version: 10, name: REQUEST_COST_BOUNDARY_MIGRATION_NAME, up: applyRequestCostBoundary }
 ];
 
 // src/graph.ts
@@ -523,6 +574,7 @@ function openSessionGraph(dbPath, options = {}) {
   const db = openDatabase(dbPath, { schemaVersion: options.schemaVersion, readonly: options.readonly });
   if (options.readonly) assertMigratedOrClose(db);
   else runMigrations(db, MIGRATIONS);
+  if (options.normalized && !options.readonly) ensureNormalizedSchema(db);
   return {
     db,
     transcripts: new WatermarkTable(db, { name: KIT.watermark }),
@@ -538,13 +590,13 @@ function assertMigratedOrClose(db) {
   throw new SessionGraphNotMigratedError(missing);
 }
 function appliedNames(db) {
-  if (!hasTable(db, MIGRATION_TABLE_NAME)) return /* @__PURE__ */ new Map();
+  if (!hasTable2(db, MIGRATION_TABLE_NAME)) return /* @__PURE__ */ new Map();
   const rows = db.prepare(`SELECT version, name FROM ${MIGRATION_TABLE_NAME}`).all();
   return new Map(rows.map((r) => [r.version, r.name]));
 }
 function resetIndex(graph) {
   graph.db.transaction(() => {
-    for (const table of DERIVED_TABLES) graph.db.exec(`DELETE FROM "${table}"`);
+    for (const table of derivedTables(graph.db)) graph.db.exec(`DELETE FROM "${table}"`);
     graph.spans.clearIndex();
     for (const row of graph.transcripts.list()) graph.transcripts.rewind(row.sourceKey);
   })();
@@ -832,8 +884,6 @@ var ASSET_UPSERTS = {
   files: `INSERT INTO file (file_ref, repo, path) VALUES (@fileRef, @repo, @path) ON CONFLICT (file_ref) DO NOTHING`,
   tasks: `INSERT INTO task (task_ref, task_id, status) VALUES (@taskRef, @taskId, @status)
         ON CONFLICT (task_ref) DO UPDATE SET status = COALESCE(excluded.status, status)`,
-  artifacts: `INSERT INTO artifact (artifact_ref, kind, title, url, path, created_at) VALUES (@artifactRef, @artifactKind, @title, @url, @path, @ts)
-        ON CONFLICT (artifact_ref) DO NOTHING`,
   prMerges: `INSERT INTO pr_merge_observation (number, repo_hint, merged_at) VALUES (@number, @repoHint, @ts)
         ON CONFLICT (number, repo_hint, merged_at) DO NOTHING`,
   prCreates: `INSERT INTO pr_create_observation (tool_use_id, title, number, repo, url) VALUES (@toolUseId, @title, @number, @repo, @url)
@@ -1114,9 +1164,18 @@ function reconcile(graph) {
 
 // src/refresh.ts
 import { promises as fs } from "fs";
+import { hasTable as hasTable3 } from "@titan-design/store-sqlite";
+import os from "os";
 import { contentHash, resumePoint } from "@titan-design/locator";
 import { TranscriptParseError as TranscriptParseError2, extractTranscript as extractTranscript2 } from "@titan-design/session-read";
 
+// src/expand-home.ts
+import path from "path";
+function expandHome(file, homeDir) {
+  if (file === "~") return homeDir;
+  return file.startsWith("~/") ? path.join(homeDir, file.slice(2)) : file;
+}
+
 // src/review-rounds.ts
 import { RELATIONS as RELATIONS2 } from "@titan-design/session-read";
 var isReviewerProfile = (profile) => profile === "reviewer" || profile.endsWith("-reviewer");
@@ -1535,7 +1594,7 @@ async function indexTranscript(graph, transcript, options = {}) {
   }
 }
 async function refreshCorpus(graph, transcripts, options = {}) {
-  const { resolveTasks, resolveOrigins: originResolver, resolvePrs, isReviewerProfile: isReviewerProfile2, full, facetLimit, ...perTranscript } = options;
+  const { resolveTasks, resolveOrigins: originResolver, resolvePrs, isReviewerProfile: isReviewerProfile2, full, facetLimit, homeDir, present, ...perTranscript } = options;
   const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };
   const touched = [];
   let facts = 0;
@@ -1553,19 +1612,20 @@ async function refreshCorpus(graph, transcripts, options = {}) {
   const prs = await enrichPrs(graph, resolvePrs);
   const reviews = projectReviewRounds(graph, { isReviewerProfile: isReviewerProfile2 });
   const tasks = await enrichTasks(graph, resolveTasks, allTaskIds(graph));
-  const markedMissing = await markMissing(graph, transcripts);
+  const markedMissing = await markMissing(graph, transcripts, homeDir ?? os.homedir(), present);
   const facetSummary = { facetsBackfilled: facets.backfilled, facetBacklog: facets.backlog };
   return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, origins, prs, reviews, markedMissing, ...facetSummary };
 }
-async function markMissing(graph, discovered) {
-  const present = new Set(discovered.map((t) => t.displayPath));
+async function markMissing(graph, discovered, homeDir, alsoPresent = []) {
+  const present = /* @__PURE__ */ new Set([...discovered.map((t) => t.displayPath), ...alsoPresent]);
+  const hasNormalized = hasTable3(graph.db, "normalized_source");
   const byPath = new Map(discovered.map((t) => [t.displayPath, t.absolutePath]));
   let marked = 0;
   for (const row of graph.transcripts.list()) {
     if (row.status === "missing" || present.has(row.sourceKey)) continue;
-    const normalized = graph.db.prepare("SELECT descriptor FROM normalized_source WHERE transcript_id = ?").get(row.sourceId);
+    const normalized = hasNormalized ? graph.db.prepare("SELECT descriptor FROM normalized_source WHERE transcript_id = ?").get(row.sourceId) : void 0;
     const absolute = normalized ? JSON.parse(normalized.descriptor).path : byPath.get(row.sourceKey) ?? row.sourceKey;
-    if (await exists(absolute)) continue;
+    if (await exists(expandHome(absolute, homeDir))) continue;
     graph.transcripts.markStatus(row.sourceKey, "missing", "source file no longer exists");
     marked += 1;
   }
@@ -1718,6 +1778,7 @@ function observationText(o) {
 
 // src/normalized-index.ts
 async function indexCodexSource(graph, source) {
+  ensureNormalizedSchema(graph.db);
   const ref = conversationRef3(source.conversation);
   const base = { conversationRef: ref, observations: 0 };
   const row = graph.transcripts.ensure(source.sourceId);
@@ -1812,12 +1873,14 @@ function* stagedRows(graph, table) {
 // src/normalized-query.ts
 import { contentHash as contentHash3, prefixHash } from "@titan-design/locator";
 import { readSessionSourceText, readSessionText, SessionUsageAccumulator } from "@titan-design/session-read";
-async function readIndexedText(graph, span) {
-  const text = await readSourceText(graph, span);
+import { hasTable as hasTable4 } from "@titan-design/store-sqlite";
+import os2 from "os";
+async function readIndexedText(graph, span, options = {}) {
+  const text = await readSourceText(graph, span, options.homeDir ?? os2.homedir());
   return text !== null && span.field === "prompt" ? stripInjected(text) : text;
 }
-async function readSourceText(graph, span) {
-  const row = graph.db.prepare(`SELECT n.locators FROM normalized_span n JOIN search_span s USING(span_id)
+async function readSourceText(graph, span, homeDir) {
+  const row = !hasTable4(graph.db, "normalized_span") ? void 0 : graph.db.prepare(`SELECT n.locators FROM normalized_span n JOIN search_span s USING(span_id)
     WHERE s.source_id = ? AND s.byte_offset = ? AND s.field = ?`).get(span.sourceId, span.byteOffset, span.field);
   if (row) {
     const source = graph.db.prepare("SELECT descriptor FROM normalized_source WHERE transcript_id = ?").get(span.sourceId);
@@ -1839,12 +1902,13 @@ async function readSourceText(graph, span) {
     const texts = await Promise.all(JSON.parse(row.locators).map((locator) => readSessionSourceText(locator, { sources: [JSON.parse(source.descriptor)] })));
     return texts.some((text) => text === null) ? null : texts.join("\n");
   }
-  const normalized = graph.db.prepare("SELECT 1 FROM normalized_source WHERE transcript_id = ?").get(span.sourceId);
+  const normalized = hasTable4(graph.db, "normalized_source") && graph.db.prepare("SELECT 1 FROM normalized_source WHERE transcript_id = ?").get(span.sourceId);
   if (normalized) return null;
   const legacy = graph.transcripts.list().find((t) => t.sourceId === span.sourceId);
-  return legacy ? readSessionText({ path: legacy.sourceKey, byteOffset: span.byteOffset, byteLength: span.byteLength, field: span.field }) : null;
+  return legacy ? readSessionText({ path: expandHome(legacy.sourceKey, homeDir), byteOffset: span.byteOffset, byteLength: span.byteLength, field: span.field }) : null;
 }
 function normalizedSessions(graph, options = {}) {
+  if (!hasTable4(graph.db, "normalized_event")) return [];
   const rows = graph.db.prepare(`SELECT c.ref,c.harness,c.native_id,c.namespace,MIN(e.ts) AS started,
     COUNT(DISTINCT CASE WHEN e.kind = 'native_turn' THEN e.turn_ref END) AS turns
     FROM conversation c JOIN (SELECT DISTINCT conversation_ref FROM normalized_source) s ON s.conversation_ref = c.ref
@@ -1877,6 +1941,7 @@ function normalizedSessions(graph, options = {}) {
   });
 }
 function normalizedUsage(graph, ref) {
+  if (!hasTable4(graph.db, "normalized_event")) return [];
   const preferred = graph.db.prepare(`SELECT transcript_id FROM normalized_event
     WHERE conversation_ref = ? AND usage IS NOT NULL AND history_origin IS NULL
     GROUP BY transcript_id ORDER BY MAX(ts) DESC, COUNT(*) DESC, transcript_id ASC LIMIT 1`).get(ref);
@@ -1902,6 +1967,7 @@ export {
   FACET_TABLE,
   KIT,
   MIGRATIONS,
+  NORMALIZED_TABLES,
   NO_ENRICHMENT,
   NO_ORIGINS,
   NO_PR_OUTCOMES,
@@ -1921,8 +1987,10 @@ export {
   applyDelta,
   backfillFacets,
   countRounds,
+  derivedTables,
   enrichPrs,
   enrichTasks,
+  ensureNormalizedSchema,
   indexCodexSource,
   indexTranscript,
   isInjectedCause,