squish-memory 1.1.5 → 1.2.1

package/{dist/db/bootstrap.js → db/bootstrap.ts}

@@ -1,14 +1,43 @@
-import { existsSync, mkdirSync } from 'fs';
-import { logger } from '../core/logger.js';
-import { getDataDir } from '../config.js';
-/**
- * Note on boolean columns:
- * SQLite uses INTEGER 0/1 for boolean values (no native boolean type)
- * PostgreSQL uses native BOOLEAN type
- */
+import type { Database } from 'better-sqlite3';
+import type { Pool } from 'pg';
+import { existsSync, mkdirSync } from 'fs';
+import { logger } from '../core/logger.js';
+import { getDataDir } from '../config.js';
+import { runAllMigrations } from './migrations/index.js';
+
+/**
+ * Note on boolean columns:
+ * SQLite uses INTEGER 0/1 for boolean values (no native boolean type)
+ * PostgreSQL uses native BOOLEAN type
+ */
+
 const sqliteSchemaSql = `
 PRAGMA foreign_keys = ON;
 
+-- Schema version tracking table (v1.2.0+)
+CREATE TABLE IF NOT EXISTS _schema_versions (
+  version TEXT PRIMARY KEY,
+  description TEXT NOT NULL,
+  applied_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+
+-- Agent preferences table (v1.2.0+) - stores accumulated agent preferences from learnings
+CREATE TABLE IF NOT EXISTS agent_preferences (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  source_memory_id TEXT,
+  confidence REAL DEFAULT 0.5,
+  usage_count INTEGER DEFAULT 1,
+  last_updated INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  UNIQUE(project_id, key)
+);
+
+CREATE INDEX IF NOT EXISTS agent_preferences_project_idx ON agent_preferences(project_id);
+CREATE INDEX IF NOT EXISTS agent_preferences_key_idx ON agent_preferences(key);
+
 CREATE TABLE IF NOT EXISTS users (
   id TEXT PRIMARY KEY,
   external_id TEXT UNIQUE,
@@ -55,22 +84,33 @@ CREATE TABLE IF NOT EXISTS memories (
   is_merged INTEGER DEFAULT 0,
   merged_into_id TEXT,
   merged_at INTEGER,
-  is_canonical INTEGER DEFAULT 0,
-  merge_source_ids TEXT,
-  is_mergeable INTEGER DEFAULT 1,
-  merge_version INTEGER DEFAULT 1,
-  importance_score INTEGER DEFAULT 50,
-  importance_decay_rate INTEGER DEFAULT 30,
-  last_importance_recalc INTEGER,
-  consolidated_into TEXT,
-  consolidated_at INTEGER,
-  is_consolidated INTEGER DEFAULT 0,
-  sector TEXT DEFAULT 'episodic',
-  tier TEXT DEFAULT 'hot',
-  context_status TEXT DEFAULT 'out-of-context',
-  decay_rate INTEGER DEFAULT 30,
-  coactivation_score INTEGER DEFAULT 0,
-  last_decay_at INTEGER DEFAULT (strftime('%s','now')),
+  is_canonical INTEGER DEFAULT 0,
+  merge_source_ids TEXT,
+  is_mergeable INTEGER DEFAULT 1,
+  merge_version INTEGER DEFAULT 1,
+  namespace_id TEXT REFERENCES namespaces(id) ON DELETE SET NULL,
+  namespace_path TEXT,
+  has_l0_abstract INTEGER DEFAULT 0,
+  has_l1_overview INTEGER DEFAULT 0,
+  last_layer_update INTEGER,
+  importance_score INTEGER DEFAULT 50,
+  importance_decay_rate INTEGER DEFAULT 30,
+  last_importance_recalc INTEGER,
+  retrieval_priority INTEGER DEFAULT 50,
+  tokens_estimate INTEGER DEFAULT 0,
+  consolidated_into TEXT,
+  consolidated_at INTEGER,
+  is_consolidated INTEGER DEFAULT 0,
+  sector TEXT DEFAULT 'episodic',
+  tier TEXT DEFAULT 'hot',
+  status TEXT DEFAULT 'active',
+  encrypted_content TEXT,
+  encryption_nonce TEXT,
+  is_encrypted INTEGER DEFAULT 0,
+  context_status TEXT DEFAULT 'out-of-context',
+  decay_rate INTEGER DEFAULT 30,
+  coactivation_score INTEGER DEFAULT 0,
+  last_decay_at INTEGER DEFAULT (strftime('%s','now')),
   agent_id TEXT,
   agent_role TEXT,
   visibility_scope TEXT DEFAULT 'private',
@@ -82,11 +122,14 @@ CREATE TABLE IF NOT EXISTS memories (
   triggered_by TEXT,
   capture_reason TEXT,
   last_used_at INTEGER,
-  usage_count INTEGER DEFAULT 0,
-  valid_from INTEGER,
-  valid_to INTEGER,
-  superseded_by TEXT,
-  version INTEGER DEFAULT 1,
+  usage_count INTEGER DEFAULT 0,
+  valid_from INTEGER,
+  valid_to INTEGER,
+  recorded_at INTEGER DEFAULT (strftime('%s','now')),
+  superseded_by TEXT,
+  version INTEGER DEFAULT 1,
+  place_id TEXT,
+  place_sort_order INTEGER DEFAULT 0,
   created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
   updated_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
 );
@@ -168,6 +211,7 @@ CREATE TABLE IF NOT EXISTS learnings (
   relevance_score INTEGER DEFAULT 50,
   category TEXT,
   importance INTEGER DEFAULT 50,
+  confidence INTEGER DEFAULT 50,
   metadata TEXT,
   is_imported INTEGER DEFAULT 0,
   -- UAM: Agent integration columns
@@ -180,7 +224,7 @@ CREATE TABLE IF NOT EXISTS learnings (
 CREATE INDEX IF NOT EXISTS learnings_project_idx ON learnings(project_id);
 CREATE INDEX IF NOT EXISTS learnings_type_idx ON learnings(type);
 CREATE INDEX IF NOT EXISTS learnings_action_idx ON learnings(action);
-CREATE INDEX IF NOT EXISTS observations_created_idx ON observations(created_at);
+CREATE INDEX IF NOT EXISTS learnings_created_idx ON learnings(created_at);
 
 CREATE TABLE IF NOT EXISTS entities (
   id TEXT PRIMARY KEY,
@@ -393,7 +437,7 @@ CREATE TABLE IF NOT EXISTS places (
   name TEXT NOT NULL,
   place_type TEXT NOT NULL,
   parent_id TEXT REFERENCES places(id) ON DELETE SET NULL,
-  loci_index INTEGER DEFAULT 0,
+  sort_order INTEGER DEFAULT 0,
   position_x INTEGER DEFAULT 0,
   position_y INTEGER DEFAULT 0,
   description TEXT,
@@ -405,13 +449,14 @@ CREATE TABLE IF NOT EXISTS places (
 CREATE INDEX IF NOT EXISTS places_project_idx ON places(project_id);
 CREATE INDEX IF NOT EXISTS places_type_idx ON places(place_type);
 CREATE INDEX IF NOT EXISTS places_parent_idx ON places(parent_id);
-CREATE INDEX IF NOT EXISTS places_loci_idx ON places(project_id, loci_index);
+CREATE INDEX IF NOT EXISTS places_sort_order_idx ON places(project_id, sort_order);
 
 -- Memory-Place assignments
 CREATE TABLE IF NOT EXISTS memory_places (
   id TEXT PRIMARY KEY,
   memory_id TEXT REFERENCES memories(id) ON DELETE CASCADE NOT NULL,
   place_id TEXT REFERENCES places(id) ON DELETE CASCADE NOT NULL,
+  place_sort_order INTEGER DEFAULT 0,
   is_manual INTEGER DEFAULT 0,
   rule_id TEXT,
   created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
@@ -436,12 +481,76 @@ CREATE TABLE IF NOT EXISTS place_rules (
 );
 CREATE INDEX IF NOT EXISTS place_rules_project_idx ON place_rules(project_id);
 CREATE INDEX IF NOT EXISTS place_rules_type_idx ON place_rules(place_type);
-`;
-const postgresStatements = [
-    `CREATE EXTENSION IF NOT EXISTS pgcrypto;`,
-    `CREATE EXTENSION IF NOT EXISTS vector;`,
-    `CREATE EXTENSION IF NOT EXISTS pg_trgm;`,
-    `CREATE TABLE IF NOT EXISTS users (
+-- session_summaries table
+CREATE TABLE IF NOT EXISTS session_summaries (
+  id TEXT PRIMARY KEY,
+  conversation_id TEXT REFERENCES conversations(id) ON DELETE CASCADE NOT NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  summary_type TEXT NOT NULL,
+  content TEXT NOT NULL,
+  compressed_from INTEGER,
+  tokens_saved INTEGER,
+  embedding BLOB,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+CREATE INDEX IF NOT EXISTS session_summaries_conversation_idx ON session_summaries(conversation_id);
+CREATE INDEX IF NOT EXISTS session_summaries_project_idx ON session_summaries(project_id);
+CREATE INDEX IF NOT EXISTS session_summaries_type_idx ON session_summaries(summary_type);
+CREATE INDEX IF NOT EXISTS session_summaries_created_idx ON session_summaries(created_at);
+
+-- Belief Systems - Derived Beliefs from Memory (v1.3.0+)
+CREATE TABLE IF NOT EXISTS beliefs (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  belief_type TEXT NOT NULL,
+  statement TEXT NOT NULL,
+  normalized_key TEXT NOT NULL,
+  confidence REAL DEFAULT 0.5,
+  belief_decay_rate INTEGER DEFAULT 30,
+  last_confirmed_at INTEGER,
+  source_count INTEGER DEFAULT 1,
+  status TEXT DEFAULT 'active',
+  reason TEXT,
+  context TEXT,
+  evidence_summary TEXT,
+  metadata TEXT,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  updated_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  UNIQUE(project_id, normalized_key)
+);
+CREATE INDEX IF NOT EXISTS beliefs_project_idx ON beliefs(project_id);
+CREATE INDEX IF NOT EXISTS beliefs_type_idx ON beliefs(belief_type);
+CREATE INDEX IF NOT EXISTS beliefs_status_idx ON beliefs(status);
+CREATE INDEX IF NOT EXISTS beliefs_confidence_idx ON beliefs(confidence);
+
+CREATE TABLE IF NOT EXISTS belief_memory_sources (
+  id TEXT PRIMARY KEY,
+  belief_id TEXT REFERENCES beliefs(id) ON DELETE CASCADE,
+  memory_id TEXT REFERENCES memories(id) ON DELETE CASCADE,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  UNIQUE(belief_id, memory_id)
+);
+CREATE INDEX IF NOT EXISTS belief_sources_belief_idx ON belief_memory_sources(belief_id);
+CREATE INDEX IF NOT EXISTS belief_sources_memory_idx ON belief_memory_sources(memory_id);
+
+CREATE TABLE IF NOT EXISTS belief_edges (
+  id TEXT PRIMARY KEY,
+  from_belief_id TEXT REFERENCES beliefs(id) ON DELETE CASCADE,
+  to_belief_id TEXT REFERENCES beliefs(id) ON DELETE CASCADE,
+  edge_type TEXT NOT NULL,
+  metadata TEXT,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  UNIQUE(from_belief_id, to_belief_id, edge_type)
+);
+CREATE INDEX IF NOT EXISTS belief_edges_from_idx ON belief_edges(from_belief_id);
+CREATE INDEX IF NOT EXISTS belief_edges_to_idx ON belief_edges(to_belief_id);
+`;
+
+const postgresStatements = [
+  `CREATE EXTENSION IF NOT EXISTS pgcrypto;`,
+  `CREATE EXTENSION IF NOT EXISTS vector;`,
+  `CREATE EXTENSION IF NOT EXISTS pg_trgm;`,
+  `CREATE TABLE IF NOT EXISTS users (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     external_id TEXT UNIQUE,
     name TEXT,
@@ -449,8 +558,8 @@ const postgresStatements = [
     preferences JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE TABLE IF NOT EXISTS projects (
+  );`,
+  `CREATE TABLE IF NOT EXISTS projects (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     name TEXT NOT NULL,
     path TEXT NOT NULL,
@@ -458,9 +567,9 @@ const postgresStatements = [
     metadata JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS projects_path_idx ON projects(path);`,
-    `CREATE TABLE IF NOT EXISTS memories (
+  );`,
+  `CREATE INDEX IF NOT EXISTS projects_path_idx ON projects(path);`,
+`CREATE TABLE IF NOT EXISTS memories (
   id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
   project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
   user_id UUID REFERENCES users(id) ON DELETE SET NULL,
@@ -521,13 +630,13 @@ const postgresStatements = [
   last_accessed_at TIMESTAMPTZ,
   created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
   updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-);`,
-    `CREATE INDEX IF NOT EXISTS memories_project_idx ON memories(project_id);`,
-    `CREATE INDEX IF NOT EXISTS memories_type_idx ON memories(type);`,
-    `CREATE INDEX IF NOT EXISTS memories_created_idx ON memories(created_at);`,
-    `CREATE INDEX IF NOT EXISTS memories_tags_idx ON memories USING GIN(tags);`,
-    `CREATE INDEX IF NOT EXISTS memories_content_trgm_idx ON memories USING GIN (content gin_trgm_ops);`,
-    `CREATE TABLE IF NOT EXISTS conversations (
+);`,
+  `CREATE INDEX IF NOT EXISTS memories_project_idx ON memories(project_id);`,
+  `CREATE INDEX IF NOT EXISTS memories_type_idx ON memories(type);`,
+  `CREATE INDEX IF NOT EXISTS memories_created_idx ON memories(created_at);`,
+  `CREATE INDEX IF NOT EXISTS memories_tags_idx ON memories USING GIN(tags);`,
+  `CREATE INDEX IF NOT EXISTS memories_content_trgm_idx ON memories USING GIN (content gin_trgm_ops);`,
+  `CREATE TABLE IF NOT EXISTS conversations (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     user_id UUID REFERENCES users(id) ON DELETE SET NULL,
@@ -541,11 +650,11 @@ const postgresStatements = [
     metadata JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS conversations_project_idx ON conversations(project_id);`,
-    `CREATE INDEX IF NOT EXISTS conversations_session_idx ON conversations(session_id);`,
-    `CREATE INDEX IF NOT EXISTS conversations_started_idx ON conversations(started_at);`,
-    `CREATE TABLE IF NOT EXISTS messages (
+  );`,
+  `CREATE INDEX IF NOT EXISTS conversations_project_idx ON conversations(project_id);`,
+  `CREATE INDEX IF NOT EXISTS conversations_session_idx ON conversations(session_id);`,
+  `CREATE INDEX IF NOT EXISTS conversations_started_idx ON conversations(started_at);`,
+  `CREATE TABLE IF NOT EXISTS messages (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     conversation_id UUID NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
     role TEXT NOT NULL,
@@ -555,13 +664,13 @@ const postgresStatements = [
     tool_calls JSONB,
     metadata JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS messages_conversation_idx ON messages(conversation_id);`,
-    `CREATE INDEX IF NOT EXISTS messages_role_idx ON messages(role);`,
-    `CREATE INDEX IF NOT EXISTS messages_created_idx ON messages(created_at);`,
-    `CREATE INDEX IF NOT EXISTS messages_content_trgm_idx ON messages USING GIN (content gin_trgm_ops);`,
-    // Learnings table (renamed from observations)
-    `CREATE TABLE IF NOT EXISTS learnings (
+  );`,
+  `CREATE INDEX IF NOT EXISTS messages_conversation_idx ON messages(conversation_id);`,
+  `CREATE INDEX IF NOT EXISTS messages_role_idx ON messages(role);`,
+  `CREATE INDEX IF NOT EXISTS messages_created_idx ON messages(created_at);`,
+  `CREATE INDEX IF NOT EXISTS messages_content_trgm_idx ON messages USING GIN (content gin_trgm_ops);`,
+  // Learnings table (renamed from observations)
+  `CREATE TABLE IF NOT EXISTS learnings (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     conversation_id UUID REFERENCES conversations(id) ON DELETE SET NULL,
@@ -574,6 +683,7 @@ const postgresStatements = [
     memory_id UUID REFERENCES memories(id) ON DELETE SET NULL,
     category TEXT,
     importance INTEGER DEFAULT 50,
+    confidence INTEGER DEFAULT 50,
     metadata JSONB,
     is_imported BOOLEAN DEFAULT FALSE,
     -- UAM: Agent integration columns
@@ -581,11 +691,11 @@ const postgresStatements = [
     tool_name TEXT,
     session_id TEXT,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS learnings_project_idx ON learnings(project_id);`,
-    `CREATE INDEX IF NOT EXISTS learnings_type_idx ON learnings(type);`,
-    `CREATE INDEX IF NOT EXISTS learnings_action_idx ON learnings(action);`,
-    `CREATE TABLE IF NOT EXISTS entities (
+  );`,
+  `CREATE INDEX IF NOT EXISTS learnings_project_idx ON learnings(project_id);`,
+  `CREATE INDEX IF NOT EXISTS learnings_type_idx ON learnings(type);`,
+  `CREATE INDEX IF NOT EXISTS learnings_action_idx ON learnings(action);`,
+  `CREATE TABLE IF NOT EXISTS entities (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     name TEXT NOT NULL,
@@ -595,11 +705,11 @@ const postgresStatements = [
     properties JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS entities_project_idx ON entities(project_id);`,
-    `CREATE INDEX IF NOT EXISTS entities_type_idx ON entities(type);`,
-    `CREATE INDEX IF NOT EXISTS entities_name_idx ON entities(name);`,
-    `CREATE TABLE IF NOT EXISTS entity_relations (
+  );`,
+  `CREATE INDEX IF NOT EXISTS entities_project_idx ON entities(project_id);`,
+  `CREATE INDEX IF NOT EXISTS entities_type_idx ON entities(type);`,
+  `CREATE INDEX IF NOT EXISTS entities_name_idx ON entities(name);`,
+  `CREATE TABLE IF NOT EXISTS entity_relations (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     from_entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
     to_entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
@@ -607,11 +717,11 @@ const postgresStatements = [
     weight INTEGER DEFAULT 1,
     properties JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS relations_from_idx ON entity_relations(from_entity_id);`,
-    `CREATE INDEX IF NOT EXISTS relations_to_idx ON entity_relations(to_entity_id);`,
-    `CREATE INDEX IF NOT EXISTS relations_type_idx ON entity_relations(type);`,
-    `CREATE TABLE IF NOT EXISTS core_memory (
+  );`,
+  `CREATE INDEX IF NOT EXISTS relations_from_idx ON entity_relations(from_entity_id);`,
+  `CREATE INDEX IF NOT EXISTS relations_to_idx ON entity_relations(to_entity_id);`,
+  `CREATE INDEX IF NOT EXISTS relations_type_idx ON entity_relations(type);`,
+  `CREATE TABLE IF NOT EXISTS core_memory (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     user_id UUID REFERENCES users(id) ON DELETE SET NULL,
@@ -621,11 +731,11 @@ const postgresStatements = [
     version INTEGER DEFAULT 1 NOT NULL,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS core_memory_project_idx ON core_memory(project_id);`,
-    `CREATE INDEX IF NOT EXISTS core_memory_user_idx ON core_memory(user_id);`,
-    `CREATE INDEX IF NOT EXISTS core_memory_section_idx ON core_memory(section);`,
-    `CREATE TABLE IF NOT EXISTS context_sessions (
+  );`,
+  `CREATE INDEX IF NOT EXISTS core_memory_project_idx ON core_memory(project_id);`,
+  `CREATE INDEX IF NOT EXISTS core_memory_user_idx ON core_memory(user_id);`,
+  `CREATE INDEX IF NOT EXISTS core_memory_section_idx ON core_memory(section);`,
+  `CREATE TABLE IF NOT EXISTS context_sessions (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     session_id TEXT NOT NULL UNIQUE,
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
@@ -638,11 +748,11 @@ const postgresStatements = [
     metadata JSONB,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS context_sessions_session_idx ON context_sessions(session_id);`,
-    `CREATE INDEX IF NOT EXISTS context_sessions_project_idx ON context_sessions(project_id);`,
-    `CREATE INDEX IF NOT EXISTS context_sessions_created_idx ON context_sessions(created_at);`,
-    `CREATE TABLE IF NOT EXISTS memory_merge_proposals (
+  );`,
+  `CREATE INDEX IF NOT EXISTS context_sessions_session_idx ON context_sessions(session_id);`,
+  `CREATE INDEX IF NOT EXISTS context_sessions_project_idx ON context_sessions(project_id);`,
+  `CREATE INDEX IF NOT EXISTS context_sessions_created_idx ON context_sessions(created_at);`,
+  `CREATE TABLE IF NOT EXISTS memory_merge_proposals (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
     user_id UUID REFERENCES users(id) ON DELETE SET NULL,
@@ -661,10 +771,10 @@ const postgresStatements = [
     review_notes TEXT,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     expires_at TIMESTAMPTZ
-  );`,
-    `CREATE INDEX IF NOT EXISTS memory_merge_proposals_project_status_idx ON memory_merge_proposals(project_id, status);`,
-    `CREATE INDEX IF NOT EXISTS memory_merge_proposals_created_at_idx ON memory_merge_proposals(created_at);`,
-    `CREATE TABLE IF NOT EXISTS memory_merge_history (
+  );`,
+  `CREATE INDEX IF NOT EXISTS memory_merge_proposals_project_status_idx ON memory_merge_proposals(project_id, status);`,
+  `CREATE INDEX IF NOT EXISTS memory_merge_proposals_created_at_idx ON memory_merge_proposals(created_at);`,
+  `CREATE TABLE IF NOT EXISTS memory_merge_history (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
     user_id UUID REFERENCES users(id) ON DELETE SET NULL,
@@ -678,19 +788,19 @@ const postgresStatements = [
     reversed_at TIMESTAMPTZ,
     reversed_by UUID,
     merged_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE TABLE IF NOT EXISTS memory_hash_cache (
+  );`,
+  `CREATE TABLE IF NOT EXISTS memory_hash_cache (
     memory_id UUID PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
     project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
     simhash TEXT,
     minhash TEXT,
     content_hash TEXT NOT NULL,
     last_updated TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS memory_hash_cache_project_id_idx ON memory_hash_cache(project_id);`,
-    `CREATE INDEX IF NOT EXISTS memory_hash_cache_simhash_idx ON memory_hash_cache(simhash);`,
-    // memory_associations table (v1.1.0+)
-    `CREATE TABLE IF NOT EXISTS memory_associations (
+  );`,
+  `CREATE INDEX IF NOT EXISTS memory_hash_cache_project_id_idx ON memory_hash_cache(project_id);`,
+  `CREATE INDEX IF NOT EXISTS memory_hash_cache_simhash_idx ON memory_hash_cache(simhash);`,
+  // memory_associations table (v1.1.0+)
+  `CREATE TABLE IF NOT EXISTS memory_associations (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     from_memory_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
     to_memory_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
@@ -701,10 +811,10 @@ const postgresStatements = [
     last_coactivated_at TIMESTAMPTZ,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     UNIQUE(from_memory_id, to_memory_id)
-  );`,
-    `CREATE INDEX IF NOT EXISTS associations_graph_traversal_idx ON memory_associations(from_memory_id, to_memory_id, weight, association_type);`,
-    // namespaces table
-    `CREATE TABLE IF NOT EXISTS namespaces (
+  );`,
+  `CREATE INDEX IF NOT EXISTS associations_graph_traversal_idx ON memory_associations(from_memory_id, to_memory_id, weight, association_type);`,
+  // namespaces table
+  `CREATE TABLE IF NOT EXISTS namespaces (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     name TEXT NOT NULL,
@@ -714,11 +824,11 @@ const postgresStatements = [
     metadata TEXT,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS namespaces_project_idx ON namespaces(project_id);`,
-    `CREATE INDEX IF NOT EXISTS namespaces_parent_idx ON namespaces(parent_id);`,
-    // maintenance_jobs table
-    `CREATE TABLE IF NOT EXISTS maintenance_jobs (
+  );`,
+  `CREATE INDEX IF NOT EXISTS namespaces_project_idx ON namespaces(project_id);`,
+  `CREATE INDEX IF NOT EXISTS namespaces_parent_idx ON namespaces(parent_id);`,
+  // maintenance_jobs table
+  `CREATE TABLE IF NOT EXISTS maintenance_jobs (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
     job_name TEXT NOT NULL,
@@ -738,19 +848,19 @@ const postgresStatements = [
     job_config TEXT,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS maintenance_jobs_name_idx ON maintenance_jobs(job_name);`,
-    `CREATE INDEX IF NOT EXISTS maintenance_jobs_next_run_idx ON maintenance_jobs(next_run_at);`,
-    `CREATE INDEX IF NOT EXISTS maintenance_jobs_type_idx ON maintenance_jobs(job_type);`,
-    `CREATE INDEX IF NOT EXISTS maintenance_jobs_enabled_idx ON maintenance_jobs(enabled);`,
-    // places table (v1.1.5) - Spatial memory organization
-    `CREATE TABLE IF NOT EXISTS places (
+  );`,
+  `CREATE INDEX IF NOT EXISTS maintenance_jobs_name_idx ON maintenance_jobs(job_name);`,
+  `CREATE INDEX IF NOT EXISTS maintenance_jobs_next_run_idx ON maintenance_jobs(next_run_at);`,
+  `CREATE INDEX IF NOT EXISTS maintenance_jobs_type_idx ON maintenance_jobs(job_type);`,
+  `CREATE INDEX IF NOT EXISTS maintenance_jobs_enabled_idx ON maintenance_jobs(enabled);`,
+  // places table (v1.1.5) - Spatial memory organization
+  `CREATE TABLE IF NOT EXISTS places (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE NOT NULL,
     name TEXT NOT NULL,
     place_type TEXT NOT NULL,
     parent_id UUID REFERENCES places(id) ON DELETE SET NULL,
-    loci_index INTEGER DEFAULT 0,
+    sort_order INTEGER DEFAULT 0,
     position_x INTEGER DEFAULT 0,
     position_y INTEGER DEFAULT 0,
     description TEXT,
@@ -758,24 +868,24 @@ const postgresStatements = [
     memory_count INTEGER DEFAULT 0,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS places_project_idx ON places(project_id);`,
-    `CREATE INDEX IF NOT EXISTS places_type_idx ON places(place_type);`,
-    `CREATE INDEX IF NOT EXISTS places_parent_idx ON places(parent_id);`,
-    `CREATE INDEX IF NOT EXISTS places_loci_idx ON places(project_id, loci_index);`,
-    // memory_places table
-    `CREATE TABLE IF NOT EXISTS memory_places (
+  );`,
+  `CREATE INDEX IF NOT EXISTS places_project_idx ON places(project_id);`,
+  `CREATE INDEX IF NOT EXISTS places_type_idx ON places(place_type);`,
+  `CREATE INDEX IF NOT EXISTS places_parent_idx ON places(parent_id);`,
+  `CREATE INDEX IF NOT EXISTS places_sort_order_idx ON places(project_id, sort_order);`,
+  // memory_places table
+  `CREATE TABLE IF NOT EXISTS memory_places (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     memory_id UUID REFERENCES memories(id) ON DELETE CASCADE NOT NULL,
     place_id UUID REFERENCES places(id) ON DELETE CASCADE NOT NULL,
     is_manual BOOLEAN DEFAULT FALSE,
     rule_id UUID,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS memory_places_memory_idx ON memory_places(memory_id);`,
-    `CREATE INDEX IF NOT EXISTS memory_places_place_idx ON memory_places(place_id);`,
-    // place_rules table
-    `CREATE TABLE IF NOT EXISTS place_rules (
+  );`,
+  `CREATE INDEX IF NOT EXISTS memory_places_memory_idx ON memory_places(memory_id);`,
+  `CREATE INDEX IF NOT EXISTS memory_places_place_idx ON memory_places(place_id);`,
+  // place_rules table
+  `CREATE TABLE IF NOT EXISTS place_rules (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     project_id UUID REFERENCES projects(id) ON DELETE CASCADE NOT NULL,
     name TEXT NOT NULL,
@@ -788,298 +898,158 @@ const postgresStatements = [
     enabled BOOLEAN DEFAULT TRUE,
     created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
     updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-  );`,
-    `CREATE INDEX IF NOT EXISTS place_rules_project_idx ON place_rules(project_id);`,
-    `CREATE INDEX IF NOT EXISTS place_rules_type_idx ON place_rules(place_type);`
-];
-/**
- * Ensure the data directory exists (.squish folder in project root)
- */
-export async function ensureDataDirectory() {
-    try {
-        const dataDir = getDataDir();
-        if (!existsSync(dataDir)) {
-            mkdirSync(dataDir, { recursive: true });
-            logger.info(`Created data directory at: ${dataDir}`);
-        }
-    }
-    catch (error) {
-        logger.error('Failed to create data directory', error);
-        throw new Error(`Failed to initialize data directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-export async function ensureSqliteSchema(sqlite) {
-    // Run schema creation FIRST (creates tables with latest schema)
-    sqlite.exec(sqliteSchemaSql);
-    // Run migrations AFTER (for existing databases that need column additions)
-    await runSqliteMigrations(sqlite);
+  );`,
+  `CREATE INDEX IF NOT EXISTS place_rules_project_idx ON place_rules(project_id);`,
+  `CREATE INDEX IF NOT EXISTS place_rules_type_idx ON place_rules(place_type);`,
+  // Belief Systems - Derived Beliefs from Memory (v1.3.0+)
+  `CREATE TABLE IF NOT EXISTS beliefs (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+    belief_type TEXT NOT NULL,
+    statement TEXT NOT NULL,
+    normalized_key TEXT NOT NULL,
+    confidence REAL DEFAULT 0.5,
+    belief_decay_rate INTEGER DEFAULT 30,
+    last_confirmed_at TIMESTAMPTZ,
+    source_count INTEGER DEFAULT 1,
+    status TEXT DEFAULT 'active',
+    reason TEXT,
+    context TEXT,
+    evidence_summary TEXT,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+    updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+    UNIQUE(project_id, normalized_key)
+  );`,
+  `CREATE INDEX IF NOT EXISTS beliefs_project_idx ON beliefs(project_id);`,
+  `CREATE INDEX IF NOT EXISTS beliefs_type_idx ON beliefs(belief_type);`,
+  `CREATE INDEX IF NOT EXISTS beliefs_status_idx ON beliefs(status);`,
+  `CREATE INDEX IF NOT EXISTS beliefs_confidence_idx ON beliefs(confidence);`,
+  `CREATE TABLE IF NOT EXISTS belief_memory_sources (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    belief_id UUID REFERENCES beliefs(id) ON DELETE CASCADE,
+    memory_id UUID REFERENCES memories(id) ON DELETE CASCADE,
+    created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+    UNIQUE(belief_id, memory_id)
+  );`,
+  `CREATE INDEX IF NOT EXISTS belief_sources_belief_idx ON belief_memory_sources(belief_id);`,
+  `CREATE INDEX IF NOT EXISTS belief_sources_memory_idx ON belief_memory_sources(memory_id);`,
+  `CREATE TABLE IF NOT EXISTS belief_edges (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    from_belief_id UUID REFERENCES beliefs(id) ON DELETE CASCADE,
+    to_belief_id UUID REFERENCES beliefs(id) ON DELETE CASCADE,
+    edge_type TEXT NOT NULL,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+    UNIQUE(from_belief_id, to_belief_id, edge_type)
+  );`,
+  `CREATE INDEX IF NOT EXISTS belief_edges_from_idx ON belief_edges(from_belief_id);`,
+  `CREATE INDEX IF NOT EXISTS belief_edges_to_idx ON belief_edges(to_belief_id);`
+];
+
+/**
+ * Ensure the data directory exists (.squish folder in project root)
+ */
+export async function ensureDataDirectory(): Promise<void> {
+  try {
+    const dataDir = getDataDir();
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+      logger.info(`Created data directory at: ${dataDir}`);
+    }
+  } catch (error) {
+    logger.error('Failed to create data directory', error);
+    throw new Error(`Failed to initialize data directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+export async function ensureSqliteSchema(sqlite: Database): Promise<void> {
+  // Run schema creation FIRST (creates tables with latest schema).
+  // Older installs may fail partway through when later indexes/triggers refer
+  // to columns that migrations have not added yet, so tolerate that first pass.
+  execSqliteSchema(sqlite, { tolerant: true });
+  
+  // Initialize schema version tracking
+  await initializeSchemaVersionTable(sqlite);
+  
+  // Run migrations AFTER (for existing databases that need column additions)
+  await runSqliteMigrations(sqlite);
+
+  // Replay the full schema after migrations so deferred indexes/triggers land.
+  execSqliteSchema(sqlite, { tolerant: false });
 }
-async function runSqliteMigrations(sqlite) {
-    // Check if memories table exists
-    const tableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get();
-    if (!tableCheck) {
-        // Table doesn't exist yet - it will be created by schema SQL with all columns
-        // No migrations needed
-        return;
-    }
-    // Migrations for memories table (deduplicated, ordered by version)
-    const memoriesMigrations = [
-        // Base columns (v0.1.x - v0.5.x)
-        { col: 'embedding', sql: 'ALTER TABLE memories ADD COLUMN embedding BLOB' },
-        { col: 'relevance_score', sql: 'ALTER TABLE memories ADD COLUMN relevance_score INTEGER DEFAULT 50' },
-        // Merge tracking (v0.6.x)
-        { col: 'is_merged', sql: 'ALTER TABLE memories ADD COLUMN is_merged INTEGER DEFAULT 0' },
-        { col: 'merged_into_id', sql: 'ALTER TABLE memories ADD COLUMN merged_into_id TEXT' },
-        { col: 'is_mergeable', sql: 'ALTER TABLE memories ADD COLUMN is_mergeable INTEGER DEFAULT 1' },
-        { col: 'is_canonical', sql: 'ALTER TABLE memories ADD COLUMN is_canonical INTEGER DEFAULT 0' },
-        { col: 'merged_at', sql: 'ALTER TABLE memories ADD COLUMN merged_at INTEGER' },
-        { col: 'merge_source_ids', sql: 'ALTER TABLE memories ADD COLUMN merge_source_ids TEXT' },
-        { col: 'merge_version', sql: 'ALTER TABLE memories ADD COLUMN merge_version INTEGER DEFAULT 1' },
-        // Importance scoring (v0.8.0)
-        { col: 'importance_score', sql: 'ALTER TABLE memories ADD COLUMN importance_score INTEGER DEFAULT 50' },
-        { col: 'importance_decay_rate', sql: 'ALTER TABLE memories ADD COLUMN importance_decay_rate INTEGER DEFAULT 30' },
-        { col: 'last_importance_recalc', sql: 'ALTER TABLE memories ADD COLUMN last_importance_recalc INTEGER' },
-        // Consolidation (v0.8.0)
-        { col: 'consolidated_into', sql: 'ALTER TABLE memories ADD COLUMN consolidated_into TEXT' },
-        { col: 'consolidated_at', sql: 'ALTER TABLE memories ADD COLUMN consolidated_at INTEGER' },
-        { col: 'is_consolidated', sql: 'ALTER TABLE memories ADD COLUMN is_consolidated INTEGER DEFAULT 0' },
-        // Memory lifecycle (v0.8.0)
-        { col: 'sector', sql: 'ALTER TABLE memories ADD COLUMN sector TEXT DEFAULT "episodic"' },
-        { col: 'tier', sql: 'ALTER TABLE memories ADD COLUMN tier TEXT DEFAULT "hot"' },
-        { col: 'context_status', sql: 'ALTER TABLE memories ADD COLUMN context_status TEXT DEFAULT "out-of-context"' },
-        { col: 'decay_rate', sql: 'ALTER TABLE memories ADD COLUMN decay_rate INTEGER DEFAULT 30' },
-        { col: 'coactivation_score', sql: 'ALTER TABLE memories ADD COLUMN coactivation_score INTEGER DEFAULT 0' },
-        { col: 'last_decay_at', sql: 'ALTER TABLE memories ADD COLUMN last_decay_at INTEGER DEFAULT (strftime(\'%s\',\'now\'))' },
-        // Agent tracking (v0.8.0)
-        { col: 'agent_id', sql: 'ALTER TABLE memories ADD COLUMN agent_id TEXT' },
-        { col: 'agent_role', sql: 'ALTER TABLE memories ADD COLUMN agent_role TEXT' },
-        { col: 'retrieval_priority', sql: 'ALTER TABLE memories ADD COLUMN retrieval_priority INTEGER DEFAULT 50' },
-        // Data governance (v0.9.0)
-        { col: 'recorded_at', sql: 'ALTER TABLE memories ADD COLUMN recorded_at INTEGER DEFAULT (strftime(\'%s\',\'now\'))' },
-        { col: 'confidence', sql: 'ALTER TABLE memories ADD COLUMN confidence INTEGER DEFAULT 50' },
-        { col: 'valid_from', sql: 'ALTER TABLE memories ADD COLUMN valid_from INTEGER' },
-        { col: 'valid_to', sql: 'ALTER TABLE memories ADD COLUMN valid_to INTEGER' },
-        { col: 'superseded_by', sql: 'ALTER TABLE memories ADD COLUMN superseded_by TEXT' },
-        { col: 'version', sql: 'ALTER TABLE memories ADD COLUMN version INTEGER DEFAULT 1' },
-        { col: 'is_active', sql: 'ALTER TABLE memories ADD COLUMN is_active INTEGER DEFAULT 1' },
-        { col: 'expires_at', sql: 'ALTER TABLE memories ADD COLUMN expires_at INTEGER' },
-        // Privacy & access (v0.9.0)
-        { col: 'is_private', sql: 'ALTER TABLE memories ADD COLUMN is_private INTEGER DEFAULT 0' },
-        { col: 'has_secrets', sql: 'ALTER TABLE memories ADD COLUMN has_secrets INTEGER DEFAULT 0' },
-        { col: 'visibility_scope', sql: 'ALTER TABLE memories ADD COLUMN visibility_scope TEXT DEFAULT "private"' },
-        { col: 'is_protected', sql: 'ALTER TABLE memories ADD COLUMN is_protected INTEGER DEFAULT 0' },
-        { col: 'is_pinned', sql: 'ALTER TABLE memories ADD COLUMN is_pinned INTEGER DEFAULT 0' },
-        { col: 'is_immutable', sql: 'ALTER TABLE memories ADD COLUMN is_immutable INTEGER DEFAULT 0' },
-        { col: 'write_scope', sql: 'ALTER TABLE memories ADD COLUMN write_scope TEXT' },
-        { col: 'read_scope', sql: 'ALTER TABLE memories ADD COLUMN read_scope TEXT' },
-        // Usage tracking (v0.9.0)
-        { col: 'triggered_by', sql: 'ALTER TABLE memories ADD COLUMN triggered_by TEXT' },
-        { col: 'capture_reason', sql: 'ALTER TABLE memories ADD COLUMN capture_reason TEXT' },
-        { col: 'last_used_at', sql: 'ALTER TABLE memories ADD COLUMN last_used_at INTEGER' },
-        { col: 'usage_count', sql: 'ALTER TABLE memories ADD COLUMN usage_count INTEGER DEFAULT 0' },
-        { col: 'user_id', sql: 'ALTER TABLE memories ADD COLUMN user_id TEXT' },
-        // Layer tracking (v0.9.x)
-        { col: 'has_l0_abstract', sql: 'ALTER TABLE memories ADD COLUMN has_l0_abstract INTEGER DEFAULT 0' },
-        { col: 'has_l1_overview', sql: 'ALTER TABLE memories ADD COLUMN has_l1_overview INTEGER DEFAULT 0' },
-        { col: 'last_layer_update', sql: 'ALTER TABLE memories ADD COLUMN last_layer_update INTEGER' },
-        // Namespace support (v1.0.x)
-        { col: 'namespace_id', sql: 'ALTER TABLE memories ADD COLUMN namespace_id TEXT REFERENCES namespaces(id) ON DELETE SET NULL' },
-        { col: 'namespace_path', sql: 'ALTER TABLE memories ADD COLUMN namespace_path TEXT' },
-        // Places support (v1.1.5) - Spatial memory organization
-        { col: 'place_id', sql: 'ALTER TABLE memories ADD COLUMN place_id TEXT REFERENCES places(id) ON DELETE SET NULL' },
-        { col: 'place_loci_index', sql: 'ALTER TABLE memories ADD COLUMN place_loci_index INTEGER' },
-        // Token tracking (v1.0.x)
-        { col: 'tokens_estimate', sql: 'ALTER TABLE memories ADD COLUMN tokens_estimate INTEGER DEFAULT 0' },
-        // Iteration 3: Confidence flags (default: speculative)
-        { col: 'confidence_level', sql: 'ALTER TABLE memories ADD COLUMN confidence_level TEXT DEFAULT "speculative"' },
-        // v1.1.0: Status and encryption
-        { col: 'status', sql: 'ALTER TABLE memories ADD COLUMN status TEXT DEFAULT "active"' },
-        { col: 'encrypted_content', sql: 'ALTER TABLE memories ADD COLUMN encrypted_content TEXT' },
-        { col: 'encryption_nonce', sql: 'ALTER TABLE memories ADD COLUMN encryption_nonce TEXT' },
-        { col: 'is_encrypted', sql: 'ALTER TABLE memories ADD COLUMN is_encrypted INTEGER DEFAULT 0' },
-        // Places support (v1.1.5) - Spatial memory organization
-        { col: 'place_id', sql: 'ALTER TABLE memories ADD COLUMN place_id UUID REFERENCES places(id) ON DELETE SET NULL' },
-        { col: 'place_loci_index', sql: 'ALTER TABLE memories ADD COLUMN place_loci_index INTEGER' }
-    ];
-    // Get existing columns for memories table
-    const tableInfo = sqlite.prepare("PRAGMA table_info(memories)").all();
-    const existingColumns = new Set(tableInfo.map(col => col.name));
-    for (const migration of memoriesMigrations) {
-        if (!existingColumns.has(migration.col)) {
-            try {
-                sqlite.exec(migration.sql);
-                logger.info(`Migration: Added column ${migration.col} to memories table`);
-            }
-            catch (error) {
-                // Re-throw real errors - only ignore "duplicate column" errors
-                const msg = error instanceof Error ? error.message : String(error);
-                if (msg.includes('duplicate column name')) {
-                    logger.debug(`Migration skipped for ${migration.col}: column already exists`);
-                }
-                else {
-                    throw new Error(`Migration failed for column ${migration.col}: ${msg}`);
-                }
-            }
-        }
-    }
-    // v0.9.2: Add tokens_estimate to core_memory
-    const coreMemoryTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='core_memory'").get();
-    if (coreMemoryTableCheck) {
-        const coreMemoryInfo = sqlite.prepare("PRAGMA table_info(core_memory)").all();
-        const existingCoreMemoryColumns = new Set(coreMemoryInfo.map(col => col.name));
-        const coreMemoryMigrations = [
-            { col: 'tokens_estimate', sql: 'ALTER TABLE core_memory ADD COLUMN tokens_estimate INTEGER DEFAULT 0 NOT NULL' },
-        ];
-        for (const migration of coreMemoryMigrations) {
-            if (!existingCoreMemoryColumns.has(migration.col)) {
-                try {
-                    sqlite.exec(migration.sql);
-                    logger.info(`Migration: Added column ${migration.col} to core_memory table`);
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    if (msg.includes('duplicate column name')) {
-                        logger.debug(`Migration skipped for ${migration.col}: column already exists`);
-                    }
-                    else {
-                        throw new Error(`Migration failed for column ${migration.col}: ${msg}`);
-                    }
-                }
-            }
-        }
-    }
-    // Migrations for learnings table (v1.2.x) - renamed from observations
-    // First, check if we need to rename observations -> learnings
-    const observationsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='observations'").get();
-    const learningsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'").get();
-    if (observationsTableCheck && !learningsTableCheck) {
-        // Rename observations to learnings
-        try {
-            sqlite.exec("ALTER TABLE observations RENAME TO learnings");
-            logger.info("Migration: Renamed observations table to learnings");
-        }
-        catch (error) {
-            const err = error instanceof Error ? error.message : String(error);
-            logger.warn(`Migration note: Could not rename observations to learnings: ${err}`);
-        }
-    }
-    // Now run migrations on learnings table (whether renamed or new)
-    const learningsInfo = sqlite.prepare("PRAGMA table_info(learnings)").all();
-    const existingLearningsColumns = new Set(learningsInfo.map(col => col.name));
-    const learningsMigrations = [
-        { col: 'embedding', sql: 'ALTER TABLE learnings ADD COLUMN embedding BLOB' },
-        { col: 'folder_path', sql: 'ALTER TABLE learnings ADD COLUMN folder_path TEXT' },
-        { col: 'project_path', sql: 'ALTER TABLE learnings ADD COLUMN project_path TEXT' },
-        { col: 'is_private', sql: 'ALTER TABLE learnings ADD COLUMN is_private INTEGER DEFAULT 0' },
-        { col: 'has_secrets', sql: 'ALTER TABLE learnings ADD COLUMN has_secrets INTEGER DEFAULT 0' },
-        { col: 'relevance_score', sql: 'ALTER TABLE learnings ADD COLUMN relevance_score INTEGER DEFAULT 50' },
-        { col: 'memory_id', sql: 'ALTER TABLE learnings ADD COLUMN memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL' },
-        { col: 'is_imported', sql: 'ALTER TABLE learnings ADD COLUMN is_imported INTEGER DEFAULT 0' },
-    ];
-    for (const migration of learningsMigrations) {
-        if (!existingLearningsColumns.has(migration.col)) {
-            try {
-                sqlite.exec(migration.sql);
-                logger.info(`Migration: Added column ${migration.col} to learnings table`);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                if (msg.includes('duplicate column name')) {
-                    logger.debug(`Migration skipped for ${migration.col}: column already exists`);
-                }
-                else {
-                    logger.warn(`Migration note for ${migration.col}: ${msg}`);
-                }
-            }
-        }
-    }
-    // Add indexes if they don't exist
-    const existingIndexes = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='learnings'").all();
-    const existingIndexNames = new Set(existingIndexes.map(idx => idx.name));
-    const indexMigrations = [
-        { name: 'learnings_folder_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_folder_idx ON learnings(folder_path)' },
-        { name: 'learnings_relevance_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_relevance_idx ON learnings(relevance_score)' },
-        { name: 'learnings_private_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_private_idx ON learnings(is_private)' },
-        { name: 'learnings_memory_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_memory_idx ON learnings(memory_id)' },
-    ];
-    for (const idx of indexMigrations) {
-        if (!existingIndexNames.has(idx.name)) {
-            try {
-                sqlite.exec(idx.sql);
-                logger.info(`Migration: Added index ${idx.name} to learnings table`);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                logger.warn(`Index migration note for ${idx.name}: ${msg}`);
-            }
-        }
-    }
-    // Migrations for maintenance_jobs table (v1.0.x)
-    const maintenanceJobsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='maintenance_jobs'").get();
-    if (maintenanceJobsTableCheck) {
-        const maintenanceJobsInfo = sqlite.prepare("PRAGMA table_info(maintenance_jobs)").all();
-        const existingMaintenanceJobsColumns = new Set(maintenanceJobsInfo.map(col => col.name));
-        // Check if table has wrong schema (camelCase columns from bug in earlier version)
-        const hasCamelCaseColumns = existingMaintenanceJobsColumns.has('jobName') ||
-            existingMaintenanceJobsColumns.has('jobType') ||
-            existingMaintenanceJobsColumns.has('cronExpression');
-        if (hasCamelCaseColumns) {
-            // Table has incorrect camelCase schema - need to recreate it
-            logger.warn('Maintenance jobs table has incorrect schema (camelCase columns). Recreating...');
-            try {
-                // Drop the malformed table
-                sqlite.exec('DROP TABLE IF EXISTS maintenance_jobs');
-                // Recreate with correct schema - it will be created by the schema SQL
-                logger.info('Dropped malformed maintenance_jobs table. It will be recreated with correct schema.');
-            }
-            catch (error) {
-                logger.error('Failed to recreate maintenance_jobs table:', error);
-            }
-        }
-        else {
-            // Normal migrations for correct schema
-            const maintenanceJobsMigrations = [
-                { col: 'schedule', sql: 'ALTER TABLE maintenance_jobs DROP COLUMN schedule' },
-                { col: 'cron_expression', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN cron_expression TEXT' },
-                { col: 'last_run_at', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_at INTEGER' },
-                { col: 'last_run_duration', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_duration INTEGER' },
-                { col: 'last_run_status', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_status TEXT' },
-                { col: 'last_run_error', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_error TEXT' },
-                { col: 'total_runs', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN total_runs INTEGER DEFAULT 0' },
-                { col: 'success_count', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN success_count INTEGER DEFAULT 0' },
-                { col: 'failure_count', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN failure_count INTEGER DEFAULT 0' },
-                { col: 'job_config', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN job_config TEXT' },
-                { col: 'next_run_at', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN next_run_at INTEGER' },
-                { col: 'run_count', sql: 'ALTER TABLE maintenance_jobs DROP COLUMN run_count' },
-            ];
-            for (const migration of maintenanceJobsMigrations) {
-                // For DROP migrations, only run if column EXISTS
-                // For ADD migrations, only run if column does NOT exist
-                const shouldRun = migration.sql.startsWith('ALTER TABLE maintenance_jobs DROP COLUMN')
-                    ? existingMaintenanceJobsColumns.has(migration.col)
-                    : !existingMaintenanceJobsColumns.has(migration.col);
-                if (shouldRun) {
-                    try {
-                        sqlite.exec(migration.sql);
-                        logger.info(`Migration: ${migration.col} on maintenance_jobs table`);
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        if (msg.includes('duplicate column name') || msg.includes('no such column')) {
-                            logger.debug(`Migration skipped for ${migration.col}: ${msg.includes('duplicate column name') ? 'column already exists' : 'column does not exist'}`);
-                        }
-                        else {
-                            throw new Error(`Migration failed for column ${migration.col}: ${msg}`);
-                        }
-                    }
-                }
-            }
-        }
-    }
+
+// Schema versions for tracking
+const SCHEMA_VERSIONS = [
+  { version: '1.2.0-base', description: 'Initial v1.2.0 schema with schema_versions table' },
+  { version: '1.2.0-place-sort', description: 'Add place_sort_order column to places' },
+  { version: '1.2.0-mem-place', description: 'Add place_sort_order to memories and memory_places' },
+  { version: '1.2.0-agent-prefs', description: 'Add agent_preferences table for agent evolution' },
+];
+
+async function initializeSchemaVersionTable(sqlite: Database): Promise<void> {
+  // Get existing versions
+  const existingVersions = sqlite.prepare("SELECT version FROM _schema_versions").all() as Array<{version: string}>;
+  const appliedVersions = new Set(existingVersions.map(v => v.version));
+  
+  // Insert any missing versions
+  for (const { version, description } of SCHEMA_VERSIONS) {
+    if (!appliedVersions.has(version)) {
+      try {
+        sqlite.prepare("INSERT INTO _schema_versions (version, description) VALUES (?, ?)").run(version, description);
+        logger.info(`Schema version ${version} recorded`);
+      } catch (error) {
+        // Ignore duplicate errors
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!msg.includes('UNIQUE constraint failed')) {
+          logger.warn(`Could not record schema version ${version}: ${msg}`);
+        }
+      }
+    }
+  }
+}
+
+export async function getSchemaVersion(sqlite: Database): Promise<string | null> {
+  const result = sqlite.prepare("SELECT version FROM _schema_versions ORDER BY applied_at DESC LIMIT 1").get() as {version: string} | undefined;
+  return result?.version || null;
+}
+
+export async function runMigrationsForVersion(sqlite: Database, targetVersion: string): Promise<void> {
+  const currentVersion = await getSchemaVersion(sqlite);
+  logger.info(`Current schema version: ${currentVersion}, target: ${targetVersion}`);
+  
+  // Run ensureSqliteSchema which handles all migrations
+  await runSqliteMigrations(sqlite);
+}
+
+async function runSqliteMigrations(sqlite: Database): Promise<void> {
+  // All migrations are in separate files - just run them all
+  await runAllMigrations(sqlite);
 }
-export async function ensurePostgresSchema(pool) {
-    for (const statement of postgresStatements) {
-        await pool.query(statement);
+
+function execSqliteSchema(
+  sqlite: Database,
+  options: { tolerant: boolean },
+): void {
+  try {
+    sqlite.exec(sqliteSchemaSql);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const isRecoverable =
+      message.includes('no such column') ||
+      message.includes('has no column named');
+
+    if (options.tolerant && isRecoverable) {
+      logger.debug(`Deferred schema statement until after migrations: ${message}`);
+      return;
     }
+
+    throw error;
+  }
 }
-//# sourceMappingURL=bootstrap.js.map
+
+export async function ensurePostgresSchema(pool: Pool): Promise<void> {
+  for (const statement of postgresStatements) {
+    await pool.query(statement);
+  }
+}