squish-memory 1.0.2 → 1.2.0

package/dist/{drizzle → db/drizzle}/schema.js

@@ -1,6 +1,5 @@
 import { pgTable, text, timestamp, uuid, integer, boolean, jsonb, index, vector, numeric } from 'drizzle-orm/pg-core';
 import { relations } from 'drizzle-orm';
-// ============================================================================
 // Core Tables
 // ============================================================================
 /**
@@ -15,7 +14,6 @@ export const users = pgTable('users', {
     createdAt: timestamp('created_at').defaultNow().notNull(),
     updatedAt: timestamp('updated_at').defaultNow().notNull(),
 });
-// ============================================================================
 // Memory Editing Tables
 // ============================================================================
 /**
@@ -74,7 +72,8 @@ export const memories = pgTable('memories', {
     embedding: vector('embedding', { dimensions: 1536 }), // OpenAI ada-002 compatible
     // Metadata
     source: text('source'), // Where this memory came from (tool, hook, user)
-    confidence: integer('confidence').default(100), // 0-100 confidence score
+    confidence: integer('confidence').default(50), // 0-100 confidence score (default: speculative)
+    confidenceLevel: text('confidence_level').default('speculative').$type(), // Iteration 3: Confidence flags (default: speculative)
     tags: text('tags').array(),
     metadata: jsonb('metadata').$type(),
     // v0.2.0: Privacy and relevance
@@ -84,7 +83,12 @@ export const memories = pgTable('memories', {
     // v0.3.0: Lifecycle Management
     sector: text('sector').default('episodic').$type(),
     tier: text('tier').default('hot').$type(),
-    decayRate: integer('decay_rate').default(30), // days until decay
+    status: text('status').notNull().default('active'),
+    encrypted_content: text('encrypted_content'),
+    encryption_nonce: text('encryption_nonce'),
+    is_encrypted: boolean('is_encrypted').default(false),
+    // Per-memory decay rate (integer percentage, e.g., 30 = 30% decay per cycle)
+    decayRate: integer('decay_rate').default(30),
     coactivationScore: integer('coactivation_score').default(0), // 0-100
     lastDecayAt: timestamp('last_decay_at').defaultNow(),
     // v0.3.0: Agent-Aware
@@ -124,10 +128,15 @@ export const memories = pgTable('memories', {
     // v0.4.2: Namespace support
     namespaceId: uuid('namespace_id').references(() => namespaces.id, { onDelete: 'set null' }),
     namespacePath: text('namespace_path'),
+    // v1.1.5: Places support (spatial memory organization)
+    placeId: uuid('place_id').references(() => places.id, { onDelete: 'set null' }),
+    placeSortOrder: integer('place_sort_order'),
     // v0.4.3: Layer support
     hasL0Abstract: boolean('has_l0_abstract').default(false),
     hasL1Overview: boolean('has_l1_overview').default(false),
     lastLayerUpdate: timestamp('last_layer_update'),
+    // v1.0.x: Token tracking
+    tokensEstimate: integer('tokens_estimate').default(0).notNull(),
     createdAt: timestamp('created_at').defaultNow().notNull(),
     updatedAt: timestamp('updated_at').defaultNow().notNull(),
 }, (table) => [
@@ -205,41 +214,64 @@ export const messages = pgTable('messages', {
     index('messages_created_idx').on(table.createdAt),
 ]);
 /**
- * Observations - auto-captured tool usage and events
+ * Learnings - agent learnings: success, failure, fix, insight
  */
-export const observations = pgTable('observations', {
+export const learnings = pgTable('learnings', {
     id: uuid('id').primaryKey().defaultRandom(),
     projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }),
     conversationId: uuid('conversation_id').references(() => conversations.id, { onDelete: 'set null' }),
-    // What happened
+    // Learning type: success, failure, fix, insight
     type: text('type').notNull().$type(),
-    action: text('action').notNull(), // e.g., 'Edit', 'Read', 'Bash'
-    target: text('target'), // e.g., file path, command
+    action: text('action').notNull(),
+    target: text('target'),
     // Details
     summary: text('summary').notNull(),
     details: jsonb('details').$type(),
     // Semantic search
     embedding: vector('embedding', { dimensions: 1536 }),
-    // v0.2.0: Folder-scoped observations
+    // Optional link to a memory
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'set null' }),
+    // Folder-scoped
     folderPath: text('folder_path'),
     projectPath: text('project_path'),
-    // v0.2.0: Privacy and relevance
+    // Privacy and relevance
     isPrivate: boolean('is_private').default(false),
     hasSecrets: boolean('has_secrets').default(false),
-    relevanceScore: integer('relevance_score').default(50), // 0-100
+    relevanceScore: integer('relevance_score').default(50),
     // Classification
-    category: text('category'), // e.g., 'refactoring', 'debugging', 'feature'
-    importance: integer('importance').default(50), // 0-100
+    category: text('category'),
+    importance: integer('importance').default(50),
     metadata: jsonb('metadata').$type(),
+    // Migration tracking
+    isImported: boolean('is_imported').default(false),
     createdAt: timestamp('created_at').defaultNow().notNull(),
 }, (table) => [
-    index('observations_project_idx').on(table.projectId),
-    index('observations_type_idx').on(table.type),
-    index('observations_action_idx').on(table.action),
-    index('observations_created_idx').on(table.createdAt),
-    index('observations_folder_idx').on(table.folderPath),
-    index('observations_relevance_idx').on(table.relevanceScore),
-    index('observations_private_idx').on(table.isPrivate),
+    index('learnings_project_idx').on(table.projectId),
+    index('learnings_type_idx').on(table.type),
+    index('learnings_action_idx').on(table.action),
+    index('learnings_created_idx').on(table.createdAt),
+    index('learnings_folder_idx').on(table.folderPath),
+    index('learnings_relevance_idx').on(table.relevanceScore),
+    index('learnings_private_idx').on(table.isPrivate),
+    index('learnings_memory_idx').on(table.memoryId),
+]);
+/**
+ * Agent Preferences - learned agent preferences from learnings
+ * Enables agents to evolve and remember preferences over time
+ */
+export const agentPreferences = pgTable('agent_preferences', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    key: text('key').notNull(), // e.g., "prefer_bun", "prefer_typescript"
+    value: text('value').notNull(), // e.g., "bun", "true"
+    sourceMemoryId: uuid('source_memory_id').references(() => memories.id, { onDelete: 'set null' }),
+    confidence: numeric('confidence', { precision: 3, scale: 2 }).default('0.5'), // 0.00 to 1.00
+    usageCount: integer('usage_count').default(1),
+    lastUpdated: timestamp('last_updated').defaultNow().notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('agent_preferences_project_idx').on(table.projectId),
+    index('agent_preferences_key_idx').on(table.key),
 ]);
 /**
  * Entities - knowledge graph nodes
@@ -277,6 +309,63 @@ export const namespaces = pgTable('namespaces', {
     index('namespaces_project_idx').on(table.projectId),
     index('namespaces_parent_idx').on(table.parentId),
 ]);
+/**
+ * Places - Spatial memory organization
+ */
+export const places = pgTable('places', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    name: text('name').notNull(),
+    placeType: text('place_type').notNull(),
+    parentId: uuid('parent_id').references(() => places.id, { onDelete: 'set null' }),
+    sortOrder: integer('sort_order').default(0),
+    positionX: integer('position_x').default(0),
+    positionY: integer('position_y').default(0),
+    description: text('description'),
+    purpose: text('purpose'),
+    memoryCount: integer('memory_count').default(0),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('places_project_idx').on(table.projectId),
+    index('places_type_idx').on(table.placeType),
+    index('places_parent_idx').on(table.parentId),
+    index('places_sort_order_idx').on(table.projectId, table.sortOrder),
+]);
+/**
+ * Memory-Place assignments
+ */
+export const memoryPlaces = pgTable('memory_places', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'cascade' }).notNull(),
+    placeId: uuid('place_id').references(() => places.id, { onDelete: 'cascade' }).notNull(),
+    isManual: boolean('is_manual').default(false),
+    ruleId: uuid('rule_id'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('memory_places_memory_idx').on(table.memoryId),
+    index('memory_places_place_idx').on(table.placeId),
+]);
+/**
+ * Place auto-assignment rules
+ */
+export const placeRules = pgTable('place_rules', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    name: text('name').notNull(),
+    placeType: text('place_type').notNull(),
+    matchTool: text('match_tool'),
+    matchKeyword: text('match_keyword'),
+    matchTag: text('match_tag'),
+    matchMemoryType: text('match_memory_type'),
+    priority: integer('priority').default(0),
+    enabled: boolean('enabled').default(true),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('place_rules_project_idx').on(table.projectId),
+    index('place_rules_type_idx').on(table.placeType),
+]);
 /**
  * Memory Layers - Tiered L0/L1/L2 summaries for token-efficient retrieval
  */
@@ -308,7 +397,6 @@ export const entityRelations = pgTable('entity_relations', {
     index('relations_to_idx').on(table.toEntityId),
     index('relations_type_idx').on(table.type),
 ]);
-// ============================================================================
 // v0.3.0: Lifecycle & Governance Tables
 // ============================================================================
 /**
@@ -366,7 +454,6 @@ export const memorySnapshots = pgTable('memory_snapshots', {
     index('snapshots_type_idx').on(table.snapshotType),
     index('snapshots_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Progressive Disclosure & Context Paging Tables
 // ============================================================================
 /**
@@ -415,7 +502,6 @@ export const contextPagingSessions = pgTable('context_paging_sessions', {
     index('context_paging_project_idx').on(table.projectId),
     index('context_paging_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Memory Merging Tables
 // ============================================================================
 /**
@@ -559,7 +645,6 @@ export const contextSessions = pgTable('context_sessions', {
     index('context_sessions_project_idx').on(table.projectId),
     index('context_sessions_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Relations (Drizzle ORM)
 // ============================================================================
 export const usersRelations = relations(users, ({ many }) => ({
@@ -569,7 +654,7 @@ export const usersRelations = relations(users, ({ many }) => ({
 export const projectsRelations = relations(projects, ({ many }) => ({
     memories: many(memories),
     conversations: many(conversations),
-    observations: many(observations),
+    learnings: many(learnings),
     entities: many(entities),
 }));
 export const memoriesRelations = relations(memories, ({ one }) => ({
@@ -592,21 +677,35 @@ export const conversationsRelations = relations(conversations, ({ one, many }) =
         references: [users.id],
     }),
     messages: many(messages),
-    observations: many(observations),
+    learnings: many(learnings),
 }));
-export const messagesRelations = relations(messages, ({ one }) => ({
+export const learningsRelations = relations(learnings, ({ one }) => ({
+    project: one(projects, {
+        fields: [learnings.projectId],
+        references: [projects.id],
+    }),
     conversation: one(conversations, {
-        fields: [messages.conversationId],
+        fields: [learnings.conversationId],
         references: [conversations.id],
     }),
+    memory: one(memories, {
+        fields: [learnings.memoryId],
+        references: [memories.id],
+    }),
 }));
-export const observationsRelations = relations(observations, ({ one }) => ({
+export const agentPreferencesRelations = relations(agentPreferences, ({ one }) => ({
     project: one(projects, {
-        fields: [observations.projectId],
+        fields: [agentPreferences.projectId],
         references: [projects.id],
     }),
+    sourceMemory: one(memories, {
+        fields: [agentPreferences.sourceMemoryId],
+        references: [memories.id],
+    }),
+}));
+export const messagesRelations = relations(messages, ({ one }) => ({
     conversation: one(conversations, {
-        fields: [observations.conversationId],
+        fields: [messages.conversationId],
         references: [conversations.id],
     }),
 }));
@@ -696,4 +795,65 @@ export const memoryHashCacheRelations = relations(memoryHashCache, ({ one }) =>
         references: [projects.id],
     }),
 }));
+// Belief Systems - Derived Beliefs from Memory
+// ============================================================================
+/**
+ * Beliefs - Derived semantic beliefs extracted from memories
+ * Represents inferred decisions, preferences, constraints, failure causes
+ */
+export const beliefs = pgTable('beliefs', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }),
+    // Belief identification
+    beliefType: text('belief_type').notNull(),
+    statement: text('statement').notNull(),
+    normalizedKey: text('normalized_key').notNull(),
+    // Confidence and decay
+    confidence: integer('confidence').default(50), // 0-100
+    beliefDecayRate: integer('belief_decay_rate').default(30), // days half-life
+    lastConfirmedAt: timestamp('last_confirmed_at'),
+    sourceCount: integer('source_count').default(1),
+    // Status
+    status: text('status').default('active'),
+    // Context and evidence
+    reason: text('reason'),
+    context: text('context'),
+    evidenceSummary: text('evidence_summary'),
+    // Metadata (stores edges, derivation info)
+    metadata: jsonb('metadata'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('beliefs_project_idx').on(table.projectId),
+    index('beliefs_type_idx').on(table.beliefType),
+    index('beliefs_status_idx').on(table.status),
+    index('beliefs_confidence_idx').on(table.confidence),
+    index('beliefs_normalized_key_idx').on(table.normalizedKey),
+]);
+/**
+ * Belief Memory Sources - Links beliefs to source memories
+ */
+export const beliefMemorySources = pgTable('belief_memory_sources', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    beliefId: uuid('belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'cascade' }).notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('belief_sources_belief_idx').on(table.beliefId),
+    index('belief_sources_memory_idx').on(table.memoryId),
+]);
+/**
+ * Belief Edges - Relationships between beliefs
+ */
+export const beliefEdges = pgTable('belief_edges', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    fromBeliefId: uuid('from_belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    toBeliefId: uuid('to_belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    edgeType: text('edge_type').notNull(),
+    metadata: jsonb('metadata'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('belief_edges_from_idx').on(table.fromBeliefId),
+    index('belief_edges_to_idx').on(table.toBeliefId),
+]);
 //# sourceMappingURL=schema.js.map

package/dist/db/drizzle.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;
+//# sourceMappingURL=drizzle.config.d.ts.map

package/dist/db/drizzle.config.js

@@ -0,0 +1,12 @@
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    schema: './drizzle/schema.ts',
+    out: './drizzle/migrations',
+    dialect: 'postgresql',
+    dbCredentials: {
+        url: process.env.DATABASE_URL || 'postgres://squish:squish_dev@localhost:5432/squish',
+    },
+    verbose: true,
+    strict: true,
+});
+//# sourceMappingURL=drizzle.config.js.map

package/dist/db/index.d.ts

@@ -1,10 +1,6 @@
 import { createDb } from './adapter.js';
 import { config } from '../config.js';
-export declare function getDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("../drizzle/schema.js")> & {
-    $client: import("pg").Pool;
-}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("../drizzle/schema-sqlite.js")> & {
-    $client: import("better-sqlite3").Database;
-}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("../drizzle/schema-sqlite.js")>>;
+export declare function getDb(): Promise<any>;
 export declare function checkDatabaseHealth(): Promise<boolean>;
 export { config };
 export { createDb };

package/dist/db/index.js

@@ -1,6 +1,9 @@
 import { createDb } from './adapter.js';
 import { config } from '../config.js';
 import { logger } from '../core/logger.js';
+import { isDatabaseUnavailableError } from '../core/lib/utils.js';
+// Use any for db to avoid type conflicts between different drivers
+// The actual type will be determined at runtime based on mode
 let db = null;
 let dbError = null;
 export async function getDb() {
@@ -9,7 +12,38 @@ export async function getDb() {
     }
     if (!db) {
         try {
-            db = await createDb();
+            // Priority: remote (user's Supabase/Neon) > team (PostgreSQL) > local (SQLite)
+            if (config.isRemoteMode) {
+                if (config.remoteBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+                    const { createNeonClient } = await import('./neon.js');
+                    db = await createNeonClient();
+                }
+                else if (config.supabaseUrl && config.supabaseKey) {
+                    const { createSupabaseClient } = await import('./supabase.js');
+                    db = await createSupabaseClient();
+                }
+                else {
+                    throw new Error('Remote backend not configured (need SUPABASE_URL or NEON_PROJECT_ID)');
+                }
+            }
+            else if (config.isTeamMode) {
+                // Team mode: PostgreSQL (or Supabase/Neon if explicitly configured)
+                if (config.teamBackend === 'supabase' && config.supabaseUrl && config.supabaseKey) {
+                    const { createSupabaseClient } = await import('./supabase.js');
+                    db = await createSupabaseClient();
+                }
+                else if (config.teamBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+                    const { createNeonClient } = await import('./neon.js');
+                    db = await createNeonClient();
+                }
+                else {
+                    db = await createDb();
+                }
+            }
+            else {
+                // Local mode: SQLite
+                db = await createDb();
+            }
         }
         catch (error) {
             dbError = error instanceof Error ? error.message : 'Database initialization failed';
@@ -21,21 +55,30 @@ export async function getDb() {
 export async function checkDatabaseHealth() {
     try {
         const database = await getDb();
-        // Try a simple query - use a raw query that's guaranteed to work
-        const dbClient = database.$client;
+        const dbClient = database.$client ?? database;
         if (dbClient && typeof dbClient.query === 'function') {
             await dbClient.query('SELECT 1');
         }
+        else if (dbClient && typeof dbClient.exec === 'function') {
+            dbClient.exec('SELECT 1');
+        }
         else if (dbClient && typeof dbClient.prepare === 'function') {
-            dbClient.prepare('SELECT 1').get();
+            const statement = dbClient.prepare('SELECT 1');
+            if (typeof statement.get === 'function') {
+                statement.get();
+            }
+            else if (typeof statement.step === 'function') {
+                statement.step();
+            }
+            if (typeof statement.free === 'function') {
+                statement.free();
+            }
         }
         return true;
     }
     catch (error) {
-        // Check if it's a known database unavailability issue
-        if (error.message?.includes('not a valid Win32 application') ||
-            error.message?.includes('Database unavailable')) {
-            return false; // Graceful degradation - database unavailable but not an error
+        if (isDatabaseUnavailableError(error)) {
+            return false;
         }
         logger.error('Database health check failed', error);
         return false;

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

@@ -0,0 +1,6 @@
+/**
+ * Memory associations table migrations
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runAssociationsMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=associations.d.ts.map

package/dist/db/migrations/associations.js

@@ -0,0 +1,29 @@
+/**
+ * Memory associations table migrations
+ */
+import { logger } from '../../core/logger.js';
+export async function runAssociationsMigrations(sqlite) {
+    const associationsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_associations'").get();
+    if (!associationsTableCheck)
+        return;
+    const associationsInfo = sqlite.prepare("PRAGMA table_info(memory_associations)").all();
+    const existingAssociationsColumns = new Set(associationsInfo.map(col => col.name));
+    const associationsMigrations = [
+        { col: 'metadata', sql: 'ALTER TABLE memory_associations ADD COLUMN metadata TEXT' },
+    ];
+    for (const migration of associationsMigrations) {
+        if (!existingAssociationsColumns.has(migration.col)) {
+            try {
+                sqlite.exec(migration.sql);
+                logger.info(`Migration: Added column ${migration.col} to memory_associations table`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                if (!msg.includes('duplicate column name')) {
+                    throw new Error(`Migration failed for memory_associations.${migration.col}: ${msg}`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=associations.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Beliefs table migrations
+ * Uses schema definitions to generate migrations
+ *
+ * For existing databases without beliefs table (pre-v1.2.0), creates the table.
+ * Then runs column migrations for all belief-related tables.
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runBeliefMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=beliefs.d.ts.map

package/dist/db/migrations/beliefs.js

@@ -0,0 +1,76 @@
+/**
+ * Beliefs table migrations
+ * Uses schema definitions to generate migrations
+ *
+ * For existing databases without beliefs table (pre-v1.2.0), creates the table.
+ * Then runs column migrations for all belief-related tables.
+ */
+import { migrateTable } from '../schema/generator.js';
+import { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from '../schema/beliefs.js';
+import { logger } from '../../core/logger.js';
+export async function runBeliefMigrations(sqlite) {
+    // Check if beliefs table exists at all (for existing databases pre-v1.2.0)
+    const beliefsCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='beliefs'").get();
+    if (!beliefsCheck) {
+        // Create beliefs table for existing databases upgrading to v1.2.0
+        logger.info('Migration: Creating beliefs table for existing database');
+        try {
+            sqlite.exec(`
+        CREATE TABLE IF NOT EXISTS beliefs (
+          id TEXT PRIMARY KEY,
+          project_id TEXT,
+          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,
+          updated_at INTEGER,
+          UNIQUE(project_id, normalized_key)
+        )
+      `);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.warn(`Migration: Could not create beliefs table: ${msg}`);
+        }
+    }
+    const beliefSourcesCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='belief_memory_sources'").get();
+    if (!beliefSourcesCheck) {
+        sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS belief_memory_sources (
+        id TEXT PRIMARY KEY,
+        belief_id TEXT,
+        memory_id TEXT,
+        created_at INTEGER,
+        UNIQUE(belief_id, memory_id)
+      )
+    `);
+    }
+    const beliefEdgesCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='belief_edges'").get();
+    if (!beliefEdgesCheck) {
+        sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS belief_edges (
+        id TEXT PRIMARY KEY,
+        from_belief_id TEXT,
+        to_belief_id TEXT,
+        edge_type TEXT NOT NULL,
+        metadata TEXT,
+        created_at INTEGER,
+        UNIQUE(from_belief_id, to_belief_id, edge_type)
+      )
+    `);
+    }
+    // Run column migrations - adds missing columns to existing tables
+    await migrateTable(sqlite, beliefsSchema);
+    await migrateTable(sqlite, beliefMemorySourcesSchema);
+    await migrateTable(sqlite, beliefEdgesSchema);
+}
+//# sourceMappingURL=beliefs.js.map

package/dist/db/migrations/core-memory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core memory table migrations
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runCoreMemoryMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=core-memory.d.ts.map

package/dist/db/migrations/core-memory.js

@@ -0,0 +1,29 @@
+/**
+ * Core memory table migrations
+ */
+import { logger } from '../../core/logger.js';
+export async function runCoreMemoryMigrations(sqlite) {
+    const coreMemoryTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='core_memory'").get();
+    if (!coreMemoryTableCheck)
+        return;
+    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')) {
+                    throw new Error(`Migration failed for core_memory.${migration.col}: ${msg}`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=core-memory.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * FTS (Full-Text Search) table migrations
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runFtsMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=fts.d.ts.map