hippo-memory 1.60.0 → 1.61.0

package/dist/db/migrations/v14.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v14: Migration;
+//# sourceMappingURL=v14.d.ts.map

package/dist/db/migrations/v14.js

@@ -0,0 +1,66 @@
+import { tableHasColumn } from '../tables.js';
+export const v14 = {
+    version: 14,
+    up: (db) => {
+        // A3 provenance envelope: kind, scope, owner, artifact_ref.
+        // SQLite ALTER TABLE ADD COLUMN cannot add CHECK; CHECK enforcement lives
+        // in INSERT/UPDATE triggers added later in this migration.
+        if (!tableHasColumn(db, 'memories', 'kind')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN kind TEXT DEFAULT 'distilled'`);
+        }
+        if (!tableHasColumn(db, 'memories', 'scope')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN scope TEXT`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope) WHERE scope IS NOT NULL`);
+        }
+        if (!tableHasColumn(db, 'memories', 'owner')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN owner TEXT`);
+        }
+        if (!tableHasColumn(db, 'memories', 'artifact_ref')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN artifact_ref TEXT`);
+        }
+        // Backfill kind for any rows where it's NULL (pre-migration data).
+        db.exec(`UPDATE memories SET kind = 'superseded' WHERE kind IS NULL AND superseded_by IS NOT NULL`);
+        db.exec(`UPDATE memories SET kind = 'distilled' WHERE kind IS NULL`);
+        // raw_archive: legitimate path for kind='raw' removal (used by archiveRawMemory).
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS raw_archive (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          memory_id TEXT NOT NULL,
+          archived_at TEXT NOT NULL,
+          reason TEXT NOT NULL,
+          archived_by TEXT,
+          payload_json TEXT NOT NULL
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_raw_archive_memory_id ON raw_archive(memory_id)`);
+        // Append-only invariant: kind='raw' rows cannot be deleted directly.
+        // Use raw_archive flow: archive-then-update-then-delete (see src/raw-archive.ts).
+        db.exec(`
+        CREATE TRIGGER IF NOT EXISTS trg_memories_raw_append_only
+        BEFORE DELETE ON memories
+        WHEN OLD.kind = 'raw'
+        BEGIN
+          SELECT RAISE(ABORT, 'raw is append-only');
+        END
+      `);
+        // CHECK substitute: ALTER TABLE cannot add CHECK, so enforce kind allowed-set
+        // via INSERT/UPDATE triggers.
+        db.exec(`
+        CREATE TRIGGER IF NOT EXISTS trg_memories_kind_check_insert
+        BEFORE INSERT ON memories
+        WHEN NEW.kind IS NOT NULL AND NEW.kind NOT IN ('raw','distilled','superseded','archived')
+        BEGIN
+          SELECT RAISE(ABORT, 'invalid kind: must be raw|distilled|superseded|archived');
+        END
+      `);
+        db.exec(`
+        CREATE TRIGGER IF NOT EXISTS trg_memories_kind_check_update
+        BEFORE UPDATE ON memories
+        WHEN NEW.kind IS NOT NULL AND NEW.kind NOT IN ('raw','distilled','superseded','archived')
+        BEGIN
+          SELECT RAISE(ABORT, 'invalid kind: must be raw|distilled|superseded|archived');
+        END
+      `);
+    },
+};
+//# sourceMappingURL=v14.js.map

package/dist/db/migrations/v15.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v15: Migration;
+//# sourceMappingURL=v15.d.ts.map

package/dist/db/migrations/v15.js

@@ -0,0 +1,42 @@
+export const v15 = {
+    version: 15,
+    up: (db) => {
+        // A3 hardening (post-review): close the NULL-kind bypass and add raw_archive
+        // dedup safety. Both findings landed in /review on commits 41b1f4d..6456e7d.
+        //
+        // (1) Original v14 triggers used `WHEN NEW.kind IS NOT NULL AND NEW.kind NOT IN (...)`.
+        //     A direct INSERT/UPDATE setting kind=NULL bypassed the CHECK substitute. Replace
+        //     with `WHEN NEW.kind IS NULL OR NEW.kind NOT IN (...)` so NULL is rejected too.
+        // (2) Add UNIQUE(memory_id, archived_at) to raw_archive so re-archiving the same id
+        //     in the same instant cannot produce ambiguous audit rows. Per-id history is still
+        //     allowed (different timestamps).
+        db.exec(`DROP TRIGGER IF EXISTS trg_memories_kind_check_insert`);
+        db.exec(`DROP TRIGGER IF EXISTS trg_memories_kind_check_update`);
+        db.exec(`
+        CREATE TRIGGER trg_memories_kind_check_insert
+        BEFORE INSERT ON memories
+        WHEN NEW.kind IS NULL OR NEW.kind NOT IN ('raw','distilled','superseded','archived')
+        BEGIN
+          SELECT RAISE(ABORT, 'invalid kind: must be raw|distilled|superseded|archived (not null)');
+        END
+      `);
+        db.exec(`
+        CREATE TRIGGER trg_memories_kind_check_update
+        BEFORE UPDATE ON memories
+        WHEN NEW.kind IS NULL OR NEW.kind NOT IN ('raw','distilled','superseded','archived')
+        BEGIN
+          SELECT RAISE(ABORT, 'invalid kind: must be raw|distilled|superseded|archived (not null)');
+        END
+      `);
+        // Defensive: any rows that somehow have NULL kind get fixed (shouldn't exist post-v14
+        // backfill, but cheap insurance).
+        db.exec(`UPDATE memories SET kind = 'distilled' WHERE kind IS NULL`);
+        // raw_archive uniqueness. SQLite cannot ADD CONSTRAINT, but a partial unique index
+        // on (memory_id, archived_at) is equivalent for INSERT-time enforcement.
+        db.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_raw_archive_id_at
+        ON raw_archive(memory_id, archived_at)
+      `);
+    },
+};
+//# sourceMappingURL=v15.js.map

package/dist/db/migrations/v16.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v16: Migration;
+//# sourceMappingURL=v16.d.ts.map

package/dist/db/migrations/v16.js

@@ -0,0 +1,61 @@
+import { tableHasColumn } from '../tables.js';
+export const v16 = {
+    version: 16,
+    up: (db) => {
+        // A5 stub auth: add tenant_id to all data tables. Single-tenant per deployment;
+        // multi-tenant enforcement deferred to v2 (full A5). The columns are needed now
+        // so future B-track tables don't have to backfill.
+        if (!tableHasColumn(db, 'memories', 'tenant_id')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'working_memory', 'tenant_id')) {
+            db.exec(`ALTER TABLE working_memory ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'consolidation_runs', 'tenant_id')) {
+            db.exec(`ALTER TABLE consolidation_runs ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'task_snapshots', 'tenant_id')) {
+            db.exec(`ALTER TABLE task_snapshots ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'memory_conflicts', 'tenant_id')) {
+            db.exec(`ALTER TABLE memory_conflicts ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        // Composite indexes for recall hot paths. Leading column is tenant_id so
+        // single-tenant lookups are O(log n).
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_tenant_created ON memories(tenant_id, created)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_working_memory_tenant ON working_memory(tenant_id, importance DESC, created_at DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_consolidation_runs_tenant_ts ON consolidation_runs(tenant_id, timestamp DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_status ON task_snapshots(tenant_id, status, updated_at DESC)`);
+        // A5 stub auth: api_keys (scrypt-hashed; plaintext returned to caller exactly once)
+        // and audit_log (append-only mutation trail). Both carry tenant_id from day 1 so
+        // future multi-tenant enforcement is a config flip, not a re-migration.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS api_keys (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          key_id TEXT UNIQUE NOT NULL,
+          key_hash TEXT NOT NULL,
+          tenant_id TEXT NOT NULL DEFAULT 'default',
+          label TEXT,
+          created_at TEXT NOT NULL,
+          revoked_at TEXT
+        )
+      `);
+        db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_api_keys_tenant_active
+        ON api_keys(tenant_id) WHERE revoked_at IS NULL
+      `);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS audit_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts TEXT NOT NULL,
+          tenant_id TEXT NOT NULL DEFAULT 'default',
+          actor TEXT NOT NULL,
+          op TEXT NOT NULL,
+          target_id TEXT,
+          metadata_json TEXT NOT NULL DEFAULT '{}'
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_audit_log_tenant_ts ON audit_log(tenant_id, ts DESC)`);
+    },
+};
+//# sourceMappingURL=v16.js.map

package/dist/db/migrations/v17.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v17: Migration;
+//# sourceMappingURL=v17.d.ts.map

package/dist/db/migrations/v17.js

@@ -0,0 +1,46 @@
+export const v17 = {
+    version: 17,
+    up: (db) => {
+        // E1.3 Slack ingestion: idempotency log, per-channel backfill cursors, DLQ.
+        // See docs/plans/2026-04-29-e1.3-slack-ingestion.md.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS slack_event_log (
+          event_id TEXT PRIMARY KEY,
+          ingested_at TEXT NOT NULL,
+          memory_id TEXT
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_slack_event_log_memory ON slack_event_log(memory_id) WHERE memory_id IS NOT NULL`);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS slack_cursors (
+          tenant_id TEXT NOT NULL,
+          channel_id TEXT NOT NULL,
+          latest_ts TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (tenant_id, channel_id)
+        )
+      `);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS slack_dlq (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          tenant_id TEXT NOT NULL,
+          raw_payload TEXT NOT NULL,
+          error TEXT NOT NULL,
+          received_at TEXT NOT NULL,
+          retried_at TEXT
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_slack_dlq_tenant_received ON slack_dlq(tenant_id, received_at)`);
+        // Multi-tenant routing seam (review patch #6). Empty by default — single-
+        // tenant deployments resolve via HIPPO_TENANT fallback. Multi-workspace
+        // deployments populate this table to map team_id → tenant_id.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS slack_workspaces (
+          team_id TEXT PRIMARY KEY,
+          tenant_id TEXT NOT NULL,
+          added_at TEXT NOT NULL
+        )
+      `);
+    },
+};
+//# sourceMappingURL=v17.js.map

package/dist/db/migrations/v18.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v18: Migration;
+//# sourceMappingURL=v18.d.ts.map

package/dist/db/migrations/v18.js

@@ -0,0 +1,60 @@
+export const v18 = {
+    version: 18,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS goal_stack (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          tenant_id TEXT NOT NULL DEFAULT 'default',
+          goal_name TEXT NOT NULL,
+          level INTEGER NOT NULL DEFAULT 0
+            CHECK (level BETWEEN 0 AND 2),
+          parent_goal_id TEXT REFERENCES goal_stack(id) ON DELETE SET NULL,
+          status TEXT NOT NULL CHECK (status IN ('active','suspended','completed')),
+          success_condition TEXT,
+          retrieval_policy_id TEXT,
+          created_at TEXT NOT NULL,
+          completed_at TEXT,
+          outcome_score REAL
+            CHECK (outcome_score IS NULL OR (outcome_score >= 0 AND outcome_score <= 1))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_goal_stack_tenant_session_status
+          ON goal_stack(tenant_id, session_id, status, created_at);
+
+        CREATE TABLE IF NOT EXISTS retrieval_policy (
+          id TEXT PRIMARY KEY,
+          goal_id TEXT NOT NULL REFERENCES goal_stack(id) ON DELETE CASCADE,
+          policy_type TEXT NOT NULL CHECK (policy_type IN
+            ('schema-fit-biased','error-prioritized','recency-first','hybrid')),
+          weight_schema_fit REAL NOT NULL DEFAULT 1.0
+            CHECK (weight_schema_fit >= 0 AND weight_schema_fit <= 100),
+          weight_recency REAL NOT NULL DEFAULT 1.0
+            CHECK (weight_recency >= 0 AND weight_recency <= 100),
+          weight_outcome REAL NOT NULL DEFAULT 1.0
+            CHECK (weight_outcome >= 0 AND weight_outcome <= 100),
+          error_priority REAL NOT NULL DEFAULT 1.0
+            CHECK (error_priority >= 0 AND error_priority <= 100)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_retrieval_policy_goal
+          ON retrieval_policy(goal_id);
+
+        CREATE TABLE IF NOT EXISTS goal_recall_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          goal_id TEXT NOT NULL REFERENCES goal_stack(id) ON DELETE CASCADE,
+          memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          tenant_id TEXT NOT NULL DEFAULT 'default',
+          session_id TEXT NOT NULL,
+          recalled_at TEXT NOT NULL,
+          score REAL NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_goal_recall_log_goal
+          ON goal_recall_log(goal_id);
+        CREATE UNIQUE INDEX IF NOT EXISTS uniq_goal_recall_log_memory_goal
+          ON goal_recall_log(memory_id, goal_id);
+      `);
+    },
+};
+//# sourceMappingURL=v18.js.map

package/dist/db/migrations/v19.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v19: Migration;
+//# sourceMappingURL=v19.d.ts.map

package/dist/db/migrations/v19.js

@@ -0,0 +1,28 @@
+import { tableHasColumn } from '../tables.js';
+export const v19 = {
+    version: 19,
+    up: (db) => {
+        // v0.39 commit 3 (Slack hardening): widen slack_dlq with bucketing,
+        // retry tracking, and the signature/timestamp pair that lets `hippo
+        // slack dlq replay` re-verify before re-running ingest. ALTER ADD
+        // COLUMN with DEFAULT is non-destructive — legacy rows take the
+        // default values. Idempotent via tableHasColumn().
+        if (!tableHasColumn(db, 'slack_dlq', 'team_id')) {
+            db.exec(`ALTER TABLE slack_dlq ADD COLUMN team_id TEXT`);
+        }
+        if (!tableHasColumn(db, 'slack_dlq', 'bucket')) {
+            db.exec(`ALTER TABLE slack_dlq ADD COLUMN bucket TEXT NOT NULL DEFAULT 'parse_error'`);
+            // SQLite ALTER TABLE cannot add CHECK; bucket value enforcement is app-level.
+        }
+        if (!tableHasColumn(db, 'slack_dlq', 'retry_count')) {
+            db.exec(`ALTER TABLE slack_dlq ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0`);
+        }
+        if (!tableHasColumn(db, 'slack_dlq', 'signature')) {
+            db.exec(`ALTER TABLE slack_dlq ADD COLUMN signature TEXT`);
+        }
+        if (!tableHasColumn(db, 'slack_dlq', 'slack_timestamp')) {
+            db.exec(`ALTER TABLE slack_dlq ADD COLUMN slack_timestamp TEXT`);
+        }
+    },
+};
+//# sourceMappingURL=v19.js.map

package/dist/db/migrations/v20.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v20: Migration;
+//# sourceMappingURL=v20.d.ts.map

package/dist/db/migrations/v20.js

@@ -0,0 +1,42 @@
+export const v20 = {
+    version: 20,
+    up: (db) => {
+        // v0.39 commit 4 (GDPR Path A backfill): redact every existing
+        // raw_archive.payload_json so historical archives match the new
+        // metadata-only contract from src/raw-archive.ts. Read each row, parse
+        // the existing JSON to extract tenant_id and kind (best effort), then
+        // UPDATE with the redacted shape. Rows with unparseable legacy JSON get
+        // redacted with tenant_id='unknown', kind='unknown'. The audit_log
+        // remains the compliance record.
+        // SAFETY: rows' shape matches the four columns named in the SELECT above.
+        const rows = db
+            .prepare(`SELECT id, archived_at, reason, payload_json FROM raw_archive`)
+            .all();
+        const update = db.prepare(`UPDATE raw_archive SET payload_json = ? WHERE id = ?`);
+        for (const row of rows) {
+            let tenant = 'unknown';
+            let kind = 'unknown';
+            try {
+                // SAFETY: parsed is a best-effort JSON.parse of legacy payload_json;
+                // an unexpected shape only yields undefined fields (falling back to
+                // 'unknown' below), and a parse failure is caught, so this never crashes.
+                const parsed = JSON.parse(row.payload_json);
+                tenant = parsed.tenant_id ?? 'unknown';
+                kind = parsed.kind ?? 'unknown';
+            }
+            catch {
+                // Unparseable legacy payload — redact with unknowns.
+            }
+            const redacted = JSON.stringify({
+                redacted: true,
+                archived_at: row.archived_at,
+                tenant_id: tenant,
+                kind,
+                reason: row.reason,
+                migration: 'v20_redact',
+            });
+            update.run(redacted, row.id);
+        }
+    },
+};
+//# sourceMappingURL=v20.js.map

package/dist/db/migrations/v21.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v21: Migration;
+//# sourceMappingURL=v21.d.ts.map

package/dist/db/migrations/v21.js

@@ -0,0 +1,16 @@
+import { tableHasColumn } from '../tables.js';
+export const v21 = {
+    version: 21,
+    up: (db) => {
+        // v0.39 codex round 3: per-row mirror cleanup tracking. Replaces the
+        // global gdpr_v20_mirror_cleanup meta gate (which made the reaper
+        // one-shot and silently swallowed failed unlinks). With this column the
+        // reaper processes only rows WHERE mirror_cleaned_at IS NULL, sets the
+        // timestamp on success, and leaves it NULL on any unlink failure so the
+        // next openHippoDb retries automatically.
+        if (!tableHasColumn(db, 'raw_archive', 'mirror_cleaned_at')) {
+            db.exec(`ALTER TABLE raw_archive ADD COLUMN mirror_cleaned_at TEXT`);
+        }
+    },
+};
+//# sourceMappingURL=v21.js.map

package/dist/db/migrations/v22.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v22: Migration;
+//# sourceMappingURL=v22.d.ts.map

package/dist/db/migrations/v22.js

@@ -0,0 +1,82 @@
+import { tableHasColumn } from '../tables.js';
+export const v22 = {
+    version: 22,
+    up: (db) => {
+        // Tenant-isolation gap on continuity tables (codex review 2026-05-02).
+        // session_events and session_handoffs predate the v16 tenant migration
+        // and were never added to it, so the v0.40.0 provenance gate work
+        // exposed a real cross-tenant leak when continuity primitives are used.
+        // Adds tenant_id (NOT NULL DEFAULT 'default') with smart backfill from
+        // task_snapshots.session_id when unambiguous, plus an optional scope
+        // column so a private-channel-derived handoff can default-deny via the
+        // same rule recall already enforces.
+        //
+        // Self-heal partial-init stores: re-run the v4/v5 CREATE TABLE IF NOT
+        // EXISTS bodies before ALTERing. A silent skip would otherwise stamp
+        // schema_version=22 on a DB missing the underlying tables, leaving
+        // them permanently absent.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS session_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          task TEXT,
+          event_type TEXT NOT NULL,
+          content TEXT NOT NULL,
+          source TEXT NOT NULL,
+          metadata_json TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS session_handoffs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          repo_root TEXT,
+          task_id TEXT,
+          summary TEXT NOT NULL,
+          next_action TEXT,
+          artifacts_json TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL
+        );
+      `);
+        if (!tableHasColumn(db, 'session_events', 'tenant_id')) {
+            db.exec(`ALTER TABLE session_events ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'session_events', 'scope')) {
+            db.exec(`ALTER TABLE session_events ADD COLUMN scope TEXT`);
+        }
+        if (!tableHasColumn(db, 'session_handoffs', 'tenant_id')) {
+            db.exec(`ALTER TABLE session_handoffs ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        if (!tableHasColumn(db, 'session_handoffs', 'scope')) {
+            db.exec(`ALTER TABLE session_handoffs ADD COLUMN scope TEXT`);
+        }
+        // Smart backfill: rows whose session_id maps to exactly one tenant in
+        // task_snapshots inherit that tenant. Ambiguous or unmapped rows stay
+        // at the column default ('default'). Conservative: never crosses
+        // tenant boundaries on guesses. The COUNT(DISTINCT) gate is the load-
+        // bearing check; without it, rows with multiple tenants under the same
+        // session_id would silently pick whichever group came first.
+        db.exec(`
+        UPDATE session_events
+           SET tenant_id = (
+             SELECT MAX(t.tenant_id) FROM task_snapshots t
+              WHERE t.session_id = session_events.session_id
+           )
+         WHERE tenant_id = 'default'
+           AND (SELECT COUNT(DISTINCT t.tenant_id) FROM task_snapshots t
+                 WHERE t.session_id = session_events.session_id) = 1
+      `);
+        db.exec(`
+        UPDATE session_handoffs
+           SET tenant_id = (
+             SELECT MAX(t.tenant_id) FROM task_snapshots t
+              WHERE t.session_id = session_handoffs.session_id
+           )
+         WHERE tenant_id = 'default'
+           AND (SELECT COUNT(DISTINCT t.tenant_id) FROM task_snapshots t
+                 WHERE t.session_id = session_handoffs.session_id) = 1
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_events_tenant_session ON session_events(tenant_id, session_id, created_at DESC, id DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_session ON session_handoffs(tenant_id, session_id, created_at DESC)`);
+    },
+};
+//# sourceMappingURL=v22.js.map

package/dist/db/migrations/v23.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v23: Migration;
+//# sourceMappingURL=v23.d.ts.map

package/dist/db/migrations/v23.js

@@ -0,0 +1,48 @@
+import { tableHasColumn, tableExists } from '../tables.js';
+export const v23 = {
+    version: 23,
+    up: (db) => {
+        // task_snapshots: add scope so all three continuity tables carry it.
+        // Self-heal partial-init stores via CREATE TABLE IF NOT EXISTS (the v22
+        // session_events / session_handoffs healing is upstream).
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS task_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          next_step TEXT NOT NULL,
+          status TEXT NOT NULL,
+          source TEXT NOT NULL,
+          session_id TEXT,
+          tenant_id TEXT NOT NULL DEFAULT 'default',
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+        if (!tableHasColumn(db, 'task_snapshots', 'scope')) {
+            db.exec(`ALTER TABLE task_snapshots ADD COLUMN scope TEXT`);
+        }
+        // Quarantine policy (codex round 1 P1): pre-existing continuity rows
+        // with NULL scope cannot be safely classified as public after the fact.
+        // Mark them 'unknown:legacy' so the api.recall + cmdRecall default-deny
+        // filter excludes them for no-scope callers. Fresh rows from new
+        // writers carry NULL when scope is unspecified (legitimate non-Slack
+        // writes); the 'unknown:legacy' marker is a v23-only one-shot for
+        // pre-upgrade rows.
+        //
+        // Run UPDATEs only on tables that exist (some test paths and edge stores
+        // skip v22's table healing). The UPDATEs are themselves idempotent via
+        // the WHERE scope IS NULL clause, so re-running is a no-op.
+        if (tableExists(db, 'task_snapshots')) {
+            db.exec(`UPDATE task_snapshots SET scope = 'unknown:legacy' WHERE scope IS NULL`);
+        }
+        if (tableExists(db, 'session_events')) {
+            db.exec(`UPDATE session_events SET scope = 'unknown:legacy' WHERE scope IS NULL`);
+        }
+        if (tableExists(db, 'session_handoffs')) {
+            db.exec(`UPDATE session_handoffs SET scope = 'unknown:legacy' WHERE scope IS NULL`);
+        }
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_scope ON task_snapshots(tenant_id, scope, status)`);
+    },
+};
+//# sourceMappingURL=v23.js.map

package/dist/db/migrations/v24.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v24: Migration;
+//# sourceMappingURL=v24.d.ts.map

package/dist/db/migrations/v24.js

@@ -0,0 +1,72 @@
+export const v24 = {
+    version: 24,
+    up: (db) => {
+        // v1.3.0 GitHub connector schema (codex round 1, 2026-05-04).
+        // Six tables + a min_compatible_binary meta row for rollback safety.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS github_event_log (
+          idempotency_key TEXT PRIMARY KEY,
+          delivery_id TEXT NOT NULL,
+          event_name TEXT NOT NULL,
+          ingested_at TEXT NOT NULL,
+          memory_id TEXT
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_github_event_log_memory ON github_event_log(memory_id) WHERE memory_id IS NOT NULL`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_github_event_log_delivery ON github_event_log(delivery_id)`);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS github_cursors (
+          tenant_id TEXT NOT NULL,
+          repo_full_name TEXT NOT NULL,
+          issues_hwm TEXT,
+          issue_comments_hwm TEXT,
+          pr_review_comments_hwm TEXT,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (tenant_id, repo_full_name)
+        )
+      `);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS github_dlq (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          tenant_id TEXT NOT NULL,
+          raw_payload TEXT NOT NULL,
+          error TEXT NOT NULL,
+          event_name TEXT,
+          delivery_id TEXT,
+          signature TEXT,
+          installation_id TEXT,
+          repo_full_name TEXT,
+          retry_count INTEGER NOT NULL DEFAULT 0,
+          received_at TEXT NOT NULL,
+          retried_at TEXT,
+          bucket TEXT NOT NULL DEFAULT 'parse_error'
+        )
+      `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_github_dlq_tenant_received ON github_dlq(tenant_id, received_at)`);
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS github_installations (
+          installation_id TEXT PRIMARY KEY,
+          tenant_id TEXT NOT NULL,
+          added_at TEXT NOT NULL
+        )
+      `);
+        // PAT-mode multi-tenant routing (codex P0 #4). Maps repo_full_name to
+        // tenant when the webhook envelope has no `installation` field. Composite
+        // PK so the same repo can intentionally be visible to multiple tenants
+        // (e.g., shared tooling accounts) — collision is on (repo, tenant) pair.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS github_repositories (
+          repo_full_name TEXT NOT NULL,
+          tenant_id TEXT NOT NULL,
+          added_at TEXT NOT NULL,
+          PRIMARY KEY (repo_full_name, tenant_id)
+        )
+      `);
+        // Rollback-safety guard (codex P0 #2). Any binary < 1.2.1 lacks the
+        // generic *:private:* default-deny and would leak github:private:* rows
+        // if it opened this DB. The startup guard in v1.2.1+ refuses to open a
+        // DB whose min_compatible_binary is newer than its own version.
+        db.prepare(`INSERT INTO meta(key, value) VALUES('min_compatible_binary', ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run('1.2.1');
+    },
+};
+//# sourceMappingURL=v24.js.map

package/dist/db/migrations/v25.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v25: Migration;
+//# sourceMappingURL=v25.d.ts.map