@titan-design/session-graph 0.2.0 → 0.3.1

package/README.md

@@ -29,12 +29,36 @@ const summary = await refreshCorpus(graph, await discoverTranscripts());
 3. `reconcile` folds cross-transcript observations: `gh pr merge` sightings onto PRs,
    complete `gh pr create` sightings into new PR rows, subagent end times and parentage
    from child sessions.
-4. Rows whose source file has vanished are marked `missing`. Their facts stay: surviving
+4. `enrichTasks` runs if the caller passed a `resolveTasks` resolver, once over the whole
+   task table. See below.
+5. Rows whose source file has vanished are marked `missing`. Their facts stay: surviving
    Claude Code's own pruning is much of the point.
 
 `resetIndex` clears every derived table and rewinds watermarks; the next refresh rebuilds
 from byte 0 to the same rows a chunked history produced.
 
+## The task resolver
+
+A transcript states the id a command acted on and nothing else, so a task's title, its
+initiative, and the status it holds *right now* exist nowhere in the corpus. Pass a
+resolver and a product fills them; pass nothing and the graph is exactly what the
+transcripts said.
+
+```ts
+await refreshCorpus(graph, transcripts, {
+  resolveTasks: async (taskIds) => new Map(taskIds.map((id) => [id, myStore.get(id)])),
+});
+```
+
+- **Precedence.** Every field the resolver states wins; every field it omits or nulls keeps
+  what the transcripts derived. The store is the system of record for a task's present
+  status, while a transcript only witnesses a command that was observed to run.
+- **Batching.** One call per refresh, holding every task id in the graph, because a real
+  resolver reads a database. Returning an id no transcript mentioned inserts that task.
+- **Failure.** A resolver that throws costs that pass its enrichment and nothing else; the
+  rows stand as the transcripts left them and `summary.tasks` carries `failed` plus the
+  `error` message for the caller to log.
+
 ## Tables
 
 Kit tables: `transcript` (watermark), `edge` (bi-temporal, `session:… touched file:…`),

package/dist/index.d.ts

@@ -43,6 +43,26 @@ declare const MIGRATIONS: Migration[];
  */
 declare function applyDelta(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void;
 
+/**
+ * Drop every derived row one transcript produced, so re-reading it from byte 0
+ * rebuilds those rows instead of doubling them.
+ *
+ * `resetIndex` already states the reason at corpus scale: rewinding alone is not
+ * enough, because the accumulating upserts add a second copy of every count. A
+ * rewritten single transcript has the same problem one file at a time.
+ * `session.turn_count`, the `session_model_usage` token buckets and the
+ * commit/push counts all sum into what is already there, and rows the rewrite
+ * removed are never deleted — `fact` survives on its unique
+ * `(transcript_id, byte_offset)` index, so stale facts simply persist.
+ *
+ * Shared identity rows survive on purpose. `pr`, `branch`, `file`, `task` and
+ * `artifact` are keyed by ref, many transcripts assert the same one, and the
+ * inserts are insert-if-absent; a single transcript cannot know whether it was
+ * the only source. The two observation tables are left for the same reason —
+ * `reconcile` folds them, and re-reading re-asserts the same rows.
+ */
+declare function purgeTranscript(graph: SessionGraph, transcriptId: number): void;
+
 /** Recompute turn aggregates for the given sessions in one transaction. */
 declare function rollupSessions(graph: SessionGraph, sessionIds: readonly string[]): number;
 interface ReconcileCounts {
@@ -53,22 +73,67 @@ interface ReconcileCounts {
 /** Whole-table reconciliations, run once at the end of a refresh pass after the rollup. */
 declare function reconcile(graph: SessionGraph): ReconcileCounts;
 
+/**
+ * What a product's task store knows and a transcript cannot state: the task's
+ * present title, its initiative, and the status it holds right now rather than
+ * the one some command was observed to set. Every field is optional; an omitted
+ * or null field leaves whatever the transcripts derived in place.
+ */
+interface ResolvedTask {
+    initiative?: string | null;
+    title?: string | null;
+    status?: string | null;
+}
+/** Resolutions keyed by bare task id (`AW-23`, not `task:AW-23`). */
+type TaskResolution = ReadonlyMap<string, ResolvedTask | null | undefined>;
+/**
+ * Supplied by the caller, never by this package: session-graph is tier 2 and
+ * must not learn where any product keeps its tasks. Called once per pass with
+ * every task id at once, because a real resolver reads a store. Returning an id
+ * that no transcript mentioned inserts that task; that is how a task nobody
+ * worked on gets into the graph.
+ */
+type TaskResolver = (taskIds: readonly string[]) => PromiseLike<TaskResolution> | TaskResolution;
+interface TaskEnrichment {
+    /** Task ids handed to the resolver. */
+    requested: number;
+    /** Task rows the resolver wrote. */
+    applied: number;
+    /** The resolver threw; rows stand as the transcripts left them. */
+    failed: boolean;
+    /** Why it failed, for the caller to log. Absent unless `failed`. */
+    error?: string;
+}
+declare const NO_ENRICHMENT: TaskEnrichment;
+declare function allTaskIds(graph: SessionGraph): string[];
+/**
+ * Enrich task rows from a caller-supplied resolver. Runs outside the delta's
+ * transaction because a resolver is async; a crash between the two leaves rows
+ * un-enriched, which the next pass corrects. A resolver that throws costs this
+ * pass its enrichment and nothing else.
+ */
+declare function enrichTasks(graph: SessionGraph, resolver: TaskResolver | undefined, taskIds: readonly string[]): Promise<TaskEnrichment>;
+
 interface IndexOptions {
     /** Re-hash the already-read prefix to catch same-length rewrites. O(file), so opt in. */
     verifyHash?: boolean;
     /** Store a whole-file content hash for durability reporting. O(file), so opt in. */
     withContentHash?: boolean;
+    /** Fill task title, initiative and present status from the caller's store. Absent means transcripts alone. */
+    resolveTasks?: TaskResolver;
 }
 type TranscriptOutcome = {
     status: "unchanged" | "indexed" | "rewound";
     transcriptId: number;
     sessionIds: string[];
     facts: number;
+    tasks: TaskEnrichment;
 } | {
     status: "missing" | "quarantined";
     transcriptId: number;
     sessionIds: string[];
     facts: 0;
+    tasks: TaskEnrichment;
     reason: string;
 };
 /**
@@ -87,15 +152,22 @@ interface RefreshSummary {
     facts: number;
     turnsRolledUp: number;
     reconciled: ReconcileCounts;
+    tasks: TaskEnrichment;
     markedMissing: number;
 }
 /**
  * One pass over a corpus: index every transcript, roll up the sessions that
- * changed, reconcile cross-transcript observations, and mark rows whose source
- * file is gone. Idempotent: a second pass over unchanged files changes nothing.
+ * changed, reconcile cross-transcript observations, enrich tasks, and mark rows
+ * whose source file is gone. Idempotent: a second pass over unchanged files
+ * changes nothing.
+ *
+ * The resolver is hoisted out of the per-transcript loop and run once over the
+ * whole task table, so a corpus of N transcripts costs one resolver call rather
+ * than N, and a task whose store row changed refreshes even when no transcript
+ * did. That bounds staleness to one pass.
  */
 declare function refreshCorpus(graph: SessionGraph, transcripts: readonly DiscoveredTranscript[], options?: IndexOptions & {
     full?: boolean;
 }): Promise<RefreshSummary>;
 
-export { DERIVED_TABLES, DOMAIN_DDL, type IndexOptions, KIT, MIGRATIONS, type ReconcileCounts, type RefreshSummary, type SessionGraph, type TranscriptOutcome, allSessionIds, applyDelta, indexTranscript, openSessionGraph, reconcile, refreshCorpus, resetIndex, rollupSessions };
+export { DERIVED_TABLES, DOMAIN_DDL, type IndexOptions, KIT, MIGRATIONS, NO_ENRICHMENT, type ReconcileCounts, type RefreshSummary, type ResolvedTask, type SessionGraph, type TaskEnrichment, type TaskResolution, type TaskResolver, type TranscriptOutcome, allSessionIds, allTaskIds, applyDelta, enrichTasks, indexTranscript, openSessionGraph, purgeTranscript, reconcile, refreshCorpus, resetIndex, rollupSessions };

package/dist/index.js

@@ -304,6 +304,22 @@ function factIdFor(db, transcriptId, byteOffset) {
   return row?.fact_id ?? null;
 }
 
+// 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"];
+function purgeTranscript(graph, transcriptId) {
+  graph.db.transaction(() => {
+    const owned = graph.db.prepare("SELECT session_id FROM session WHERE transcript_id = ?").all(transcriptId);
+    for (const { session_id } of owned) graph.spans.purgeOwner(sessionRef2(session_id));
+    for (const table of SESSION_SCOPED) {
+      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);
+    graph.db.prepare("DELETE FROM fact WHERE transcript_id = ?").run(transcriptId);
+    graph.db.prepare("DELETE FROM session WHERE transcript_id = ?").run(transcriptId);
+  })();
+}
+
 // src/rollup.ts
 var BATCH = 400;
 var ROLLUP = `
@@ -375,22 +391,68 @@ function reconcile(graph) {
 import { promises as fs } from "fs";
 import { contentHash, resumePoint } from "@titan-design/locator";
 import { TranscriptParseError, extractTranscript } from "@titan-design/session-read";
+
+// 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)
+  ON CONFLICT (task_ref) DO UPDATE SET
+    initiative = COALESCE(excluded.initiative, initiative),
+    title      = COALESCE(excluded.title, title),
+    status     = COALESCE(excluded.status, status)`;
+function allTaskIds(graph) {
+  return graph.db.prepare("SELECT task_id FROM task").all().map((r) => r.task_id);
+}
+async function enrichTasks(graph, resolver, taskIds) {
+  const unique = [...new Set(taskIds)];
+  if (!resolver) return NO_ENRICHMENT;
+  try {
+    const resolved = await resolver(unique);
+    return { requested: unique.length, applied: write(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) {
+  const upsert = graph.db.prepare(UPSERT_TASK);
+  return graph.db.transaction(() => {
+    let applied = 0;
+    for (const [taskId, fields] of resolved) {
+      if (!fields) continue;
+      applied += upsert.run({
+        taskRef: taskRef(taskId),
+        taskId,
+        initiative: fields.initiative ?? null,
+        title: fields.title ?? null,
+        status: fields.status ?? null
+      }).changes;
+    }
+    return applied;
+  })();
+}
+
+// src/refresh.ts
 async function indexTranscript(graph, transcript, options = {}) {
   const row = graph.transcripts.ensure(transcript.displayPath);
   const entry = { path: transcript.displayPath, lastByteOffset: row.lastOffset, prefixHash: row.prefixHash };
   const point = await resumePoint(entry, transcript.absolutePath, { verifyHash: options.verifyHash });
-  const base = { transcriptId: row.sourceId, sessionIds: [] };
+  const base = { transcriptId: row.sourceId, sessionIds: [], tasks: NO_ENRICHMENT };
   if (point.state === "missing") {
     graph.transcripts.markStatus(transcript.displayPath, "missing", "source file no longer exists");
     return { ...base, status: "missing", facts: 0, reason: "source file no longer exists" };
   }
-  if (point.state === "unchanged") return { ...base, status: "unchanged", facts: 0 };
+  if (point.state === "unchanged") {
+    if (row.status === "missing") graph.transcripts.markStatus(transcript.displayPath, "ok", null);
+    return { ...base, status: "unchanged", facts: 0 };
+  }
   try {
     const delta = await extractTranscript(transcript.absolutePath, {
       fromByteOffset: point.start,
       priorPrefixHash: point.state === "rewritten" ? null : row.prefixHash,
       subagentId: transcript.subagentId
     });
+    if (point.state === "rewritten") purgeTranscript(graph, row.sourceId);
     applyDelta(graph, row.sourceId, delta);
     const stat = await fs.stat(transcript.absolutePath);
     graph.transcripts.advance(transcript.displayPath, {
@@ -401,7 +463,9 @@ async function indexTranscript(graph, transcript, options = {}) {
       contentHash: options.withContentHash ? await contentHash(transcript.absolutePath) : null
     });
     const sessionIds = delta.sessions.map((s) => s.sessionId);
-    return { ...base, sessionIds, status: point.state === "rewritten" ? "rewound" : "indexed", facts: delta.facts.length };
+    const taskIds = delta.tasks.map((t) => t.taskId);
+    const tasks = taskIds.length > 0 ? await enrichTasks(graph, options.resolveTasks, taskIds) : NO_ENRICHMENT;
+    return { ...base, sessionIds, tasks, status: point.state === "rewritten" ? "rewound" : "indexed", facts: delta.facts.length };
   } catch (err) {
     if (!(err instanceof TranscriptParseError)) throw err;
     graph.transcripts.markStatus(transcript.displayPath, "quarantined", err.message);
@@ -409,19 +473,21 @@ async function indexTranscript(graph, transcript, options = {}) {
   }
 }
 async function refreshCorpus(graph, transcripts, options = {}) {
+  const { resolveTasks, ...perTranscript } = options;
   const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };
   const touched = [];
   let facts = 0;
   for (const transcript of transcripts) {
-    const outcome = await indexTranscript(graph, transcript, options);
+    const outcome = await indexTranscript(graph, transcript, perTranscript);
     counts[outcome.status] += 1;
     facts += outcome.facts;
     touched.push(...outcome.sessionIds);
   }
   const turnsRolledUp = rollupSessions(graph, options.full ? allSessionIds(graph) : touched);
   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, markedMissing };
+  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, markedMissing };
 }
 async function markMissing(graph, discovered) {
   const present = new Set(discovered.map((t) => t.displayPath));
@@ -449,10 +515,14 @@ export {
   DOMAIN_DDL,
   KIT,
   MIGRATIONS,
+  NO_ENRICHMENT,
   allSessionIds,
+  allTaskIds,
   applyDelta,
+  enrichTasks,
   indexTranscript,
   openSessionGraph,
+  purgeTranscript,
   reconcile,
   refreshCorpus,
   resetIndex,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/graph.ts","../src/schema.ts","../src/apply.ts","../src/rollup.ts","../src/refresh.ts"],"sourcesContent":["import { EdgeTable, SpanFtsTables, WatermarkTable, openDatabase, runMigrations, type Db } from \"@titan-design/store-sqlite\";\nimport { DERIVED_TABLES, KIT, MIGRATIONS } from \"./schema.js\";\n\n/** One open session graph: the connection plus the kit helpers bound to its tables. */\nexport interface SessionGraph {\n  db: Db;\n  transcripts: WatermarkTable;\n  edges: EdgeTable;\n  spans: SpanFtsTables;\n}\n\nexport function openSessionGraph(dbPath: string): SessionGraph {\n  const db = openDatabase(dbPath);\n  runMigrations(db, MIGRATIONS);\n  return {\n    db,\n    transcripts: new WatermarkTable(db, { name: KIT.watermark }),\n    edges: new EdgeTable(db, { name: KIT.edge }),\n    spans: new SpanFtsTables(db, { name: KIT.spanFts }),\n  };\n}\n\n/**\n * Clear every derived row and rewind all watermarks so the next refresh\n * rebuilds from byte 0. Rewinding alone is not enough: the accumulating\n * upserts would add a second copy of every count.\n */\nexport function resetIndex(graph: SessionGraph): void {\n  graph.db.transaction(() => {\n    for (const table of DERIVED_TABLES) graph.db.exec(`DELETE FROM \"${table}\"`);\n    graph.spans.clearIndex();\n    for (const row of graph.transcripts.list()) graph.transcripts.rewind(row.sourceKey);\n  })();\n}\n\nexport function allSessionIds(graph: SessionGraph): string[] {\n  return (graph.db.prepare(\"SELECT session_id FROM session\").all() as { session_id: string }[]).map((r) => r.session_id);\n}\n","import { SQL_NOW, kitMigration, type Migration } from \"@titan-design/store-sqlite\";\n\n/** Kit table names this graph uses. `watermark` rows are transcripts; `search_*` are the FTS spans. */\nexport const KIT = { watermark: \"transcript\", edge: \"edge\", spanFts: \"search\" } as const;\n\n/**\n * Domain tables. Everything here is derivable from the transcripts plus the\n * watermark table, which is what makes drop-and-rederive a safe rebuild.\n * Locators are `(transcript_id, byte_offset, byte_length)`; `fact_id` rows\n * resolve through the facts table's unique `(transcript_id, byte_offset)`.\n */\nexport 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 (${SQL_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`;\n\n/** Every derived table, in an order safe to clear. The watermark table is not derived. */\nexport const DERIVED_TABLES = [\n  `${KIT.spanFts}_span`,\n  KIT.edge,\n  \"turn\",\n  \"permission_phase\",\n  \"human_edit\",\n  \"file_checkpoint\",\n  \"subagent\",\n  \"session_model_usage\",\n  \"session\",\n  \"fact\",\n  \"pr\",\n  \"pr_merge_observation\",\n  \"pr_create_observation\",\n  \"branch\",\n  \"file\",\n  \"task\",\n  \"artifact\",\n] as const;\n\nexport const MIGRATIONS: Migration[] = [\n  kitMigration(1, { watermark: KIT.watermark, edge: KIT.edge, spanFts: KIT.spanFts }, \"kit tables\"),\n  { version: 2, name: \"session graph tables\", up: (db) => db.exec(DOMAIN_DDL) },\n];\n","import { sessionRef, type TranscriptDelta } from \"@titan-design/session-read\";\nimport type { Db } from \"@titan-design/store-sqlite\";\nimport type { SessionGraph } from \"./graph.js\";\n\n/**\n * Apply one transcript chunk's delta in a single transaction, so a crash can\n * never leave rows committed behind a stale watermark or ahead of their rows.\n * Append-only tables are idempotent through unique indexes; session and usage\n * rows accumulate; ref-keyed assets insert-if-absent with COALESCE merges that\n * mirror `EventFolder`'s rules.\n */\nexport function applyDelta(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void {\n  graph.db.transaction(() => {\n    applyFacts(graph.db, transcriptId, delta);\n    applySessions(graph.db, transcriptId, delta);\n    applyAssets(graph.db, delta);\n    applyPhases(graph.db, transcriptId, delta);\n    applyLinkedRows(graph, transcriptId, delta);\n  })();\n}\n\nconst INSERT_FACT = `\n  INSERT INTO fact (transcript_id, byte_offset, byte_length, event_type, ts, seq, session_id, prompt_id, tool_use_id)\n  VALUES (@transcriptId, @byteOffset, @byteLength, @eventType, @ts, @seq, @sessionId, @promptId, @toolUseId)\n  ON CONFLICT (transcript_id, byte_offset) DO NOTHING`;\n\n/** Facts carry a per-transcript `seq` continuing from whatever is stored. */\nfunction applyFacts(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const next = db.prepare(\"SELECT COALESCE(MAX(seq), -1) + 1 AS next FROM fact WHERE transcript_id = ?\").get(transcriptId) as { next: number };\n  const insert = db.prepare(INSERT_FACT);\n  let seq = next.next;\n  for (const f of delta.facts) {\n    insert.run({ transcriptId, byteOffset: f.byteOffset, byteLength: f.byteLength, eventType: f.eventType, ts: f.ts, seq: seq++, sessionId: f.sessionId, promptId: f.promptId, toolUseId: f.toolUseId });\n  }\n}\n\nconst UPSERT_SESSION = `\n  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)\n  VALUES (@sessionId, @transcriptId, @startedAt, @endedAt, @startType, @cwd, @gitBranch, @aiTitle, @seedPrompt, @cliVersion, @turnDelta, @commitDelta, @pushDelta)\n  ON CONFLICT (session_id) DO UPDATE SET\n    started_at  = MIN(COALESCE(started_at, excluded.started_at), COALESCE(excluded.started_at, started_at)),\n    ended_at    = MAX(COALESCE(ended_at, excluded.ended_at), COALESCE(excluded.ended_at, ended_at)),\n    start_type  = CASE\n      WHEN excluded.start_type IS NULL THEN start_type\n      WHEN start_type IS NULL THEN excluded.start_type\n      WHEN COALESCE(excluded.started_at, started_at) < COALESCE(started_at, excluded.started_at) THEN excluded.start_type\n      ELSE start_type END,\n    cwd         = COALESCE(excluded.cwd, cwd),\n    git_branch  = COALESCE(git_branch, excluded.git_branch),\n    ai_title    = COALESCE(excluded.ai_title, ai_title),\n    seed_prompt = COALESCE(seed_prompt, excluded.seed_prompt),\n    cli_version = COALESCE(excluded.cli_version, cli_version),\n    turn_count   = turn_count + excluded.turn_count,\n    commit_count = commit_count + excluded.commit_count,\n    push_count   = push_count + excluded.push_count`;\n\nconst UPSERT_USAGE = `\n  INSERT INTO session_model_usage (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, thinking_tokens, request_count)\n  VALUES (@sessionId, @model, @inputTokens, @outputTokens, @cacheReadTokens, @cacheCreationTokens, @thinkingTokens, @requestCount)\n  ON CONFLICT (session_id, model) DO UPDATE SET\n    input_tokens = input_tokens + excluded.input_tokens, output_tokens = output_tokens + excluded.output_tokens,\n    cache_read_tokens = cache_read_tokens + excluded.cache_read_tokens,\n    cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,\n    thinking_tokens = thinking_tokens + excluded.thinking_tokens, request_count = request_count + excluded.request_count`;\n\nfunction applySessions(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const upsertSession = db.prepare(UPSERT_SESSION);\n  for (const s of delta.sessions) upsertSession.run({ ...s, transcriptId });\n  const upsertUsage = db.prepare(UPSERT_USAGE);\n  for (const u of delta.usage) upsertUsage.run(u);\n}\n\nconst ASSET_UPSERTS = {\n  prs: `INSERT INTO pr (pr_ref, number, repo, title, url) VALUES (@prRef, @number, @repo, @title, @url)\n        ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(title, excluded.title), url = COALESCE(url, excluded.url)`,\n  branches: `INSERT INTO branch (branch_ref, repo, name, base, created_at, deleted_at) VALUES (@branchRef, @repo, @name, @base, @createdAt, @deletedAt)\n        ON CONFLICT (branch_ref) DO UPDATE SET base = COALESCE(base, excluded.base),\n          created_at = MIN(COALESCE(created_at, excluded.created_at), COALESCE(excluded.created_at, created_at)),\n          deleted_at = MAX(COALESCE(deleted_at, excluded.deleted_at), COALESCE(excluded.deleted_at, deleted_at))`,\n  files: `INSERT INTO file (file_ref, repo, path) VALUES (@fileRef, @repo, @path) ON CONFLICT (file_ref) DO NOTHING`,\n  tasks: `INSERT INTO task (task_ref, task_id, status) VALUES (@taskRef, @taskId, @status)\n        ON CONFLICT (task_ref) DO UPDATE SET status = COALESCE(excluded.status, status)`,\n  artifacts: `INSERT INTO artifact (artifact_ref, kind, title, url, path, created_at) VALUES (@artifactRef, @artifactKind, @title, @url, @path, @ts)\n        ON CONFLICT (artifact_ref) DO NOTHING`,\n  prMerges: `INSERT INTO pr_merge_observation (number, repo_hint, merged_at) VALUES (@number, @repoHint, @ts)\n        ON CONFLICT (number, repo_hint, merged_at) DO NOTHING`,\n  prCreates: `INSERT INTO pr_create_observation (tool_use_id, title, number, repo, url) VALUES (@toolUseId, @title, @number, @repo, @url)\n        ON CONFLICT (tool_use_id) DO UPDATE SET title = COALESCE(title, excluded.title), number = COALESCE(number, excluded.number),\n          repo = COALESCE(repo, excluded.repo), url = COALESCE(url, excluded.url)`,\n} as const;\n\nfunction applyAssets(db: Db, delta: TranscriptDelta): void {\n  for (const [kind, sql] of Object.entries(ASSET_UPSERTS) as [keyof typeof ASSET_UPSERTS, string][]) {\n    const statement = db.prepare(sql);\n    for (const row of delta[kind] as unknown as Record<string, unknown>[]) statement.run(pick(row, sql));\n  }\n}\n\n/** better-sqlite3 rejects unused named parameters, so pass only the ones the statement binds. */\nfunction pick(row: Record<string, unknown>, sql: string): Record<string, unknown> {\n  const names = new Set([...sql.matchAll(/@(\\w+)/g)].map((m) => m[1]!));\n  return Object.fromEntries([...names].map((name) => [name, row[name] ?? null]));\n}\n\n/**\n * Bi-temporal phase collapse: a candidate matching the session's open phase is a\n * no-op; otherwise the open phase closes at the new `t_valid` and a replacement\n * row is inserted. Done here so a chunk boundary mid-run cannot add a phase.\n */\nfunction applyPhases(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const current = db.prepare(\"SELECT phase_id, to_mode FROM permission_phase WHERE session_id = ? AND trigger = ? AND t_invalid IS NULL ORDER BY phase_id DESC LIMIT 1\");\n  const close = db.prepare(\"UPDATE permission_phase SET t_invalid = ? WHERE phase_id = ?\");\n  const insert = db.prepare(\"INSERT INTO permission_phase (session_id, from_mode, to_mode, trigger, t_valid, fact_id) VALUES (?, ?, ?, ?, ?, ?)\");\n  for (const phase of delta.phases) {\n    const open = current.get(phase.sessionId, phase.trigger) as { phase_id: number; to_mode: string } | undefined;\n    if (open?.to_mode === phase.toMode) continue;\n    if (open) close.run(phase.ts, open.phase_id);\n    insert.run(phase.sessionId, open?.to_mode ?? null, phase.toMode, phase.trigger, phase.ts, factIdFor(db, transcriptId, phase.byteOffset));\n  }\n}\n\nfunction applyLinkedRows(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void {\n  const { db } = graph;\n  const factId = (byteOffset: number) => factIdFor(db, transcriptId, byteOffset);\n\n  const upsertTurn = db.prepare(`\n    INSERT INTO turn (prompt_id, session_id, turn_index, started_at, fact_id_start)\n    VALUES (?, ?, (SELECT COALESCE(MAX(turn_index), -1) + 1 FROM turn WHERE session_id = ?), ?, ?)\n    ON CONFLICT (prompt_id) DO UPDATE SET session_id = MIN(session_id, excluded.session_id)`);\n  for (const t of delta.turns) upsertTurn.run(t.promptId, t.sessionId, t.sessionId, t.ts, factId(t.byteOffset));\n\n  const insertEdit = db.prepare(\"INSERT INTO human_edit (session_id, file_path, ts, fact_id) VALUES (?, ?, ?, ?) ON CONFLICT (session_id, file_path, ts) DO NOTHING\");\n  for (const e of delta.humanEdits) insertEdit.run(e.sessionId, e.filePath, e.ts, factId(e.byteOffset));\n\n  const insertCheckpoint = db.prepare(`\n    INSERT INTO file_checkpoint (session_id, file_path, backup_file_name, version, backup_time, fact_id) VALUES (?, ?, ?, ?, ?, ?)\n    ON CONFLICT (session_id, file_path, backup_file_name) DO NOTHING`);\n  for (const c of delta.fileCheckpoints) insertCheckpoint.run(c.sessionId, c.filePath, c.backupFileName, c.version, c.backupTime, factId(c.byteOffset));\n\n  const upsertSubagent = db.prepare(`\n    INSERT INTO subagent (agent_ref, session_id, agent_type, label, started_at, fact_id) VALUES (?, ?, ?, ?, ?, ?)\n    ON CONFLICT (agent_ref) DO UPDATE SET session_id = COALESCE(session_id, excluded.session_id),\n      agent_type = COALESCE(agent_type, excluded.agent_type), label = COALESCE(label, excluded.label), started_at = COALESCE(started_at, excluded.started_at)`);\n  for (const s of delta.subagents) upsertSubagent.run(s.agentRef, s.sessionId, s.agentType, s.label, s.ts || null, factId(s.byteOffset));\n\n  // The dispatch row and this bridge come from different lines; an upsert survives a chunk boundary between them.\n  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\");\n  for (const l of delta.subagentTranscripts) linkTranscript.run(l.agentRef, l.childSessionId);\n\n  for (const e of delta.edges) graph.edges.assert({ sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.byteOffset) });\n\n  for (const span of delta.spans) {\n    graph.spans.index({ ownerRef: sessionRef(span.sessionId), field: span.field, sourceId: transcriptId, byteOffset: span.byteOffset, byteLength: span.byteLength }, span.text);\n  }\n}\n\nfunction factIdFor(db: Db, transcriptId: number, byteOffset: number): number | null {\n  const row = db.prepare(\"SELECT fact_id FROM fact WHERE transcript_id = ? AND byte_offset = ?\").get(transcriptId, byteOffset) as { fact_id: number } | undefined;\n  return row?.fact_id ?? null;\n}\n","import type { SessionGraph } from \"./graph.js\";\n\nconst BATCH = 400;\n\n/**\n * Turn aggregates that no single line can supply. Contract: recompute, never\n * accumulate. Every value is a pure function of the fact rows, so incremental\n * refreshes and full rebuilds converge regardless of chunk boundaries.\n */\nconst ROLLUP = `\n  WITH ordered AS (\n    SELECT fact_id, session_id, event_type, ts, prompt_id,\n      COUNT(CASE WHEN event_type = 'user_prompt' THEN 1 END) OVER (\n        PARTITION BY session_id ORDER BY ts, transcript_id, seq ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS turn_no,\n      LAG(event_type) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_type,\n      LAG(ts) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_ts\n    FROM fact WHERE session_id IN (SELECT value FROM json_each(@sessionIds))\n  ),\n  owners AS (SELECT session_id, turn_no, prompt_id FROM ordered WHERE event_type = 'user_prompt'),\n  agg AS (\n    SELECT owners.prompt_id AS prompt_id, MAX(ordered.ts) AS ended_at,\n      CAST(ROUND((julianday(MAX(ordered.ts)) - julianday(MIN(ordered.ts))) * 86400000) AS INTEGER) AS duration_ms,\n      SUM(CASE WHEN ordered.event_type = 'tool_decision' THEN 1 ELSE 0 END) AS tool_call_count,\n      CAST(COALESCE(SUM(CASE\n        WHEN ordered.event_type IN ('assistant_response', 'tool_decision') AND ordered.prev_type IN ('user_prompt', 'tool_result', 'tool_result_error')\n        THEN ROUND((julianday(ordered.ts) - julianday(ordered.prev_ts)) * 86400000) END), 0) AS INTEGER) AS thinking_ms\n    FROM ordered JOIN owners ON owners.session_id = ordered.session_id AND owners.turn_no = ordered.turn_no\n    GROUP BY owners.prompt_id\n  )\n  UPDATE turn SET ended_at = agg.ended_at, duration_ms = COALESCE(agg.duration_ms, 0),\n    tool_call_count = agg.tool_call_count, thinking_ms = COALESCE(agg.thinking_ms, 0)\n  FROM agg WHERE turn.prompt_id = agg.prompt_id`;\n\n/** `turn_index` is insert-order at write time; recomputing it from `started_at` makes it a property of the corpus. */\nconst RENUMBER_TURNS = `\n  WITH ordered AS (\n    SELECT prompt_id, ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY started_at, prompt_id) - 1 AS idx\n    FROM turn WHERE session_id IN (SELECT value FROM json_each(@sessionIds))\n  )\n  UPDATE turn SET turn_index = ordered.idx FROM ordered WHERE turn.prompt_id = ordered.prompt_id`;\n\n/** Recompute turn aggregates for the given sessions in one transaction. */\nexport function rollupSessions(graph: SessionGraph, sessionIds: readonly string[]): number {\n  const unique = [...new Set(sessionIds)];\n  if (unique.length === 0) return 0;\n  const aggregate = graph.db.prepare(ROLLUP);\n  const renumber = graph.db.prepare(RENUMBER_TURNS);\n  return graph.db.transaction(() => {\n    let updated = 0;\n    for (let i = 0; i < unique.length; i += BATCH) {\n      const batch = JSON.stringify(unique.slice(i, i + BATCH));\n      renumber.run({ sessionIds: batch });\n      updated += aggregate.run({ sessionIds: batch }).changes;\n    }\n    return updated;\n  })();\n}\n\n/** A merge sighting and the `pr-link` naming the same PR routinely live in different transcripts; fold at pass end. */\nconst RECONCILE_PR_MERGES = `\n  UPDATE pr SET state = 'merged',\n    merged_at = (SELECT MIN(o.merged_at) FROM pr_merge_observation o WHERE o.number = pr.number AND (o.repo_hint IS NULL OR pr.repo LIKE '%/' || o.repo_hint))\n  WHERE EXISTS (SELECT 1 FROM pr_merge_observation o WHERE o.number = pr.number AND (o.repo_hint IS NULL OR pr.repo LIKE '%/' || o.repo_hint))`;\n\n/** Both halves of a `gh pr create` make a real PR whether or not a `pr-link` ever mentioned it. */\nconst RECONCILE_PR_CREATES = `\n  INSERT INTO pr (pr_ref, number, repo, title, url)\n  SELECT 'pr:' || repo || '#' || number, number, repo, title, url FROM pr_create_observation\n  WHERE number IS NOT NULL AND repo IS NOT NULL AND title IS NOT NULL\n  ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(pr.title, excluded.title), url = COALESCE(pr.url, excluded.url)`;\n\n/**\n * A subagent ends when its child session's last line does, not when the\n * dispatch's tool_result returns (most dispatches are async and return at\n * launch). Parentage comes from the dispatch that ran inside a child transcript.\n */\nconst RECONCILE_SUBAGENTS = `\n  UPDATE subagent SET\n    ended_at = COALESCE((SELECT s.ended_at FROM session s WHERE s.session_id = subagent.child_session_id), ended_at),\n    parent_agent_ref = COALESCE((SELECT p.agent_ref FROM subagent p WHERE p.child_session_id = subagent.session_id), parent_agent_ref)`;\n\nexport interface ReconcileCounts {\n  prMerges: number;\n  prCreates: number;\n  subagents: number;\n}\n\n/** Whole-table reconciliations, run once at the end of a refresh pass after the rollup. */\nexport function reconcile(graph: SessionGraph): ReconcileCounts {\n  return {\n    prCreates: graph.db.prepare(RECONCILE_PR_CREATES).run().changes,\n    prMerges: graph.db.prepare(RECONCILE_PR_MERGES).run().changes,\n    subagents: graph.db.prepare(RECONCILE_SUBAGENTS).run().changes,\n  };\n}\n","import { promises as fs } from \"node:fs\";\nimport { contentHash, resumePoint } from \"@titan-design/locator\";\nimport { TranscriptParseError, extractTranscript, type DiscoveredTranscript } from \"@titan-design/session-read\";\nimport { applyDelta } from \"./apply.js\";\nimport { allSessionIds, type SessionGraph } from \"./graph.js\";\nimport { reconcile, rollupSessions, type ReconcileCounts } from \"./rollup.js\";\n\nexport interface IndexOptions {\n  /** Re-hash the already-read prefix to catch same-length rewrites. O(file), so opt in. */\n  verifyHash?: boolean;\n  /** Store a whole-file content hash for durability reporting. O(file), so opt in. */\n  withContentHash?: boolean;\n}\n\nexport type TranscriptOutcome =\n  | { status: \"unchanged\" | \"indexed\" | \"rewound\"; transcriptId: number; sessionIds: string[]; facts: number }\n  | { status: \"missing\" | \"quarantined\"; transcriptId: number; sessionIds: string[]; facts: 0; reason: string };\n\n/**\n * Bring one transcript up to date: read from its watermark (or byte 0 after a\n * rewrite), apply the delta, advance the watermark. A malformed line\n * quarantines the transcript instead of poisoning the pass.\n */\nexport async function indexTranscript(graph: SessionGraph, transcript: DiscoveredTranscript, options: IndexOptions = {}): Promise<TranscriptOutcome> {\n  const row = graph.transcripts.ensure(transcript.displayPath);\n  const entry = { path: transcript.displayPath, lastByteOffset: row.lastOffset, prefixHash: row.prefixHash };\n  const point = await resumePoint(entry, transcript.absolutePath, { verifyHash: options.verifyHash });\n  const base = { transcriptId: row.sourceId, sessionIds: [] as string[] };\n  if (point.state === \"missing\") {\n    graph.transcripts.markStatus(transcript.displayPath, \"missing\", \"source file no longer exists\");\n    return { ...base, status: \"missing\", facts: 0, reason: \"source file no longer exists\" };\n  }\n  if (point.state === \"unchanged\") return { ...base, status: \"unchanged\", facts: 0 };\n\n  try {\n    const delta = await extractTranscript(transcript.absolutePath, {\n      fromByteOffset: point.start,\n      priorPrefixHash: point.state === \"rewritten\" ? null : row.prefixHash,\n      subagentId: transcript.subagentId,\n    });\n    applyDelta(graph, row.sourceId, delta);\n    const stat = await fs.stat(transcript.absolutePath);\n    graph.transcripts.advance(transcript.displayPath, {\n      lastOffset: delta.lastByteOffset,\n      prefixHash: delta.prefixHash,\n      fileSize: stat.size,\n      fileMtime: stat.mtime.toISOString(),\n      contentHash: options.withContentHash ? await contentHash(transcript.absolutePath) : null,\n    });\n    const sessionIds = delta.sessions.map((s) => s.sessionId);\n    return { ...base, sessionIds, status: point.state === \"rewritten\" ? \"rewound\" : \"indexed\", facts: delta.facts.length };\n  } catch (err) {\n    if (!(err instanceof TranscriptParseError)) throw err;\n    graph.transcripts.markStatus(transcript.displayPath, \"quarantined\", err.message);\n    return { ...base, status: \"quarantined\", facts: 0, reason: err.message };\n  }\n}\n\nexport interface RefreshSummary {\n  transcripts: number;\n  indexed: number;\n  unchanged: number;\n  rewound: number;\n  missing: number;\n  quarantined: number;\n  facts: number;\n  turnsRolledUp: number;\n  reconciled: ReconcileCounts;\n  markedMissing: number;\n}\n\n/**\n * One pass over a corpus: index every transcript, roll up the sessions that\n * changed, reconcile cross-transcript observations, and mark rows whose source\n * file is gone. Idempotent: a second pass over unchanged files changes nothing.\n */\nexport async function refreshCorpus(graph: SessionGraph, transcripts: readonly DiscoveredTranscript[], options: IndexOptions & { full?: boolean } = {}): Promise<RefreshSummary> {\n  const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };\n  const touched: string[] = [];\n  let facts = 0;\n  for (const transcript of transcripts) {\n    const outcome = await indexTranscript(graph, transcript, options);\n    counts[outcome.status] += 1;\n    facts += outcome.facts;\n    touched.push(...outcome.sessionIds);\n  }\n  const turnsRolledUp = rollupSessions(graph, options.full ? allSessionIds(graph) : touched);\n  const reconciled = reconcile(graph);\n  const markedMissing = await markMissing(graph, transcripts);\n  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, markedMissing };\n}\n\n/** Rows absent from discovery are only nominated; an `fs.stat` decides, so an empty scan cannot condemn the corpus. */\nasync function markMissing(graph: SessionGraph, discovered: readonly DiscoveredTranscript[]): Promise<number> {\n  const present = new Set(discovered.map((t) => t.displayPath));\n  const byPath = new Map(discovered.map((t) => [t.displayPath, t.absolutePath]));\n  let marked = 0;\n  for (const row of graph.transcripts.list()) {\n    if (row.status === \"missing\" || present.has(row.sourceKey)) continue;\n    const absolute = byPath.get(row.sourceKey) ?? row.sourceKey;\n    if (await exists(absolute)) continue;\n    graph.transcripts.markStatus(row.sourceKey, \"missing\", \"source file no longer exists\");\n    marked += 1;\n  }\n  return marked;\n}\n\nasync function exists(absolutePath: string): Promise<boolean> {\n  try {\n    await fs.stat(absolutePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/graph.ts","../src/schema.ts","../src/apply.ts","../src/purge.ts","../src/rollup.ts","../src/refresh.ts","../src/tasks.ts"],"sourcesContent":["import { EdgeTable, SpanFtsTables, WatermarkTable, openDatabase, runMigrations, type Db } from \"@titan-design/store-sqlite\";\nimport { DERIVED_TABLES, KIT, MIGRATIONS } from \"./schema.js\";\n\n/** One open session graph: the connection plus the kit helpers bound to its tables. */\nexport interface SessionGraph {\n  db: Db;\n  transcripts: WatermarkTable;\n  edges: EdgeTable;\n  spans: SpanFtsTables;\n}\n\nexport function openSessionGraph(dbPath: string): SessionGraph {\n  const db = openDatabase(dbPath);\n  runMigrations(db, MIGRATIONS);\n  return {\n    db,\n    transcripts: new WatermarkTable(db, { name: KIT.watermark }),\n    edges: new EdgeTable(db, { name: KIT.edge }),\n    spans: new SpanFtsTables(db, { name: KIT.spanFts }),\n  };\n}\n\n/**\n * Clear every derived row and rewind all watermarks so the next refresh\n * rebuilds from byte 0. Rewinding alone is not enough: the accumulating\n * upserts would add a second copy of every count.\n */\nexport function resetIndex(graph: SessionGraph): void {\n  graph.db.transaction(() => {\n    for (const table of DERIVED_TABLES) graph.db.exec(`DELETE FROM \"${table}\"`);\n    graph.spans.clearIndex();\n    for (const row of graph.transcripts.list()) graph.transcripts.rewind(row.sourceKey);\n  })();\n}\n\nexport function allSessionIds(graph: SessionGraph): string[] {\n  return (graph.db.prepare(\"SELECT session_id FROM session\").all() as { session_id: string }[]).map((r) => r.session_id);\n}\n","import { SQL_NOW, kitMigration, type Migration } from \"@titan-design/store-sqlite\";\n\n/** Kit table names this graph uses. `watermark` rows are transcripts; `search_*` are the FTS spans. */\nexport const KIT = { watermark: \"transcript\", edge: \"edge\", spanFts: \"search\" } as const;\n\n/**\n * Domain tables. Everything here is derivable from the transcripts plus the\n * watermark table, which is what makes drop-and-rederive a safe rebuild.\n * Locators are `(transcript_id, byte_offset, byte_length)`; `fact_id` rows\n * resolve through the facts table's unique `(transcript_id, byte_offset)`.\n */\nexport 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 (${SQL_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`;\n\n/** Every derived table, in an order safe to clear. The watermark table is not derived. */\nexport const DERIVED_TABLES = [\n  `${KIT.spanFts}_span`,\n  KIT.edge,\n  \"turn\",\n  \"permission_phase\",\n  \"human_edit\",\n  \"file_checkpoint\",\n  \"subagent\",\n  \"session_model_usage\",\n  \"session\",\n  \"fact\",\n  \"pr\",\n  \"pr_merge_observation\",\n  \"pr_create_observation\",\n  \"branch\",\n  \"file\",\n  \"task\",\n  \"artifact\",\n] as const;\n\nexport const MIGRATIONS: Migration[] = [\n  kitMigration(1, { watermark: KIT.watermark, edge: KIT.edge, spanFts: KIT.spanFts }, \"kit tables\"),\n  { version: 2, name: \"session graph tables\", up: (db) => db.exec(DOMAIN_DDL) },\n];\n","import { sessionRef, type TranscriptDelta } from \"@titan-design/session-read\";\nimport type { Db } from \"@titan-design/store-sqlite\";\nimport type { SessionGraph } from \"./graph.js\";\n\n/**\n * Apply one transcript chunk's delta in a single transaction, so a crash can\n * never leave rows committed behind a stale watermark or ahead of their rows.\n * Append-only tables are idempotent through unique indexes; session and usage\n * rows accumulate; ref-keyed assets insert-if-absent with COALESCE merges that\n * mirror `EventFolder`'s rules.\n */\nexport function applyDelta(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void {\n  graph.db.transaction(() => {\n    applyFacts(graph.db, transcriptId, delta);\n    applySessions(graph.db, transcriptId, delta);\n    applyAssets(graph.db, delta);\n    applyPhases(graph.db, transcriptId, delta);\n    applyLinkedRows(graph, transcriptId, delta);\n  })();\n}\n\nconst INSERT_FACT = `\n  INSERT INTO fact (transcript_id, byte_offset, byte_length, event_type, ts, seq, session_id, prompt_id, tool_use_id)\n  VALUES (@transcriptId, @byteOffset, @byteLength, @eventType, @ts, @seq, @sessionId, @promptId, @toolUseId)\n  ON CONFLICT (transcript_id, byte_offset) DO NOTHING`;\n\n/** Facts carry a per-transcript `seq` continuing from whatever is stored. */\nfunction applyFacts(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const next = db.prepare(\"SELECT COALESCE(MAX(seq), -1) + 1 AS next FROM fact WHERE transcript_id = ?\").get(transcriptId) as { next: number };\n  const insert = db.prepare(INSERT_FACT);\n  let seq = next.next;\n  for (const f of delta.facts) {\n    insert.run({ transcriptId, byteOffset: f.byteOffset, byteLength: f.byteLength, eventType: f.eventType, ts: f.ts, seq: seq++, sessionId: f.sessionId, promptId: f.promptId, toolUseId: f.toolUseId });\n  }\n}\n\nconst UPSERT_SESSION = `\n  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)\n  VALUES (@sessionId, @transcriptId, @startedAt, @endedAt, @startType, @cwd, @gitBranch, @aiTitle, @seedPrompt, @cliVersion, @turnDelta, @commitDelta, @pushDelta)\n  ON CONFLICT (session_id) DO UPDATE SET\n    started_at  = MIN(COALESCE(started_at, excluded.started_at), COALESCE(excluded.started_at, started_at)),\n    ended_at    = MAX(COALESCE(ended_at, excluded.ended_at), COALESCE(excluded.ended_at, ended_at)),\n    start_type  = CASE\n      WHEN excluded.start_type IS NULL THEN start_type\n      WHEN start_type IS NULL THEN excluded.start_type\n      WHEN COALESCE(excluded.started_at, started_at) < COALESCE(started_at, excluded.started_at) THEN excluded.start_type\n      ELSE start_type END,\n    cwd         = COALESCE(excluded.cwd, cwd),\n    git_branch  = COALESCE(git_branch, excluded.git_branch),\n    ai_title    = COALESCE(excluded.ai_title, ai_title),\n    seed_prompt = COALESCE(seed_prompt, excluded.seed_prompt),\n    cli_version = COALESCE(excluded.cli_version, cli_version),\n    turn_count   = turn_count + excluded.turn_count,\n    commit_count = commit_count + excluded.commit_count,\n    push_count   = push_count + excluded.push_count`;\n\nconst UPSERT_USAGE = `\n  INSERT INTO session_model_usage (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, thinking_tokens, request_count)\n  VALUES (@sessionId, @model, @inputTokens, @outputTokens, @cacheReadTokens, @cacheCreationTokens, @thinkingTokens, @requestCount)\n  ON CONFLICT (session_id, model) DO UPDATE SET\n    input_tokens = input_tokens + excluded.input_tokens, output_tokens = output_tokens + excluded.output_tokens,\n    cache_read_tokens = cache_read_tokens + excluded.cache_read_tokens,\n    cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,\n    thinking_tokens = thinking_tokens + excluded.thinking_tokens, request_count = request_count + excluded.request_count`;\n\nfunction applySessions(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const upsertSession = db.prepare(UPSERT_SESSION);\n  for (const s of delta.sessions) upsertSession.run({ ...s, transcriptId });\n  const upsertUsage = db.prepare(UPSERT_USAGE);\n  for (const u of delta.usage) upsertUsage.run(u);\n}\n\nconst ASSET_UPSERTS = {\n  prs: `INSERT INTO pr (pr_ref, number, repo, title, url) VALUES (@prRef, @number, @repo, @title, @url)\n        ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(title, excluded.title), url = COALESCE(url, excluded.url)`,\n  branches: `INSERT INTO branch (branch_ref, repo, name, base, created_at, deleted_at) VALUES (@branchRef, @repo, @name, @base, @createdAt, @deletedAt)\n        ON CONFLICT (branch_ref) DO UPDATE SET base = COALESCE(base, excluded.base),\n          created_at = MIN(COALESCE(created_at, excluded.created_at), COALESCE(excluded.created_at, created_at)),\n          deleted_at = MAX(COALESCE(deleted_at, excluded.deleted_at), COALESCE(excluded.deleted_at, deleted_at))`,\n  files: `INSERT INTO file (file_ref, repo, path) VALUES (@fileRef, @repo, @path) ON CONFLICT (file_ref) DO NOTHING`,\n  tasks: `INSERT INTO task (task_ref, task_id, status) VALUES (@taskRef, @taskId, @status)\n        ON CONFLICT (task_ref) DO UPDATE SET status = COALESCE(excluded.status, status)`,\n  artifacts: `INSERT INTO artifact (artifact_ref, kind, title, url, path, created_at) VALUES (@artifactRef, @artifactKind, @title, @url, @path, @ts)\n        ON CONFLICT (artifact_ref) DO NOTHING`,\n  prMerges: `INSERT INTO pr_merge_observation (number, repo_hint, merged_at) VALUES (@number, @repoHint, @ts)\n        ON CONFLICT (number, repo_hint, merged_at) DO NOTHING`,\n  prCreates: `INSERT INTO pr_create_observation (tool_use_id, title, number, repo, url) VALUES (@toolUseId, @title, @number, @repo, @url)\n        ON CONFLICT (tool_use_id) DO UPDATE SET title = COALESCE(title, excluded.title), number = COALESCE(number, excluded.number),\n          repo = COALESCE(repo, excluded.repo), url = COALESCE(url, excluded.url)`,\n} as const;\n\nfunction applyAssets(db: Db, delta: TranscriptDelta): void {\n  for (const [kind, sql] of Object.entries(ASSET_UPSERTS) as [keyof typeof ASSET_UPSERTS, string][]) {\n    const statement = db.prepare(sql);\n    for (const row of delta[kind] as unknown as Record<string, unknown>[]) statement.run(pick(row, sql));\n  }\n}\n\n/** better-sqlite3 rejects unused named parameters, so pass only the ones the statement binds. */\nfunction pick(row: Record<string, unknown>, sql: string): Record<string, unknown> {\n  const names = new Set([...sql.matchAll(/@(\\w+)/g)].map((m) => m[1]!));\n  return Object.fromEntries([...names].map((name) => [name, row[name] ?? null]));\n}\n\n/**\n * Bi-temporal phase collapse: a candidate matching the session's open phase is a\n * no-op; otherwise the open phase closes at the new `t_valid` and a replacement\n * row is inserted. Done here so a chunk boundary mid-run cannot add a phase.\n */\nfunction applyPhases(db: Db, transcriptId: number, delta: TranscriptDelta): void {\n  const current = db.prepare(\"SELECT phase_id, to_mode FROM permission_phase WHERE session_id = ? AND trigger = ? AND t_invalid IS NULL ORDER BY phase_id DESC LIMIT 1\");\n  const close = db.prepare(\"UPDATE permission_phase SET t_invalid = ? WHERE phase_id = ?\");\n  const insert = db.prepare(\"INSERT INTO permission_phase (session_id, from_mode, to_mode, trigger, t_valid, fact_id) VALUES (?, ?, ?, ?, ?, ?)\");\n  for (const phase of delta.phases) {\n    const open = current.get(phase.sessionId, phase.trigger) as { phase_id: number; to_mode: string } | undefined;\n    if (open?.to_mode === phase.toMode) continue;\n    if (open) close.run(phase.ts, open.phase_id);\n    insert.run(phase.sessionId, open?.to_mode ?? null, phase.toMode, phase.trigger, phase.ts, factIdFor(db, transcriptId, phase.byteOffset));\n  }\n}\n\nfunction applyLinkedRows(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void {\n  const { db } = graph;\n  const factId = (byteOffset: number) => factIdFor(db, transcriptId, byteOffset);\n\n  const upsertTurn = db.prepare(`\n    INSERT INTO turn (prompt_id, session_id, turn_index, started_at, fact_id_start)\n    VALUES (?, ?, (SELECT COALESCE(MAX(turn_index), -1) + 1 FROM turn WHERE session_id = ?), ?, ?)\n    ON CONFLICT (prompt_id) DO UPDATE SET session_id = MIN(session_id, excluded.session_id)`);\n  for (const t of delta.turns) upsertTurn.run(t.promptId, t.sessionId, t.sessionId, t.ts, factId(t.byteOffset));\n\n  const insertEdit = db.prepare(\"INSERT INTO human_edit (session_id, file_path, ts, fact_id) VALUES (?, ?, ?, ?) ON CONFLICT (session_id, file_path, ts) DO NOTHING\");\n  for (const e of delta.humanEdits) insertEdit.run(e.sessionId, e.filePath, e.ts, factId(e.byteOffset));\n\n  const insertCheckpoint = db.prepare(`\n    INSERT INTO file_checkpoint (session_id, file_path, backup_file_name, version, backup_time, fact_id) VALUES (?, ?, ?, ?, ?, ?)\n    ON CONFLICT (session_id, file_path, backup_file_name) DO NOTHING`);\n  for (const c of delta.fileCheckpoints) insertCheckpoint.run(c.sessionId, c.filePath, c.backupFileName, c.version, c.backupTime, factId(c.byteOffset));\n\n  const upsertSubagent = db.prepare(`\n    INSERT INTO subagent (agent_ref, session_id, agent_type, label, started_at, fact_id) VALUES (?, ?, ?, ?, ?, ?)\n    ON CONFLICT (agent_ref) DO UPDATE SET session_id = COALESCE(session_id, excluded.session_id),\n      agent_type = COALESCE(agent_type, excluded.agent_type), label = COALESCE(label, excluded.label), started_at = COALESCE(started_at, excluded.started_at)`);\n  for (const s of delta.subagents) upsertSubagent.run(s.agentRef, s.sessionId, s.agentType, s.label, s.ts || null, factId(s.byteOffset));\n\n  // The dispatch row and this bridge come from different lines; an upsert survives a chunk boundary between them.\n  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\");\n  for (const l of delta.subagentTranscripts) linkTranscript.run(l.agentRef, l.childSessionId);\n\n  for (const e of delta.edges) graph.edges.assert({ sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.byteOffset) });\n\n  for (const span of delta.spans) {\n    graph.spans.index({ ownerRef: sessionRef(span.sessionId), field: span.field, sourceId: transcriptId, byteOffset: span.byteOffset, byteLength: span.byteLength }, span.text);\n  }\n}\n\nfunction factIdFor(db: Db, transcriptId: number, byteOffset: number): number | null {\n  const row = db.prepare(\"SELECT fact_id FROM fact WHERE transcript_id = ? AND byte_offset = ?\").get(transcriptId, byteOffset) as { fact_id: number } | undefined;\n  return row?.fact_id ?? null;\n}\n","import { sessionRef } from \"@titan-design/session-read\";\nimport type { SessionGraph } from \"./graph.js\";\nimport { KIT } from \"./schema.js\";\n\n/** Derived tables keyed by `session_id`, reachable from a transcript through `session`. */\nconst SESSION_SCOPED = [\"turn\", \"permission_phase\", \"human_edit\", \"file_checkpoint\", \"subagent\", \"session_model_usage\"] as const;\n\n/**\n * Drop every derived row one transcript produced, so re-reading it from byte 0\n * rebuilds those rows instead of doubling them.\n *\n * `resetIndex` already states the reason at corpus scale: rewinding alone is not\n * enough, because the accumulating upserts add a second copy of every count. A\n * rewritten single transcript has the same problem one file at a time.\n * `session.turn_count`, the `session_model_usage` token buckets and the\n * commit/push counts all sum into what is already there, and rows the rewrite\n * removed are never deleted — `fact` survives on its unique\n * `(transcript_id, byte_offset)` index, so stale facts simply persist.\n *\n * Shared identity rows survive on purpose. `pr`, `branch`, `file`, `task` and\n * `artifact` are keyed by ref, many transcripts assert the same one, and the\n * inserts are insert-if-absent; a single transcript cannot know whether it was\n * the only source. The two observation tables are left for the same reason —\n * `reconcile` folds them, and re-reading re-asserts the same rows.\n */\nexport function purgeTranscript(graph: SessionGraph, transcriptId: number): void {\n  graph.db.transaction(() => {\n    const owned = graph.db.prepare(\"SELECT session_id FROM session WHERE transcript_id = ?\").all(transcriptId) as { session_id: string }[];\n    for (const { session_id } of owned) graph.spans.purgeOwner(sessionRef(session_id));\n\n    // Children first: each subquery reads the `session` rows deleted last.\n    for (const table of SESSION_SCOPED) {\n      graph.db.prepare(`DELETE FROM \"${table}\" WHERE session_id IN (SELECT session_id FROM session WHERE transcript_id = ?)`).run(transcriptId);\n    }\n    graph.db.prepare(`DELETE FROM \"${KIT.edge}\" WHERE fact_id IN (SELECT fact_id FROM fact WHERE transcript_id = ?)`).run(transcriptId);\n    graph.db.prepare(\"DELETE FROM fact WHERE transcript_id = ?\").run(transcriptId);\n    graph.db.prepare(\"DELETE FROM session WHERE transcript_id = ?\").run(transcriptId);\n  })();\n}\n","import type { SessionGraph } from \"./graph.js\";\n\nconst BATCH = 400;\n\n/**\n * Turn aggregates that no single line can supply. Contract: recompute, never\n * accumulate. Every value is a pure function of the fact rows, so incremental\n * refreshes and full rebuilds converge regardless of chunk boundaries.\n */\nconst ROLLUP = `\n  WITH ordered AS (\n    SELECT fact_id, session_id, event_type, ts, prompt_id,\n      COUNT(CASE WHEN event_type = 'user_prompt' THEN 1 END) OVER (\n        PARTITION BY session_id ORDER BY ts, transcript_id, seq ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS turn_no,\n      LAG(event_type) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_type,\n      LAG(ts) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_ts\n    FROM fact WHERE session_id IN (SELECT value FROM json_each(@sessionIds))\n  ),\n  owners AS (SELECT session_id, turn_no, prompt_id FROM ordered WHERE event_type = 'user_prompt'),\n  agg AS (\n    SELECT owners.prompt_id AS prompt_id, MAX(ordered.ts) AS ended_at,\n      CAST(ROUND((julianday(MAX(ordered.ts)) - julianday(MIN(ordered.ts))) * 86400000) AS INTEGER) AS duration_ms,\n      SUM(CASE WHEN ordered.event_type = 'tool_decision' THEN 1 ELSE 0 END) AS tool_call_count,\n      CAST(COALESCE(SUM(CASE\n        WHEN ordered.event_type IN ('assistant_response', 'tool_decision') AND ordered.prev_type IN ('user_prompt', 'tool_result', 'tool_result_error')\n        THEN ROUND((julianday(ordered.ts) - julianday(ordered.prev_ts)) * 86400000) END), 0) AS INTEGER) AS thinking_ms\n    FROM ordered JOIN owners ON owners.session_id = ordered.session_id AND owners.turn_no = ordered.turn_no\n    GROUP BY owners.prompt_id\n  )\n  UPDATE turn SET ended_at = agg.ended_at, duration_ms = COALESCE(agg.duration_ms, 0),\n    tool_call_count = agg.tool_call_count, thinking_ms = COALESCE(agg.thinking_ms, 0)\n  FROM agg WHERE turn.prompt_id = agg.prompt_id`;\n\n/** `turn_index` is insert-order at write time; recomputing it from `started_at` makes it a property of the corpus. */\nconst RENUMBER_TURNS = `\n  WITH ordered AS (\n    SELECT prompt_id, ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY started_at, prompt_id) - 1 AS idx\n    FROM turn WHERE session_id IN (SELECT value FROM json_each(@sessionIds))\n  )\n  UPDATE turn SET turn_index = ordered.idx FROM ordered WHERE turn.prompt_id = ordered.prompt_id`;\n\n/** Recompute turn aggregates for the given sessions in one transaction. */\nexport function rollupSessions(graph: SessionGraph, sessionIds: readonly string[]): number {\n  const unique = [...new Set(sessionIds)];\n  if (unique.length === 0) return 0;\n  const aggregate = graph.db.prepare(ROLLUP);\n  const renumber = graph.db.prepare(RENUMBER_TURNS);\n  return graph.db.transaction(() => {\n    let updated = 0;\n    for (let i = 0; i < unique.length; i += BATCH) {\n      const batch = JSON.stringify(unique.slice(i, i + BATCH));\n      renumber.run({ sessionIds: batch });\n      updated += aggregate.run({ sessionIds: batch }).changes;\n    }\n    return updated;\n  })();\n}\n\n/** A merge sighting and the `pr-link` naming the same PR routinely live in different transcripts; fold at pass end. */\nconst RECONCILE_PR_MERGES = `\n  UPDATE pr SET state = 'merged',\n    merged_at = (SELECT MIN(o.merged_at) FROM pr_merge_observation o WHERE o.number = pr.number AND (o.repo_hint IS NULL OR pr.repo LIKE '%/' || o.repo_hint))\n  WHERE EXISTS (SELECT 1 FROM pr_merge_observation o WHERE o.number = pr.number AND (o.repo_hint IS NULL OR pr.repo LIKE '%/' || o.repo_hint))`;\n\n/** Both halves of a `gh pr create` make a real PR whether or not a `pr-link` ever mentioned it. */\nconst RECONCILE_PR_CREATES = `\n  INSERT INTO pr (pr_ref, number, repo, title, url)\n  SELECT 'pr:' || repo || '#' || number, number, repo, title, url FROM pr_create_observation\n  WHERE number IS NOT NULL AND repo IS NOT NULL AND title IS NOT NULL\n  ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(pr.title, excluded.title), url = COALESCE(pr.url, excluded.url)`;\n\n/**\n * A subagent ends when its child session's last line does, not when the\n * dispatch's tool_result returns (most dispatches are async and return at\n * launch). Parentage comes from the dispatch that ran inside a child transcript.\n */\nconst RECONCILE_SUBAGENTS = `\n  UPDATE subagent SET\n    ended_at = COALESCE((SELECT s.ended_at FROM session s WHERE s.session_id = subagent.child_session_id), ended_at),\n    parent_agent_ref = COALESCE((SELECT p.agent_ref FROM subagent p WHERE p.child_session_id = subagent.session_id), parent_agent_ref)`;\n\nexport interface ReconcileCounts {\n  prMerges: number;\n  prCreates: number;\n  subagents: number;\n}\n\n/** Whole-table reconciliations, run once at the end of a refresh pass after the rollup. */\nexport function reconcile(graph: SessionGraph): ReconcileCounts {\n  return {\n    prCreates: graph.db.prepare(RECONCILE_PR_CREATES).run().changes,\n    prMerges: graph.db.prepare(RECONCILE_PR_MERGES).run().changes,\n    subagents: graph.db.prepare(RECONCILE_SUBAGENTS).run().changes,\n  };\n}\n","import { promises as fs } from \"node:fs\";\nimport { contentHash, resumePoint } from \"@titan-design/locator\";\nimport { TranscriptParseError, extractTranscript, type DiscoveredTranscript } from \"@titan-design/session-read\";\nimport { applyDelta } from \"./apply.js\";\nimport { allSessionIds, type SessionGraph } from \"./graph.js\";\nimport { purgeTranscript } from \"./purge.js\";\nimport { reconcile, rollupSessions, type ReconcileCounts } from \"./rollup.js\";\nimport { allTaskIds, enrichTasks, NO_ENRICHMENT, type TaskEnrichment, type TaskResolver } from \"./tasks.js\";\n\nexport interface IndexOptions {\n  /** Re-hash the already-read prefix to catch same-length rewrites. O(file), so opt in. */\n  verifyHash?: boolean;\n  /** Store a whole-file content hash for durability reporting. O(file), so opt in. */\n  withContentHash?: boolean;\n  /** Fill task title, initiative and present status from the caller's store. Absent means transcripts alone. */\n  resolveTasks?: TaskResolver;\n}\n\nexport type TranscriptOutcome =\n  | { status: \"unchanged\" | \"indexed\" | \"rewound\"; transcriptId: number; sessionIds: string[]; facts: number; tasks: TaskEnrichment }\n  | { status: \"missing\" | \"quarantined\"; transcriptId: number; sessionIds: string[]; facts: 0; tasks: TaskEnrichment; reason: string };\n\n/**\n * Bring one transcript up to date: read from its watermark (or byte 0 after a\n * rewrite), apply the delta, advance the watermark. A malformed line\n * quarantines the transcript instead of poisoning the pass.\n */\nexport async function indexTranscript(graph: SessionGraph, transcript: DiscoveredTranscript, options: IndexOptions = {}): Promise<TranscriptOutcome> {\n  const row = graph.transcripts.ensure(transcript.displayPath);\n  const entry = { path: transcript.displayPath, lastByteOffset: row.lastOffset, prefixHash: row.prefixHash };\n  const point = await resumePoint(entry, transcript.absolutePath, { verifyHash: options.verifyHash });\n  const base = { transcriptId: row.sourceId, sessionIds: [] as string[], tasks: NO_ENRICHMENT };\n  if (point.state === \"missing\") {\n    graph.transcripts.markStatus(transcript.displayPath, \"missing\", \"source file no longer exists\");\n    return { ...base, status: \"missing\", facts: 0, reason: \"source file no longer exists\" };\n  }\n  if (point.state === \"unchanged\") {\n    // A file that vanished and came back unchanged resumes at EOF, so there are no\n    // bytes to read and `advance()` — the only writer of status 'ok' — never runs,\n    // stranding the row on 'missing' forever. Clear it here rather than forcing a\n    // re-read, which would rewrite the prefix hash from a zero-byte delta.\n    // Quarantine is deliberately not cleared: the same bytes still will not parse.\n    if (row.status === \"missing\") graph.transcripts.markStatus(transcript.displayPath, \"ok\", null);\n    return { ...base, status: \"unchanged\", facts: 0 };\n  }\n\n  try {\n    const delta = await extractTranscript(transcript.absolutePath, {\n      fromByteOffset: point.start,\n      priorPrefixHash: point.state === \"rewritten\" ? null : row.prefixHash,\n      subagentId: transcript.subagentId,\n    });\n    // After extraction, never before: a parse failure quarantines the transcript,\n    // and purging first would destroy rows we could then no longer rebuild.\n    if (point.state === \"rewritten\") purgeTranscript(graph, row.sourceId);\n    applyDelta(graph, row.sourceId, delta);\n    const stat = await fs.stat(transcript.absolutePath);\n    graph.transcripts.advance(transcript.displayPath, {\n      lastOffset: delta.lastByteOffset,\n      prefixHash: delta.prefixHash,\n      fileSize: stat.size,\n      fileMtime: stat.mtime.toISOString(),\n      contentHash: options.withContentHash ? await contentHash(transcript.absolutePath) : null,\n    });\n    const sessionIds = delta.sessions.map((s) => s.sessionId);\n    const taskIds = delta.tasks.map((t) => t.taskId);\n    const tasks = taskIds.length > 0 ? await enrichTasks(graph, options.resolveTasks, taskIds) : NO_ENRICHMENT;\n    return { ...base, sessionIds, tasks, status: point.state === \"rewritten\" ? \"rewound\" : \"indexed\", facts: delta.facts.length };\n  } catch (err) {\n    if (!(err instanceof TranscriptParseError)) throw err;\n    graph.transcripts.markStatus(transcript.displayPath, \"quarantined\", err.message);\n    return { ...base, status: \"quarantined\", facts: 0, reason: err.message };\n  }\n}\n\nexport interface RefreshSummary {\n  transcripts: number;\n  indexed: number;\n  unchanged: number;\n  rewound: number;\n  missing: number;\n  quarantined: number;\n  facts: number;\n  turnsRolledUp: number;\n  reconciled: ReconcileCounts;\n  tasks: TaskEnrichment;\n  markedMissing: number;\n}\n\n/**\n * One pass over a corpus: index every transcript, roll up the sessions that\n * changed, reconcile cross-transcript observations, enrich tasks, and mark rows\n * whose source file is gone. Idempotent: a second pass over unchanged files\n * changes nothing.\n *\n * The resolver is hoisted out of the per-transcript loop and run once over the\n * whole task table, so a corpus of N transcripts costs one resolver call rather\n * than N, and a task whose store row changed refreshes even when no transcript\n * did. That bounds staleness to one pass.\n */\nexport async function refreshCorpus(graph: SessionGraph, transcripts: readonly DiscoveredTranscript[], options: IndexOptions & { full?: boolean } = {}): Promise<RefreshSummary> {\n  const { resolveTasks, ...perTranscript } = options;\n  const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };\n  const touched: string[] = [];\n  let facts = 0;\n  for (const transcript of transcripts) {\n    const outcome = await indexTranscript(graph, transcript, perTranscript);\n    counts[outcome.status] += 1;\n    facts += outcome.facts;\n    touched.push(...outcome.sessionIds);\n  }\n  const turnsRolledUp = rollupSessions(graph, options.full ? allSessionIds(graph) : touched);\n  const reconciled = reconcile(graph);\n  const tasks = await enrichTasks(graph, resolveTasks, allTaskIds(graph));\n  const markedMissing = await markMissing(graph, transcripts);\n  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, markedMissing };\n}\n\n/** Rows absent from discovery are only nominated; an `fs.stat` decides, so an empty scan cannot condemn the corpus. */\nasync function markMissing(graph: SessionGraph, discovered: readonly DiscoveredTranscript[]): Promise<number> {\n  const present = new Set(discovered.map((t) => t.displayPath));\n  const byPath = new Map(discovered.map((t) => [t.displayPath, t.absolutePath]));\n  let marked = 0;\n  for (const row of graph.transcripts.list()) {\n    if (row.status === \"missing\" || present.has(row.sourceKey)) continue;\n    const absolute = byPath.get(row.sourceKey) ?? row.sourceKey;\n    if (await exists(absolute)) continue;\n    graph.transcripts.markStatus(row.sourceKey, \"missing\", \"source file no longer exists\");\n    marked += 1;\n  }\n  return marked;\n}\n\nasync function exists(absolutePath: string): Promise<boolean> {\n  try {\n    await fs.stat(absolutePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n","import { taskRef } from \"@titan-design/session-read\";\nimport type { SessionGraph } from \"./graph.js\";\n\n/**\n * What a product's task store knows and a transcript cannot state: the task's\n * present title, its initiative, and the status it holds right now rather than\n * the one some command was observed to set. Every field is optional; an omitted\n * or null field leaves whatever the transcripts derived in place.\n */\nexport interface ResolvedTask {\n  initiative?: string | null;\n  title?: string | null;\n  status?: string | null;\n}\n\n/** Resolutions keyed by bare task id (`AW-23`, not `task:AW-23`). */\nexport type TaskResolution = ReadonlyMap<string, ResolvedTask | null | undefined>;\n\n/**\n * Supplied by the caller, never by this package: session-graph is tier 2 and\n * must not learn where any product keeps its tasks. Called once per pass with\n * every task id at once, because a real resolver reads a store. Returning an id\n * that no transcript mentioned inserts that task; that is how a task nobody\n * worked on gets into the graph.\n */\nexport type TaskResolver = (taskIds: readonly string[]) => PromiseLike<TaskResolution> | TaskResolution;\n\nexport interface TaskEnrichment {\n  /** Task ids handed to the resolver. */\n  requested: number;\n  /** Task rows the resolver wrote. */\n  applied: number;\n  /** The resolver threw; rows stand as the transcripts left them. */\n  failed: boolean;\n  /** Why it failed, for the caller to log. Absent unless `failed`. */\n  error?: string;\n}\n\nexport const NO_ENRICHMENT: TaskEnrichment = Object.freeze({ requested: 0, applied: 0, failed: false });\n\n/**\n * COALESCE gives the resolver precedence over the transcripts on every field it\n * states, and none on the fields it omits: the store is the system of record for\n * a task's present status, while a transcript only witnesses a command that ran.\n */\nconst UPSERT_TASK = `\n  INSERT INTO task (task_ref, task_id, initiative, title, status) VALUES (@taskRef, @taskId, @initiative, @title, @status)\n  ON CONFLICT (task_ref) DO UPDATE SET\n    initiative = COALESCE(excluded.initiative, initiative),\n    title      = COALESCE(excluded.title, title),\n    status     = COALESCE(excluded.status, status)`;\n\nexport function allTaskIds(graph: SessionGraph): string[] {\n  return (graph.db.prepare(\"SELECT task_id FROM task\").all() as { task_id: string }[]).map((r) => r.task_id);\n}\n\n/**\n * Enrich task rows from a caller-supplied resolver. Runs outside the delta's\n * transaction because a resolver is async; a crash between the two leaves rows\n * un-enriched, which the next pass corrects. A resolver that throws costs this\n * pass its enrichment and nothing else.\n */\nexport async function enrichTasks(graph: SessionGraph, resolver: TaskResolver | undefined, taskIds: readonly string[]): Promise<TaskEnrichment> {\n  const unique = [...new Set(taskIds)];\n  if (!resolver) return NO_ENRICHMENT;\n  try {\n    const resolved = await resolver(unique);\n    return { requested: unique.length, applied: write(graph, resolved), failed: false };\n  } catch (err) {\n    return { requested: unique.length, applied: 0, failed: true, error: err instanceof Error ? err.message : String(err) };\n  }\n}\n\nfunction write(graph: SessionGraph, resolved: TaskResolution): number {\n  const upsert = graph.db.prepare(UPSERT_TASK);\n  return graph.db.transaction(() => {\n    let applied = 0;\n    for (const [taskId, fields] of resolved) {\n      if (!fields) continue;\n      applied += upsert.run({\n        taskRef: taskRef(taskId),\n        taskId,\n        initiative: fields.initiative ?? null,\n        title: fields.title ?? null,\n        status: fields.status ?? null,\n      }).changes;\n    }\n    return applied;\n  })();\n}\n"],"mappings":"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","names":["sessionRef","sessionRef"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titan-design/session-graph",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Fold session events into the activity graph on store-sqlite",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,9 +32,9 @@
   },
   "dependencies": {
     "@titan-design/cluster": "^0.1.0",
+    "@titan-design/session-read": "^0.2.0",
     "@titan-design/locator": "^0.1.0",
-    "@titan-design/store-sqlite": "^0.1.0",
-    "@titan-design/session-read": "^0.2.0"
+    "@titan-design/store-sqlite": "^0.1.0"
   },
   "scripts": {
     "build": "tsup",