nlm-memory 0.21.0 → 0.21.13

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

@@ -4,6 +4,11 @@
  * Constructor takes the Pool from PgStorage. Also exposes recentWrites()
  * and recentMarkers() for the /live HTTP endpoints, and insertSession() +
  * insertSessionForTest() for ingest and test seeding.
+ *
+ * Tenancy: mirrors SqliteSessionStore — every method takes `tenantId` as its
+ * non-optional first parameter and routes STAMP-table WHERE fragments
+ * through `tenantClausePg`. See that file's header comment for the full
+ * per-table rationale.
  */
 import type { Pool } from "pg";
 import type { KeywordNeighbor, SearchOptions, SemanticNeighbor, SessionStore } from "../../ports/session-store.js";
@@ -14,35 +19,34 @@ export declare class PgSessionStore implements SessionStore {
     readonly pool: Pool;
     constructor(pool: Pool);
     private overlayCache;
-    private overlayCacheAt;
     invalidateOverlayCache(): void;
     private overlay;
-    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>;
-    getSessionScopeById(id: string): Promise<string | null>;
-    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?: {
+    getById(tenantId: string, sessionId: string): Promise<Session | null>;
+    getByIds(tenantId: string, ids: ReadonlyArray<string>): Promise<ReadonlyArray<Session>>;
+    listByDateRange(tenantId: string, fromIso: string, toIso: string): Promise<ReadonlyArray<Session>>;
+    semanticSearch(tenantId: string, queryVector: Float32Array, limit: number, opts?: SearchOptions): Promise<ReadonlyArray<SemanticNeighbor>>;
+    keywordSearch(tenantId: string, query: string, limit: number, opts?: SearchOptions): Promise<ReadonlyArray<KeywordNeighbor>>;
+    resolveSuccessors(tenantId: string, ids: ReadonlyArray<string>): Promise<Map<string, string>>;
+    updateStatus(tenantId: string, sessionId: string, status: SessionStatus): Promise<void>;
+    markSuperseded(tenantId: string, predecessorId: string, successorId: string): Promise<void>;
+    getSessionScopeById(tenantId: string, id: string): Promise<string | null>;
+    setWorkstreamBinding(tenantId: string, sessionId: string, workstreamId: string | null, source: import("../workstream/model.js").BindingSource | null, confidence: number | null): Promise<void>;
+    listSessionIdsByWorkstreams(tenantId: string, workstreamIds: ReadonlyArray<string>): Promise<ReadonlyArray<string>>;
+    getEntities(tenantId: string, sessionId: string): Promise<ReadonlyArray<string>>;
+    getWorkstreamIds(tenantId: string, sessionIds: ReadonlyArray<string>): Promise<Map<string, string | null>>;
+    recentWrites(tenantId: string, limit: number): Promise<RecentWrite[]>;
+    recentMarkers(tenantId: string, limit: number): Promise<RecentMarker[]>;
+    insertSession(tenantId: string, record: IngestRecord, embedder?: import("../../ports/llm-client.js").LLMClient | null, supersedes?: Supersedes | null, factSink?: {
         factStore: PgFactStore;
         facts: ReadonlyArray<Fact>;
     } | null): Promise<void>;
-    insertSessionForTest(session: Session): Promise<void>;
+    insertSessionForTest(session: Session, tenantId?: string): Promise<void>;
     /** PG counterpart of SqliteSessionStore.listBackfillCandidates. */
-    listBackfillCandidates(filter: BackfillCandidateFilter): Promise<BackfillCandidate[]>;
+    listBackfillCandidates(tenantId: string, filter: BackfillCandidateFilter): Promise<BackfillCandidate[]>;
     /** PG counterpart of SqliteSessionStore.insertFactsForSession — writes facts
      *  for an EXISTING session row (deterministic supersedence + best-effort
      *  embeddings) in one transaction. Used by the fact backfill. */
-    insertFactsForSession(sessionId: string, factStore: PgFactStore, facts: ReadonlyArray<Fact>, embedder?: import("../../ports/llm-client.js").LLMClient | null): Promise<void>;
+    insertFactsForSession(tenantId: string, sessionId: string, factStore: PgFactStore, facts: ReadonlyArray<Fact>, embedder?: import("../../ports/llm-client.js").LLMClient | null): Promise<void>;
     private loadEntities;
     private loadMarkers;
     private loadEdges;

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

@@ -4,6 +4,11 @@
  * Constructor takes the Pool from PgStorage. Also exposes recentWrites()
  * and recentMarkers() for the /live HTTP endpoints, and insertSession() +
  * insertSessionForTest() for ingest and test seeding.
+ *
+ * Tenancy: mirrors SqliteSessionStore — every method takes `tenantId` as its
+ * non-optional first parameter and routes STAMP-table WHERE fragments
+ * through `tenantClausePg`. See that file's header comment for the full
+ * per-table rationale.
  */
 import { tokenize } from "../recall/tokenize.js";
 import { ingestSessionFactsOnClient } from "./pg-fact-ingest.js";
@@ -11,28 +16,39 @@ 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";
+import { tenantClausePg } from "../tenancy/tenant-clause.js";
+import { DEFAULT_TEAM_ID } from "../tenancy/default-team.js";
+import { recordEmbedFailure } from "../health/embed-failure-state.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.
+ * Scoped to the same tenant as the new session.
  */
-async function findContinuesPredecessorPg(client, newId, rawEntities) {
+async function findContinuesPredecessorPg(client, tenantId, 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 placeholders = entities.map((_, i) => `$${i + 3}`).join(",");
+    // session_entities rows are always written with the same tenant_id as their
+    // owning session (every write site stamps both together), so scoping the
+    // outer `sessions` row by tenant is already sufficient. The `se.tenant_id =
+    // s.tenant_id` join condition below is defense in depth (guard test C4
+    // explicitly permits column-to-column tenant equality as a join form).
+    const tc = tenantClausePg(tenantId, 2, "s.tenant_id");
     const res = await client.query(`SELECT s.id AS id
        FROM sessions s
-       JOIN session_entities se ON se.session_id = s.id
+       JOIN session_entities se ON se.session_id = s.id AND se.tenant_id = s.tenant_id
       WHERE s.id != $1
+        AND ${tc.sql}
         AND se.entity_canonical IN (${placeholders})
       GROUP BY s.id
-     HAVING COUNT(DISTINCT se.entity_canonical) = $${entities.length + 2}
+     HAVING COUNT(DISTINCT se.entity_canonical) = $${entities.length + 3}
         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]);
+      LIMIT 1`, [newId, tc.param, ...entities, entities.length]);
     return res.rows[0]?.id ?? null;
 }
 export class PgSessionStore {
@@ -42,74 +58,79 @@ export class PgSessionStore {
     constructor(pool) {
         this.pool = pool;
     }
-    overlayCache = null;
-    overlayCacheAt = 0;
+    // Keyed by tenantId — see SqliteSessionStore's identical cache for the
+    // tenancy rationale (program spec §4.6 hardening 1).
+    overlayCache = new Map();
     invalidateOverlayCache() {
-        this.overlayCache = null;
+        this.overlayCache.clear();
     }
-    async overlay() {
+    async overlay(tenantId) {
         // 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;
+        const cached = this.overlayCache.get(tenantId);
+        if (cached !== undefined && Date.now() - cached.at < 30_000) {
+            return cached.overlay;
         }
-        this.overlayCache = await loadActionOverlayPg(this.pool);
-        this.overlayCacheAt = Date.now();
-        return this.overlayCache;
+        const overlay = await loadActionOverlayPg(this.pool, tenantId);
+        this.overlayCache.set(tenantId, { overlay, at: Date.now() });
+        return overlay;
     }
-    async getById(sessionId) {
+    async getById(tenantId, sessionId) {
+        const tc = tenantClausePg(tenantId, 2);
         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,
               classifier_provider, classifier_model, classifier_confidence,
               agent_persona, parent_session_id,
               primary_model, total_tokens, skill
-       FROM sessions WHERE id = $1`, [sessionId]);
+       FROM sessions WHERE id = $1 AND ${tc.sql}`, [sessionId, tc.param]);
         if (!result.rows[0])
             return null;
         const [entitiesMap, markersMap, edgesMap, overlay] = await Promise.all([
-            this.loadEntities([sessionId]),
+            this.loadEntities(tenantId, [sessionId]),
             this.loadMarkers([sessionId]),
             this.loadEdges([sessionId]),
-            this.overlay(),
+            this.overlay(tenantId),
         ]);
         const edges = edgesMap.get(sessionId);
         return rowToSession(result.rows[0], entitiesMap, markersMap, overlay, edges);
     }
-    async getByIds(ids) {
+    async getByIds(tenantId, ids) {
         if (ids.length === 0)
             return [];
         const placeholders = ids.map((_, i) => `$${i + 1}`).join(",");
+        const tc = tenantClausePg(tenantId, ids.length + 1);
         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
-       FROM sessions WHERE id IN (${placeholders})`, [...ids]);
+       FROM sessions WHERE id IN (${placeholders}) AND ${tc.sql}`, [...ids, tc.param]);
         if (result.rows.length === 0)
             return [];
         const foundIds = result.rows.map((r) => r.id);
         const [entitiesMap, markersMap, overlay] = await Promise.all([
-            this.loadEntities(foundIds),
+            this.loadEntities(tenantId, foundIds),
             this.loadMarkers(foundIds),
-            this.overlay(),
+            this.overlay(tenantId),
         ]);
         return result.rows.map((r) => rowToSession({ ...r, body: null }, entitiesMap, markersMap, overlay));
     }
-    async listByDateRange(fromIso, toIso) {
+    async listByDateRange(tenantId, fromIso, toIso) {
+        const tc = tenantClausePg(tenantId, 3);
         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]);
+       WHERE started_at < $1 AND (ended_at IS NULL OR ended_at >= $2) AND ${tc.sql}
+       ORDER BY started_at ASC`, [toIso, fromIso, tc.param]);
         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.loadEntities(tenantId, ids),
             this.loadMarkers(ids),
-            this.overlay(),
+            this.overlay(tenantId),
         ]);
         return result.rows.map((r) => rowToSession({ ...r, body: null }, entitiesMap, markersMap, overlay));
     }
-    async semanticSearch(queryVector, limit, opts) {
+    async semanticSearch(tenantId, queryVector, limit, opts) {
         const wsIds = opts?.workstreamIds;
         if (wsIds !== undefined && wsIds.length === 0)
             return [];
@@ -124,19 +145,24 @@ export class PgSessionStore {
             params.push(wsIds);
             wsClause = `AND s.workstream_id = ANY($${params.length}::text[])`;
         }
+        // Tenant filter is applied in the id-resolution join against `sessions`
+        // (program spec §4.3, vector-path rule) — the `<->` KNN scan over
+        // session_embedding_chunks has no tenant column of its own.
+        const tc = tenantClausePg(tenantId, params.length + 1, "s.tenant_id");
+        params.push(tc.param);
+        const limitParam = `$${params.length + 1}`;
         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}
+       WHERE ${tc.sql} ${wsClause}
        GROUP BY sec.session_id, s.status
        HAVING ${statusFilter}
        ORDER BY distance
        LIMIT ${limitParam}`, params);
         return result.rows.map((r) => ({ sessionId: r.session_id, distance: r.distance }));
     }
-    async keywordSearch(query, limit, opts) {
+    async keywordSearch(tenantId, query, limit, opts) {
         const wsIds = opts?.workstreamIds;
         if (wsIds !== undefined && wsIds.length === 0)
             return [];
@@ -154,6 +180,8 @@ export class PgSessionStore {
             params.push(wsIds);
             wsClause = `AND workstream_id = ANY($${params.length}::text[])`;
         }
+        const tc = tenantClausePg(tenantId, params.length + 1);
+        params.push(tc.param);
         params.push(k);
         const limitParam = `$${params.length}`;
         const result = await this.pool.query(`SELECT id AS session_id,
@@ -162,39 +190,46 @@ export class PgSessionStore {
        WHERE fts_vector @@ websearch_to_tsquery('english', $1)
          AND ${statusFilter}
          ${wsClause}
+         AND ${tc.sql}
        ORDER BY score DESC
        LIMIT ${limitParam}`, params);
         return result.rows.map((r) => ({ sessionId: r.session_id, score: r.score }));
     }
-    async resolveSuccessors(ids) {
+    async resolveSuccessors(tenantId, ids) {
         if (ids.length === 0)
             return new Map();
         const placeholders = ids.map((_, i) => `$${i + 1}`).join(",");
-        const result = await this.pool.query(`SELECT from_session, to_session FROM session_edges
-       WHERE kind = 'supersedes' AND to_session IN (${placeholders})`, [...ids]);
+        const tc = tenantClausePg(tenantId, ids.length + 1, "s.tenant_id");
+        const result = await this.pool.query(`SELECT se.from_session, se.to_session
+       FROM session_edges se
+       JOIN sessions s ON s.id = se.to_session
+       WHERE se.kind = 'supersedes' AND se.to_session IN (${placeholders}) AND ${tc.sql}`, [...ids, tc.param]);
         const out = new Map();
         for (const r of result.rows)
             out.set(r.to_session, r.from_session);
         return out;
     }
-    async updateStatus(sessionId, status) {
+    async updateStatus(tenantId, sessionId, status) {
         if (status === "idle") {
             throw new Error("Cannot persist derived status 'idle' — only active/closed/superseded");
         }
-        await this.pool.query("UPDATE sessions SET status = $1, updated_at = NOW() WHERE id = $2", [status, sessionId]);
+        const tc = tenantClausePg(tenantId, 3);
+        await this.pool.query(`UPDATE sessions SET status = $1, updated_at = NOW() WHERE id = $2 AND ${tc.sql}`, [status, sessionId, tc.param]);
     }
-    async markSuperseded(predecessorId, successorId) {
+    async markSuperseded(tenantId, predecessorId, successorId) {
         if (predecessorId === successorId) {
             throw new Error("A session cannot supersede itself");
         }
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
-            const predExists = await client.query("SELECT COUNT(*) AS c FROM sessions WHERE id = $1", [predecessorId]);
+            const predExistsTc = tenantClausePg(tenantId, 2);
+            const predExists = await client.query(`SELECT COUNT(*) AS c FROM sessions WHERE id = $1 AND ${predExistsTc.sql}`, [predecessorId, predExistsTc.param]);
             if (Number(predExists.rows[0]?.c) === 0) {
                 throw new Error(`predecessor session ${predecessorId} not found`);
             }
-            const succExists = await client.query("SELECT COUNT(*) AS c FROM sessions WHERE id = $1", [successorId]);
+            const succExistsTc = tenantClausePg(tenantId, 2);
+            const succExists = await client.query(`SELECT COUNT(*) AS c FROM sessions WHERE id = $1 AND ${succExistsTc.sql}`, [successorId, succExistsTc.param]);
             if (Number(succExists.rows[0]?.c) === 0) {
                 throw new Error(`successor session ${successorId} not found`);
             }
@@ -223,8 +258,12 @@ export class PgSessionStore {
             await client.query(`INSERT INTO session_edges (from_session, to_session, kind)
          VALUES ($1, $2, 'supersedes')
          ON CONFLICT DO NOTHING`, [successorId, predecessorId]);
-            await client.query("UPDATE sessions SET status = 'superseded', updated_at = NOW() WHERE id = $1", [predecessorId]);
-            // Cascade supersedence to facts in a single correlated UPDATE
+            const statusTc = tenantClausePg(tenantId, 2);
+            await client.query(`UPDATE sessions SET status = 'superseded', updated_at = NOW() WHERE id = $1 AND ${statusTc.sql}`, [predecessorId, statusTc.param]);
+            // Cascade supersedence to facts in a single correlated UPDATE, scoped to
+            // the caller's tenant on both sides of the join.
+            const sTc = tenantClausePg(tenantId, 3, "s.tenant_id");
+            const pTc = tenantClausePg(tenantId, 3, "p.tenant_id");
             const cascadeSQL = `
         UPDATE facts AS p
         SET superseded_by = (
@@ -233,18 +272,21 @@ export class PgSessionStore {
             AND s.subject = p.subject
             AND s.predicate = p.predicate
             AND s.superseded_by IS NULL
+            AND ${sTc.sql}
           LIMIT 1
         )
         WHERE p.source_session_id = $1
+          AND ${pTc.sql}
           AND EXISTS (
             SELECT 1 FROM facts s
             WHERE s.source_session_id = $2
               AND s.subject = p.subject
               AND s.predicate = p.predicate
               AND s.superseded_by IS NULL
+              AND ${sTc.sql}
           )
       `;
-            const cascaded = await client.query(cascadeSQL + " RETURNING p.id", [predecessorId, successorId]);
+            const cascaded = await client.query(cascadeSQL + " RETURNING p.id", [predecessorId, successorId, sTc.param]);
             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]);
@@ -259,43 +301,49 @@ export class PgSessionStore {
             client.release();
         }
     }
-    async getSessionScopeById(id) {
-        const r = await this.pool.query("SELECT scope FROM sessions WHERE id = $1", [id]);
+    async getSessionScopeById(tenantId, id) {
+        const tc = tenantClausePg(tenantId, 2);
+        const r = await this.pool.query(`SELECT scope FROM sessions WHERE id = $1 AND ${tc.sql}`, [id, tc.param]);
         return r.rows[0]?.scope ?? null;
     }
-    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 setWorkstreamBinding(tenantId, sessionId, workstreamId, source, confidence) {
+        const tc = tenantClausePg(tenantId, 5);
+        await this.pool.query(`UPDATE sessions SET workstream_id = $1, binding_source = $2, binding_confidence = $3, updated_at = NOW() WHERE id = $4 AND ${tc.sql}`, [workstreamId, source, confidence, sessionId, tc.param]);
     }
-    async listSessionIdsByWorkstreams(workstreamIds) {
+    async listSessionIdsByWorkstreams(tenantId, 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]);
+        const tc = tenantClausePg(tenantId, workstreamIds.length + 1);
+        const r = await this.pool.query(`SELECT id FROM sessions WHERE workstream_id IN (${ph}) AND ${tc.sql} ORDER BY started_at ASC`, [...workstreamIds, tc.param]);
         return r.rows.map((row) => row.id);
     }
-    async getEntities(sessionId) {
-        return (await this.loadEntities([sessionId])).get(sessionId) ?? [];
+    async getEntities(tenantId, sessionId) {
+        return (await this.loadEntities(tenantId, [sessionId])).get(sessionId) ?? [];
     }
-    async getWorkstreamIds(sessionIds) {
+    async getWorkstreamIds(tenantId, 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]);
+        const tc = tenantClausePg(tenantId, sessionIds.length + 1);
+        const result = await this.pool.query(`SELECT id, workstream_id FROM sessions WHERE id IN (${ph}) AND ${tc.sql}`, [...sessionIds, tc.param]);
         for (const r of result.rows)
             out.set(r.id, r.workstream_id);
         return out;
     }
-    async recentWrites(limit) {
+    async recentWrites(tenantId, limit) {
+        const tc = tenantClausePg(tenantId, 2);
         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]);
+       FROM sessions WHERE ${tc.sql} ORDER BY created_at DESC LIMIT $1`, [limit, tc.param]);
         if (result.rows.length === 0)
             return [];
         const ids = result.rows.map((r) => r.id);
+        const entTc = tenantClausePg(tenantId, 2);
         const entityResult = await this.pool.query(`SELECT session_id, entity_canonical
        FROM session_entities
-       WHERE session_id = ANY($1)
-       ORDER BY entity_canonical`, [ids]);
+       WHERE session_id = ANY($1) AND ${entTc.sql}
+       ORDER BY entity_canonical`, [ids, entTc.param]);
         const byId = new Map();
         for (const e of entityResult.rows) {
             const list = byId.get(e.session_id);
@@ -306,15 +354,17 @@ export class PgSessionStore {
         }
         return result.rows.map((r) => ({ ...r, entities: byId.get(r.id) ?? [] }));
     }
-    async recentMarkers(limit) {
+    async recentMarkers(tenantId, limit) {
+        const tc = tenantClausePg(tenantId, 2, "s.tenant_id");
         const result = await this.pool.query(`SELECT m.session_id AS "sessionId", m.kind, m.text, s.label, s.created_at AS "createdAt"
        FROM markers m
        JOIN sessions s ON s.id = m.session_id
+       WHERE ${tc.sql}
        ORDER BY s.created_at DESC, m.position ASC
-       LIMIT $1`, [limit]);
+       LIMIT $1`, [limit, tc.param]);
         return result.rows;
     }
-    async insertSession(record, embedder = null, supersedes = null, factSink = null) {
+    async insertSession(tenantId, record, embedder = null, supersedes = null, factSink = null) {
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
@@ -324,8 +374,8 @@ export class PgSessionStore {
            transcript_offset, transcript_length,
            classifier_provider, classifier_model, classifier_confidence,
            scope, agent_persona, parent_session_id,
-           primary_model, total_tokens, skill
-         ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23)
+           primary_model, total_tokens, skill, tenant_id
+         ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24)
          ON CONFLICT (id) DO UPDATE SET
            ended_at = EXCLUDED.ended_at,
            duration_min = EXCLUDED.duration_min,
@@ -358,6 +408,7 @@ export class PgSessionStore {
                 record.primaryModel ?? null,
                 record.totalTokens ?? null,
                 record.skill ?? null,
+                tenantId,
             ]);
             await client.query("DELETE FROM markers WHERE session_id = $1", [record.id]);
             for (let i = 0; i < record.decisions.length; i++) {
@@ -373,36 +424,43 @@ export class PgSessionStore {
             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 variantTc = tenantClausePg(tenantId, 1);
+            const variantRes = await client.query(`SELECT variant, canonical FROM entity_variants WHERE ${variantTc.sql} AND variant = ANY($2)`, [variantTc.param, 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 oldTc = tenantClausePg(tenantId, 1);
+            const oldRes = await client.query(`SELECT entity_canonical FROM session_entities WHERE ${oldTc.sql} AND session_id = $2`, [oldTc.param, 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]);
+            const deleteTc = tenantClausePg(tenantId, 1);
+            await client.query(`DELETE FROM session_entities WHERE ${deleteTc.sql} AND session_id = $2`, [deleteTc.param, 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 NOTHING`, [name, record.id]);
+                const insertTc = tenantClausePg(tenantId, 1);
+                await client.query(`INSERT INTO entities (tenant_id, canonical, type, status, source, first_seen_session, last_seen_session, session_count)
+           VALUES ($1, $2, 'candidate', 'candidate', 'auto-detected', $3, $3, 0)
+           ON CONFLICT (tenant_id, canonical) DO NOTHING`, [insertTc.param, 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]);
+                    const touchTc = tenantClausePg(tenantId, 2);
+                    await client.query(`UPDATE entities SET last_seen_session = $1, updated_at = NOW() WHERE ${touchTc.sql} AND canonical = $3`, [record.id, touchTc.param, name]);
                 }
-                await client.query("INSERT INTO session_entities (session_id, entity_canonical) VALUES ($1, $2)", [record.id, name]);
+                await client.query("INSERT INTO session_entities (tenant_id, session_id, entity_canonical) VALUES ($1, $2, $3)", [tenantId, 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]);
+                const recomputeTc = tenantClausePg(tenantId, 2);
+                await client.query(`UPDATE entities SET session_count = (SELECT COUNT(*) FROM session_entities WHERE ${recomputeTc.sql} AND entity_canonical = $1), updated_at = NOW() WHERE ${recomputeTc.sql} AND canonical = $1`, [name, recomputeTc.param]);
             }
             if (supersedes && supersedes.priorSessionId !== record.id) {
                 const predecessorStatus = supersedes.kind === "replaces" ? "replaced" : "superseded";
                 await client.query(`INSERT INTO session_edges (from_session, to_session, kind)
            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]);
+                const predStatusTc = tenantClausePg(tenantId, 3);
+                await client.query(`UPDATE sessions SET status = $1, updated_at = NOW() WHERE id = $2 AND ${predStatusTc.sql}`, [predecessorStatus, supersedes.priorSessionId, predStatusTc.param]);
             }
             else {
-                const priorId = await findContinuesPredecessorPg(client, record.id, record.entities);
+                const priorId = await findContinuesPredecessorPg(client, tenantId, 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]);
@@ -410,7 +468,7 @@ export class PgSessionStore {
             }
             // 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, record.scope);
+                await ingestSessionFactsOnClient(client, tenantId, record.id, factSink.facts, record.scope);
             }
             await client.query("COMMIT");
         }
@@ -437,6 +495,7 @@ export class PgSessionStore {
                     await this.pool.query("INSERT INTO session_chunk_map (chunk_id, session_id, chunk_idx) VALUES ($1, $2, $3)", [chunkId, record.id, chunkIdx]);
                 }
                 catch (err) {
+                    recordEmbedFailure("chunk");
                     process.stderr.write(`[nlm] embedding chunk failed session=${record.id} chunk=${chunkIdx}: ${String(err)}\n`);
                 }
             }
@@ -450,27 +509,30 @@ export class PgSessionStore {
                         continue;
                     try {
                         const { vector } = await embedder.embed(factText, "document");
-                        await factSink.factStore.upsertEmbedding(fact.id, vector);
+                        await factSink.factStore.upsertEmbedding(tenantId, fact.id, vector);
                     }
-                    catch {
-                        // Tolerated; see comment above.
+                    catch (err) {
+                        // Tolerated; the fact row stays current, semantic recall misses
+                        // it until a future re-ingest.
+                        recordEmbedFailure("fact");
+                        process.stderr.write(`[nlm] embedding fact failed fact=${fact.id}: ${String(err)}\n`);
                     }
                 }
             }
         }
     }
-    async insertSessionForTest(session) {
+    async insertSessionForTest(session, tenantId = DEFAULT_TEAM_ID) {
         const status = session.status === "idle" ? "active" : session.status;
         await this.pool.query(`INSERT INTO sessions (id, runtime, runtime_session_id, started_at, ended_at,
-         duration_min, label, summary, body, status, transcript_kind, transcript_path)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+         duration_min, label, summary, body, status, transcript_kind, transcript_path, tenant_id)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
             session.id, session.runtime, session.runtimeSessionId, session.startedAt,
             session.endedAt, session.durationMin, session.label, session.summary,
-            session.body, status, session.transcriptKind, session.transcriptPath,
+            session.body, status, session.transcriptKind, session.transcriptPath, tenantId,
         ]);
         for (const e of session.entities) {
-            await this.pool.query("INSERT INTO entities (canonical, type, status) VALUES ($1, 'candidate', 'active') ON CONFLICT DO NOTHING", [e]);
-            await this.pool.query("INSERT INTO session_entities (session_id, entity_canonical) VALUES ($1, $2) ON CONFLICT DO NOTHING", [session.id, e]);
+            await this.pool.query("INSERT INTO entities (tenant_id, canonical, type, status) VALUES ($1, $2, 'candidate', 'active') ON CONFLICT DO NOTHING", [tenantId, e]);
+            await this.pool.query("INSERT INTO session_entities (tenant_id, session_id, entity_canonical) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING", [tenantId, session.id, e]);
         }
         for (let i = 0; i < session.decisions.length; i++) {
             await this.pool.query("INSERT INTO markers (session_id, kind, text, position) VALUES ($1, 'decision', $2, $3)", [session.id, session.decisions[i], i]);
@@ -480,32 +542,41 @@ export class PgSessionStore {
         }
     }
     /** PG counterpart of SqliteSessionStore.listBackfillCandidates. */
-    async listBackfillCandidates(filter) {
+    async listBackfillCandidates(tenantId, filter) {
         const params = [filter.cutoff];
         let fromClause = "";
         if (filter.from) {
             params.push(filter.from);
             fromClause = `AND s.id > $${params.length}`;
         }
+        // facts.tenant_id is always stamped to match its source_session_id's
+        // session tenant (every write site stamps both together), so scoping by
+        // source_session_id = s.id against an already tenant-filtered `s` is
+        // already sufficient. The f.tenant_id = s.tenant_id condition below is
+        // defense in depth (guard test C4 permits column-to-column tenant
+        // equality as a join form).
         const existingFactsClause = filter.reprocess
             ? ""
-            : "AND NOT EXISTS (SELECT 1 FROM facts f WHERE f.source_session_id = s.id)";
+            : "AND NOT EXISTS (SELECT 1 FROM facts f WHERE f.source_session_id = s.id AND f.tenant_id = s.tenant_id)";
+        const tc = tenantClausePg(tenantId, params.length + 1, "s.tenant_id");
+        params.push(tc.param);
         const result = await this.pool.query(`SELECT s.id, s.started_at, s.body FROM sessions s
        WHERE s.started_at < $1 AND s.body IS NOT NULL AND length(s.body) > 0
          ${existingFactsClause}
          ${fromClause}
+         AND ${tc.sql}
        ORDER BY s.started_at ASC, s.id ASC`, params);
         return result.rows.map((r) => ({ id: r.id, startedAt: r.started_at, body: r.body }));
     }
     /** PG counterpart of SqliteSessionStore.insertFactsForSession — writes facts
      *  for an EXISTING session row (deterministic supersedence + best-effort
      *  embeddings) in one transaction. Used by the fact backfill. */
-    async insertFactsForSession(sessionId, factStore, facts, embedder = null) {
-        const sessionScope = await this.getSessionScopeById(sessionId);
+    async insertFactsForSession(tenantId, sessionId, factStore, facts, embedder = null) {
+        const sessionScope = await this.getSessionScopeById(tenantId, sessionId);
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
-            await ingestSessionFactsOnClient(client, sessionId, facts, sessionScope);
+            await ingestSessionFactsOnClient(client, tenantId, sessionId, facts, sessionScope);
             await client.query("COMMIT");
         }
         catch (err) {
@@ -522,7 +593,7 @@ export class PgSessionStore {
                     continue;
                 try {
                     const { vector } = await embedder.embed(factText, "document");
-                    await factStore.upsertEmbedding(fact.id, vector);
+                    await factStore.upsertEmbedding(tenantId, fact.id, vector);
                 }
                 catch {
                     // Best-effort; a per-fact embed failure leaves the fact current but
@@ -531,12 +602,13 @@ export class PgSessionStore {
             }
         }
     }
-    async loadEntities(ids) {
+    async loadEntities(tenantId, ids) {
         if (ids.length === 0)
             return new Map();
         const placeholders = ids.map((_, i) => `$${i + 1}`).join(",");
+        const tc = tenantClausePg(tenantId, ids.length + 1);
         const result = await this.pool.query(`SELECT session_id, entity_canonical FROM session_entities
-       WHERE session_id IN (${placeholders}) ORDER BY session_id`, [...ids]);
+       WHERE session_id IN (${placeholders}) AND ${tc.sql} ORDER BY session_id`, [...ids, tc.param]);
         const out = new Map();
         for (const r of result.rows) {
             const list = out.get(r.session_id);