@titan-design/session-graph 0.10.0 → 0.12.0

package/README.md

@@ -21,8 +21,12 @@ const summary = await refreshCorpus(graph, await discoverTranscripts());
 `openSessionGraph` takes an optional `schemaVersion`: the highest migration version the
 *caller* owns, checked before any migration runs. A product layering its own tables on this
 graph passes its own top version, since this package's `MIGRATIONS` are one band of a shared
-database rather than the top of it. `products/session-miner` numbers its own from 1000 and
-passes 1002.
+database rather than the top of it. `products/session-miner` numbers its own from 2000 and
+passes 2002, clear of active-work's band at 1001.
+
+`{ readonly: true }` opens a graph another process owns without writing to it. No
+migrations run, and the open throws `SessionGraphNotMigratedError` when the graph lacks any
+migration this package declares, so a reader never meets a table it does not expect.
 
 ## What a refresh does
 
@@ -174,6 +178,44 @@ Everything except `transcript` is derivable, which is what makes the schema safe
 by drop-and-rederive.
 
 
+## Injected context
+
+A `user` record carries more than the human typed. The harness, hooks and agent-chat put
+their own blocks there, and indexing them would make every session match its own
+reminders and briefs. `stripInjected` removes them before a prompt reaches `search_fts`,
+and `readIndexedText` applies it again on readback, so a miner excerpt shows the same
+text. Only prompt spans change. `fact`, `normalized_event` and the audit tables keep
+every line, and a turn with nothing left indexes no prompt span.
+An index built before this rule keeps its old prompt spans until `resetIndex` rebuilds it.
+
+- **Whole line.** A line whose session-read inbound cause is anything but `human_typed` or
+  `tool_result` indexes no prompt. That covers `isMeta` lines (hook and SessionStart
+  bootstrap output, skill loads, harness resumes), peer channel messages, task
+  notifications, compaction summaries, scheduled wakeups, image notes and local commands.
+- **Headless prompts.** A line whose `promptSource` is `sdk` indexes no prompt. The host
+  writes `sdk` for every headless turn, which is how an agent-chat spawn brief with no
+  framing is told apart from a typed prompt. The cost: a person running `claude -p` also
+  writes `sdk` turns, and those are excluded too. Pass `indexSdkPrompts: true` to
+  `refreshCorpus`, `indexTranscript` or `applyDelta` to keep them. `isUntypedPrompt` exposes
+  the rule.
+- **Blocks cut on their own lines.** session-read's closed `INJECTED_MARKERS`
+  (`<system-reminder>`, `<channel source="...">`, `<task-notification>`), plus
+  `<user-prompt-submit-hook>`, `<command-name>`, `<command-message>`,
+  `<local-command-caveat>`, `<local-command-stdout>`, `<local-command-stderr>`,
+  `<bash-stdout>` and `<bash-stderr>`. A block is cut only when its opening tag starts a
+  line and its closing tag ends one (another cut block may follow on the same line). Nested
+  tags of the same name are balanced. A tag quoted inside a sentence stays.
+  `[Request interrupted by user…]` notes are cut wherever they sit.
+- **Kept words.** `<command-args>` and `<bash-input>` lose their tags and keep their
+  contents, because the human typed them.
+- **Whole turn by text.** session-read's unclosed markers heading the text (local-command
+  output, compaction summary, image note, loop wakeup, the agent-chat orientation header).
+  agent-chat puts no tag around a spawn brief, so a brief typed into a live session is known
+  by the framing agent-chat writes itself: a `# Predecessor:` handover, or the isolated or
+  shared worktree note that ends the brief.
+- **Tool-result echoes.** `tool_result` blocks never enter prompt text; a user line's prompt
+  span holds its text blocks only. Background results arrive as `<task-notification>`.
+
 ## Mixed harnesses
 
 `indexCodexSource(graph, source)` consumes descriptors returned by session-read's
@@ -222,7 +264,16 @@ empty tables, so existing rows are untouched.
   session-analytics. A rewritten transcript purges its sessions' episodes.
 - `price` holds USD per million tokens by model prefix and effective date.
   `syncPrices(graph, rows, { tableVersion, source })` replaces the whole table in one
-  transaction.
+  transaction. `reconcilePrices(graph, rows, { tableVersion, source })` upserts instead: it adds
+  missing models, updates changed rates, stamps the table version, and keeps rows the table
+  does not name unless it has a `source`, in which case rows of that source the table dropped
+  are pruned. A stored row from a newer `tableVersion` is never overwritten or pruned, so an
+  older caller cannot downgrade rates. It writes nothing when the graph already matches. Pass session-analytics'
+  `PRICE_TABLE` and `PRICE_TABLE_VERSION`; session-graph cannot import that package, so the
+  product does. `titan-miner` reconciles every time it opens the graph, so `titan-miner refresh`
+  brings a live graph's prices current. Only that entry point reconciles: a graph opened any
+  other way (a read-only connection, another product's bundled graph) keeps whatever rows it
+  stored, and its cost reports price from them. Such a caller must call `reconcilePrices` itself.
 - `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.

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Db, WatermarkTable, EdgeTable, SpanFtsTables, Migration } from '@titan-design/store-sqlite';
-import { TranscriptDelta, DiscoveredTranscript, SessionSourceDescriptor, SessionUsageSummary } from '@titan-design/session-read';
+import { TranscriptDelta, DiscoveredTranscript, SessionSourceDescriptor, WakeCause, Inbound, SessionUsageSummary } from '@titan-design/session-read';
 
 /** One open session graph: the connection plus the kit helpers bound to its tables. */
 interface SessionGraph {
@@ -15,6 +15,15 @@ interface OpenSessionGraphOptions {
      * package's: `MIGRATIONS` here is one band of a shared database, never the top of it.
      */
     schemaVersion?: number;
+    /**
+     * Open a graph another process owns without writing to it: no migrations run, and
+     * the graph must already carry every migration this package declares.
+     */
+    readonly?: boolean;
+}
+declare class SessionGraphNotMigratedError extends Error {
+    readonly missing: readonly string[];
+    constructor(missing: readonly string[]);
 }
 declare function openSessionGraph(dbPath: string, options?: OpenSessionGraphOptions): SessionGraph;
 /**
@@ -111,6 +120,8 @@ declare function applyDelta(graph: SessionGraph, transcriptId: number, delta: Tr
 interface DeltaSource {
     /** The Claude config dir the transcript was found under; `null` when discovery did not say. */
     account?: string | null;
+    /** Index prompts the host labels `promptSource: "sdk"` (spawned agents and `claude -p`). Off by default; see README "Injected context". */
+    indexSdkPrompts?: boolean;
 }
 
 /**
@@ -365,6 +376,8 @@ interface IndexOptions {
     resolveOrigins?: OriginResolver;
     /** Fill PR state, merge, close and review rounds from the caller's forge. Runs once per `refreshCorpus` pass. Absent means transcripts alone. */
     resolvePrs?: PrResolver;
+    /** Index prompts the host labels `promptSource: "sdk"`: spawned agents' briefs, and `claude -p` runs a person typed. Default false. */
+    indexSdkPrompts?: boolean;
 }
 interface RefreshOptions extends IndexOptions {
     /** Which sender profiles' chat verdicts count toward review rounds. Defaults to `reviewer` and `*-reviewer`. */
@@ -475,6 +488,17 @@ interface SyncPricesOptions {
 }
 /** Replace every `price` row with `rows` in one transaction, so `request_cost` never reads a half-written table. */
 declare function syncPrices(graph: SessionGraph, rows: readonly PriceInput[], options: SyncPricesOptions): number;
+interface ReconcileResult {
+    added: number;
+    updated: number;
+    pruned: number;
+}
+/**
+ * Upsert `rows` into `price`, stamping `tableVersion`; a current graph is not written.
+ * A stored row from a newer table version is left alone, so an older caller never downgrades rates.
+ * With a `source`, rows of that source the table no longer names are pruned (a longer stale prefix would win in `request_cost`), unless a newer version wrote any of them.
+ */
+declare function reconcilePrices(graph: SessionGraph, rows: readonly PriceInput[], options: SyncPricesOptions): ReconcileResult;
 
 interface NormalizedIndexResult {
     status: "indexed" | "unchanged" | "missing" | "quarantined";
@@ -485,6 +509,12 @@ interface NormalizedIndexResult {
 /** Replay changed sources into temporary staging; swap rows and watermark atomically. */
 declare function indexCodexSource(graph: SessionGraph, source: SessionSourceDescriptor): Promise<NormalizedIndexResult>;
 
+declare function isInjectedCause(cause: WakeCause): boolean;
+/** A line nobody typed: an injected cause, or a headless `sdk` prompt unless the caller keeps those. */
+declare function isUntypedPrompt(inbound: Pick<Inbound, "cause" | "promptSource">, indexSdkPrompts?: boolean): boolean;
+/** Prompt text with every injected block removed; empty when nothing the human wrote is left. */
+declare function stripInjected(text: string): string;
+
 interface IndexedSpan {
     sourceId: number;
     byteOffset: number;
@@ -520,4 +550,4 @@ declare function normalizedUsage(graph: SessionGraph, ref: string): NormalizedUs
 /** 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 RefreshOptions, type RefreshSummary, type ResolvedOrigin, type ResolvedPr, type ResolvedReview, type ResolvedTask, type ReviewProjection, type ReviewRoundOptions, type ReviewerProfilePredicate, type SessionGraph, type SyncPricesOptions, type TaskEnrichment, type TaskLinkSource, type TaskResolution, type TaskResolver, type TranscriptOutcome, allSessionIds, allTaskIds, applyAudit, applyDelta, backfillFacets, countRounds, enrichPrs, enrichTasks, indexCodexSource, indexTranscript, isReviewerProfile, normalizedSessions, normalizedUsage, openSessionGraph, projectReviewRounds, prsNeedingOutcome, purgeTranscript, readIndexedText, reconcile, refreshCorpus, replaceEpisodes, resetIndex, resolveConversationAlias, resolveOrigins, rollupSessions, sessionsNeedingOrigin, 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, 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 };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/graph.ts
-import { EdgeTable, SpanFtsTables, WatermarkTable, openDatabase, runMigrations } from "@titan-design/store-sqlite";
+import { EdgeTable, MIGRATION_TABLE_NAME, SpanFtsTables, WatermarkTable, hasTable, openDatabase, runMigrations } from "@titan-design/store-sqlite";
 
 // src/audit-schema.ts
 var AUDIT_MIGRATION_NAME = "audit tables";
@@ -511,9 +511,18 @@ var MIGRATIONS = [
 ];
 
 // src/graph.ts
+var SessionGraphNotMigratedError = class extends Error {
+  constructor(missing) {
+    super(`the graph does not carry session-graph migrations ${missing.join(", ")}; let its owner migrate it before opening it read-only`);
+    this.missing = missing;
+    this.name = "SessionGraphNotMigratedError";
+  }
+  missing;
+};
 function openSessionGraph(dbPath, options = {}) {
-  const db = openDatabase(dbPath, { schemaVersion: options.schemaVersion });
-  runMigrations(db, MIGRATIONS);
+  const db = openDatabase(dbPath, { schemaVersion: options.schemaVersion, readonly: options.readonly });
+  if (options.readonly) assertMigratedOrClose(db);
+  else runMigrations(db, MIGRATIONS);
   return {
     db,
     transcripts: new WatermarkTable(db, { name: KIT.watermark }),
@@ -521,6 +530,18 @@ function openSessionGraph(dbPath, options = {}) {
     spans: new SpanFtsTables(db, { name: KIT.spanFts })
   };
 }
+function assertMigratedOrClose(db) {
+  const applied = appliedNames(db);
+  const missing = MIGRATIONS.filter((m) => applied.get(m.version) !== m.name).map((m) => `${m.version} (${m.name})`);
+  if (missing.length === 0) return;
+  db.close();
+  throw new SessionGraphNotMigratedError(missing);
+}
+function appliedNames(db) {
+  if (!hasTable(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}"`);
@@ -667,6 +688,89 @@ function advanceFacet(db, transcriptId, fromByteOffset, indexedTo, version = EXT
   db.prepare(`UPDATE ${FACET_TABLE} SET indexed_to = ? WHERE transcript_id = ? AND facet = ? AND version = ?`).run(indexedTo, transcriptId, AUDIT_FACET, version);
 }
 
+// src/injected-text.ts
+import { hasMarker, INJECTED_MARKERS } from "@titan-design/session-read";
+var INJECTED_CAUSES = /* @__PURE__ */ new Set([
+  "compaction",
+  "channel_message",
+  "channel_system",
+  "task_notification",
+  "scheduled_wakeup",
+  "usage_limit_resume",
+  "harness_resume",
+  "local_command",
+  "image_meta",
+  "hook_or_reminder"
+]);
+function isInjectedCause(cause) {
+  return INJECTED_CAUSES.has(cause);
+}
+function isUntypedPrompt(inbound, indexSdkPrompts = false) {
+  return isInjectedCause(inbound.cause) || !indexSdkPrompts && inbound.promptSource === "sdk";
+}
+var CUT_TAGS = [
+  ...Object.values(INJECTED_MARKERS).flatMap((m) => m.close ? [m.close.slice(2, -1)] : []),
+  "user-prompt-submit-hook",
+  "command-name",
+  "command-message",
+  "local-command-caveat",
+  "local-command-stdout",
+  "local-command-stderr",
+  "bash-stdout",
+  "bash-stderr"
+].join("|");
+var CUT_OPEN = new RegExp(`<(${CUT_TAGS})(?=[\\s>])[^>]*>`, "g");
+var LINE_END_OR_BLOCK = new RegExp(`^[ \\t]*(?:\\r?\\n|$|<(?:${CUT_TAGS})(?=[\\s>]))`);
+function opensBlock(text, at, keptFrom) {
+  const lead = text.slice(Math.max(text.lastIndexOf("\n", at - 1) + 1, keptFrom), at);
+  return lead.trim() === "";
+}
+function balancedClose(text, tag, from) {
+  const tags = new RegExp(`<(/?)${tag}(?=[\\s>])[^>]*>`, "g");
+  tags.lastIndex = from;
+  let depth = 1;
+  for (let m = tags.exec(text); m; m = tags.exec(text)) {
+    depth += m[1] ? -1 : 1;
+    if (depth === 0) return tags.lastIndex;
+  }
+  return null;
+}
+function closesLine(text, at) {
+  return LINE_END_OR_BLOCK.test(text.slice(at));
+}
+function cutBlocks(text) {
+  let kept = "";
+  let keptFrom = 0;
+  CUT_OPEN.lastIndex = 0;
+  for (let open = CUT_OPEN.exec(text); open; open = CUT_OPEN.exec(text)) {
+    if (!opensBlock(text, open.index, keptFrom)) continue;
+    const end = balancedClose(text, open[1], CUT_OPEN.lastIndex);
+    if (end === null || !closesLine(text, end)) continue;
+    kept += text.slice(keptFrom, open.index);
+    keptFrom = end;
+    CUT_OPEN.lastIndex = end;
+  }
+  return kept + text.slice(keptFrom);
+}
+var INTERRUPTION = /\[Request interrupted by user[^\]\n]*\]/g;
+var HUMAN_WRAPPERS = ["command-args", "bash-input"].map((tag) => new RegExp(`</?${tag}>`, "g"));
+var WHOLE_TURN_MARKERS = Object.keys(INJECTED_MARKERS).filter((name) => INJECTED_MARKERS[name].close === null);
+var SPAWN_BRIEF_FRAMING = [
+  /^# Predecessor: .*\n\nYou are taking over from /,
+  /Commit your work there; nothing outside it is yours to change\.\s*$/,
+  /You may be sharing it with other agents, so stay inside the paths you were given\.\s*$/
+];
+function isWholeTurnInjected(text) {
+  const trimmed = text.trim();
+  return WHOLE_TURN_MARKERS.some((name) => hasMarker(trimmed, name)) || SPAWN_BRIEF_FRAMING.some((re) => re.test(trimmed));
+}
+function stripInjected(text) {
+  let kept = cutBlocks(text);
+  for (const re of [INTERRUPTION, ...HUMAN_WRAPPERS]) kept = kept.replace(re, "");
+  if (isWholeTurnInjected(kept)) return "";
+  return kept.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
 // src/apply.ts
 import { RELATIONS, sessionRef } from "@titan-design/session-read";
 function applyDelta(graph, transcriptId, delta, source = {}) {
@@ -677,6 +781,7 @@ function applyDelta(graph, transcriptId, delta, source = {}) {
     applyAssets(graph.db, delta);
     applyPhases(graph.db, transcriptId, delta);
     applyLinkedRows(graph, transcriptId, delta);
+    applySpans(graph, transcriptId, delta, source.indexSdkPrompts ?? false);
     applyReviewVerdicts(graph.db, transcriptId, delta);
     applyAudit(graph.db, transcriptId, delta);
   })();
@@ -815,8 +920,14 @@ function applyLinkedRows(graph, transcriptId, delta) {
   const linkTranscript = db.prepare("INSERT INTO subagent (agent_ref, child_session_id) VALUES (?, ?) ON CONFLICT (agent_ref) DO UPDATE SET child_session_id = excluded.child_session_id");
   for (const l of delta.subagentTranscripts) linkTranscript.run(l.agentRef, l.childSessionId);
   for (const e of delta.edges) assertTranscriptEdge(graph, { sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.byteOffset) });
+}
+function applySpans(graph, transcriptId, delta, indexSdkPrompts) {
+  const injectedLines = new Set(delta.inbound.filter((i) => isUntypedPrompt(i, indexSdkPrompts)).map((i) => i.byteOffset));
   for (const span of delta.spans) {
-    graph.spans.index({ ownerRef: sessionRef(span.sessionId), field: span.field, sourceId: transcriptId, byteOffset: span.byteOffset, byteLength: span.byteLength }, span.text);
+    const isPrompt = span.field === "prompt";
+    const text = !isPrompt ? span.text : injectedLines.has(span.byteOffset) ? "" : stripInjected(span.text);
+    if (isPrompt && !text) continue;
+    graph.spans.index({ ownerRef: sessionRef(span.sessionId), field: span.field, sourceId: transcriptId, byteOffset: span.byteOffset, byteLength: span.byteLength }, text);
   }
 }
 function assertTranscriptEdge(graph, edge) {
@@ -1403,7 +1514,7 @@ async function indexTranscript(graph, transcript, options = {}) {
     });
     const rewound = point.state === "rewritten" || delta.restartedFromZero;
     if (rewound) purgeTranscript(graph, row.sourceId);
-    applyDelta(graph, row.sourceId, delta, { account: transcript.account });
+    applyDelta(graph, row.sourceId, delta, { account: transcript.account, indexSdkPrompts: options.indexSdkPrompts });
     advanceFacet(graph.db, row.sourceId, rewound ? 0 : point.start, delta.lastByteOffset);
     const stat2 = await fs.stat(transcript.absolutePath);
     graph.transcripts.advance(transcript.displayPath, {
@@ -1523,6 +1634,48 @@ function syncPrices(graph, rows, options) {
   })();
   return rows.length;
 }
+function matchesRow(stored, r, version, source) {
+  return stored.table_version === version && stored.source === source && [stored.input_usd_mtok, stored.cache_read_usd_mtok, stored.cache_write_5m_usd_mtok, stored.cache_write_1h_usd_mtok, stored.output_usd_mtok].every((v, i) => v === [r.input, r.cacheRead, r.cacheWrite5m, r.cacheWrite1h, r.output][i]);
+}
+function reconcilePrices(graph, rows, options) {
+  const find = graph.db.prepare("SELECT * FROM price WHERE model = ? AND effective_from = ?");
+  const upsert = 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 (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT (model, effective_from) DO UPDATE SET table_version = excluded.table_version,
+       input_usd_mtok = excluded.input_usd_mtok, cache_read_usd_mtok = excluded.cache_read_usd_mtok,
+       cache_write_5m_usd_mtok = excluded.cache_write_5m_usd_mtok, cache_write_1h_usd_mtok = excluded.cache_write_1h_usd_mtok,
+       output_usd_mtok = excluded.output_usd_mtok, source = excluded.source`
+  );
+  const source = options.source ?? null;
+  const result = { added: 0, updated: 0, pruned: 0 };
+  graph.db.transaction(() => {
+    for (const r of rows) {
+      const stored = find.get(r.modelPrefix, r.effectiveFrom);
+      if (stored && stored.table_version > options.tableVersion) continue;
+      if (stored && matchesRow(stored, r, options.tableVersion, source)) continue;
+      upsert.run(r.modelPrefix, r.effectiveFrom, options.tableVersion, r.input, r.cacheRead, r.cacheWrite5m, r.cacheWrite1h, r.output, source);
+      if (stored) result.updated++;
+      else result.added++;
+    }
+    if (source !== null) result.pruned = pruneAbsent(graph, rows, source, options.tableVersion);
+  })();
+  return result;
+}
+function pruneAbsent(graph, rows, source, tableVersion) {
+  const owned = graph.db.prepare("SELECT model, effective_from, table_version FROM price WHERE source = ?").all(source);
+  if (owned.some((o) => o.table_version > tableVersion)) return 0;
+  const keep = new Set(rows.map((r) => `${r.modelPrefix}\0${r.effectiveFrom}`));
+  const drop = graph.db.prepare("DELETE FROM price WHERE model = ? AND effective_from = ?");
+  let pruned = 0;
+  for (const o of owned) {
+    if (keep.has(`${o.model}\0${o.effective_from}`)) continue;
+    drop.run(o.model, o.effective_from);
+    pruned++;
+  }
+  return pruned;
+}
 
 // src/normalized-index.ts
 import { randomUUID } from "crypto";
@@ -1556,7 +1709,8 @@ function insertObservation(graph, transcriptId, o) {
   );
 }
 function observationText(o) {
-  if (o.kind === "message") return o.content.map((p) => ({ field: o.role === "user" ? "prompt" : "assistant_response", text: p.text.slice(0, SPAN_TEXT_CAP), locator: p.locator }));
+  if (o.kind === "message" && o.role === "user") return o.content.map((p) => ({ field: "prompt", text: stripInjected(p.text).slice(0, SPAN_TEXT_CAP), locator: p.locator })).filter((p) => p.text);
+  if (o.kind === "message") return o.content.map((p) => ({ field: "assistant_response", text: p.text.slice(0, SPAN_TEXT_CAP), locator: p.locator }));
   if (o.kind === "tool_call" && o.inputLocator) return [{ field: "tool_input", text: normalizedSearchText(o.input), locator: o.inputLocator }];
   if (o.kind === "tool_result" && o.outputLocator) return [{ field: "tool_result", text: normalizedSearchText(o.output), locator: o.outputLocator }];
   return [];
@@ -1659,6 +1813,10 @@ function* stagedRows(graph, table) {
 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);
+  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)
     WHERE s.source_id = ? AND s.byte_offset = ? AND s.field = ?`).get(span.sourceId, span.byteOffset, span.field);
   if (row) {
@@ -1756,6 +1914,7 @@ export {
   REVIEW_DDL,
   REVIEW_TABLE,
   REVIEW_VERDICT_MIGRATION_NAME,
+  SessionGraphNotMigratedError,
   allSessionIds,
   allTaskIds,
   applyAudit,
@@ -1766,7 +1925,9 @@ export {
   enrichTasks,
   indexCodexSource,
   indexTranscript,
+  isInjectedCause,
   isReviewerProfile,
+  isUntypedPrompt,
   normalizedSessions,
   normalizedUsage,
   openSessionGraph,
@@ -1775,6 +1936,7 @@ export {
   purgeTranscript,
   readIndexedText,
   reconcile,
+  reconcilePrices,
   refreshCorpus,
   replaceEpisodes,
   resetIndex,
@@ -1782,6 +1944,7 @@ export {
   resolveOrigins,
   rollupSessions,
   sessionsNeedingOrigin,
+  stripInjected,
   syncPrices
 };
 //# sourceMappingURL=index.js.map