create-walle 0.1.0

package/template/wall-e/brain.js

@@ -0,0 +1,1235 @@
+// --- WALL-E Brain: SQLite Database Layer (WAL mode, better-sqlite3) ---
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const { v4: uuidv4 } = require('uuid');
+
+// Load .env from project root (ensures standalone scripts get env vars too)
+try {
+  const _envPath = path.resolve(__dirname, '..', '.env');
+  fs.readFileSync(_envPath, 'utf8').split('\n').forEach(line => {
+    const m = line.match(/^\s*([^#=]+?)\s*=\s*(.*?)\s*$/);
+    if (m && !process.env[m[1]]) process.env[m[1]] = m[2];
+  });
+} catch {}
+
+const DATA_DIR = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
+const DEFAULT_DB_PATH = path.join(DATA_DIR, 'wall-e-brain.db');
+const BACKUP_DIR = path.join(DATA_DIR, 'backups');
+
+let db = null;
+let currentDbPath = null;
+
+function getDb() {
+  if (db) return db;
+  throw new Error('Database not initialized. Call initDb() first.');
+}
+
+function getDbPath() {
+  return currentDbPath || DEFAULT_DB_PATH;
+}
+
+function initDb(dbPath) {
+  dbPath = dbPath || DEFAULT_DB_PATH;
+  currentDbPath = dbPath;
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
+
+  const newDb = new Database(dbPath);
+  try {
+    newDb.pragma('journal_mode = WAL');
+    newDb.pragma('busy_timeout = 5000');
+    newDb.pragma('foreign_keys = ON');
+    db = newDb;
+    createTables();
+    // Migrations: add skill columns to tasks table if missing
+    try { newDb.prepare("SELECT skill FROM tasks LIMIT 0").run(); } catch (_) {
+      newDb.prepare("ALTER TABLE tasks ADD COLUMN skill TEXT").run();
+    }
+    try { newDb.prepare("SELECT skill_config FROM tasks LIMIT 0").run(); } catch (_) {
+      newDb.prepare("ALTER TABLE tasks ADD COLUMN skill_config TEXT").run();
+    }
+  } catch (err) {
+    newDb.close();
+    db = null;
+    currentDbPath = null;
+    throw err;
+  }
+  return db;
+}
+
+function createTables() {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS owner (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      source TEXT NOT NULL,
+      source_id TEXT,
+      source_channel TEXT,
+      memory_type TEXT NOT NULL,
+      direction TEXT,
+      participants TEXT,
+      subject TEXT,
+      content TEXT NOT NULL,
+      content_raw TEXT,
+      metadata TEXT,
+      importance REAL DEFAULT 0.5,
+      timestamp TEXT NOT NULL,
+      ingested_at TEXT DEFAULT (datetime('now')),
+      archived_at TEXT,
+      extraction_status TEXT DEFAULT 'pending'
+    );
+
+    CREATE TABLE IF NOT EXISTS knowledge (
+      id TEXT PRIMARY KEY,
+      category TEXT NOT NULL,
+      subject TEXT NOT NULL,
+      predicate TEXT NOT NULL,
+      object TEXT NOT NULL,
+      confidence REAL DEFAULT 0.5,
+      source_memory_ids TEXT,
+      first_seen TEXT NOT NULL,
+      last_confirmed TEXT NOT NULL,
+      times_confirmed INTEGER DEFAULT 1,
+      superseded_by TEXT REFERENCES knowledge(id),
+      status TEXT DEFAULT 'active'
+    );
+
+    CREATE TABLE IF NOT EXISTS patterns (
+      id TEXT PRIMARY KEY,
+      pattern_type TEXT NOT NULL,
+      domain TEXT,
+      description TEXT NOT NULL,
+      pattern_data TEXT NOT NULL,
+      sample_size INTEGER DEFAULT 0,
+      confidence REAL DEFAULT 0.5,
+      first_observed TEXT NOT NULL,
+      last_observed TEXT NOT NULL,
+      status TEXT DEFAULT 'active'
+    );
+
+    CREATE TABLE IF NOT EXISTS code_identity (
+      id TEXT PRIMARY KEY,
+      aspect TEXT NOT NULL,
+      description TEXT NOT NULL,
+      evidence TEXT,
+      evidence_sources TEXT,
+      strength REAL DEFAULT 0.5,
+      repos_observed TEXT,
+      first_seen TEXT,
+      last_seen TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS people (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      aliases TEXT,
+      identities TEXT,
+      relationship TEXT,
+      trust_level REAL DEFAULT 0.5,
+      trust_reason TEXT,
+      interaction_freq TEXT,
+      last_interaction TEXT,
+      notes TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS personas (
+      id TEXT PRIMARY KEY,
+      person_id TEXT REFERENCES people(id),
+      persona_type TEXT,
+      sharing_rules TEXT,
+      tone TEXT,
+      boundaries TEXT,
+      examples TEXT,
+      last_updated TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS current_state (
+      id TEXT PRIMARY KEY,
+      state_type TEXT NOT NULL,
+      value TEXT NOT NULL,
+      priority INTEGER DEFAULT 0,
+      started_at TEXT,
+      expires_at TEXT,
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS loop_checkpoints (
+      loop_name TEXT PRIMARY KEY,
+      last_run_at TEXT NOT NULL,
+      last_memory_at TEXT,
+      metadata TEXT,
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_actions (
+      id TEXT PRIMARY KEY,
+      action_type TEXT NOT NULL,
+      tier INTEGER NOT NULL,
+      domain TEXT,
+      trigger_memory_id TEXT REFERENCES memories(id),
+      description TEXT NOT NULL,
+      content TEXT,
+      target TEXT,
+      confidence REAL NOT NULL,
+      status TEXT DEFAULT 'pending',
+      review_note TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      acted_at TEXT,
+      reviewed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS domain_confidence (
+      id TEXT PRIMARY KEY,
+      domain TEXT NOT NULL UNIQUE,
+      current_tier INTEGER DEFAULT 1,
+      confidence REAL DEFAULT 0.3,
+      total_actions INTEGER DEFAULT 0,
+      approved_actions INTEGER DEFAULT 0,
+      rejected_actions INTEGER DEFAULT 0,
+      last_promotion TEXT,
+      last_demotion TEXT,
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS pending_questions (
+      id TEXT PRIMARY KEY,
+      question_type TEXT NOT NULL,
+      question TEXT NOT NULL,
+      context TEXT,
+      options TEXT,
+      priority TEXT DEFAULT 'normal',
+      status TEXT DEFAULT 'pending',
+      answer TEXT,
+      resolution_type TEXT,
+      resolution_evidence TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      answered_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_exchanges (
+      id TEXT PRIMARY KEY,
+      direction TEXT NOT NULL,
+      remote_agent_id TEXT NOT NULL,
+      person_id TEXT REFERENCES people(id),
+      persona_id TEXT REFERENCES personas(id),
+      topic TEXT,
+      message_in TEXT,
+      message_out TEXT,
+      shared_knowledge TEXT,
+      withheld TEXT,
+      confidence REAL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Indexes
+    CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source, source_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_memories_time ON memories(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+    CREATE INDEX IF NOT EXISTS idx_memories_extraction ON memories(extraction_status);
+
+    CREATE INDEX IF NOT EXISTS idx_knowledge_subject ON knowledge(subject, predicate);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_category ON knowledge(category);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_status ON knowledge(status);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_active_subject ON knowledge(status, subject, predicate);
+
+    CREATE INDEX IF NOT EXISTS idx_patterns_type_domain ON patterns(pattern_type, domain);
+    CREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);
+
+    CREATE INDEX IF NOT EXISTS idx_code_identity_aspect ON code_identity(aspect);
+
+    CREATE INDEX IF NOT EXISTS idx_people_name ON people(name);
+    CREATE INDEX IF NOT EXISTS idx_people_relationship ON people(relationship);
+
+    CREATE INDEX IF NOT EXISTS idx_personas_person ON personas(person_id);
+
+    CREATE INDEX IF NOT EXISTS idx_state_type ON current_state(state_type);
+
+    CREATE INDEX IF NOT EXISTS idx_actions_status ON agent_actions(status, created_at);
+    CREATE INDEX IF NOT EXISTS idx_actions_type ON agent_actions(action_type);
+    CREATE INDEX IF NOT EXISTS idx_actions_trigger ON agent_actions(trigger_memory_id);
+
+    CREATE INDEX IF NOT EXISTS idx_questions_status ON pending_questions(status);
+
+    CREATE INDEX IF NOT EXISTS idx_exchanges_person ON agent_exchanges(person_id);
+    CREATE INDEX IF NOT EXISTS idx_exchanges_remote ON agent_exchanges(remote_agent_id);
+
+    CREATE TABLE IF NOT EXISTS daily_summaries (
+      id TEXT PRIMARY KEY,
+      date TEXT NOT NULL UNIQUE,
+      summary TEXT NOT NULL,
+      stats TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_daily_summaries_date ON daily_summaries(date);
+
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id TEXT PRIMARY KEY,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      channel TEXT DEFAULT 'ctm',
+      session_id TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_time ON chat_messages(created_at);
+
+    CREATE TABLE IF NOT EXISTS skills (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      tool_definitions TEXT,
+      trigger_type TEXT DEFAULT 'interval',
+      trigger_config TEXT,
+      prompt_template TEXT,
+      enabled INTEGER DEFAULT 1,
+      success_count INTEGER DEFAULT 0,
+      failure_count INTEGER DEFAULT 0,
+      last_run TEXT,
+      last_result TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_skills_enabled ON skills(enabled);
+
+    CREATE TABLE IF NOT EXISTS skill_executions (
+      id TEXT PRIMARY KEY,
+      skill_id TEXT REFERENCES skills(id),
+      status TEXT NOT NULL,
+      tool_calls TEXT,
+      tool_results TEXT,
+      memories_created INTEGER DEFAULT 0,
+      error TEXT,
+      duration_ms INTEGER,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_skill_exec_skill ON skill_executions(skill_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS briefing_items (
+      id TEXT PRIMARY KEY,
+      task_id TEXT,
+      skill TEXT,
+      title TEXT NOT NULL,
+      category TEXT,
+      owner TEXT,
+      urgency TEXT DEFAULT 'low',
+      status TEXT DEFAULT 'open',
+      snooze_until TEXT,
+      context TEXT,
+      first_seen TEXT NOT NULL,
+      last_seen TEXT NOT NULL,
+      times_seen INTEGER DEFAULT 1,
+      resolved_at TEXT,
+      notes TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_briefing_items_status ON briefing_items(status);
+    CREATE INDEX IF NOT EXISTS idx_briefing_items_skill ON briefing_items(skill, status);
+    CREATE INDEX IF NOT EXISTS idx_briefing_items_task ON briefing_items(task_id);
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT DEFAULT 'pending',
+      priority TEXT DEFAULT 'normal',
+      type TEXT DEFAULT 'once',
+      execution TEXT DEFAULT 'chat',
+      script TEXT,
+      schedule TEXT,
+      due_at TEXT,
+      next_run_at TEXT,
+      started_at TEXT,
+      completed_at TEXT,
+      last_run_at TEXT,
+      run_count INTEGER DEFAULT 0,
+      result TEXT,
+      error TEXT,
+      checkpoint TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_due ON tasks(due_at);
+    CREATE INDEX IF NOT EXISTS idx_tasks_next ON tasks(next_run_at);
+  `);
+}
+
+function closeDb() {
+  if (backupIntervalId) {
+    clearInterval(backupIntervalId);
+    backupIntervalId = null;
+  }
+  if (db) {
+    try { db.pragma('wal_checkpoint(TRUNCATE)'); } catch (_) {}
+    db.close();
+    db = null;
+    currentDbPath = null;
+  }
+}
+
+// -- Owner config --
+
+function setOwner(key, value) {
+  getDb().prepare(
+    'INSERT INTO owner (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'
+  ).run(key, value);
+}
+
+function getOwner(key) {
+  const row = getDb().prepare('SELECT value FROM owner WHERE key = ?').get(key);
+  return row ? row.value : null;
+}
+
+function getOwnerName() {
+  return getOwner('name');
+}
+
+// -- Memory CRUD --
+
+function insertMemory(mem) {
+  if (!mem.source) throw new Error('Memory requires source');
+  if (!mem.memory_type) throw new Error('Memory requires memory_type');
+  if (!mem.content) throw new Error('Memory requires content');
+  if (!mem.timestamp) throw new Error('Memory requires timestamp');
+
+  // Dedup: if source+source_id already exists, skip
+  if (mem.source_id) {
+    const existing = getDb().prepare(
+      'SELECT id FROM memories WHERE source = ? AND source_id = ?'
+    ).get(mem.source, mem.source_id);
+    if (existing) return null;
+  }
+
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO memories (id, source, source_id, source_channel, memory_type, direction, participants, subject, content, content_raw, metadata, importance, timestamp)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, mem.source, mem.source_id || null, mem.source_channel || null,
+    mem.memory_type, mem.direction || null, mem.participants || null,
+    mem.subject || null, mem.content, mem.content_raw || null,
+    mem.metadata || null, mem.importance ?? 0.5, mem.timestamp
+  );
+  return { id };
+}
+
+function getMemory(id) {
+  return getDb().prepare('SELECT * FROM memories WHERE id = ?').get(id) || null;
+}
+
+function listMemories({ source, since, extractionStatus, limit } = {}) {
+  const conditions = [];
+  const params = [];
+
+  if (source) {
+    conditions.push('source = ?');
+    params.push(source);
+  }
+  if (since) {
+    conditions.push('timestamp >= ?');
+    params.push(since);
+  }
+  if (extractionStatus) {
+    conditions.push('extraction_status = ?');
+    params.push(extractionStatus);
+  }
+
+  let sql = 'SELECT * FROM memories';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY timestamp DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    params.push(limit);
+  }
+
+  return getDb().prepare(sql).all(...params);
+}
+
+function updateMemoryExtraction(id, status) {
+  getDb().prepare('UPDATE memories SET extraction_status = ? WHERE id = ?').run(status, id);
+}
+
+// -- Knowledge CRUD --
+
+function insertKnowledge(k) {
+  if (!k.category) throw new Error('Knowledge requires category');
+  if (!k.subject) throw new Error('Knowledge requires subject');
+  if (!k.predicate) throw new Error('Knowledge requires predicate');
+  if (!k.object) throw new Error('Knowledge requires object');
+
+  const id = uuidv4();
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO knowledge (id, category, subject, predicate, object, confidence, source_memory_ids, first_seen, last_confirmed)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, k.category, k.subject, k.predicate, k.object,
+    k.confidence ?? 0.5, k.source_memory_ids || null, now, now
+  );
+  return { id };
+}
+
+function getKnowledge(id) {
+  return getDb().prepare('SELECT * FROM knowledge WHERE id = ?').get(id) || null;
+}
+
+function findKnowledge({ subject, predicate, status, category } = {}) {
+  const conditions = [];
+  const params = [];
+
+  if (subject) {
+    conditions.push('subject = ?');
+    params.push(subject);
+  }
+  if (predicate) {
+    conditions.push('predicate = ?');
+    params.push(predicate);
+  }
+  if (status) {
+    conditions.push('status = ?');
+    params.push(status);
+  }
+  if (category) {
+    conditions.push('category = ?');
+    params.push(category);
+  }
+
+  let sql = 'SELECT * FROM knowledge';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY last_confirmed DESC';
+
+  return getDb().prepare(sql).all(...params);
+}
+
+// -- Checkpoint CRUD --
+
+function upsertCheckpoint(loopName, data) {
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO loop_checkpoints (loop_name, last_run_at, last_memory_at, metadata, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(loop_name) DO UPDATE SET
+      last_run_at = excluded.last_run_at,
+      last_memory_at = excluded.last_memory_at,
+      metadata = excluded.metadata,
+      updated_at = excluded.updated_at
+  `).run(
+    loopName, now, data.last_memory_at || null, data.metadata || null, now
+  );
+}
+
+function getCheckpoint(loopName) {
+  return getDb().prepare('SELECT * FROM loop_checkpoints WHERE loop_name = ?').get(loopName) || null;
+}
+
+// -- Backup --
+
+let backupIntervalId = null;
+
+function createBackup(label) {
+  getDb(); // throws if not initialized
+  db.pragma('wal_checkpoint(TRUNCATE)');
+
+  const timestamp = new Date().toISOString().replace(/:/g, '-');
+  const backupName = `wall-e-brain-${timestamp}-${label}.db`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+
+  if (!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
+  fs.copyFileSync(currentDbPath, backupPath);
+
+  cleanOldBackups();
+
+  return { backupName, backupPath, timestamp };
+}
+
+function cleanOldBackups() {
+  if (!fs.existsSync(BACKUP_DIR)) return;
+  const files = fs.readdirSync(BACKUP_DIR);
+  const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+
+  for (const file of files) {
+    if (file.startsWith('wall-e-brain-') && file.endsWith('.db')) {
+      const filePath = path.join(BACKUP_DIR, file);
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < thirtyDaysAgo) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  }
+}
+
+function startDailyBackup() {
+  // Check if backup exists for today
+  const today = new Date().toISOString().slice(0, 10);
+  let needsBackup = true;
+
+  if (fs.existsSync(BACKUP_DIR)) {
+    const files = fs.readdirSync(BACKUP_DIR);
+    const todayPrefix = `wall-e-brain-${today}`;
+    needsBackup = !files.some(f => f.startsWith(todayPrefix) && f.endsWith('.db'));
+  }
+
+  if (needsBackup) {
+    try { createBackup('daily'); } catch (_) {}
+  }
+
+  // Check hourly
+  backupIntervalId = setInterval(() => {
+    const todayNow = new Date().toISOString().slice(0, 10);
+    let exists = false;
+    if (fs.existsSync(BACKUP_DIR)) {
+      const files = fs.readdirSync(BACKUP_DIR);
+      const prefix = `wall-e-brain-${todayNow}`;
+      exists = files.some(f => f.startsWith(prefix) && f.endsWith('.db'));
+    }
+    if (!exists) {
+      try { createBackup('daily'); } catch (_) {}
+    }
+  }, 60 * 60 * 1000);
+
+  // Don't keep process alive just for backups
+  if (backupIntervalId.unref) backupIntervalId.unref();
+}
+
+// -- People CRUD --
+
+function insertPerson({ name, relationship, aliases, identities, trust_level, notes }) {
+  if (!name) throw new Error('Person requires name');
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO people (id, name, relationship, aliases, identities, trust_level, notes)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(id, name, relationship || null, aliases || null, identities || null, trust_level ?? 0.5, notes || null);
+  return { id };
+}
+
+function getPerson(id) {
+  return getDb().prepare('SELECT * FROM people WHERE id = ?').get(id) || null;
+}
+
+function listPeople({ relationship, limit } = {}) {
+  const conditions = [];
+  const params = [];
+  if (relationship) {
+    conditions.push('relationship = ?');
+    params.push(relationship);
+  }
+  let sql = 'SELECT * FROM people';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY name';
+  if (limit) {
+    sql += ' LIMIT ?';
+    params.push(limit);
+  }
+  return getDb().prepare(sql).all(...params);
+}
+
+const PERSON_ALLOWED_FIELDS = ['trust_level', 'trust_reason', 'relationship', 'notes', 'aliases', 'identities', 'interaction_freq', 'last_interaction'];
+
+function updatePerson(id, updates) {
+  if (!updates || typeof updates !== 'object') throw new Error('Updates must be an object');
+  const keys = Object.keys(updates);
+  if (keys.length === 0) throw new Error('No updates provided');
+  const invalid = keys.filter(k => !PERSON_ALLOWED_FIELDS.includes(k));
+  if (invalid.length > 0) throw new Error(`Invalid update fields: ${invalid.join(', ')}`);
+
+  const sets = keys.map(k => `${k} = ?`);
+  const params = keys.map(k => updates[k]);
+  params.push(id);
+  const result = getDb().prepare(`UPDATE people SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+  if (result.changes === 0) throw new Error(`Person not found: ${id}`);
+}
+
+// -- Pending Questions --
+
+function insertQuestion({ question_type, question, context, options, priority }) {
+  if (!question_type) throw new Error('Question requires question_type');
+  if (!question) throw new Error('Question requires question');
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO pending_questions (id, question_type, question, context, options, priority)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, question_type, question, context || null, options || null, priority || 'normal');
+  return { id };
+}
+
+function listQuestions({ status, question_type, limit } = {}) {
+  const conditions = [];
+  const params = [];
+  if (status) {
+    conditions.push('status = ?');
+    params.push(status);
+  }
+  if (question_type) {
+    conditions.push('question_type = ?');
+    params.push(question_type);
+  }
+  let sql = 'SELECT * FROM pending_questions';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY created_at DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    params.push(limit);
+  }
+  return getDb().prepare(sql).all(...params);
+}
+
+function answerQuestion(id, { answer, resolution_type, resolution_evidence }) {
+  if (!answer) throw new Error('Answer is required');
+  if (!resolution_type) throw new Error('Resolution type is required');
+
+  const statusMap = {
+    answered: 'answered',
+    inferred: 'inferred',
+    dismissed: 'dismissed',
+    expired: 'expired',
+  };
+  const newStatus = statusMap[resolution_type];
+  if (!newStatus) throw new Error(`Invalid resolution_type: ${resolution_type}. Must be one of: ${Object.keys(statusMap).join(', ')}`);
+
+  const now = new Date().toISOString();
+  const result = getDb().prepare(`
+    UPDATE pending_questions SET answer = ?, resolution_type = ?, resolution_evidence = ?, status = ?, answered_at = ?
+    WHERE id = ?
+  `).run(answer, resolution_type, resolution_evidence || null, newStatus, now, id);
+  if (result.changes === 0) throw new Error(`Question not found: ${id}`);
+}
+
+// -- Knowledge updates --
+
+function supersedeKnowledge(oldId, newId) {
+  const result = getDb().prepare(
+    "UPDATE knowledge SET superseded_by = ?, status = 'superseded' WHERE id = ?"
+  ).run(newId, oldId);
+  if (result.changes === 0) throw new Error(`Knowledge not found: ${oldId}`);
+}
+
+const VALID_KNOWLEDGE_STATUSES = ['active', 'superseded', 'disputed', 'retracted'];
+
+function updateKnowledgeStatus(id, status) {
+  if (!VALID_KNOWLEDGE_STATUSES.includes(status)) {
+    throw new Error(`Invalid knowledge status: ${status}. Must be one of: ${VALID_KNOWLEDGE_STATUSES.join(', ')}`);
+  }
+  const result = getDb().prepare('UPDATE knowledge SET status = ? WHERE id = ?').run(status, id);
+  if (result.changes === 0) throw new Error(`Knowledge not found: ${id}`);
+}
+
+// -- Stats --
+
+function getBrainStats() {
+  const d = getDb();
+  const memory_count = d.prepare('SELECT count(*) as cnt FROM memories').get().cnt;
+  const knowledge_count = d.prepare('SELECT count(*) as cnt FROM knowledge').get().cnt;
+  const people_count = d.prepare('SELECT count(*) as cnt FROM people').get().cnt;
+  const pattern_count = d.prepare('SELECT count(*) as cnt FROM patterns').get().cnt;
+  const pending_question_count = d.prepare("SELECT count(*) as cnt FROM pending_questions WHERE status = 'pending'").get().cnt;
+  return { memory_count, knowledge_count, people_count, pattern_count, pending_question_count };
+}
+
+// -- Daily Summaries --
+
+function insertDailySummary(date, summary, stats) {
+  if (!date) throw new Error('Daily summary requires date');
+  if (!summary) throw new Error('Daily summary requires summary');
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO daily_summaries (id, date, summary, stats)
+    VALUES (?, ?, ?, ?)
+  `).run(id, date, summary, stats ? JSON.stringify(stats) : null);
+  return { id };
+}
+
+function getDailySummary(date) {
+  return getDb().prepare('SELECT * FROM daily_summaries WHERE date = ?').get(date) || null;
+}
+
+function listDailySummaries(limit) {
+  let sql = 'SELECT * FROM daily_summaries ORDER BY date DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    return getDb().prepare(sql).all(limit);
+  }
+  return getDb().prepare(sql).all();
+}
+
+// -- Agent Actions CRUD --
+
+function insertAction({ action_type, tier, domain, trigger_memory_id, description, content, target, confidence }) {
+  if (!action_type) throw new Error('Action requires action_type');
+  if (!description) throw new Error('Action requires description');
+  if (confidence == null) throw new Error('Action requires confidence');
+  if (tier == null) throw new Error('Action requires tier');
+
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO agent_actions (id, action_type, tier, domain, trigger_memory_id, description, content, target, confidence)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, action_type, tier, domain || null, trigger_memory_id || null, description, content || null, target || null, confidence);
+  return { id };
+}
+
+function getAction(id) {
+  return getDb().prepare('SELECT * FROM agent_actions WHERE id = ?').get(id) || null;
+}
+
+function listActions({ status, domain, limit } = {}) {
+  const conditions = [];
+  const params = [];
+  if (status) {
+    conditions.push('status = ?');
+    params.push(status);
+  }
+  if (domain) {
+    conditions.push('domain = ?');
+    params.push(domain);
+  }
+  let sql = 'SELECT * FROM agent_actions';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY created_at DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    params.push(limit);
+  }
+  return getDb().prepare(sql).all(...params);
+}
+
+function updateActionStatus(id, status, review_note) {
+  const now = new Date().toISOString();
+  let sql, params;
+  if (status === 'approved') {
+    sql = 'UPDATE agent_actions SET status = ?, acted_at = ?, reviewed_at = ? WHERE id = ?';
+    params = [status, now, now, id];
+  } else if (status === 'rejected') {
+    sql = 'UPDATE agent_actions SET status = ?, review_note = ?, reviewed_at = ? WHERE id = ?';
+    params = [status, review_note || null, now, id];
+  } else {
+    sql = 'UPDATE agent_actions SET status = ? WHERE id = ?';
+    params = [status, id];
+  }
+  const result = getDb().prepare(sql).run(...params);
+  if (result.changes === 0) throw new Error(`Action not found: ${id}`);
+}
+
+// -- Persona CRUD --
+
+function insertPersona({ person_id, persona_type, sharing_rules, tone, boundaries, examples }) {
+  if (!person_id) throw new Error('Persona requires person_id');
+  const id = uuidv4();
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO personas (id, person_id, persona_type, sharing_rules, tone, boundaries, examples, last_updated)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, person_id, persona_type || null,
+    typeof sharing_rules === 'string' ? sharing_rules : JSON.stringify(sharing_rules || {}),
+    tone || 'professional',
+    typeof boundaries === 'string' ? boundaries : JSON.stringify(boundaries || {}),
+    typeof examples === 'string' ? examples : JSON.stringify(examples || []),
+    now
+  );
+  return { id };
+}
+
+function getPersonaForPerson(personId) {
+  return getDb().prepare('SELECT * FROM personas WHERE person_id = ?').get(personId) || null;
+}
+
+function listPersonas() {
+  return getDb().prepare(`
+    SELECT personas.*, people.name AS person_name, people.relationship AS person_relationship
+    FROM personas
+    LEFT JOIN people ON personas.person_id = people.id
+    ORDER BY people.name
+  `).all();
+}
+
+const PERSONA_ALLOWED_FIELDS = ['persona_type', 'sharing_rules', 'tone', 'boundaries', 'examples'];
+
+function updatePersona(id, updates) {
+  if (!updates || typeof updates !== 'object') throw new Error('Updates must be an object');
+  const keys = Object.keys(updates);
+  if (keys.length === 0) throw new Error('No updates provided');
+  const invalid = keys.filter(k => !PERSONA_ALLOWED_FIELDS.includes(k));
+  if (invalid.length > 0) throw new Error(`Invalid update fields: ${invalid.join(', ')}`);
+
+  // Stringify objects
+  const processed = {};
+  for (const k of keys) {
+    const v = updates[k];
+    processed[k] = (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
+  }
+
+  const sets = keys.map(k => `${k} = ?`);
+  sets.push('last_updated = ?');
+  const params = keys.map(k => processed[k]);
+  params.push(new Date().toISOString());
+  params.push(id);
+  const result = getDb().prepare(`UPDATE personas SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+  if (result.changes === 0) throw new Error(`Persona not found: ${id}`);
+}
+
+// -- Agent Exchanges query --
+
+function listExchanges({ limit } = {}) {
+  let sql = 'SELECT * FROM agent_exchanges ORDER BY created_at DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    return getDb().prepare(sql).all(limit);
+  }
+  return getDb().prepare(sql).all();
+}
+
+// ── Chat Messages ──
+
+function insertChatMessage({ role, content, channel, session_id }) {
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO chat_messages (id, role, content, channel, session_id, created_at)
+    VALUES (?, ?, ?, ?, ?, datetime('now'))
+  `).run(id, role, content, channel || 'ctm', session_id || null);
+  return { id };
+}
+
+function listChatMessages({ session_id, channel, limit } = {}) {
+  const params = [];
+  let where = ' WHERE 1=1';
+  if (session_id) { where += ' AND session_id = ?'; params.push(session_id); }
+  if (channel) { where += ' AND channel = ?'; params.push(channel); }
+
+  if (limit) {
+    // Get the most recent N messages, then return in chronological order
+    // Use id as tiebreaker for same-second timestamps (UUIDs sort by insertion order)
+    const sql = `SELECT * FROM (SELECT * FROM chat_messages${where} ORDER BY created_at DESC, id DESC LIMIT ?) ORDER BY created_at ASC, id ASC`;
+    params.push(limit);
+    return getDb().prepare(sql).all(...params);
+  }
+  return getDb().prepare(`SELECT * FROM chat_messages${where} ORDER BY created_at ASC, id ASC`).all(...params);
+}
+
+function searchChatMessages({ query, limit } = {}) {
+  if (!query || !query.trim()) return [];
+  const terms = query.trim().split(/\s+/).filter(Boolean);
+  const conditions = terms.map(() => 'content LIKE ?');
+  const params = terms.map(t => '%' + t + '%');
+  const lim = Math.min(Math.max(limit || 50, 1), 200);
+  params.push(lim);
+  return getDb().prepare(
+    `SELECT * FROM chat_messages WHERE ${conditions.join(' AND ')} ORDER BY created_at DESC, id DESC LIMIT ?`
+  ).all(...params);
+}
+
+function deleteChatMessages({ session_id, user_content, assistant_content }) {
+  const db = getDb();
+  if (user_content) {
+    db.prepare('DELETE FROM chat_messages WHERE session_id = ? AND role = ? AND content = ?')
+      .run(session_id || 'default', 'user', user_content);
+  }
+  if (assistant_content) {
+    db.prepare('DELETE FROM chat_messages WHERE session_id = ? AND role = ? AND content = ?')
+      .run(session_id || 'default', 'assistant', assistant_content);
+  }
+}
+
+function clearChatSession(session_id) {
+  getDb().prepare('DELETE FROM chat_messages WHERE session_id = ?').run(session_id);
+}
+
+// -- Skills CRUD --
+
+function insertSkill({ name, description, tool_definitions, trigger_type, trigger_config, prompt_template }) {
+  if (!name) throw new Error('Skill requires name');
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO skills (id, name, description, tool_definitions, trigger_type, trigger_config, prompt_template)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, name, description || null,
+    tool_definitions || null,
+    trigger_type || 'interval',
+    trigger_config || null,
+    prompt_template || null
+  );
+  return { id };
+}
+
+function getSkill(id) {
+  return getDb().prepare('SELECT * FROM skills WHERE id = ?').get(id) || null;
+}
+
+function getSkillByName(name) {
+  return getDb().prepare('SELECT * FROM skills WHERE name = ?').get(name) || null;
+}
+
+function listSkills({ enabled } = {}) {
+  if (enabled !== undefined && enabled !== null) {
+    return getDb().prepare('SELECT * FROM skills WHERE enabled = ? ORDER BY name').all(enabled);
+  }
+  return getDb().prepare('SELECT * FROM skills ORDER BY name').all();
+}
+
+const SKILL_ALLOWED_FIELDS = ['name', 'description', 'tool_definitions', 'trigger_type', 'trigger_config', 'prompt_template', 'enabled'];
+
+function updateSkill(id, updates) {
+  if (!updates || typeof updates !== 'object') throw new Error('Updates must be an object');
+  const keys = Object.keys(updates);
+  if (keys.length === 0) throw new Error('No updates provided');
+  const invalid = keys.filter(k => !SKILL_ALLOWED_FIELDS.includes(k));
+  if (invalid.length > 0) throw new Error(`Invalid update fields: ${invalid.join(', ')}`);
+
+  const sets = keys.map(k => `${k} = ?`);
+  const params = keys.map(k => updates[k]);
+  params.push(id);
+  const result = getDb().prepare(`UPDATE skills SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+  if (result.changes === 0) throw new Error(`Skill not found: ${id}`);
+}
+
+function insertSkillExecution({ skill_id, status, tool_calls, tool_results, memories_created, error, duration_ms }) {
+  if (!skill_id) throw new Error('Skill execution requires skill_id');
+  if (!status) throw new Error('Skill execution requires status');
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO skill_executions (id, skill_id, status, tool_calls, tool_results, memories_created, error, duration_ms)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, skill_id, status, tool_calls || null, tool_results || null, memories_created || 0, error || null, duration_ms || null);
+  return { id };
+}
+
+function listSkillExecutions({ skill_id, limit } = {}) {
+  const conditions = [];
+  const params = [];
+  if (skill_id) {
+    conditions.push('skill_id = ?');
+    params.push(skill_id);
+  }
+  let sql = 'SELECT * FROM skill_executions';
+  if (conditions.length > 0) {
+    sql += ' WHERE ' + conditions.join(' AND ');
+  }
+  sql += ' ORDER BY created_at DESC';
+  if (limit) {
+    sql += ' LIMIT ?';
+    params.push(limit);
+  }
+  return getDb().prepare(sql).all(...params);
+}
+
+function updateSkillStats(skillId, success) {
+  const now = new Date().toISOString();
+  const field = success ? 'success_count' : 'failure_count';
+  const lastResult = success ? 'success' : 'failure';
+  const result = getDb().prepare(
+    `UPDATE skills SET ${field} = ${field} + 1, last_run = ?, last_result = ? WHERE id = ?`
+  ).run(now, lastResult, skillId);
+  if (result.changes === 0) throw new Error(`Skill not found: ${skillId}`);
+}
+
+// ── Tasks ──
+
+function insertTask({ title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config }) {
+  const id = uuidv4();
+  getDb().prepare(`
+    INSERT INTO tasks (id, title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, title, description || null, priority || 'normal', type || 'once',
+    execution || 'chat', script || null, schedule || null, due_at || null, next_run_at || due_at || null,
+    skill || null, skill_config || null);
+  return { id };
+}
+
+function getTask(id) {
+  return getDb().prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+}
+
+function listTasks({ status, limit } = {}) {
+  const params = [];
+  let sql = 'SELECT * FROM tasks';
+  if (status) { sql += ' WHERE status = ?'; params.push(status); }
+  sql += ' ORDER BY CASE priority WHEN \'urgent\' THEN 0 WHEN \'high\' THEN 1 WHEN \'normal\' THEN 2 WHEN \'low\' THEN 3 END, created_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function updateTask(id, updates) {
+  const allowed = ['title', 'description', 'status', 'priority', 'type', 'execution', 'script', 'schedule', 'due_at', 'next_run_at', 'started_at', 'completed_at', 'last_run_at', 'run_count', 'result', 'error', 'checkpoint', 'skill', 'skill_config'];
+  const sets = [];
+  const params = [];
+  for (const [k, v] of Object.entries(updates)) {
+    if (allowed.includes(k)) { sets.push(`${k} = ?`); params.push(v); }
+  }
+  if (sets.length === 0) return;
+  sets.push('updated_at = datetime(\'now\')');
+  params.push(id);
+  getDb().prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+
+function deleteTask(id) {
+  getDb().prepare('DELETE FROM tasks WHERE id = ?').run(id);
+}
+
+function getDueTasks() {
+  const now = new Date().toISOString();
+  return getDb().prepare(`
+    SELECT * FROM tasks WHERE status = 'pending' AND (next_run_at IS NULL OR next_run_at <= ?) ORDER BY next_run_at ASC
+  `).all(now);
+}
+
+// ── Briefing Items ──
+
+function insertBriefingItem({ task_id, skill, title, category, owner, urgency, status, context, first_seen, last_seen }) {
+  if (!title) throw new Error('Briefing item requires title');
+  const id = uuidv4();
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO briefing_items (id, task_id, skill, title, category, owner, urgency, status, context, first_seen, last_seen)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, task_id || null, skill || null, title, category || null, owner || null,
+    urgency || 'low', status || 'open', context || null, first_seen || now, last_seen || now);
+  return { id };
+}
+
+function listBriefingItems({ skill, status, limit } = {}) {
+  const conditions = [];
+  const params = [];
+  if (skill) { conditions.push('skill = ?'); params.push(skill); }
+  if (status) { conditions.push('status = ?'); params.push(status); }
+  // Un-snooze items whose snooze has expired
+  const now = new Date().toISOString();
+  let sql = 'SELECT * FROM briefing_items';
+  if (conditions.length > 0) sql += ' WHERE ' + conditions.join(' AND ');
+  sql += ' ORDER BY CASE urgency WHEN \'critical\' THEN 0 WHEN \'today\' THEN 1 WHEN \'this_week\' THEN 2 WHEN \'async\' THEN 3 ELSE 4 END, last_seen DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function getBriefingItem(id) {
+  return getDb().prepare('SELECT * FROM briefing_items WHERE id = ?').get(id) || null;
+}
+
+function updateBriefingItem(id, updates) {
+  const allowed = ['status', 'urgency', 'owner', 'category', 'snooze_until', 'notes', 'resolved_at', 'last_seen', 'times_seen', 'context'];
+  const sets = [];
+  const params = [];
+  for (const [k, v] of Object.entries(updates)) {
+    if (allowed.includes(k)) { sets.push(`${k} = ?`); params.push(v); }
+  }
+  if (sets.length === 0) return;
+  params.push(id);
+  const result = getDb().prepare(`UPDATE briefing_items SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+  if (result.changes === 0) throw new Error(`Briefing item not found: ${id}`);
+}
+
+function findBriefingItemByTitle(skill, title) {
+  return getDb().prepare(
+    'SELECT * FROM briefing_items WHERE skill = ? AND title = ? AND status NOT IN (\'done\', \'dismissed\')'
+  ).get(skill, title) || null;
+}
+
+function listOpenBriefingItems(skill) {
+  return getDb().prepare(
+    'SELECT * FROM briefing_items WHERE skill = ? AND status NOT IN (\'done\', \'dismissed\') ORDER BY last_seen DESC'
+  ).all(skill);
+}
+
+module.exports = {
+  initDb,
+  getDb,
+  closeDb,
+  getDbPath,
+  DATA_DIR,
+  BACKUP_DIR,
+  // Owner
+  setOwner,
+  getOwner,
+  getOwnerName,
+  // Memory
+  insertMemory,
+  getMemory,
+  listMemories,
+  updateMemoryExtraction,
+  // Knowledge
+  insertKnowledge,
+  getKnowledge,
+  findKnowledge,
+  // Checkpoints
+  upsertCheckpoint,
+  getCheckpoint,
+  // People
+  insertPerson,
+  getPerson,
+  listPeople,
+  updatePerson,
+  // Personas
+  insertPersona,
+  getPersonaForPerson,
+  listPersonas,
+  updatePersona,
+  // Questions
+  insertQuestion,
+  listQuestions,
+  answerQuestion,
+  // Knowledge updates
+  supersedeKnowledge,
+  updateKnowledgeStatus,
+  // Stats
+  getBrainStats,
+  // Daily Summaries
+  insertDailySummary,
+  getDailySummary,
+  listDailySummaries,
+  // Agent Actions
+  insertAction,
+  getAction,
+  listActions,
+  updateActionStatus,
+  // Agent Exchanges
+  listExchanges,
+  // Chat Messages
+  insertChatMessage,
+  listChatMessages,
+  searchChatMessages,
+  deleteChatMessages,
+  clearChatSession,
+  // Backup
+  createBackup,
+  startDailyBackup,
+  // Skills
+  insertSkill,
+  getSkill,
+  getSkillByName,
+  listSkills,
+  updateSkill,
+  insertSkillExecution,
+  listSkillExecutions,
+  updateSkillStats,
+  // Tasks
+  insertTask,
+  getTask,
+  listTasks,
+  updateTask,
+  deleteTask,
+  getDueTasks,
+  // Briefing Items
+  insertBriefingItem,
+  getBriefingItem,
+  listBriefingItems,
+  updateBriefingItem,
+  findBriefingItemByTitle,
+  listOpenBriefingItems,
+};