omegon-pi 0.14.3 → 0.15.0

package/extensions/project-memory/factstore.ts

@@ -156,6 +156,12 @@ export interface Fact {
   /** jj change ID at fact creation — permanent provenance anchor.
    *  Survives rebase/squash. Null for facts created outside jj repos. */
   jj_change_id: string | null;
+  /** Persona that owns this fact. Null = project-level fact. */
+  persona_id: string | null;
+  /** Memory layer: 'project' | 'persona' | 'working'. */
+  layer: string;
+  /** JSON array of domain tags (e.g. ["pcb","thermal"]). Null = untagged. */
+  tags: string | null;
 }
 
 export interface MindRecord {
@@ -320,7 +326,7 @@ export class FactStore {
   }
 
   /** Current schema version — bump when adding migrations */
-  static readonly SCHEMA_VERSION = 5;
+  static readonly SCHEMA_VERSION = 6;
 
   private getSchemaVersion(): number {
     try {
@@ -452,29 +458,49 @@ export class FactStore {
       this.setSchemaVersion(4);
     }
 
-    // Migration 4→5: schema alignment + jj change ID provenance tracking
+    // Migration 4→5: full Rust↔TS schema alignment
     //
-    // Two concerns:
-    // 1. DBs created by the Rust omegon binary at schema v4 are missing columns
-    //    that the TS schema has always had: created_session, superseded_at,
-    //    archived_at (facts), session_id (episodes), and related tables
-    //    (episode_facts, episodes_vec). These must be added idempotently.
-    // 2. jj_change_id column for provenance tracking (new in v5).
+    // The Rust omegon-memory crate owns the canonical schema but may produce
+    // DBs missing columns/tables that TS requires. This migration idempotently
+    // brings ANY DB (Rust v4, Rust v5, or TS-created) to a state where all
+    // TS code paths work. Every ALTER TABLE is wrapped in try/catch because
+    // the column may already exist.
     if (current < 5) {
-      // Add columns that may be missing from Rust-created DBs.
-      // Each ALTER TABLE is wrapped in try/catch — "duplicate column" is expected
-      // for DBs created by TS (which always had these columns).
-      const addColumnIfMissing = (table: string, col: string, type: string = "TEXT") => {
-        try { this.db.prepare(`ALTER TABLE ${table} ADD COLUMN ${col} ${type}`).run(); } catch { /* exists */ }
+      const addCol = (table: string, col: string, typedef: string = "TEXT") => {
+        try { this.db.prepare(`ALTER TABLE ${table} ADD COLUMN ${col} ${typedef}`).run(); } catch { /* exists */ }
       };
-      addColumnIfMissing("facts", "created_session");
-      addColumnIfMissing("facts", "superseded_at");
-      addColumnIfMissing("facts", "archived_at");
-      addColumnIfMissing("facts", "jj_change_id");
-      addColumnIfMissing("episodes", "session_id");
-      addColumnIfMissing("episodes", "jj_change_id");
-
-      // Create tables that may not exist in Rust-created DBs
+
+      // --- facts table ---
+      addCol("facts", "created_session");
+      addCol("facts", "superseded_at");
+      addCol("facts", "archived_at");
+      addCol("facts", "jj_change_id");
+
+      // --- edges table ---
+      // Rust edges is minimal: id, source_fact_id, target_fact_id, relation,
+      // description, weight, created_at. TS needs these additional columns:
+      addCol("edges", "confidence", "REAL NOT NULL DEFAULT 1.0");
+      addCol("edges", "last_reinforced", "TEXT NOT NULL DEFAULT ''");
+      addCol("edges", "reinforcement_count", "INTEGER NOT NULL DEFAULT 1");
+      addCol("edges", "decay_rate", `REAL NOT NULL DEFAULT ${DECAY.baseRate}`);
+      addCol("edges", "status", "TEXT NOT NULL DEFAULT 'active'");
+      addCol("edges", "created_session");
+      addCol("edges", "source_mind");
+      addCol("edges", "target_mind");
+
+      // --- minds table ---
+      // Rust minds is minimal: name, description, status, origin_type, created_at.
+      addCol("minds", "origin_path");
+      addCol("minds", "origin_url");
+      addCol("minds", "readonly", "INTEGER NOT NULL DEFAULT 0");
+      addCol("minds", "parent");
+      addCol("minds", "last_sync");
+
+      // --- episodes table ---
+      addCol("episodes", "session_id");
+      addCol("episodes", "jj_change_id");
+
+      // --- tables that may not exist in Rust-created DBs ---
       this.db.exec(`
         CREATE TABLE IF NOT EXISTS episode_facts (
           episode_id TEXT NOT NULL,
@@ -493,9 +519,27 @@ export class FactStore {
         );
       `);
 
-      // Indexes on these columns are created by ensureIndexes() after all migrations.
+      // Indexes on migration-added columns are created by ensureIndexes().
       this.setSchemaVersion(5);
     }
+
+    // Migration 5→6: Persona system
+    //
+    // Adds persona ownership and memory layering to facts:
+    //   persona_id — which persona owns the fact (NULL = project-level)
+    //   layer      — memory layer: 'project' | 'persona' | 'working'
+    //   tags       — JSON array of domain tags (e.g. ["pcb","thermal"])
+    // All additive. Existing data reads cleanly with defaults.
+    if (current < 6) {
+      const addCol = (table: string, col: string, typedef: string = "TEXT") => {
+        try { this.db.prepare(`ALTER TABLE ${table} ADD COLUMN ${col} ${typedef}`).run(); } catch { /* exists */ }
+      };
+      addCol("facts", "persona_id");
+      addCol("facts", "layer", "TEXT NOT NULL DEFAULT 'project'");
+      addCol("facts", "tags");
+      // Indexes created by ensureIndexes().
+      this.setSchemaVersion(6);
+    }
   }
 
   private initSchema(): void {
@@ -578,12 +622,8 @@ export class FactStore {
         FOREIGN KEY (target_fact_id) REFERENCES facts(id) ON DELETE CASCADE
       );
 
-      CREATE INDEX IF NOT EXISTS idx_edges_source
-        ON edges(source_fact_id) WHERE status = 'active';
-      CREATE INDEX IF NOT EXISTS idx_edges_target
-        ON edges(target_fact_id) WHERE status = 'active';
-      CREATE INDEX IF NOT EXISTS idx_edges_relation
-        ON edges(relation) WHERE status = 'active';
+      -- Edge indexes that reference 'status' are created in ensureIndexes()
+      -- after migrations add the status column (missing in Rust-created DBs).
     `);
 
     // FTS5 virtual table for full-text search
@@ -642,17 +682,30 @@ export class FactStore {
     }
   }
 
+  /**
+   * Create indexes on columns that may not exist until after migrations.
+   * Called AFTER runMigrations() so Rust-created DBs have had their
+   * missing columns added before we try to index them.
+   */
   /**
    * Create indexes on columns that may not exist until after migrations.
    * Called AFTER runMigrations() so Rust-created DBs have had their
    * missing columns added before we try to index them.
    */
   private ensureIndexes(): void {
-    const safeIndex = (sql: string) => {
-      try { this.db.prepare(sql).run(); } catch { /* column or index issue — non-fatal */ }
+    const idx = (sql: string) => {
+      try { this.db.prepare(sql).run(); } catch { /* column or index already exists */ }
     };
-    safeIndex(`CREATE INDEX IF NOT EXISTS idx_facts_session ON facts(created_session)`);
-    safeIndex(`CREATE INDEX IF NOT EXISTS idx_facts_version ON facts(version DESC)`);
+    // facts indexes on migration-added columns
+    idx(`CREATE INDEX IF NOT EXISTS idx_facts_session ON facts(created_session)`);
+    idx(`CREATE INDEX IF NOT EXISTS idx_facts_version ON facts(version DESC)`);
+    // edges indexes that reference 'status' (missing in Rust-created DBs before migration)
+    idx(`CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_fact_id) WHERE status = 'active'`);
+    idx(`CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_fact_id) WHERE status = 'active'`);
+    idx(`CREATE INDEX IF NOT EXISTS idx_edges_relation ON edges(relation) WHERE status = 'active'`);
+    // v6: persona system indexes
+    idx(`CREATE INDEX IF NOT EXISTS idx_facts_persona ON facts(persona_id) WHERE persona_id IS NOT NULL`);
+    idx(`CREATE INDEX IF NOT EXISTS idx_facts_layer ON facts(mind, layer) WHERE status = 'active'`);
   }
 
   // ---------------------------------------------------------------------------

package/extensions/project-memory/schema-contract.json

@@ -0,0 +1,15 @@
+{
+  "description": "Canonical memory DB schema. Generated from Rust omegon-memory. Do not edit — regenerate with: cargo test -p omegon-memory schema_contract_generate -- --ignored",
+  "schema_version": 6,
+  "tables": {
+    "edges": ["id", "source_fact_id", "target_fact_id", "relation", "description", "confidence", "last_reinforced", "reinforcement_count", "decay_rate", "status", "created_at", "created_session", "source_mind", "target_mind"],
+    "embedding_metadata": ["model_name", "dims", "inserted_at"],
+    "episode_facts": ["episode_id", "fact_id"],
+    "episodes": ["id", "mind", "title", "narrative", "date", "session_id", "created_at", "jj_change_id"],
+    "episodes_vec": ["episode_id", "embedding", "model_name", "dims", "created_at"],
+    "facts": ["id", "mind", "section", "content", "status", "created_at", "created_session", "supersedes", "superseded_at", "archived_at", "source", "content_hash", "confidence", "last_reinforced", "reinforcement_count", "decay_rate", "decay_profile", "version", "last_accessed", "jj_change_id", "persona_id", "layer", "tags"],
+    "facts_vec": ["fact_id", "embedding", "model_name", "dims", "created_at"],
+    "minds": ["name", "description", "status", "origin_type", "origin_path", "origin_url", "readonly", "parent", "created_at", "last_sync"],
+    "schema_version": ["version", "applied_at"]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omegon-pi",
-  "version": "0.14.3",
+  "version": "0.15.0",
   "description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
   "bin": {
     "omegon-pi": "bin/omegon-pi.mjs",

package/scripts/validate-schema-contract.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * validate-schema-contract.mjs
+ *
+ * Validates that the TS factstore migration produces a schema that is a
+ * superset of the Rust omegon-memory schema contract.
+ *
+ * Usage: node scripts/validate-schema-contract.mjs <path-to-schema-contract.json>
+ *
+ * The script:
+ *   1. Creates a minimal Rust-shaped DB at the contract's stated schema_version
+ *      (simulating what the Rust binary would create)
+ *   2. Opens it with FactStore (triggering TS migrations)
+ *   3. Verifies every table and column from the contract exists in the result
+ *
+ * Exit 0 = TS is compatible. Exit 1 = drift detected.
+ */
+
+import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import Database from "better-sqlite3";
+
+const contractPath = process.argv[2];
+if (!contractPath) {
+  console.error("Usage: node validate-schema-contract.mjs <schema-contract.json>");
+  process.exit(1);
+}
+
+const contract = JSON.parse(readFileSync(contractPath, "utf-8"));
+console.log(`Schema contract: version ${contract.schema_version}, ${Object.keys(contract.tables).length} tables`);
+
+// Step 1: Create a DB with ONLY the Rust contract's tables and columns.
+// This simulates what the latest Rust binary would produce.
+const dir = mkdtempSync(join(tmpdir(), "schema-validate-"));
+const dbPath = join(dir, "facts.db");
+const db = new Database(dbPath);
+db.pragma("journal_mode = WAL");
+
+for (const [table, columns] of Object.entries(contract.tables)) {
+  // Skip FTS virtual tables — they're created by TS initSchema
+  if (table.endsWith("_fts")) continue;
+
+  const colDefs = columns.map((col, i) => {
+    // First column is PRIMARY KEY
+    if (i === 0) return `${col} TEXT PRIMARY KEY`;
+    // embedding columns are BLOB
+    if (col === "embedding") return `${col} BLOB`;
+    // integer columns
+    if (["dims", "reinforcement_count", "readonly"].includes(col)) return `${col} INTEGER NOT NULL DEFAULT 0`;
+    // real columns
+    if (["confidence", "decay_rate"].includes(col)) return `${col} REAL NOT NULL DEFAULT 0`;
+    // version column
+    if (col === "version" && table === "facts") return `${col} INTEGER NOT NULL DEFAULT 0`;
+    if (col === "version" && table === "schema_version") return `${col} INTEGER PRIMARY KEY`;
+    // everything else is TEXT
+    return `${col} TEXT`;
+  });
+
+  // episode_facts has composite PK
+  if (table === "episode_facts") {
+    const cols = columns.map(c => `${c} TEXT NOT NULL`).join(", ");
+    db.exec(`CREATE TABLE IF NOT EXISTS ${table} (${cols}, PRIMARY KEY (${columns.join(", ")}))`);
+  } else {
+    db.exec(`CREATE TABLE IF NOT EXISTS ${table} (${colDefs.join(", ")})`);
+  }
+}
+
+// Insert schema version
+db.exec(`INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (${contract.schema_version}, datetime('now'))`);
+
+// Insert default mind (required by TS)
+try {
+  db.exec(`INSERT INTO minds (name, created_at) VALUES ('default', datetime('now'))`);
+} catch { /* might already exist */ }
+
+db.close();
+console.log(`Created Rust-shaped DB at ${dbPath}`);
+
+// Step 2: Open with TS FactStore — this runs migrations
+const { FactStore } = await import("../extensions/project-memory/factstore.ts");
+let store;
+try {
+  store = new FactStore(dir);
+  console.log("✓ FactStore opened Rust-shaped DB successfully");
+} catch (e) {
+  console.error(`✗ FactStore FAILED to open Rust-shaped DB: ${e.message}`);
+  rmSync(dir, { recursive: true, force: true });
+  process.exit(1);
+}
+
+// Step 3: Verify every contract table+column exists after migration
+const verifyDb = store.db ?? (store)._db ?? (() => { throw new Error("Cannot access DB handle"); })();
+let errors = 0;
+
+for (const [table, expectedCols] of Object.entries(contract.tables)) {
+  if (table.endsWith("_fts")) continue;
+
+  let actualCols;
+  try {
+    actualCols = verifyDb.prepare(`PRAGMA table_info(${table})`).all().map(r => r.name);
+  } catch {
+    console.error(`✗ Table '${table}' does not exist after TS migration`);
+    errors++;
+    continue;
+  }
+
+  for (const col of expectedCols) {
+    if (!actualCols.includes(col)) {
+      console.error(`✗ Column '${table}.${col}' required by Rust contract but missing after TS migration`);
+      errors++;
+    }
+  }
+}
+
+store.close();
+rmSync(dir, { recursive: true, force: true });
+
+if (errors > 0) {
+  console.error(`\n${errors} schema drift error(s) detected. Update the TS v5 migration in factstore.ts.`);
+  process.exit(1);
+} else {
+  console.log(`✓ All ${Object.keys(contract.tables).length} tables and columns verified — TS is compatible with Rust schema v${contract.schema_version}`);
+}