nlm-memory 0.19.0 → 0.20.1

package/dist/core/storage/pg-migrate.js

@@ -0,0 +1,73 @@
+/**
+ * Version-gated PostgreSQL migration runner. Reads versioned *.sql files from
+ * a directory, applies any whose integer prefix is not yet in schema_migrations,
+ * and returns the list of newly applied versions. Idempotent: re-running on an
+ * up-to-date database is a no-op.
+ *
+ * Migration files that contain their own BEGIN/COMMIT markers have those lines
+ * stripped; the runner wraps each file in a single transaction instead. A file
+ * whose first line is `-- nlm:no-wrap` is executed as-is (manages its own
+ * transaction). No pg migration files use that convention today; the check is
+ * kept for parity with the sqlite runner.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+const FILE_PATTERN = /^(\d+)_([a-z0-9_-]+)\.sql$/i;
+function stripTransactionMarkers(sql) {
+    return sql
+        .split("\n")
+        .filter((line) => !/^\s*(?:BEGIN|COMMIT)\s*;\s*$/.test(line))
+        .join("\n");
+}
+export async function runMigrationsPg(pool, migrationsDir) {
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version     INTEGER PRIMARY KEY,
+      name        TEXT NOT NULL,
+      applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `);
+    const { rows: appliedRows } = await pool.query("SELECT version FROM schema_migrations");
+    const applied = new Set(appliedRows.map((r) => r.version));
+    const files = readdirSync(migrationsDir)
+        .filter((f) => FILE_PATTERN.test(f))
+        .sort();
+    const newlyApplied = [];
+    for (const file of files) {
+        const match = FILE_PATTERN.exec(file);
+        if (!match)
+            continue;
+        const version = Number(match[1]);
+        const name = match[2] ?? file;
+        if (applied.has(version))
+            continue;
+        const rawSql = readFileSync(join(migrationsDir, file), "utf8");
+        const noWrap = rawSql.startsWith("-- nlm:no-wrap");
+        const client = await pool.connect();
+        try {
+            if (noWrap) {
+                await client.query(rawSql);
+                await client.query("INSERT INTO schema_migrations (version, name) VALUES ($1, $2) ON CONFLICT DO NOTHING", [version, name]);
+            }
+            else {
+                const sql = stripTransactionMarkers(rawSql);
+                await client.query("BEGIN");
+                try {
+                    await client.query(sql);
+                    await client.query("INSERT INTO schema_migrations (version, name) VALUES ($1, $2) ON CONFLICT DO NOTHING", [version, name]);
+                    await client.query("COMMIT");
+                }
+                catch (err) {
+                    await client.query("ROLLBACK");
+                    throw new Error(`Migration ${file} failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        finally {
+            client.release();
+        }
+        newlyApplied.push({ version, name });
+    }
+    return newlyApplied;
+}
+//# sourceMappingURL=pg-migrate.js.map

package/dist/core/storage/pg-migrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-migrate.js","sourceRoot":"","sources":["../../../src/core/storage/pg-migrate.ts"],"names":[],"mappings":"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"}

package/dist/core/storage/pg-session-store.d.ts

@@ -13,14 +13,23 @@ import type { PgFactStore } from "./pg-fact-store.js";
 export declare class PgSessionStore implements SessionStore {
     readonly pool: Pool;
     constructor(pool: Pool);
+    private overlayCache;
+    private overlayCacheAt;
+    invalidateOverlayCache(): void;
+    private overlay;
     list(filter?: SessionFilter): Promise<ReadonlyArray<Session>>;
     getById(sessionId: string): Promise<Session | null>;
     getByIds(ids: ReadonlyArray<string>): Promise<ReadonlyArray<Session>>;
+    listByDateRange(fromIso: string, toIso: string): Promise<ReadonlyArray<Session>>;
     semanticSearch(queryVector: Float32Array, limit: number, opts?: SearchOptions): Promise<ReadonlyArray<SemanticNeighbor>>;
     keywordSearch(query: string, limit: number, opts?: SearchOptions): Promise<ReadonlyArray<KeywordNeighbor>>;
     resolveSuccessors(ids: ReadonlyArray<string>): Promise<Map<string, string>>;
     updateStatus(sessionId: string, status: SessionStatus): Promise<void>;
     markSuperseded(predecessorId: string, successorId: string): Promise<void>;
+    setWorkstreamBinding(sessionId: string, workstreamId: string | null, source: import("../workstream/model.js").BindingSource | null, confidence: number | null): Promise<void>;
+    listSessionIdsByWorkstreams(workstreamIds: ReadonlyArray<string>): Promise<ReadonlyArray<string>>;
+    getEntities(sessionId: string): Promise<ReadonlyArray<string>>;
+    getWorkstreamIds(sessionIds: ReadonlyArray<string>): Promise<Map<string, string | null>>;
     recentWrites(limit: number): Promise<RecentWrite[]>;
     recentMarkers(limit: number): Promise<RecentMarker[]>;
     insertSession(record: IngestRecord, embedder?: import("../../ports/llm-client.js").LLMClient | null, supersedes?: Supersedes | null, factSink?: {

package/dist/core/storage/pg-session-store.js

@@ -5,7 +5,36 @@
  * and recentMarkers() for the /live HTTP endpoints, and insertSession() +
  * insertSessionForTest() for ingest and test seeding.
  */
+import { tokenize } from "../recall/tokenize.js";
+import { ingestSessionFactsOnClient } from "./pg-fact-ingest.js";
 import { chunkSessionText } from "../embedding/chunk-body.js";
+import { batchWinners } from "./fact-batch.js";
+import { loadActionOverlayPg, openQuestionId } from "../actions/overlay.js";
+import { liveSessionStatus } from "./live-status.js";
+/**
+ * PG mirror of SQLite findContinuesPredecessor: the most recent prior session
+ * whose distinct entity-set is identical to the new session's. Runs on the
+ * ingest transaction's own client. Returns null when there is no entity-set or
+ * no exact-set match, leaving the pair unlinked for the re_derivation_rate metric.
+ */
+async function findContinuesPredecessorPg(client, newId, rawEntities) {
+    const entities = [...new Set(rawEntities.map((e) => e.trim()).filter(Boolean))];
+    if (entities.length === 0)
+        return null;
+    const placeholders = entities.map((_, i) => `$${i + 2}`).join(",");
+    const res = await client.query(`SELECT s.id AS id
+       FROM sessions s
+       JOIN session_entities se ON se.session_id = s.id
+      WHERE s.id != $1
+        AND se.entity_canonical IN (${placeholders})
+      GROUP BY s.id
+     HAVING COUNT(DISTINCT se.entity_canonical) = $${entities.length + 2}
+        AND COUNT(DISTINCT se.entity_canonical)
+          = (SELECT COUNT(*) FROM session_entities x WHERE x.session_id = s.id)
+      ORDER BY s.started_at DESC, s.id DESC
+      LIMIT 1`, [newId, ...entities, entities.length]);
+    return res.rows[0]?.id ?? null;
+}
 export class PgSessionStore {
     pool;
     // `pool` is public-readonly so PG-native sibling helpers (actions-log Pg
@@ -13,18 +42,36 @@ export class PgSessionStore {
     constructor(pool) {
         this.pool = pool;
     }
+    overlayCache = null;
+    overlayCacheAt = 0;
+    invalidateOverlayCache() {
+        this.overlayCache = null;
+    }
+    async overlay() {
+        // TTL backstop: explicit invalidation covers the daemon's own writers; the
+        // 30s expiry bounds staleness if another process ever writes actions to
+        // this database.
+        if (this.overlayCache !== null && Date.now() - this.overlayCacheAt < 30_000) {
+            return this.overlayCache;
+        }
+        this.overlayCache = await loadActionOverlayPg(this.pool);
+        this.overlayCacheAt = Date.now();
+        return this.overlayCache;
+    }
     async list(filter) {
         const result = await this.pool.query(`SELECT id, runtime, runtime_session_id, started_at, ended_at, duration_min,
-              label, summary, status, transcript_kind, transcript_path, body
+              label, summary, status, transcript_kind, transcript_path, body,
+              classifier_provider, classifier_model, classifier_confidence
        FROM sessions ORDER BY started_at ASC`);
         if (result.rows.length === 0)
             return [];
         const ids = result.rows.map((r) => r.id);
-        const [entitiesMap, markersMap] = await Promise.all([
+        const [entitiesMap, markersMap, overlay] = await Promise.all([
             this.loadEntities(ids),
             this.loadMarkers(ids),
+            this.overlay(),
         ]);
-        const sessions = result.rows.map((r) => rowToSession(r, entitiesMap, markersMap));
+        const sessions = result.rows.map((r) => rowToSession(r, entitiesMap, markersMap, overlay));
         if (!filter)
             return sessions;
         return sessions.filter((s) => {
@@ -39,17 +86,19 @@ export class PgSessionStore {
     }
     async getById(sessionId) {
         const result = await this.pool.query(`SELECT id, runtime, runtime_session_id, started_at, ended_at, duration_min,
-              label, summary, status, transcript_kind, transcript_path, body
+              label, summary, status, transcript_kind, transcript_path, body,
+              classifier_provider, classifier_model, classifier_confidence
        FROM sessions WHERE id = $1`, [sessionId]);
         if (!result.rows[0])
             return null;
-        const [entitiesMap, markersMap, edgesMap] = await Promise.all([
+        const [entitiesMap, markersMap, edgesMap, overlay] = await Promise.all([
             this.loadEntities([sessionId]),
             this.loadMarkers([sessionId]),
             this.loadEdges([sessionId]),
+            this.overlay(),
         ]);
         const edges = edgesMap.get(sessionId);
-        return rowToSession(result.rows[0], entitiesMap, markersMap, edges);
+        return rowToSession(result.rows[0], entitiesMap, markersMap, overlay, edges);
     }
     async getByIds(ids) {
         if (ids.length === 0)
@@ -61,41 +110,84 @@ export class PgSessionStore {
         if (result.rows.length === 0)
             return [];
         const foundIds = result.rows.map((r) => r.id);
-        const [entitiesMap, markersMap] = await Promise.all([
+        const [entitiesMap, markersMap, overlay] = await Promise.all([
             this.loadEntities(foundIds),
             this.loadMarkers(foundIds),
+            this.overlay(),
+        ]);
+        return result.rows.map((r) => rowToSession({ ...r, body: null }, entitiesMap, markersMap, overlay));
+    }
+    async listByDateRange(fromIso, toIso) {
+        const result = await this.pool.query(`SELECT id, runtime, runtime_session_id, started_at, ended_at, duration_min,
+              label, summary, status, transcript_kind, transcript_path, workstream_id
+       FROM sessions
+       WHERE started_at < $1 AND (ended_at IS NULL OR ended_at >= $2)
+       ORDER BY started_at ASC`, [toIso, fromIso]);
+        if (result.rows.length === 0)
+            return [];
+        const ids = result.rows.map((r) => r.id);
+        const [entitiesMap, markersMap, overlay] = await Promise.all([
+            this.loadEntities(ids),
+            this.loadMarkers(ids),
+            this.overlay(),
         ]);
-        return result.rows.map((r) => rowToSession({ ...r, body: null }, entitiesMap, markersMap));
+        return result.rows.map((r) => rowToSession({ ...r, body: null }, entitiesMap, markersMap, overlay));
     }
     async semanticSearch(queryVector, limit, opts) {
+        const wsIds = opts?.workstreamIds;
+        if (wsIds !== undefined && wsIds.length === 0)
+            return [];
         const k = Math.max(1, Math.trunc(limit));
         const vecStr = `[${Array.from(queryVector).join(",")}]`;
         const statusFilter = opts?.includeSuperseded === true
             ? "s.status != 'replaced'"
             : "s.status NOT IN ('superseded', 'replaced')";
+        const params = [vecStr];
+        let wsClause = "";
+        if (wsIds?.length) {
+            params.push(wsIds);
+            wsClause = `AND s.workstream_id = ANY($${params.length}::text[])`;
+        }
+        params.push(k);
+        const limitParam = `$${params.length}`;
         const result = await this.pool.query(`SELECT sec.session_id, MIN(sec.embedding <-> $1::vector) AS distance, s.status
        FROM session_embedding_chunks sec
        JOIN sessions s ON s.id = sec.session_id
+       WHERE TRUE ${wsClause}
        GROUP BY sec.session_id, s.status
        HAVING ${statusFilter}
        ORDER BY distance
-       LIMIT $2`, [vecStr, k]);
+       LIMIT ${limitParam}`, params);
         return result.rows.map((r) => ({ sessionId: r.session_id, distance: r.distance }));
     }
     async keywordSearch(query, limit, opts) {
-        if (!query.trim())
+        const wsIds = opts?.workstreamIds;
+        if (wsIds !== undefined && wsIds.length === 0)
+            return [];
+        const terms = tokenize(query).map(sanitizeTsToken).filter(Boolean);
+        if (terms.length === 0)
             return [];
+        const tsQuery = terms.join(" OR ");
         const k = Math.max(1, Math.trunc(limit));
         const statusFilter = opts?.includeSuperseded === true
             ? "status != 'replaced'"
             : "status NOT IN ('superseded', 'replaced')";
+        const params = [tsQuery];
+        let wsClause = "";
+        if (wsIds?.length) {
+            params.push(wsIds);
+            wsClause = `AND workstream_id = ANY($${params.length}::text[])`;
+        }
+        params.push(k);
+        const limitParam = `$${params.length}`;
         const result = await this.pool.query(`SELECT id AS session_id,
               ts_rank_cd(fts_vector, websearch_to_tsquery('english', $1)) AS score
        FROM sessions
        WHERE fts_vector @@ websearch_to_tsquery('english', $1)
          AND ${statusFilter}
+         ${wsClause}
        ORDER BY score DESC
-       LIMIT $2`, [query, k]);
+       LIMIT ${limitParam}`, params);
         return result.rows.map((r) => ({ sessionId: r.session_id, score: r.score }));
     }
     async resolveSuccessors(ids) {
@@ -176,7 +268,11 @@ export class PgSessionStore {
               AND s.superseded_by IS NULL
           )
       `;
-            await client.query(cascadeSQL, [predecessorId, successorId]);
+            const cascaded = await client.query(cascadeSQL + " RETURNING p.id", [predecessorId, successorId]);
+            const cascadedIds = cascaded.rows.map((r) => r.id);
+            if (cascadedIds.length > 0) {
+                await client.query("DELETE FROM fact_embeddings WHERE fact_id = ANY($1)", [cascadedIds]);
+            }
             await client.query("COMMIT");
         }
         catch (err) {
@@ -187,6 +283,29 @@ export class PgSessionStore {
             client.release();
         }
     }
+    async setWorkstreamBinding(sessionId, workstreamId, source, confidence) {
+        await this.pool.query("UPDATE sessions SET workstream_id = $1, binding_source = $2, binding_confidence = $3, updated_at = NOW() WHERE id = $4", [workstreamId, source, confidence, sessionId]);
+    }
+    async listSessionIdsByWorkstreams(workstreamIds) {
+        if (workstreamIds.length === 0)
+            return [];
+        const ph = workstreamIds.map((_, i) => `$${i + 1}`).join(",");
+        const r = await this.pool.query(`SELECT id FROM sessions WHERE workstream_id IN (${ph}) ORDER BY started_at ASC`, [...workstreamIds]);
+        return r.rows.map((row) => row.id);
+    }
+    async getEntities(sessionId) {
+        return (await this.loadEntities([sessionId])).get(sessionId) ?? [];
+    }
+    async getWorkstreamIds(sessionIds) {
+        const out = new Map();
+        if (sessionIds.length === 0)
+            return out;
+        const ph = sessionIds.map((_, i) => `$${i + 1}`).join(",");
+        const result = await this.pool.query(`SELECT id, workstream_id FROM sessions WHERE id IN (${ph})`, [...sessionIds]);
+        for (const r of result.rows)
+            out.set(r.id, r.workstream_id);
+        return out;
+    }
     async recentWrites(limit) {
         const result = await this.pool.query(`SELECT id, runtime, label, summary, created_at AS "createdAt"
        FROM sessions ORDER BY created_at DESC LIMIT $1`, [limit]);
@@ -222,8 +341,9 @@ export class PgSessionStore {
             await client.query(`INSERT INTO sessions (
            id, runtime, runtime_session_id, started_at, ended_at, duration_min,
            label, summary, body, status, transcript_kind, transcript_path,
-           transcript_offset, transcript_length
-         ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+           transcript_offset, transcript_length,
+           classifier_provider, classifier_model, classifier_confidence
+         ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
          ON CONFLICT (id) DO UPDATE SET
            ended_at = EXCLUDED.ended_at,
            duration_min = EXCLUDED.duration_min,
@@ -231,6 +351,9 @@ export class PgSessionStore {
            summary = EXCLUDED.summary,
            body = EXCLUDED.body,
            status = EXCLUDED.status,
+           classifier_provider = EXCLUDED.classifier_provider,
+           classifier_model = EXCLUDED.classifier_model,
+           classifier_confidence = EXCLUDED.classifier_confidence,
            updated_at = NOW()`, [
                 record.id, record.runtime, record.runtimeSessionId,
                 record.startedAt, record.endedAt, record.durationMin,
@@ -238,6 +361,9 @@ export class PgSessionStore {
                 record.status === "idle" ? "active" : record.status,
                 record.transcriptKind, record.transcriptPath,
                 record.transcriptOffset, record.transcriptLength,
+                record.classifier?.provider ?? null,
+                record.classifier?.model ?? null,
+                record.classifier?.confidence ?? null,
             ]);
             await client.query("DELETE FROM markers WHERE session_id = $1", [record.id]);
             for (let i = 0; i < record.decisions.length; i++) {
@@ -246,17 +372,34 @@ export class PgSessionStore {
             for (let i = 0; i < record.openQuestions.length; i++) {
                 await client.query("INSERT INTO markers (session_id, kind, text, position) VALUES ($1, 'open', $2, $3)", [record.id, record.openQuestions[i].trim(), i]);
             }
-            for (const raw of record.entities) {
-                const name = raw.trim();
-                if (!name)
-                    continue;
+            // Replace entity-link semantics: delete the session's existing links, then
+            // re-insert for the new entity list. Without this, nlm reprocess amplifies
+            // stale links (ON CONFLICT DO NOTHING keeps dropped entities forever) and
+            // double-counts session_count on every re-ingest pass.
+            const rawNewEntities = [...new Set(record.entities.map((e) => e.trim()).filter(Boolean))];
+            // Resolve each extracted entity through entity_variants so merged surface
+            // forms bind to the canonical instead of resurrecting the retired source.
+            const variantRes = await client.query(`SELECT variant, canonical FROM entity_variants WHERE variant = ANY($1)`, [rawNewEntities]);
+            const variantMap = new Map(variantRes.rows.map((r) => [r.variant, r.canonical]));
+            const newEntities = rawNewEntities.map((name) => variantMap.get(name) ?? name);
+            const oldRes = await client.query("SELECT entity_canonical FROM session_entities WHERE session_id = $1", [record.id]);
+            const oldEntities = new Set(oldRes.rows.map((r) => r.entity_canonical));
+            await client.query("DELETE FROM session_entities WHERE session_id = $1", [record.id]);
+            for (const name of newEntities) {
                 await client.query(`INSERT INTO entities (canonical, type, status, source, first_seen_session, last_seen_session, session_count)
            VALUES ($1, 'candidate', 'candidate', 'auto-detected', $2, $2, 0)
-           ON CONFLICT (canonical) DO UPDATE SET
-             last_seen_session = $2,
-             session_count = entities.session_count + 1,
-             updated_at = NOW()`, [name, record.id]);
-                await client.query("INSERT INTO session_entities (session_id, entity_canonical) VALUES ($1, $2) ON CONFLICT DO NOTHING", [record.id, name]);
+           ON CONFLICT (canonical) DO NOTHING`, [name, record.id]);
+                // Update last_seen for entities newly added to this session; matches prior touch semantics.
+                if (!oldEntities.has(name)) {
+                    await client.query("UPDATE entities SET last_seen_session = $1, updated_at = NOW() WHERE canonical = $2", [record.id, name]);
+                }
+                await client.query("INSERT INTO session_entities (session_id, entity_canonical) VALUES ($1, $2)", [record.id, name]);
+            }
+            // Recompute session_count exactly for every entity in (old union new) so
+            // counts reflect reality regardless of prior drift.
+            const allTouched = [...new Set([...oldEntities, ...newEntities])];
+            for (const name of allTouched) {
+                await client.query("UPDATE entities SET session_count = (SELECT COUNT(*) FROM session_entities WHERE entity_canonical = $1), updated_at = NOW() WHERE canonical = $1", [name]);
             }
             if (supersedes && supersedes.priorSessionId !== record.id) {
                 const predecessorStatus = supersedes.kind === "replaces" ? "replaced" : "superseded";
@@ -264,35 +407,17 @@ export class PgSessionStore {
            VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`, [record.id, supersedes.priorSessionId, supersedes.kind]);
                 await client.query("UPDATE sessions SET status = $1, updated_at = NOW() WHERE id = $2", [predecessorStatus, supersedes.priorSessionId]);
             }
-            // Atomic session+facts ingest. Mirrors the SQLite factSink path
-            // (sqlite-session-store.insertSession) and PgFactStore.ingestSessionFacts,
-            // but runs on the session's own client so facts commit with the row.
-            // Re-ingest is idempotent: DELETE-by-session clears prior facts, then the
-            // batch UPDATE re-collapses every active (subject, predicate) sibling.
-            if (factSink !== null) {
-                await client.query("DELETE FROM facts WHERE source_session_id = $1", [record.id]);
-                if (factSink.facts.length > 0) {
-                    for (const f of factSink.facts) {
-                        await client.query(`INSERT INTO facts (id, kind, subject, predicate, value, source_session_id,
-                 source_quote, created_at, superseded_by, confidence)
-               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [f.id, f.kind, f.subject, f.predicate, f.value, f.sourceSessionId,
-                            f.sourceQuote, f.createdAt, f.supersededBy, f.confidence]);
-                    }
-                    const values = factSink.facts
-                        .map((_, i) => `($${i * 3 + 1}, $${i * 3 + 2}, $${i * 3 + 3})`)
-                        .join(", ");
-                    const params = [];
-                    for (const f of factSink.facts)
-                        params.push(f.subject, f.predicate, f.id);
-                    await client.query(`UPDATE facts AS old
-             SET superseded_by = new_f.new_id
-             FROM (VALUES ${values}) AS new_f(subject, predicate, new_id)
-             WHERE old.subject = new_f.subject
-               AND old.predicate = new_f.predicate
-               AND old.superseded_by IS NULL
-               AND old.id != new_f.new_id`, params);
+            else {
+                const priorId = await findContinuesPredecessorPg(client, record.id, record.entities);
+                if (priorId !== null) {
+                    await client.query(`INSERT INTO session_edges (from_session, to_session, kind)
+             VALUES ($1, $2, 'continues') ON CONFLICT DO NOTHING`, [record.id, priorId]);
                 }
             }
+            // Atomic session+facts ingest on the session's own client. Single source of truth: pg-fact-ingest.ts.
+            if (factSink !== null) {
+                await ingestSessionFactsOnClient(client, record.id, factSink.facts);
+            }
             await client.query("COMMIT");
         }
         catch (err) {
@@ -325,7 +450,7 @@ export class PgSessionStore {
             // SQLite path. A per-fact embed failure leaves the fact current but
             // semantically unreachable until a future re-ingest.
             if (factSink !== null) {
-                for (const fact of factSink.facts) {
+                for (const fact of batchWinners(factSink.facts)) {
                     const factText = `${fact.subject} ${fact.predicate} ${fact.value}`.trim();
                     if (!factText)
                         continue;
@@ -385,26 +510,7 @@ export class PgSessionStore {
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
-            await client.query("DELETE FROM facts WHERE source_session_id = $1", [sessionId]);
-            if (facts.length > 0) {
-                for (const f of facts) {
-                    await client.query(`INSERT INTO facts (id, kind, subject, predicate, value, source_session_id,
-               source_quote, created_at, superseded_by, confidence)
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [f.id, f.kind, f.subject, f.predicate, f.value, f.sourceSessionId,
-                        f.sourceQuote, f.createdAt, f.supersededBy, f.confidence]);
-                }
-                const values = facts.map((_, i) => `($${i * 3 + 1}, $${i * 3 + 2}, $${i * 3 + 3})`).join(", ");
-                const supersedeParams = [];
-                for (const f of facts)
-                    supersedeParams.push(f.subject, f.predicate, f.id);
-                await client.query(`UPDATE facts AS old
-           SET superseded_by = new_f.new_id
-           FROM (VALUES ${values}) AS new_f(subject, predicate, new_id)
-           WHERE old.subject = new_f.subject
-             AND old.predicate = new_f.predicate
-             AND old.superseded_by IS NULL
-             AND old.id != new_f.new_id`, supersedeParams);
-            }
+            await ingestSessionFactsOnClient(client, sessionId, facts);
             await client.query("COMMIT");
         }
         catch (err) {
@@ -415,7 +521,7 @@ export class PgSessionStore {
             client.release();
         }
         if (embedder) {
-            for (const fact of facts) {
+            for (const fact of batchWinners(facts)) {
                 const factText = `${fact.subject} ${fact.predicate} ${fact.value}`.trim();
                 if (!factText)
                     continue;
@@ -488,8 +594,26 @@ export class PgSessionStore {
         return out;
     }
 }
-function rowToSession(row, entitiesById, markersById, edges) {
+function sanitizeTsToken(token) {
+    return token.replace(/[&|!():*'<]/g, "");
+}
+function rowToSession(row, entitiesById, markersById, overlay, edges) {
     const m = markersById.get(row.id);
+    const rawDecisions = m?.decisions ?? [];
+    const rawOpen = m?.open ?? [];
+    const activeOpen = [];
+    const promotedDecisions = [];
+    for (const text of rawOpen) {
+        const id = openQuestionId(row.id, text);
+        if (overlay.resolvedOpens.has(id))
+            continue;
+        const resolution = overlay.promotedOpens.get(id);
+        if (resolution !== undefined) {
+            promotedDecisions.push(resolution);
+            continue;
+        }
+        activeOpen.push(text);
+    }
     return {
         id: row.id,
         runtime: row.runtime,
@@ -499,16 +623,20 @@ function rowToSession(row, entitiesById, markersById, edges) {
         durationMin: row.duration_min,
         label: row.label,
         summary: row.summary,
-        status: row.status,
+        status: liveSessionStatus(row.transcript_path, row.status),
         transcriptKind: row.transcript_kind ?? "",
         transcriptPath: row.transcript_path,
         body: row.body ?? "",
         entities: entitiesById.get(row.id) ?? [],
-        decisions: m?.decisions ?? [],
-        open: m?.open ?? [],
+        decisions: [...rawDecisions, ...promotedDecisions],
+        open: activeOpen,
         ...(edges !== undefined
             ? { supersededBy: edges.supersededBy, supersedes: edges.supersedes }
             : {}),
+        workstreamId: row.workstream_id ?? null,
+        classifierProvider: row.classifier_provider ?? null,
+        classifierModel: row.classifier_model ?? null,
+        classifierConfidence: row.classifier_confidence ?? null,
     };
 }
 //# sourceMappingURL=pg-session-store.js.map