@sidurijs/core 1.0.0

package/dist/siduri-db.js

@@ -0,0 +1,1405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiduriDatabase = void 0;
+exports.safeJsonParse = safeJsonParse;
+exports.normalizeStatus = normalizeStatus;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const crypto = require('crypto');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { DatabaseSync } = require('node:sqlite');
+function safeJsonParse(str, fallback = undefined) {
+    if (!str)
+        return fallback;
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return fallback;
+    }
+}
+function normalizeStatus(status, defaultStatus = 'pending') {
+    if (!status)
+        return defaultStatus;
+    return status.toLowerCase().replace(/_/g, '-');
+}
+class SiduriDatabase {
+    db;
+    constructor(options = {}) {
+        const dbPath = options.dbPath || ':memory:';
+        this.db = new DatabaseSync(dbPath);
+        this.db.exec('PRAGMA busy_timeout = 5000');
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.initSchema();
+    }
+    initSchema() {
+        const schema = `
+      -- Self Tables
+      CREATE TABLE IF NOT EXISTS self_identity (
+        companion_id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        archetype TEXT,
+        role TEXT,
+        origin TEXT,
+        ethos TEXT,
+        version TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS self_personality (
+        companion_id TEXT PRIMARY KEY,
+        warmth REAL DEFAULT 0.5,
+        formality REAL DEFAULT 0.5,
+        sarcasm REAL DEFAULT 0.5,
+        verbosity REAL DEFAULT 0.5,
+        curiosity REAL DEFAULT 0.5,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS self_directives (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        priority INTEGER DEFAULT 50,
+        directive TEXT NOT NULL,
+        status TEXT DEFAULT 'active',
+        category TEXT DEFAULT 'behavioral',
+        scope_actor TEXT,
+        supersedes_id TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS self_relationships (
+        companion_id TEXT NOT NULL,
+        entity_id TEXT NOT NULL,
+        entity_type TEXT NOT NULL DEFAULT 'human',
+        name TEXT,
+        affiliation TEXT,
+        role TEXT DEFAULT 'user',
+        stance TEXT DEFAULT 'neutral',
+        trust_score REAL DEFAULT 0.5,
+        familiarity REAL DEFAULT 0.5,
+        interaction_conventions TEXT,
+        updated_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY(companion_id, entity_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS self_exemplars (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        user_prompt TEXT NOT NULL,
+        companion_response TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Knowledge Tables
+      CREATE TABLE IF NOT EXISTS life_inventory (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        domain TEXT NOT NULL,
+        entity_name TEXT NOT NULL,
+        properties TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS life_finance (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        category TEXT NOT NULL,
+        amount REAL NOT NULL,
+        currency TEXT DEFAULT 'USD',
+        timestamp TEXT DEFAULT (datetime('now')),
+        metadata TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS life_schedule (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        start_time TEXT NOT NULL,
+        end_time TEXT,
+        is_recurring INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'active'
+      );
+
+      CREATE TABLE IF NOT EXISTS life_preferences (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        preference_key TEXT NOT NULL,
+        preference_value TEXT NOT NULL,
+        category TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS life_entities (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        entity_type TEXT NOT NULL,
+        domain TEXT NOT NULL,
+        name TEXT NOT NULL,
+        properties TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS life_events (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        stream TEXT NOT NULL,
+        timestamp TEXT DEFAULT (datetime('now')),
+        metric_value REAL,
+        metadata TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS life_tasks (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        status TEXT DEFAULT 'backlog',
+        priority INTEGER DEFAULT 0,
+        target_date TEXT,
+        metadata TEXT,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_life_entities_comp ON life_entities(companion_id, entity_type);
+      CREATE INDEX IF NOT EXISTS idx_life_events_comp ON life_events(companion_id, stream, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_life_tasks_comp ON life_tasks(companion_id, status);
+
+      -- Memory Tables
+      CREATE TABLE IF NOT EXISTS memory_events (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        source_type TEXT NOT NULL,
+        occurred_at TEXT DEFAULT (datetime('now')),
+        payload TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_claims (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        predicate TEXT NOT NULL,
+        value TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        confidence REAL DEFAULT 1.0,
+        valid_from TEXT,
+        valid_until TEXT,
+        evidence TEXT,
+        asserted_at TEXT DEFAULT (datetime('now')),
+        supersedes TEXT,
+        source_event_id TEXT
+      );
+
+      -- FTS5 Virtual Table for Memory Claims
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_search USING fts5(
+        subject,
+        predicate,
+        value,
+        content='memory_claims',
+        content_rowid='rowid'
+      );
+
+      -- FTS5 Triggers
+      CREATE TRIGGER IF NOT EXISTS memory_claims_ai AFTER INSERT ON memory_claims BEGIN
+        INSERT INTO memory_search(rowid, subject, predicate, value) 
+        VALUES (new.rowid, new.subject, new.predicate, new.value);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_claims_ad AFTER DELETE ON memory_claims BEGIN
+        INSERT INTO memory_search(memory_search, rowid, subject, predicate, value) 
+        VALUES('delete', old.rowid, old.subject, old.predicate, old.value);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_claims_au AFTER UPDATE ON memory_claims BEGIN
+        INSERT INTO memory_search(memory_search, rowid, subject, predicate, value) 
+        VALUES('delete', old.rowid, old.subject, old.predicate, old.value);
+        INSERT INTO memory_search(rowid, subject, predicate, value) 
+        VALUES (new.rowid, new.subject, new.predicate, new.value);
+      END;
+
+      -- System Logs Table
+      CREATE TABLE IF NOT EXISTS system_logs (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        level TEXT NOT NULL,
+        subsystem TEXT NOT NULL,
+        message TEXT NOT NULL,
+        metadata TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_system_logs_comp ON system_logs(companion_id, level, created_at DESC);
+    `;
+        this.db.exec(schema);
+        try {
+            this.db.exec("ALTER TABLE memory_claims ADD COLUMN supersedes TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE memory_claims ADD COLUMN source_event_id TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN origin TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN ethos TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_directives ADD COLUMN scope_actor TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN role TEXT DEFAULT 'user'");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN stance TEXT DEFAULT 'neutral'");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN updated_at TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN role TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN name TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN affiliation TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            // Reconcile creator claims that may have been recorded before origin dual-promotion
+            const creatorClaims = this.db.prepare(`
+        SELECT * FROM memory_claims
+        WHERE predicate = 'stated_relationship'
+          AND LOWER(value) LIKE '%creator%'
+          AND LOWER(status) = 'approved'
+      `).all();
+            for (const claim of creatorClaims) {
+                const identity = this.db.prepare(`SELECT * FROM self_identity WHERE companion_id = ?`).get(claim.companion_id);
+                if (identity && !identity.origin) {
+                    const nameClaim = this.db.prepare(`
+            SELECT value FROM memory_claims
+            WHERE companion_id = ? AND subject = ? AND predicate = 'name' AND LOWER(status) = 'approved'
+            ORDER BY asserted_at DESC LIMIT 1
+          `).get(claim.companion_id, claim.subject);
+                    const originName = nameClaim?.value || (claim.subject.startsWith('actor:') ? claim.subject.slice(6) : claim.subject);
+                    this.db.prepare(`UPDATE self_identity SET origin = ? WHERE companion_id = ?`).run(originName, claim.companion_id);
+                }
+                const rel = this.db.prepare(`SELECT * FROM self_relationships WHERE companion_id = ? AND entity_id = ?`).get(claim.companion_id, claim.subject);
+                if (rel && (rel.role !== 'creator' || rel.stance !== 'familiar_loyal')) {
+                    this.db.prepare(`UPDATE self_relationships SET role = 'creator', stance = 'familiar_loyal', trust_score = 1.0 WHERE companion_id = ? AND entity_id = ?`).run(claim.companion_id, claim.subject);
+                }
+            }
+        }
+        catch {
+            // Best-effort auto-reconciliation
+        }
+    }
+    close() {
+        this.db.close();
+    }
+    // ==========================================
+    // Self Domain Methods
+    // ==========================================
+    getIdentity(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_identity WHERE companion_id = ?');
+        const row = stmt.get(companionId);
+        if (!row)
+            return undefined;
+        return {
+            companionId: row.companion_id,
+            name: row.name,
+            archetype: row.archetype || undefined,
+            role: row.role || row.archetype || undefined,
+            origin: row.origin || undefined,
+            ethos: row.ethos || undefined,
+            version: row.version,
+            updatedAt: row.updated_at
+        };
+    }
+    setIdentity(identity) {
+        const role = identity.role || identity.archetype || null;
+        const archetype = identity.archetype || identity.role || null;
+        const stmt = this.db.prepare(`
+      INSERT INTO self_identity (companion_id, name, archetype, role, origin, ethos, version, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(companion_id) DO UPDATE SET
+        name = excluded.name,
+        archetype = excluded.archetype,
+        role = excluded.role,
+        origin = excluded.origin,
+        ethos = excluded.ethos,
+        version = excluded.version,
+        updated_at = datetime('now')
+    `);
+        stmt.run(identity.companionId, identity.name, archetype, role, identity.origin || null, identity.ethos || null, identity.version);
+    }
+    getPersonality(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_personality WHERE companion_id = ?');
+        const row = stmt.get(companionId);
+        if (!row)
+            return undefined;
+        return {
+            warmth: row.warmth,
+            formality: row.formality,
+            sarcasm: row.sarcasm,
+            verbosity: row.verbosity,
+            curiosity: row.curiosity
+        };
+    }
+    setPersonality(companionId, traits) {
+        const stmt = this.db.prepare(`
+      INSERT INTO self_personality (companion_id, warmth, formality, sarcasm, verbosity, curiosity, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(companion_id) DO UPDATE SET
+        warmth = excluded.warmth,
+        formality = excluded.formality,
+        sarcasm = excluded.sarcasm,
+        verbosity = excluded.verbosity,
+        curiosity = excluded.curiosity,
+        updated_at = datetime('now')
+    `);
+        stmt.run(companionId, traits.warmth, traits.formality, traits.sarcasm, traits.verbosity, traits.curiosity);
+    }
+    rowToSelfDirective(row) {
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            priority: row.priority,
+            directive: row.directive,
+            status: normalizeStatus(row.status, 'active'),
+            category: row.category,
+            scopeActor: row.scope_actor || undefined,
+            supersedesId: row.supersedes_id || undefined,
+            createdAt: row.created_at,
+        };
+    }
+    getActiveDirectives(companionId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM self_directives 
+      WHERE companion_id = ? AND LOWER(status) = 'active'
+      ORDER BY priority DESC, created_at ASC
+    `);
+        return stmt.all(companionId).map((row) => this.rowToSelfDirective(row));
+    }
+    getAllDirectives(companionId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM self_directives 
+      WHERE companion_id = ?
+      ORDER BY priority DESC, created_at ASC
+    `);
+        return stmt.all(companionId).map((row) => this.rowToSelfDirective(row));
+    }
+    commitDirective(directive) {
+        const stmt = this.db.prepare(`
+      INSERT INTO self_directives (id, companion_id, priority, directive, status, category, scope_actor, supersedes_id, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        companion_id = excluded.companion_id,
+        priority = excluded.priority,
+        directive = excluded.directive,
+        status = excluded.status,
+        category = excluded.category,
+        scope_actor = excluded.scope_actor,
+        supersedes_id = excluded.supersedes_id
+    `);
+        stmt.run(directive.id, directive.companionId, directive.priority !== undefined ? directive.priority : 50, directive.directive, normalizeStatus(directive.status, 'active'), directive.category || 'behavioral', directive.scopeActor || null, directive.supersedesId || null, directive.createdAt || new Date().toISOString());
+    }
+    getDirective(id, companionId) {
+        const stmt = companionId
+            ? this.db.prepare('SELECT * FROM self_directives WHERE id = ? AND companion_id = ?')
+            : this.db.prepare('SELECT * FROM self_directives WHERE id = ?');
+        const row = (companionId ? stmt.get(id, companionId) : stmt.get(id));
+        if (!row)
+            return undefined;
+        return this.rowToSelfDirective(row);
+    }
+    approveDirective(id, companionId) {
+        const findStmt = companionId
+            ? this.db.prepare("SELECT id, companion_id, directive, scope_actor, status, priority, supersedes_id FROM self_directives WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, companion_id, directive, scope_actor, status, priority, supersedes_id FROM self_directives WHERE id = ?");
+        const row = (companionId ? findStmt.get(id, companionId) : findStmt.get(id));
+        if (!row) {
+            return;
+        }
+        if (normalizeStatus(row.status) !== 'pending' && normalizeStatus(row.status) !== 'superseded') {
+            if (normalizeStatus(row.status) === 'active') {
+                return;
+            }
+            throw new Error(`Cannot approve directive '${id}': invalid transition from status '${row.status}' to 'active' (only pending or superseded directives can be approved)`);
+        }
+        // If this directive supersedes an earlier directive, transition that prior directive to superseded
+        if (row.supersedes_id) {
+            const supersededId = row.supersedes_id;
+            const effectiveCompanionId = companionId || row.companion_id;
+            if (effectiveCompanionId) {
+                const supersedeStmt = this.db.prepare("UPDATE self_directives SET status = 'superseded' WHERE id = ? AND companion_id = ?");
+                supersedeStmt.run(supersededId, effectiveCompanionId);
+            }
+            else {
+                const supersedeStmt = this.db.prepare("UPDATE self_directives SET status = 'superseded' WHERE id = ?");
+                supersedeStmt.run(supersededId);
+            }
+        }
+        // Automatic Supersession: If an address directive or single-value directive is approved,
+        // transition conflicting older active/pending directives to 'superseded'
+        const addressMatch = (row.directive || '').match(/^address\s+(actor:[^\s]+|the user|user)\s+as\s+["“']?([^"”'.]+)["”']?/i);
+        let targetPriority = row.priority ?? 50;
+        if (addressMatch) {
+            targetPriority = 85;
+            const targetActor = addressMatch[1].toLowerCase();
+            const existingDirectives = this.getAllDirectives(companionId || 'default');
+            for (const d of existingDirectives) {
+                if ((d.status === 'active' || d.status === 'pending') &&
+                    d.id !== id &&
+                    d.directive &&
+                    d.directive.toLowerCase().startsWith(`address ${targetActor} as`)) {
+                    this.supersedeDirective(d.id, companionId);
+                }
+            }
+            const targetEntityId = targetActor === 'the user' || targetActor === 'user' ? 'actor:user' : targetActor;
+            const existingRel = this.getRelationship(companionId || 'default', targetEntityId);
+            if (existingRel) {
+                const cleanedAddress = addressMatch[2].trim();
+                const convs = (existingRel.interactionConventions || []).filter((c) => !c.toLowerCase().startsWith('address as'));
+                convs.push(`Address as ${cleanedAddress}`);
+                this.upsertRelationship({
+                    ...existingRel,
+                    companionId: companionId || 'default',
+                    interactionConventions: convs,
+                });
+            }
+        }
+        // Single-value directive canonical supersession (e.g. role, language, response style)
+        const roleMatch = (row.directive || '').match(/^acknowledge role as\s+([^"”'.]+)/i);
+        if (roleMatch) {
+            const existingDirectives = this.getAllDirectives(companionId || 'default');
+            for (const d of existingDirectives) {
+                if ((d.status === 'active' || d.status === 'pending') &&
+                    d.id !== id &&
+                    d.directive &&
+                    d.directive.toLowerCase().startsWith('acknowledge role as')) {
+                    this.supersedeDirective(d.id, companionId);
+                }
+            }
+        }
+        // Companion name directive detection: "Address companion as X", "Your name is X", "Call yourself X", "Acknowledge name as X"
+        const compNameMatch = (row.directive || '').match(/^(?:address\s+companion\s+as|your\s+name\s+is|call\s+yourself|acknowledge\s+name\s+as|companion\s+name\s+is)\s+["“']?([^"”'.]+)["”']?/i);
+        if (compNameMatch) {
+            const newCompanionName = compNameMatch[1].trim();
+            if (newCompanionName) {
+                const targetId = companionId || row.companion_id || 'default';
+                const currentIdentity = this.getIdentity(targetId) || {
+                    companionId: targetId,
+                    name: '',
+                    version: '1.0.0',
+                    updatedAt: new Date().toISOString(),
+                };
+                currentIdentity.name = newCompanionName;
+                currentIdentity.updatedAt = new Date().toISOString();
+                this.setIdentity(currentIdentity);
+            }
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'active', priority = MAX(priority, ?) WHERE id = ? AND companion_id = ? AND LOWER(status) IN ('pending', 'superseded')");
+            stmt.run(targetPriority, id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'active', priority = MAX(priority, ?) WHERE id = ? AND LOWER(status) IN ('pending', 'superseded')");
+            stmt.run(targetPriority, id);
+        }
+    }
+    rejectDirective(id, companionId) {
+        const findStmt = companionId
+            ? this.db.prepare("SELECT id, companion_id, status FROM self_directives WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, companion_id, status FROM self_directives WHERE id = ?");
+        const row = (companionId ? findStmt.get(id, companionId) : findStmt.get(id));
+        if (!row) {
+            return;
+        }
+        if (normalizeStatus(row.status) !== 'pending' && normalizeStatus(row.status) !== 'superseded') {
+            if (normalizeStatus(row.status) === 'rejected') {
+                return;
+            }
+            throw new Error(`Cannot reject directive '${id}': invalid transition from status '${row.status}' to 'rejected' (only pending or superseded directives can be rejected)`);
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'rejected' WHERE id = ? AND companion_id = ? AND LOWER(status) IN ('pending', 'superseded')");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'rejected' WHERE id = ? AND LOWER(status) IN ('pending', 'superseded')");
+            stmt.run(id);
+        }
+    }
+    supersedeDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'superseded' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'superseded' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    revokeDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'revoked' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'revoked' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    expireDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'expired' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'expired' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    disableDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'disabled' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'disabled' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    getRelationship(companionId, entityId) {
+        const stripped = entityId.startsWith('actor:') ? entityId.slice(6) : entityId;
+        const prefixed = entityId.startsWith('actor:') ? entityId : `actor:${entityId}`;
+        const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? AND (entity_id = ? OR entity_id = ? OR entity_id = ?)');
+        let row = stmt.get(companionId, entityId, stripped, prefixed);
+        if (!row && (entityId === 'owner-user' || entityId === 'local-user' || entityId === 'owner' || entityId === 'primary' || entityId === 'user')) {
+            const fallbackStmt = this.db.prepare("SELECT * FROM self_relationships WHERE companion_id = ? AND entity_type = 'human' ORDER BY updated_at DESC LIMIT 1");
+            row = fallbackStmt.get(companionId);
+        }
+        if (!row)
+            return undefined;
+        return {
+            companionId: row.companion_id,
+            entityId: row.entity_id,
+            entityType: row.entity_type || 'human',
+            name: row.name || undefined,
+            affiliation: row.affiliation || undefined,
+            role: row.role || 'user',
+            stance: row.stance || 'neutral',
+            trustScore: row.trust_score !== undefined && row.trust_score !== null ? row.trust_score : 0.5,
+            familiarity: row.familiarity !== undefined && row.familiarity !== null ? row.familiarity : 0.5,
+            interactionConventions: row.interaction_conventions ? JSON.parse(row.interaction_conventions) : [],
+            updatedAt: row.updated_at || undefined,
+        };
+    }
+    getRelationships(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? ORDER BY entity_id ASC');
+        return stmt.all(companionId).map((row) => ({
+            companionId: row.companion_id,
+            entityId: row.entity_id,
+            entityType: row.entity_type || 'human',
+            name: row.name || undefined,
+            affiliation: row.affiliation || undefined,
+            role: row.role || 'user',
+            stance: row.stance || 'neutral',
+            trustScore: row.trust_score !== undefined && row.trust_score !== null ? row.trust_score : 0.5,
+            familiarity: row.familiarity !== undefined && row.familiarity !== null ? row.familiarity : 0.5,
+            interactionConventions: row.interaction_conventions ? JSON.parse(row.interaction_conventions) : [],
+            updatedAt: row.updated_at || undefined,
+        }));
+    }
+    upsertRelationship(rel) {
+        const stmt = this.db.prepare(`
+      INSERT INTO self_relationships (companion_id, entity_id, entity_type, name, affiliation, role, stance, trust_score, familiarity, interaction_conventions, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(companion_id, entity_id) DO UPDATE SET
+        entity_type = excluded.entity_type,
+        name = COALESCE(excluded.name, self_relationships.name),
+        affiliation = COALESCE(excluded.affiliation, self_relationships.affiliation),
+        role = COALESCE(excluded.role, self_relationships.role),
+        stance = COALESCE(excluded.stance, self_relationships.stance),
+        trust_score = excluded.trust_score,
+        familiarity = excluded.familiarity,
+        interaction_conventions = excluded.interaction_conventions,
+        updated_at = datetime('now')
+    `);
+        stmt.run(rel.companionId, rel.entityId, rel.entityType || 'human', rel.name || null, rel.affiliation || null, rel.role || 'user', rel.stance || 'neutral', rel.trustScore !== undefined && rel.trustScore !== null ? rel.trustScore : 0.5, rel.familiarity !== undefined && rel.familiarity !== null ? rel.familiarity : 0.5, JSON.stringify(rel.interactionConventions || []));
+    }
+    getExemplars(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_exemplars WHERE companion_id = ? ORDER BY created_at ASC');
+        return stmt.all(companionId).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            user: row.user_prompt,
+            assistant: row.companion_response,
+            createdAt: row.created_at,
+        }));
+    }
+    setExemplars(companionId, exemplars) {
+        const delStmt = this.db.prepare('DELETE FROM self_exemplars WHERE companion_id = ?');
+        delStmt.run(companionId);
+        const insertStmt = this.db.prepare(`
+      INSERT INTO self_exemplars (id, companion_id, user_prompt, companion_response, created_at)
+      VALUES (?, ?, ?, ?, datetime('now'))
+    `);
+        for (let i = 0; i < exemplars.length; i++) {
+            const ex = exemplars[i];
+            const id = ex.id || `ex-${i + 1}-${Date.now()}`;
+            insertStmt.run(id, companionId, ex.user, ex.assistant);
+        }
+    }
+    // ==========================================
+    // Knowledge / Life DB Methods
+    // ==========================================
+    getInventory(companionId, domain) {
+        let stmt;
+        let rows;
+        if (domain) {
+            stmt = this.db.prepare('SELECT * FROM life_inventory WHERE companion_id = ? AND domain = ?');
+            rows = stmt.all(companionId, domain);
+        }
+        else {
+            stmt = this.db.prepare('SELECT * FROM life_inventory WHERE companion_id = ?');
+            rows = stmt.all(companionId);
+        }
+        return rows.map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            domain: row.domain,
+            entityName: row.entity_name,
+            properties: JSON.parse(row.properties),
+            updatedAt: row.updated_at
+        }));
+    }
+    upsertInventoryItem(item) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_inventory (id, companion_id, domain, entity_name, properties, updated_at)
+      VALUES (?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(id) DO UPDATE SET
+        domain = excluded.domain,
+        entity_name = excluded.entity_name,
+        properties = excluded.properties,
+        updated_at = datetime('now')
+    `);
+        stmt.run(item.id, item.companionId, item.domain, item.entityName, JSON.stringify(item.properties));
+    }
+    getFinanceEntries(companionId, limit = 50) {
+        const stmt = this.db.prepare('SELECT * FROM life_finance WHERE companion_id = ? ORDER BY timestamp DESC LIMIT ?');
+        return stmt.all(companionId, limit).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            category: row.category,
+            amount: row.amount,
+            currency: row.currency,
+            timestamp: row.timestamp,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+        }));
+    }
+    addFinanceEntry(entry) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_finance (id, companion_id, category, amount, currency, timestamp, metadata)
+      VALUES (?, ?, ?, ?, ?, coalesce(?, datetime('now')), ?)
+    `);
+        stmt.run(entry.id, entry.companionId, entry.category, entry.amount, entry.currency || 'USD', entry.timestamp || null, entry.metadata ? JSON.stringify(entry.metadata) : null);
+    }
+    getSchedule(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM life_schedule WHERE companion_id = ? AND status = ? ORDER BY start_time ASC');
+        return stmt.all(companionId, 'active').map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            title: row.title,
+            startTime: row.start_time,
+            endTime: row.end_time || undefined,
+            isRecurring: row.is_recurring === 1,
+            status: row.status
+        }));
+    }
+    upsertScheduleItem(item) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_schedule (id, companion_id, title, start_time, end_time, is_recurring, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        title = excluded.title,
+        start_time = excluded.start_time,
+        end_time = excluded.end_time,
+        is_recurring = excluded.is_recurring,
+        status = excluded.status
+    `);
+        stmt.run(item.id, item.companionId, item.title, item.startTime, item.endTime || null, item.isRecurring ? 1 : 0, item.status || 'active');
+    }
+    deleteScheduleItem(id) {
+        const stmt = this.db.prepare('DELETE FROM life_schedule WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+    getPreferences(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM life_preferences WHERE companion_id = ?');
+        return stmt.all(companionId).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            preferenceKey: row.preference_key,
+            preferenceValue: row.preference_value,
+            category: row.category,
+            updatedAt: row.updated_at
+        }));
+    }
+    upsertPreference(pref) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_preferences (id, companion_id, preference_key, preference_value, category, updated_at)
+      VALUES (?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(id) DO UPDATE SET
+        preference_key = excluded.preference_key,
+        preference_value = excluded.preference_value,
+        category = excluded.category,
+        updated_at = datetime('now')
+    `);
+        stmt.run(pref.id, pref.companionId, pref.preferenceKey, pref.preferenceValue, pref.category);
+    }
+    // --- Generic Life Entities Methods ---
+    getEntities(companionId, entityType, domain) {
+        let query = 'SELECT * FROM life_entities WHERE companion_id = ?';
+        const params = [companionId];
+        if (entityType) {
+            query += ' AND entity_type = ?';
+            params.push(entityType);
+        }
+        if (domain) {
+            query += ' AND domain = ?';
+            params.push(domain);
+        }
+        query += ' ORDER BY updated_at DESC';
+        const stmt = this.db.prepare(query);
+        return stmt.all(...params).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            entityType: row.entity_type,
+            domain: row.domain,
+            name: row.name,
+            properties: JSON.parse(row.properties || '{}'),
+            updatedAt: row.updated_at,
+        }));
+    }
+    getEntityById(id) {
+        const stmt = this.db.prepare('SELECT * FROM life_entities WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            entityType: row.entity_type,
+            domain: row.domain,
+            name: row.name,
+            properties: JSON.parse(row.properties || '{}'),
+            updatedAt: row.updated_at,
+        };
+    }
+    upsertEntity(entity) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_entities (id, companion_id, entity_type, domain, name, properties, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(id) DO UPDATE SET
+        entity_type = excluded.entity_type,
+        domain = excluded.domain,
+        name = excluded.name,
+        properties = excluded.properties,
+        updated_at = datetime('now')
+    `);
+        stmt.run(entity.id, entity.companionId, entity.entityType, entity.domain, entity.name, JSON.stringify(entity.properties || {}));
+    }
+    deleteEntity(id) {
+        const stmt = this.db.prepare('DELETE FROM life_entities WHERE id = ?');
+        const res = stmt.run(id);
+        return res.changes > 0;
+    }
+    // --- Generic Life Events (Telemetry & Logs) Methods ---
+    getEvents(companionId, stream, limit = 50) {
+        let query = 'SELECT * FROM life_events WHERE companion_id = ?';
+        const params = [companionId];
+        if (stream) {
+            query += ' AND stream = ?';
+            params.push(stream);
+        }
+        query += ' ORDER BY timestamp DESC LIMIT ?';
+        params.push(limit);
+        const stmt = this.db.prepare(query);
+        return stmt.all(...params).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            stream: row.stream,
+            timestamp: row.timestamp,
+            metricValue: row.metric_value != null ? row.metric_value : undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        }));
+    }
+    addEvent(event) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_events (id, companion_id, stream, timestamp, metric_value, metadata)
+      VALUES (?, ?, ?, coalesce(?, datetime('now')), ?, ?)
+    `);
+        stmt.run(event.id, event.companionId, event.stream, event.timestamp || null, event.metricValue != null ? event.metricValue : null, event.metadata ? JSON.stringify(event.metadata) : null);
+    }
+    // --- Generic Life Tasks (Verbs & Progress) Methods ---
+    getTasks(companionId, status) {
+        let query = 'SELECT * FROM life_tasks WHERE companion_id = ?';
+        const params = [companionId];
+        if (status) {
+            query += ' AND status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY priority DESC, updated_at DESC';
+        const stmt = this.db.prepare(query);
+        return stmt.all(...params).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            title: row.title,
+            status: row.status,
+            priority: row.priority,
+            targetDate: row.target_date || undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            updatedAt: row.updated_at,
+        }));
+    }
+    upsertTask(task) {
+        const stmt = this.db.prepare(`
+      INSERT INTO life_tasks (id, companion_id, title, status, priority, target_date, metadata, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(id) DO UPDATE SET
+        title = excluded.title,
+        status = excluded.status,
+        priority = excluded.priority,
+        target_date = excluded.target_date,
+        metadata = excluded.metadata,
+        updated_at = datetime('now')
+    `);
+        stmt.run(task.id, task.companionId, task.title, task.status || 'backlog', task.priority ?? 0, task.targetDate || null, task.metadata ? JSON.stringify(task.metadata) : null);
+    }
+    deleteTask(id) {
+        const stmt = this.db.prepare('DELETE FROM life_tasks WHERE id = ?');
+        const res = stmt.run(id);
+        return res.changes > 0;
+    }
+    // ==========================================
+    // Memory Domain Methods
+    // ==========================================
+    recordEvent(event) {
+        const stmt = this.db.prepare(`
+      INSERT INTO memory_events (id, companion_id, source_type, occurred_at, payload)
+      VALUES (?, ?, ?, coalesce(?, datetime('now')), ?)
+    `);
+        stmt.run(event.id, event.companionId, event.sourceType, event.occurredAt || null, JSON.stringify(event.payload));
+    }
+    getRecentEvents(companionId, limit = 50) {
+        const stmt = this.db.prepare('SELECT * FROM memory_events WHERE companion_id = ? ORDER BY occurred_at DESC LIMIT ?');
+        return stmt.all(companionId, limit).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            sourceType: row.source_type,
+            occurredAt: row.occurred_at,
+            payload: JSON.parse(row.payload)
+        }));
+    }
+    getEvent(id) {
+        const stmt = this.db.prepare('SELECT * FROM memory_events WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            sourceType: row.source_type,
+            occurredAt: row.occurred_at,
+            payload: JSON.parse(row.payload)
+        };
+    }
+    rowToMemoryClaim(row) {
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            subject: row.subject,
+            predicate: row.predicate,
+            value: row.value,
+            status: normalizeStatus(row.status, 'pending'),
+            confidence: row.confidence,
+            validFrom: row.valid_from || undefined,
+            validUntil: row.valid_until || undefined,
+            evidence: row.evidence ? (typeof row.evidence === 'string' ? JSON.parse(row.evidence) : row.evidence) : undefined,
+            assertedAt: row.asserted_at,
+            supersedes: row.supersedes || undefined,
+            sourceEventId: row.source_event_id || undefined,
+        };
+    }
+    proposeClaim(claim) {
+        const id = claim.id || crypto.randomUUID();
+        const status = normalizeStatus(claim.status, 'pending');
+        const confidence = claim.confidence ?? 1.0;
+        const assertedAt = claim.assertedAt || new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO memory_claims (id, companion_id, subject, predicate, value, status, confidence, valid_from, valid_until, evidence, asserted_at, supersedes, source_event_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, coalesce(?, datetime('now')), ?, ?)
+    `);
+        stmt.run(id, claim.companionId || 'default', claim.subject, claim.predicate, claim.value, status, confidence, claim.validFrom || null, claim.validUntil || null, claim.evidence ? JSON.stringify(claim.evidence) : null, assertedAt || null, claim.supersedes || null, claim.sourceEventId || null);
+        return {
+            ...claim,
+            id,
+            status: status,
+            confidence,
+            assertedAt,
+            supersedes: claim.supersedes,
+            sourceEventId: claim.sourceEventId,
+        };
+    }
+    approveClaim(id, companionId) {
+        const findClaim = companionId
+            ? this.db.prepare("SELECT id, subject, predicate, status, supersedes FROM memory_claims WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, subject, predicate, status, supersedes FROM memory_claims WHERE id = ?");
+        const row = (companionId ? findClaim.get(id, companionId) : findClaim.get(id));
+        if (!row) {
+            return;
+        }
+        if (normalizeStatus(row.status) !== 'pending') {
+            if (normalizeStatus(row.status) === 'approved') {
+                return;
+            }
+            throw new Error(`Cannot approve claim '${id}': invalid transition from status '${row.status}' to 'approved' (only pending claims can be approved)`);
+        }
+        // Explicit supersession transition: if claim explicitly targets an earlier claim
+        if (row.supersedes) {
+            const supersededId = row.supersedes;
+            if (companionId) {
+                const supersedeStmt = this.db.prepare("UPDATE memory_claims SET status = 'superseded' WHERE id = ? AND companion_id = ?");
+                supersedeStmt.run(supersededId, companionId);
+            }
+            else {
+                const supersedeStmt = this.db.prepare("UPDATE memory_claims SET status = 'superseded' WHERE id = ?");
+                supersedeStmt.run(supersededId);
+            }
+        }
+        // Automatic supersession for single-value predicates:
+        // When a single-value predicate (e.g. name, role, creator, preferred_address) is approved,
+        // transition previous active/approved claims on the same subject & predicate to 'superseded'
+        const SINGLE_VALUE_PREDICATES = new Set([
+            'name',
+            'preferred_name',
+            'preferred_address',
+            'preferred_form_of_address',
+            'form_of_address',
+            'title',
+            'honorific',
+            'role',
+            'archetype',
+            'origin',
+            'created_by',
+            'stated_relationship',
+            'relationship',
+            'relationship_to_siduri',
+            'ethos',
+            'server',
+            'uid',
+            'preferred_language',
+        ]);
+        const lowerPred = (row.predicate || '').toLowerCase();
+        if (SINGLE_VALUE_PREDICATES.has(lowerPred)) {
+            const effCompanionId = companionId || 'default';
+            const autoSupersedeStmt = this.db.prepare(`
+        UPDATE memory_claims 
+        SET status = 'superseded' 
+        WHERE companion_id = ? 
+          AND LOWER(subject) = LOWER(?) 
+          AND LOWER(predicate) = LOWER(?) 
+          AND id != ? 
+          AND LOWER(status) IN ('approved', 'pending')
+      `);
+            autoSupersedeStmt.run(effCompanionId, row.subject, row.predicate, id);
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'approved' WHERE id = ? AND companion_id = ? AND LOWER(status) = 'pending'");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'approved' WHERE id = ? AND LOWER(status) = 'pending'");
+            stmt.run(id);
+        }
+        // Canonically promote approved claim to Self domain state (identity, role, relationships)
+        const approvedClaim = this.getClaim(id);
+        if (approvedClaim) {
+            this.promoteClaimToSelf(approvedClaim);
+        }
+    }
+    /**
+     * Canonically promotes a Claim into Self domain tables.
+     */
+    promoteClaimToSelf(claim) {
+        const companionId = claim.companionId || 'default';
+        const subject = (claim.subject || '').toLowerCase();
+        const predicate = (claim.predicate || '').toLowerCase();
+        const value = claim.value || '';
+        if (!value)
+            return;
+        // 1. Identity mutations: companion identity/role/origin/name/ethos
+        const isCompanionTarget = subject.startsWith('companion') ||
+            subject === 'siduri' ||
+            subject === 'self' ||
+            subject === 'assistant' ||
+            subject === 'persona' ||
+            subject === 'ai' ||
+            subject === 'me' ||
+            ((predicate === 'name' || predicate === 'role' || predicate === 'archetype' || predicate === 'ethos' || predicate === 'origin') &&
+                !subject.startsWith('actor:') &&
+                subject !== 'user' &&
+                subject !== 'primary_user' &&
+                subject !== 'owner' &&
+                subject !== 'creator');
+        if (isCompanionTarget) {
+            const existing = this.getIdentity(companionId) || {
+                companionId,
+                name: '',
+                version: '1.0.0',
+                updatedAt: new Date().toISOString(),
+            };
+            if (predicate === 'role' || predicate === 'archetype') {
+                existing.archetype = value;
+                existing.role = value;
+                this.setIdentity(existing);
+                this.commitDirective({
+                    id: `dir-role-${claim.id || Date.now()}`,
+                    companionId,
+                    priority: 70,
+                    directive: `Acknowledge role as ${value}`,
+                    status: 'active',
+                    category: 'relational',
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            else if (predicate === 'origin' || predicate === 'created_by') {
+                existing.origin = value;
+                this.setIdentity(existing);
+            }
+            else if (predicate === 'name') {
+                existing.name = value;
+                this.setIdentity(existing);
+            }
+            else if (predicate === 'ethos') {
+                existing.ethos = value;
+                this.setIdentity(existing);
+            }
+            return;
+        }
+        // 2. Relationship mutations: creator or user stated relationship, name, preferred address, or affiliation
+        const isPreferredAddress = [
+            'preferred_address',
+            'preferred_form_of_address',
+            'preferred_name',
+            'form_of_address',
+            'title',
+            'honorific',
+            'call_me',
+            'addressed_as',
+        ].includes(predicate);
+        const isName = (predicate === 'name' && (subject.startsWith('actor:') || subject === 'user' || subject === 'primary_user')) || isPreferredAddress;
+        if (claim.claimType === 'relationship' ||
+            predicate === 'stated_relationship' ||
+            predicate === 'relationship' ||
+            predicate === 'relationship_to_siduri' ||
+            predicate === 'affiliation' ||
+            isName) {
+            const rawSubject = (claim.subject || 'actor:user').replace(/^actor:actor:/, 'actor:');
+            const isCreator = value.toLowerCase().includes('creator');
+            const isAffil = predicate === 'affiliation';
+            const existingRel = this.getRelationship(companionId, rawSubject);
+            const isPriorCreator = existingRel?.role === 'creator' || (existingRel?.stance === 'familiar_loyal' && existingRel.trustScore === 1.0);
+            const role = isCreator
+                ? 'creator'
+                : (isPriorCreator ? 'creator' : (existingRel?.role && existingRel.role !== 'user' ? existingRel.role : (isName || isAffil ? existingRel?.role || 'user' : value)));
+            const name = isName ? (isPreferredAddress && existingRel?.name ? existingRel.name : value) : existingRel?.name;
+            const affiliation = isAffil ? value : existingRel?.affiliation;
+            const stance = isCreator || isPriorCreator ? 'familiar_loyal' : (existingRel?.stance || 'neutral');
+            const trustScore = isCreator || isPriorCreator ? 1.0 : (existingRel?.trustScore ?? 0.8);
+            const familiarity = isCreator || isPriorCreator ? 0.9 : (existingRel?.familiarity ?? 0.5);
+            const conventions = isCreator || isPriorCreator
+                ? Array.from(new Set([...(existingRel?.interactionConventions || []), 'Direct communication', 'Highest administrative trust']))
+                : [...(existingRel?.interactionConventions || [])];
+            if (isPreferredAddress) {
+                const filteredConvs = conventions.filter((c) => !c.toLowerCase().startsWith('address as'));
+                filteredConvs.push(`Address as ${value}`);
+                conventions.length = 0;
+                conventions.push(...filteredConvs);
+            }
+            this.upsertRelationship({
+                companionId,
+                entityId: rawSubject,
+                entityType: 'human',
+                name,
+                affiliation,
+                role,
+                stance,
+                trustScore,
+                familiarity,
+                interactionConventions: conventions,
+            });
+            // Dual promotion: If this actor is established as creator, also populate companion's origin in self_identity
+            if (isCreator || (isName && isPriorCreator)) {
+                const existingIdentity = this.getIdentity(companionId) || {
+                    companionId,
+                    name: 'Siduri',
+                    version: '1.0.0',
+                    updatedAt: new Date().toISOString(),
+                };
+                const creatorName = name || existingRel?.name || (rawSubject.startsWith('actor:') && rawSubject !== 'actor:user' && rawSubject !== 'actor:primary' ? rawSubject.slice(6) : value);
+                existingIdentity.origin = creatorName !== 'user' && creatorName !== 'primary' ? creatorName : value;
+                existingIdentity.updatedAt = new Date().toISOString();
+                this.setIdentity(existingIdentity);
+            }
+            if (isName) {
+                const priority = isPreferredAddress ? 85 : 75;
+                const directiveId = isPreferredAddress ? `dir-prefaddr-${claim.id || Date.now()}` : `dir-name-${claim.id || Date.now()}`;
+                // If preferred address, supersede/revoke older address directives for this subject
+                if (isPreferredAddress) {
+                    const existingDirectives = this.getAllDirectives(companionId);
+                    for (const d of existingDirectives) {
+                        const lowerDir = (d.directive || '').toLowerCase();
+                        const lowerSubj = rawSubject.toLowerCase();
+                        if ((d.status === 'active' || d.status === 'pending') &&
+                            d.id !== directiveId &&
+                            (lowerDir.startsWith(`address ${lowerSubj} as`) ||
+                                lowerDir.startsWith('address the user as') ||
+                                lowerDir.startsWith('address actor:user as') ||
+                                lowerDir.startsWith('address user as'))) {
+                            this.supersedeDirective(d.id, companionId);
+                        }
+                    }
+                }
+                this.commitDirective({
+                    id: directiveId,
+                    companionId,
+                    priority,
+                    directive: `Address ${rawSubject} as ${value}`,
+                    status: 'active',
+                    category: 'relational',
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            return;
+        }
+        // 3. Behavioral rule claim
+        if (predicate === 'behavioral_rule' || predicate === 'rule') {
+            this.commitDirective({
+                id: `dir-rule-${claim.id || Date.now()}`,
+                companionId,
+                priority: 60,
+                directive: value,
+                status: 'active',
+                category: 'behavioral',
+                createdAt: new Date().toISOString(),
+            });
+        }
+    }
+    rejectClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'rejected' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'rejected' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    revokeClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'revoked' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'revoked' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    expireClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'expired' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'expired' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    markClaimSessionOnly(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'session-only' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'session-only' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    searchClaims(companionId, query, limit = 20) {
+        const cleanTokens = query
+            .replace(/[^\p{L}\p{N}\s_]/gu, ' ')
+            .trim()
+            .split(/\s+/)
+            .filter((t) => t.length > 0)
+            .map((t) => `"${t.replace(/"/g, '""')}"`);
+        if (cleanTokens.length === 0)
+            return [];
+        const ftsQuery = cleanTokens.join(' OR ');
+        const stmt = this.db.prepare(`
+      SELECT c.* FROM memory_claims c
+      JOIN memory_search s ON c.rowid = s.rowid
+      WHERE c.companion_id = ? AND LOWER(c.status) = 'approved' AND memory_search MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+        return stmt.all(companionId, ftsQuery, limit).map((row) => this.rowToMemoryClaim(row));
+    }
+    getPendingClaims(companionId, limit = 50) {
+        const stmt = this.db.prepare("SELECT * FROM memory_claims WHERE companion_id = ? AND LOWER(status) = 'pending' ORDER BY asserted_at DESC LIMIT ?");
+        return stmt.all(companionId, limit).map((row) => this.rowToMemoryClaim(row));
+    }
+    getApprovedClaims(companionId, limit = 50) {
+        const stmt = this.db.prepare("SELECT * FROM memory_claims WHERE companion_id = ? AND LOWER(status) = 'approved' ORDER BY asserted_at DESC LIMIT ?");
+        return stmt.all(companionId, limit).map((row) => this.rowToMemoryClaim(row));
+    }
+    getAllClaims(companionId, limit = 100) {
+        const stmt = companionId
+            ? this.db.prepare("SELECT * FROM memory_claims WHERE companion_id = ? ORDER BY asserted_at DESC LIMIT ?")
+            : this.db.prepare("SELECT * FROM memory_claims ORDER BY asserted_at DESC LIMIT ?");
+        const rows = companionId ? stmt.all(companionId, limit) : stmt.all(limit);
+        return rows.map((row) => this.rowToMemoryClaim(row));
+    }
+    getClaim(id) {
+        const stmt = this.db.prepare("SELECT * FROM memory_claims WHERE id = ?");
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return this.rowToMemoryClaim(row);
+    }
+    resetMemory(companionId) {
+        const deleteClaims = this.db.prepare("DELETE FROM memory_claims WHERE companion_id = ?");
+        deleteClaims.run(companionId);
+        const deleteEvents = this.db.prepare("DELETE FROM memory_events WHERE companion_id = ?");
+        deleteEvents.run(companionId);
+    }
+    // --- System Logs ---
+    insertLog(entry) {
+        const id = entry.id || crypto.randomUUID();
+        const companionId = entry.companionId || 'default';
+        const level = (entry.level || 'info').toLowerCase();
+        const subsystem = (entry.subsystem || 'system').toLowerCase();
+        const message = entry.message || '';
+        const metadata = entry.metadata ? JSON.stringify(entry.metadata) : null;
+        const createdAt = entry.createdAt || new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO system_logs (id, companion_id, level, subsystem, message, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, companionId, level, subsystem, message, metadata, createdAt);
+        // Prune logs beyond 5000 per companion to prevent unbounded growth
+        try {
+            this.db.prepare(`
+        DELETE FROM system_logs
+        WHERE companion_id = ? AND rowid NOT IN (
+          SELECT rowid FROM system_logs WHERE companion_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 5000
+        )
+      `).run(companionId, companionId);
+        }
+        catch {
+            // Best effort pruning
+        }
+        return {
+            id,
+            companionId,
+            level,
+            subsystem,
+            message,
+            metadata: entry.metadata,
+            createdAt,
+        };
+    }
+    queryLogs(options = {}) {
+        const conditions = [];
+        const params = [];
+        if (options.companionId) {
+            conditions.push('companion_id = ?');
+            params.push(options.companionId);
+        }
+        if (options.level && options.level !== 'all') {
+            conditions.push('level = ?');
+            params.push(options.level.toLowerCase());
+        }
+        if (options.subsystem && options.subsystem !== 'all') {
+            conditions.push('subsystem = ?');
+            params.push(options.subsystem.toLowerCase());
+        }
+        if (options.q && options.q.trim().length > 0) {
+            conditions.push('(message LIKE ? OR metadata LIKE ?)');
+            const term = `%${options.q.trim()}%`;
+            params.push(term, term);
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = Math.min(Math.max(Number(options.limit) || 100, 1), 1000);
+        const offset = Math.max(Number(options.offset) || 0, 0);
+        const query = `
+      SELECT id, companion_id, level, subsystem, message, metadata, created_at
+      FROM system_logs
+      ${whereClause}
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT ? OFFSET ?
+    `;
+        params.push(limit, offset);
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            level: row.level,
+            subsystem: row.subsystem,
+            message: row.message,
+            metadata: row.metadata ? safeJsonParse(row.metadata) : undefined,
+            createdAt: row.created_at,
+        }));
+    }
+    clearLogs(companionId) {
+        if (companionId) {
+            this.db.prepare('DELETE FROM system_logs WHERE companion_id = ?').run(companionId);
+        }
+        else {
+            this.db.prepare('DELETE FROM system_logs').run();
+        }
+    }
+}
+exports.SiduriDatabase = SiduriDatabase;