@titan-design/session-graph 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henry Jewkes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @titan-design/session-graph
+
+The activity graph behind a corpus of Claude Code transcripts: sessions, turns, token
+buckets, permission phases, touched files, branches, PRs, subagents, and the edges between
+them, all in one SQLite file built from `@titan-design/store-sqlite` kit tables and kept
+current incrementally.
+
+Tier 2 of the titan-platform DAG. Depends on `session-read`, `store-sqlite`, and
+`cluster`. Extracted from active-work's session index (AW-23, TP-6).
+
+```ts
+import { discoverTranscripts } from "@titan-design/session-read";
+import { openSessionGraph, refreshCorpus } from "@titan-design/session-graph";
+
+const graph = openSessionGraph("~/.local/state/miner/index.sqlite3");
+const summary = await refreshCorpus(graph, await discoverTranscripts());
+// summary.indexed, summary.unchanged, summary.rewound, summary.quarantined, summary.missing
+```
+
+## What a refresh does
+
+1. For every transcript, `indexTranscript` asks the watermark table where it stopped,
+   checks the file (`unchanged`, `appended`, `rewritten`, `missing`), reads the delta with
+   `extractTranscript`, applies it in one transaction, and advances the watermark with the
+   new prefix hash. A malformed line quarantines that transcript only.
+2. `rollupSessions` recomputes turn aggregates (index, end, duration, tool calls, thinking
+   time) for the sessions that changed. Recompute, never accumulate, so incremental and
+   full passes converge.
+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
+   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.
+
+## Tables
+
+Kit tables: `transcript` (watermark), `edge` (bi-temporal, `session:… touched file:…`),
+`search_span` + `search_fts` (contentless full-text over prompts, responses, tool inputs
+and results, keyed by the session ref). Domain tables: `fact`, `session`,
+`session_model_usage`, `turn`, `permission_phase`, `human_edit`, `file_checkpoint`, `pr`,
+`branch`, `file`, `task`, `subagent`, `artifact`, and the two PR observation tables.
+
+Everything except `transcript` is derivable, which is what makes the schema safe to evolve
+by drop-and-rederive.

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+import { Db, WatermarkTable, EdgeTable, SpanFtsTables, Migration } from '@titan-design/store-sqlite';
+import { TranscriptDelta, DiscoveredTranscript } from '@titan-design/session-read';
+
+/** One open session graph: the connection plus the kit helpers bound to its tables. */
+interface SessionGraph {
+    db: Db;
+    transcripts: WatermarkTable;
+    edges: EdgeTable;
+    spans: SpanFtsTables;
+}
+declare function openSessionGraph(dbPath: string): SessionGraph;
+/**
+ * Clear every derived row and rewind all watermarks so the next refresh
+ * rebuilds from byte 0. Rewinding alone is not enough: the accumulating
+ * upserts would add a second copy of every count.
+ */
+declare function resetIndex(graph: SessionGraph): void;
+declare function allSessionIds(graph: SessionGraph): string[];
+
+/** Kit table names this graph uses. `watermark` rows are transcripts; `search_*` are the FTS spans. */
+declare const KIT: {
+    readonly watermark: "transcript";
+    readonly edge: "edge";
+    readonly spanFts: "search";
+};
+/**
+ * Domain tables. Everything here is derivable from the transcripts plus the
+ * watermark table, which is what makes drop-and-rederive a safe rebuild.
+ * Locators are `(transcript_id, byte_offset, byte_length)`; `fact_id` rows
+ * resolve through the facts table's unique `(transcript_id, byte_offset)`.
+ */
+declare const DOMAIN_DDL = "\n  CREATE TABLE IF NOT EXISTS fact (\n    fact_id       INTEGER PRIMARY KEY,\n    transcript_id INTEGER NOT NULL,\n    byte_offset   INTEGER NOT NULL,\n    byte_length   INTEGER NOT NULL,\n    event_type    TEXT NOT NULL,\n    ts            TEXT NOT NULL,\n    seq           INTEGER NOT NULL,\n    session_id    TEXT NOT NULL,\n    prompt_id     TEXT,\n    tool_use_id   TEXT,\n    t_indexed     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),\n    UNIQUE (transcript_id, byte_offset)\n  );\n  CREATE INDEX IF NOT EXISTS idx_fact_session_ts ON fact(session_id, ts);\n  CREATE INDEX IF NOT EXISTS idx_fact_prompt ON fact(prompt_id);\n  CREATE INDEX IF NOT EXISTS idx_fact_tool_use ON fact(tool_use_id);\n\n  CREATE TABLE IF NOT EXISTS session (\n    session_id    TEXT PRIMARY KEY,\n    transcript_id INTEGER,\n    started_at    TEXT,\n    ended_at      TEXT,\n    start_type    TEXT,\n    cwd           TEXT,\n    git_branch    TEXT,\n    ai_title      TEXT,\n    seed_prompt   TEXT,\n    cli_version   TEXT,\n    turn_count    INTEGER NOT NULL DEFAULT 0,\n    commit_count  INTEGER NOT NULL DEFAULT 0,\n    push_count    INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE INDEX IF NOT EXISTS idx_session_started ON session(started_at);\n\n  CREATE TABLE IF NOT EXISTS session_model_usage (\n    session_id            TEXT NOT NULL,\n    model                 TEXT NOT NULL,\n    input_tokens          INTEGER NOT NULL DEFAULT 0,\n    output_tokens         INTEGER NOT NULL DEFAULT 0,\n    cache_read_tokens     INTEGER NOT NULL DEFAULT 0,\n    cache_creation_tokens INTEGER NOT NULL DEFAULT 0,\n    thinking_tokens       INTEGER NOT NULL DEFAULT 0,\n    request_count         INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (session_id, model)\n  );\n\n  CREATE TABLE IF NOT EXISTS turn (\n    prompt_id       TEXT PRIMARY KEY,\n    session_id      TEXT NOT NULL,\n    turn_index      INTEGER NOT NULL,\n    started_at      TEXT NOT NULL,\n    ended_at        TEXT,\n    duration_ms     INTEGER,\n    tool_call_count INTEGER NOT NULL DEFAULT 0,\n    thinking_ms     INTEGER NOT NULL DEFAULT 0,\n    fact_id_start   INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_turn_session ON turn(session_id, turn_index);\n\n  CREATE TABLE IF NOT EXISTS permission_phase (\n    phase_id   INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    from_mode  TEXT,\n    to_mode    TEXT NOT NULL,\n    trigger    TEXT NOT NULL,\n    t_valid    TEXT NOT NULL,\n    t_invalid  TEXT,\n    fact_id    INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_phase_session ON permission_phase(session_id, t_valid);\n\n  CREATE TABLE IF NOT EXISTS human_edit (\n    edit_id    INTEGER PRIMARY KEY,\n    session_id TEXT NOT NULL,\n    file_path  TEXT NOT NULL,\n    ts         TEXT NOT NULL,\n    fact_id    INTEGER,\n    UNIQUE (session_id, file_path, ts)\n  );\n\n  CREATE TABLE IF NOT EXISTS file_checkpoint (\n    checkpoint_id    INTEGER PRIMARY KEY,\n    session_id       TEXT NOT NULL,\n    file_path        TEXT NOT NULL,\n    backup_file_name TEXT NOT NULL,\n    version          INTEGER NOT NULL,\n    backup_time      TEXT NOT NULL,\n    fact_id          INTEGER,\n    UNIQUE (session_id, file_path, backup_file_name)\n  );\n\n  CREATE TABLE IF NOT EXISTS pr (\n    pr_ref TEXT PRIMARY KEY, number INTEGER, repo TEXT, title TEXT, state TEXT, url TEXT, merged_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS branch (\n    branch_ref TEXT PRIMARY KEY, repo TEXT, name TEXT NOT NULL, base TEXT, created_at TEXT, deleted_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS file (\n    file_ref TEXT PRIMARY KEY, repo TEXT, path TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS task (\n    task_ref TEXT PRIMARY KEY, task_id TEXT NOT NULL, initiative TEXT, title TEXT, status TEXT\n  );\n  CREATE TABLE IF NOT EXISTS subagent (\n    agent_ref        TEXT PRIMARY KEY,\n    session_id       TEXT,\n    child_session_id TEXT,\n    parent_agent_ref TEXT,\n    agent_type       TEXT,\n    label            TEXT,\n    started_at       TEXT,\n    ended_at         TEXT,\n    fact_id          INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS idx_subagent_child ON subagent(child_session_id);\n  CREATE TABLE IF NOT EXISTS artifact (\n    artifact_ref TEXT PRIMARY KEY, kind TEXT, title TEXT, url TEXT, path TEXT, created_at TEXT\n  );\n  CREATE TABLE IF NOT EXISTS pr_merge_observation (\n    number INTEGER NOT NULL, repo_hint TEXT, merged_at TEXT NOT NULL,\n    PRIMARY KEY (number, repo_hint, merged_at)\n  );\n  CREATE TABLE IF NOT EXISTS pr_create_observation (\n    tool_use_id TEXT PRIMARY KEY, title TEXT, number INTEGER, repo TEXT, url TEXT\n  );\n";
+/** Every derived table, in an order safe to clear. The watermark table is not derived. */
+declare const DERIVED_TABLES: readonly ["search_span", "edge", "turn", "permission_phase", "human_edit", "file_checkpoint", "subagent", "session_model_usage", "session", "fact", "pr", "pr_merge_observation", "pr_create_observation", "branch", "file", "task", "artifact"];
+declare const MIGRATIONS: Migration[];
+
+/**
+ * Apply one transcript chunk's delta in a single transaction, so a crash can
+ * never leave rows committed behind a stale watermark or ahead of their rows.
+ * Append-only tables are idempotent through unique indexes; session and usage
+ * rows accumulate; ref-keyed assets insert-if-absent with COALESCE merges that
+ * mirror `EventFolder`'s rules.
+ */
+declare function applyDelta(graph: SessionGraph, transcriptId: number, delta: TranscriptDelta): void;
+
+/** Recompute turn aggregates for the given sessions in one transaction. */
+declare function rollupSessions(graph: SessionGraph, sessionIds: readonly string[]): number;
+interface ReconcileCounts {
+    prMerges: number;
+    prCreates: number;
+    subagents: number;
+}
+/** Whole-table reconciliations, run once at the end of a refresh pass after the rollup. */
+declare function reconcile(graph: SessionGraph): ReconcileCounts;
+
+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;
+}
+type TranscriptOutcome = {
+    status: "unchanged" | "indexed" | "rewound";
+    transcriptId: number;
+    sessionIds: string[];
+    facts: number;
+} | {
+    status: "missing" | "quarantined";
+    transcriptId: number;
+    sessionIds: string[];
+    facts: 0;
+    reason: string;
+};
+/**
+ * Bring one transcript up to date: read from its watermark (or byte 0 after a
+ * rewrite), apply the delta, advance the watermark. A malformed line
+ * quarantines the transcript instead of poisoning the pass.
+ */
+declare function indexTranscript(graph: SessionGraph, transcript: DiscoveredTranscript, options?: IndexOptions): Promise<TranscriptOutcome>;
+interface RefreshSummary {
+    transcripts: number;
+    indexed: number;
+    unchanged: number;
+    rewound: number;
+    missing: number;
+    quarantined: number;
+    facts: number;
+    turnsRolledUp: number;
+    reconciled: ReconcileCounts;
+    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.
+ */
+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 };

package/dist/index.js

@@ -0,0 +1,460 @@
+// src/graph.ts
+import { EdgeTable, SpanFtsTables, WatermarkTable, openDatabase, runMigrations } from "@titan-design/store-sqlite";
+
+// src/schema.ts
+import { SQL_NOW, kitMigration } from "@titan-design/store-sqlite";
+var KIT = { watermark: "transcript", edge: "edge", spanFts: "search" };
+var DOMAIN_DDL = `
+  CREATE TABLE IF NOT EXISTS fact (
+    fact_id       INTEGER PRIMARY KEY,
+    transcript_id INTEGER NOT NULL,
+    byte_offset   INTEGER NOT NULL,
+    byte_length   INTEGER NOT NULL,
+    event_type    TEXT NOT NULL,
+    ts            TEXT NOT NULL,
+    seq           INTEGER NOT NULL,
+    session_id    TEXT NOT NULL,
+    prompt_id     TEXT,
+    tool_use_id   TEXT,
+    t_indexed     TEXT NOT NULL DEFAULT (${SQL_NOW}),
+    UNIQUE (transcript_id, byte_offset)
+  );
+  CREATE INDEX IF NOT EXISTS idx_fact_session_ts ON fact(session_id, ts);
+  CREATE INDEX IF NOT EXISTS idx_fact_prompt ON fact(prompt_id);
+  CREATE INDEX IF NOT EXISTS idx_fact_tool_use ON fact(tool_use_id);
+
+  CREATE TABLE IF NOT EXISTS session (
+    session_id    TEXT PRIMARY KEY,
+    transcript_id INTEGER,
+    started_at    TEXT,
+    ended_at      TEXT,
+    start_type    TEXT,
+    cwd           TEXT,
+    git_branch    TEXT,
+    ai_title      TEXT,
+    seed_prompt   TEXT,
+    cli_version   TEXT,
+    turn_count    INTEGER NOT NULL DEFAULT 0,
+    commit_count  INTEGER NOT NULL DEFAULT 0,
+    push_count    INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_session_started ON session(started_at);
+
+  CREATE TABLE IF NOT EXISTS session_model_usage (
+    session_id            TEXT NOT NULL,
+    model                 TEXT NOT NULL,
+    input_tokens          INTEGER NOT NULL DEFAULT 0,
+    output_tokens         INTEGER NOT NULL DEFAULT 0,
+    cache_read_tokens     INTEGER NOT NULL DEFAULT 0,
+    cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+    thinking_tokens       INTEGER NOT NULL DEFAULT 0,
+    request_count         INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (session_id, model)
+  );
+
+  CREATE TABLE IF NOT EXISTS turn (
+    prompt_id       TEXT PRIMARY KEY,
+    session_id      TEXT NOT NULL,
+    turn_index      INTEGER NOT NULL,
+    started_at      TEXT NOT NULL,
+    ended_at        TEXT,
+    duration_ms     INTEGER,
+    tool_call_count INTEGER NOT NULL DEFAULT 0,
+    thinking_ms     INTEGER NOT NULL DEFAULT 0,
+    fact_id_start   INTEGER
+  );
+  CREATE INDEX IF NOT EXISTS idx_turn_session ON turn(session_id, turn_index);
+
+  CREATE TABLE IF NOT EXISTS permission_phase (
+    phase_id   INTEGER PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    from_mode  TEXT,
+    to_mode    TEXT NOT NULL,
+    trigger    TEXT NOT NULL,
+    t_valid    TEXT NOT NULL,
+    t_invalid  TEXT,
+    fact_id    INTEGER
+  );
+  CREATE INDEX IF NOT EXISTS idx_phase_session ON permission_phase(session_id, t_valid);
+
+  CREATE TABLE IF NOT EXISTS human_edit (
+    edit_id    INTEGER PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    file_path  TEXT NOT NULL,
+    ts         TEXT NOT NULL,
+    fact_id    INTEGER,
+    UNIQUE (session_id, file_path, ts)
+  );
+
+  CREATE TABLE IF NOT EXISTS file_checkpoint (
+    checkpoint_id    INTEGER PRIMARY KEY,
+    session_id       TEXT NOT NULL,
+    file_path        TEXT NOT NULL,
+    backup_file_name TEXT NOT NULL,
+    version          INTEGER NOT NULL,
+    backup_time      TEXT NOT NULL,
+    fact_id          INTEGER,
+    UNIQUE (session_id, file_path, backup_file_name)
+  );
+
+  CREATE TABLE IF NOT EXISTS pr (
+    pr_ref TEXT PRIMARY KEY, number INTEGER, repo TEXT, title TEXT, state TEXT, url TEXT, merged_at TEXT
+  );
+  CREATE TABLE IF NOT EXISTS branch (
+    branch_ref TEXT PRIMARY KEY, repo TEXT, name TEXT NOT NULL, base TEXT, created_at TEXT, deleted_at TEXT
+  );
+  CREATE TABLE IF NOT EXISTS file (
+    file_ref TEXT PRIMARY KEY, repo TEXT, path TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS task (
+    task_ref TEXT PRIMARY KEY, task_id TEXT NOT NULL, initiative TEXT, title TEXT, status TEXT
+  );
+  CREATE TABLE IF NOT EXISTS subagent (
+    agent_ref        TEXT PRIMARY KEY,
+    session_id       TEXT,
+    child_session_id TEXT,
+    parent_agent_ref TEXT,
+    agent_type       TEXT,
+    label            TEXT,
+    started_at       TEXT,
+    ended_at         TEXT,
+    fact_id          INTEGER
+  );
+  CREATE INDEX IF NOT EXISTS idx_subagent_child ON subagent(child_session_id);
+  CREATE TABLE IF NOT EXISTS artifact (
+    artifact_ref TEXT PRIMARY KEY, kind TEXT, title TEXT, url TEXT, path TEXT, created_at TEXT
+  );
+  CREATE TABLE IF NOT EXISTS pr_merge_observation (
+    number INTEGER NOT NULL, repo_hint TEXT, merged_at TEXT NOT NULL,
+    PRIMARY KEY (number, repo_hint, merged_at)
+  );
+  CREATE TABLE IF NOT EXISTS pr_create_observation (
+    tool_use_id TEXT PRIMARY KEY, title TEXT, number INTEGER, repo TEXT, url TEXT
+  );
+`;
+var DERIVED_TABLES = [
+  `${KIT.spanFts}_span`,
+  KIT.edge,
+  "turn",
+  "permission_phase",
+  "human_edit",
+  "file_checkpoint",
+  "subagent",
+  "session_model_usage",
+  "session",
+  "fact",
+  "pr",
+  "pr_merge_observation",
+  "pr_create_observation",
+  "branch",
+  "file",
+  "task",
+  "artifact"
+];
+var MIGRATIONS = [
+  kitMigration(1, { watermark: KIT.watermark, edge: KIT.edge, spanFts: KIT.spanFts }, "kit tables"),
+  { version: 2, name: "session graph tables", up: (db) => db.exec(DOMAIN_DDL) }
+];
+
+// src/graph.ts
+function openSessionGraph(dbPath) {
+  const db = openDatabase(dbPath);
+  runMigrations(db, MIGRATIONS);
+  return {
+    db,
+    transcripts: new WatermarkTable(db, { name: KIT.watermark }),
+    edges: new EdgeTable(db, { name: KIT.edge }),
+    spans: new SpanFtsTables(db, { name: KIT.spanFts })
+  };
+}
+function resetIndex(graph) {
+  graph.db.transaction(() => {
+    for (const table of DERIVED_TABLES) graph.db.exec(`DELETE FROM "${table}"`);
+    graph.spans.clearIndex();
+    for (const row of graph.transcripts.list()) graph.transcripts.rewind(row.sourceKey);
+  })();
+}
+function allSessionIds(graph) {
+  return graph.db.prepare("SELECT session_id FROM session").all().map((r) => r.session_id);
+}
+
+// src/apply.ts
+import { sessionRef } from "@titan-design/session-read";
+function applyDelta(graph, transcriptId, delta) {
+  graph.db.transaction(() => {
+    applyFacts(graph.db, transcriptId, delta);
+    applySessions(graph.db, transcriptId, delta);
+    applyAssets(graph.db, delta);
+    applyPhases(graph.db, transcriptId, delta);
+    applyLinkedRows(graph, transcriptId, delta);
+  })();
+}
+var INSERT_FACT = `
+  INSERT INTO fact (transcript_id, byte_offset, byte_length, event_type, ts, seq, session_id, prompt_id, tool_use_id)
+  VALUES (@transcriptId, @byteOffset, @byteLength, @eventType, @ts, @seq, @sessionId, @promptId, @toolUseId)
+  ON CONFLICT (transcript_id, byte_offset) DO NOTHING`;
+function applyFacts(db, transcriptId, delta) {
+  const next = db.prepare("SELECT COALESCE(MAX(seq), -1) + 1 AS next FROM fact WHERE transcript_id = ?").get(transcriptId);
+  const insert = db.prepare(INSERT_FACT);
+  let seq = next.next;
+  for (const f of delta.facts) {
+    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 });
+  }
+}
+var UPSERT_SESSION = `
+  INSERT INTO session (session_id, transcript_id, started_at, ended_at, start_type, cwd, git_branch, ai_title, seed_prompt, cli_version, turn_count, commit_count, push_count)
+  VALUES (@sessionId, @transcriptId, @startedAt, @endedAt, @startType, @cwd, @gitBranch, @aiTitle, @seedPrompt, @cliVersion, @turnDelta, @commitDelta, @pushDelta)
+  ON CONFLICT (session_id) DO UPDATE SET
+    started_at  = MIN(COALESCE(started_at, excluded.started_at), COALESCE(excluded.started_at, started_at)),
+    ended_at    = MAX(COALESCE(ended_at, excluded.ended_at), COALESCE(excluded.ended_at, ended_at)),
+    start_type  = CASE
+      WHEN excluded.start_type IS NULL THEN start_type
+      WHEN start_type IS NULL THEN excluded.start_type
+      WHEN COALESCE(excluded.started_at, started_at) < COALESCE(started_at, excluded.started_at) THEN excluded.start_type
+      ELSE start_type END,
+    cwd         = COALESCE(excluded.cwd, cwd),
+    git_branch  = COALESCE(git_branch, excluded.git_branch),
+    ai_title    = COALESCE(excluded.ai_title, ai_title),
+    seed_prompt = COALESCE(seed_prompt, excluded.seed_prompt),
+    cli_version = COALESCE(excluded.cli_version, cli_version),
+    turn_count   = turn_count + excluded.turn_count,
+    commit_count = commit_count + excluded.commit_count,
+    push_count   = push_count + excluded.push_count`;
+var UPSERT_USAGE = `
+  INSERT INTO session_model_usage (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, thinking_tokens, request_count)
+  VALUES (@sessionId, @model, @inputTokens, @outputTokens, @cacheReadTokens, @cacheCreationTokens, @thinkingTokens, @requestCount)
+  ON CONFLICT (session_id, model) DO UPDATE SET
+    input_tokens = input_tokens + excluded.input_tokens, output_tokens = output_tokens + excluded.output_tokens,
+    cache_read_tokens = cache_read_tokens + excluded.cache_read_tokens,
+    cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,
+    thinking_tokens = thinking_tokens + excluded.thinking_tokens, request_count = request_count + excluded.request_count`;
+function applySessions(db, transcriptId, delta) {
+  const upsertSession = db.prepare(UPSERT_SESSION);
+  for (const s of delta.sessions) upsertSession.run({ ...s, transcriptId });
+  const upsertUsage = db.prepare(UPSERT_USAGE);
+  for (const u of delta.usage) upsertUsage.run(u);
+}
+var ASSET_UPSERTS = {
+  prs: `INSERT INTO pr (pr_ref, number, repo, title, url) VALUES (@prRef, @number, @repo, @title, @url)
+        ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(title, excluded.title), url = COALESCE(url, excluded.url)`,
+  branches: `INSERT INTO branch (branch_ref, repo, name, base, created_at, deleted_at) VALUES (@branchRef, @repo, @name, @base, @createdAt, @deletedAt)
+        ON CONFLICT (branch_ref) DO UPDATE SET base = COALESCE(base, excluded.base),
+          created_at = MIN(COALESCE(created_at, excluded.created_at), COALESCE(excluded.created_at, created_at)),
+          deleted_at = MAX(COALESCE(deleted_at, excluded.deleted_at), COALESCE(excluded.deleted_at, deleted_at))`,
+  files: `INSERT INTO file (file_ref, repo, path) VALUES (@fileRef, @repo, @path) ON CONFLICT (file_ref) DO NOTHING`,
+  tasks: `INSERT INTO task (task_ref, task_id) VALUES (@taskRef, @taskId) ON CONFLICT (task_ref) DO NOTHING`,
+  artifacts: `INSERT INTO artifact (artifact_ref, kind, title, url, path, created_at) VALUES (@artifactRef, @artifactKind, @title, @url, @path, @ts)
+        ON CONFLICT (artifact_ref) DO NOTHING`,
+  prMerges: `INSERT INTO pr_merge_observation (number, repo_hint, merged_at) VALUES (@number, @repoHint, @ts)
+        ON CONFLICT (number, repo_hint, merged_at) DO NOTHING`,
+  prCreates: `INSERT INTO pr_create_observation (tool_use_id, title, number, repo, url) VALUES (@toolUseId, @title, @number, @repo, @url)
+        ON CONFLICT (tool_use_id) DO UPDATE SET title = COALESCE(title, excluded.title), number = COALESCE(number, excluded.number),
+          repo = COALESCE(repo, excluded.repo), url = COALESCE(url, excluded.url)`
+};
+function applyAssets(db, delta) {
+  for (const [kind, sql] of Object.entries(ASSET_UPSERTS)) {
+    const statement = db.prepare(sql);
+    for (const row of delta[kind]) statement.run(pick(row, sql));
+  }
+}
+function pick(row, sql) {
+  const names = new Set([...sql.matchAll(/@(\w+)/g)].map((m) => m[1]));
+  return Object.fromEntries([...names].map((name) => [name, row[name] ?? null]));
+}
+function applyPhases(db, transcriptId, delta) {
+  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");
+  const close = db.prepare("UPDATE permission_phase SET t_invalid = ? WHERE phase_id = ?");
+  const insert = db.prepare("INSERT INTO permission_phase (session_id, from_mode, to_mode, trigger, t_valid, fact_id) VALUES (?, ?, ?, ?, ?, ?)");
+  for (const phase of delta.phases) {
+    const open = current.get(phase.sessionId, phase.trigger);
+    if (open?.to_mode === phase.toMode) continue;
+    if (open) close.run(phase.ts, open.phase_id);
+    insert.run(phase.sessionId, open?.to_mode ?? null, phase.toMode, phase.trigger, phase.ts, factIdFor(db, transcriptId, phase.byteOffset));
+  }
+}
+function applyLinkedRows(graph, transcriptId, delta) {
+  const { db } = graph;
+  const factId = (byteOffset) => factIdFor(db, transcriptId, byteOffset);
+  const upsertTurn = db.prepare(`
+    INSERT INTO turn (prompt_id, session_id, turn_index, started_at, fact_id_start)
+    VALUES (?, ?, (SELECT COALESCE(MAX(turn_index), -1) + 1 FROM turn WHERE session_id = ?), ?, ?)
+    ON CONFLICT (prompt_id) DO UPDATE SET session_id = MIN(session_id, excluded.session_id)`);
+  for (const t of delta.turns) upsertTurn.run(t.promptId, t.sessionId, t.sessionId, t.ts, factId(t.byteOffset));
+  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");
+  for (const e of delta.humanEdits) insertEdit.run(e.sessionId, e.filePath, e.ts, factId(e.byteOffset));
+  const insertCheckpoint = db.prepare(`
+    INSERT INTO file_checkpoint (session_id, file_path, backup_file_name, version, backup_time, fact_id) VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT (session_id, file_path, backup_file_name) DO NOTHING`);
+  for (const c of delta.fileCheckpoints) insertCheckpoint.run(c.sessionId, c.filePath, c.backupFileName, c.version, c.backupTime, factId(c.byteOffset));
+  const upsertSubagent = db.prepare(`
+    INSERT INTO subagent (agent_ref, session_id, agent_type, label, started_at, fact_id) VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT (agent_ref) DO UPDATE SET session_id = COALESCE(session_id, excluded.session_id),
+      agent_type = COALESCE(agent_type, excluded.agent_type), label = COALESCE(label, excluded.label), started_at = COALESCE(started_at, excluded.started_at)`);
+  for (const s of delta.subagents) upsertSubagent.run(s.agentRef, s.sessionId, s.agentType, s.label, s.ts || null, factId(s.byteOffset));
+  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) graph.edges.assert({ sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.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);
+  }
+}
+function factIdFor(db, transcriptId, byteOffset) {
+  const row = db.prepare("SELECT fact_id FROM fact WHERE transcript_id = ? AND byte_offset = ?").get(transcriptId, byteOffset);
+  return row?.fact_id ?? null;
+}
+
+// src/rollup.ts
+var BATCH = 400;
+var ROLLUP = `
+  WITH ordered AS (
+    SELECT fact_id, session_id, event_type, ts, prompt_id,
+      COUNT(CASE WHEN event_type = 'user_prompt' THEN 1 END) OVER (
+        PARTITION BY session_id ORDER BY ts, transcript_id, seq ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS turn_no,
+      LAG(event_type) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_type,
+      LAG(ts) OVER (PARTITION BY session_id ORDER BY ts, transcript_id, seq) AS prev_ts
+    FROM fact WHERE session_id IN (SELECT value FROM json_each(@sessionIds))
+  ),
+  owners AS (SELECT session_id, turn_no, prompt_id FROM ordered WHERE event_type = 'user_prompt'),
+  agg AS (
+    SELECT owners.prompt_id AS prompt_id, MAX(ordered.ts) AS ended_at,
+      CAST(ROUND((julianday(MAX(ordered.ts)) - julianday(MIN(ordered.ts))) * 86400000) AS INTEGER) AS duration_ms,
+      SUM(CASE WHEN ordered.event_type = 'tool_decision' THEN 1 ELSE 0 END) AS tool_call_count,
+      CAST(COALESCE(SUM(CASE
+        WHEN ordered.event_type IN ('assistant_response', 'tool_decision') AND ordered.prev_type IN ('user_prompt', 'tool_result', 'tool_result_error')
+        THEN ROUND((julianday(ordered.ts) - julianday(ordered.prev_ts)) * 86400000) END), 0) AS INTEGER) AS thinking_ms
+    FROM ordered JOIN owners ON owners.session_id = ordered.session_id AND owners.turn_no = ordered.turn_no
+    GROUP BY owners.prompt_id
+  )
+  UPDATE turn SET ended_at = agg.ended_at, duration_ms = COALESCE(agg.duration_ms, 0),
+    tool_call_count = agg.tool_call_count, thinking_ms = COALESCE(agg.thinking_ms, 0)
+  FROM agg WHERE turn.prompt_id = agg.prompt_id`;
+var RENUMBER_TURNS = `
+  WITH ordered AS (
+    SELECT prompt_id, ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY started_at, prompt_id) - 1 AS idx
+    FROM turn WHERE session_id IN (SELECT value FROM json_each(@sessionIds))
+  )
+  UPDATE turn SET turn_index = ordered.idx FROM ordered WHERE turn.prompt_id = ordered.prompt_id`;
+function rollupSessions(graph, sessionIds) {
+  const unique = [...new Set(sessionIds)];
+  if (unique.length === 0) return 0;
+  const aggregate = graph.db.prepare(ROLLUP);
+  const renumber = graph.db.prepare(RENUMBER_TURNS);
+  return graph.db.transaction(() => {
+    let updated = 0;
+    for (let i = 0; i < unique.length; i += BATCH) {
+      const batch = JSON.stringify(unique.slice(i, i + BATCH));
+      renumber.run({ sessionIds: batch });
+      updated += aggregate.run({ sessionIds: batch }).changes;
+    }
+    return updated;
+  })();
+}
+var RECONCILE_PR_MERGES = `
+  UPDATE pr SET state = 'merged',
+    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))
+  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))`;
+var RECONCILE_PR_CREATES = `
+  INSERT INTO pr (pr_ref, number, repo, title, url)
+  SELECT 'pr:' || repo || '#' || number, number, repo, title, url FROM pr_create_observation
+  WHERE number IS NOT NULL AND repo IS NOT NULL AND title IS NOT NULL
+  ON CONFLICT (pr_ref) DO UPDATE SET title = COALESCE(pr.title, excluded.title), url = COALESCE(pr.url, excluded.url)`;
+var RECONCILE_SUBAGENTS = `
+  UPDATE subagent SET
+    ended_at = COALESCE((SELECT s.ended_at FROM session s WHERE s.session_id = subagent.child_session_id), ended_at),
+    parent_agent_ref = COALESCE((SELECT p.agent_ref FROM subagent p WHERE p.child_session_id = subagent.session_id), parent_agent_ref)`;
+function reconcile(graph) {
+  return {
+    prCreates: graph.db.prepare(RECONCILE_PR_CREATES).run().changes,
+    prMerges: graph.db.prepare(RECONCILE_PR_MERGES).run().changes,
+    subagents: graph.db.prepare(RECONCILE_SUBAGENTS).run().changes
+  };
+}
+
+// src/refresh.ts
+import { promises as fs } from "fs";
+import { contentHash, resumePoint } from "@titan-design/locator";
+import { TranscriptParseError, extractTranscript } from "@titan-design/session-read";
+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: [] };
+  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 };
+  try {
+    const delta = await extractTranscript(transcript.absolutePath, {
+      fromByteOffset: point.start,
+      priorPrefixHash: point.state === "rewritten" ? null : row.prefixHash,
+      subagentId: transcript.subagentId
+    });
+    applyDelta(graph, row.sourceId, delta);
+    const stat = await fs.stat(transcript.absolutePath);
+    graph.transcripts.advance(transcript.displayPath, {
+      lastOffset: delta.lastByteOffset,
+      prefixHash: delta.prefixHash,
+      fileSize: stat.size,
+      fileMtime: stat.mtime.toISOString(),
+      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 };
+  } catch (err) {
+    if (!(err instanceof TranscriptParseError)) throw err;
+    graph.transcripts.markStatus(transcript.displayPath, "quarantined", err.message);
+    return { ...base, status: "quarantined", facts: 0, reason: err.message };
+  }
+}
+async function refreshCorpus(graph, transcripts, options = {}) {
+  const 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);
+    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 markedMissing = await markMissing(graph, transcripts);
+  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, markedMissing };
+}
+async function markMissing(graph, discovered) {
+  const present = new Set(discovered.map((t) => t.displayPath));
+  const byPath = new Map(discovered.map((t) => [t.displayPath, t.absolutePath]));
+  let marked = 0;
+  for (const row of graph.transcripts.list()) {
+    if (row.status === "missing" || present.has(row.sourceKey)) continue;
+    const absolute = byPath.get(row.sourceKey) ?? row.sourceKey;
+    if (await exists(absolute)) continue;
+    graph.transcripts.markStatus(row.sourceKey, "missing", "source file no longer exists");
+    marked += 1;
+  }
+  return marked;
+}
+async function exists(absolutePath) {
+  try {
+    await fs.stat(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  DERIVED_TABLES,
+  DOMAIN_DDL,
+  KIT,
+  MIGRATIONS,
+  allSessionIds,
+  applyDelta,
+  indexTranscript,
+  openSessionGraph,
+  reconcile,
+  refreshCorpus,
+  resetIndex,
+  rollupSessions
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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) VALUES (@taskRef, @taskId) ON CONFLICT (task_ref) DO NOTHING`,\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":[]}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@titan-design/session-graph",
+  "version": "0.1.0",
+  "description": "Fold session events into the activity graph on store-sqlite",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "author": "Henry Jewkes",
+  "license": "MIT",
+  "homepage": "https://github.com/HJewkes/titan-platform#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HJewkes/titan-platform.git",
+    "directory": "packages/session-graph"
+  },
+  "bugs": "https://github.com/HJewkes/titan-platform/issues",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@titan-design/store-sqlite": "^0.1.0",
+    "@titan-design/cluster": "^0.1.0",
+    "@titan-design/session-read": "^0.1.0",
+    "@titan-design/locator": "^0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src"
+  }
+}