squish-memory 1.1.5 → 1.2.0

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

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

package/dist/db/migrations/places.js

@@ -0,0 +1,43 @@
+/**
+ * Places table migrations
+ */
+import { logger } from '../../core/logger.js';
+export async function runPlacesMigrations(sqlite) {
+    const placesTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='places'").get();
+    if (!placesTableCheck)
+        return;
+    const placesInfo = sqlite.prepare("PRAGMA table_info(places)").all();
+    const placesColumns = new Set(placesInfo.map(col => col.name));
+    const placesMigrations = [
+        { col: 'sort_order', sql: 'ALTER TABLE places ADD COLUMN sort_order INTEGER DEFAULT 0' },
+        { col: 'loci_index', sql: '' },
+    ];
+    for (const migration of placesMigrations) {
+        if (migration.col === 'loci_index') {
+            if (placesColumns.has('loci_index') && !placesColumns.has('sort_order')) {
+                try {
+                    sqlite.exec("UPDATE places SET sort_order = loci_index WHERE sort_order = 0 OR sort_order IS NULL");
+                    logger.info('Migration: Copied loci_index data to sort_order');
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    logger.warn(`Migration: Could not copy loci_index data: ${errMsg}`);
+                }
+            }
+            continue;
+        }
+        if (!placesColumns.has(migration.col)) {
+            try {
+                sqlite.exec(migration.sql);
+                logger.info(`Migration: Added column ${migration.col} to places table`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                if (!msg.includes('duplicate column name')) {
+                    throw new Error(`Migration failed for places.${migration.col}: ${msg}`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=places.js.map

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

@@ -0,0 +1,3 @@
+import type { Database } from 'better-sqlite3';
+export declare function runProjectMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/db/migrations/projects.js

@@ -0,0 +1,13 @@
+import { migrateTable } from '../schema/generator.js';
+import { projectsSchema, usersSchema } from '../schema/projects.js';
+export async function runProjectMigrations(sqlite) {
+    const projectCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'").get();
+    if (projectCheck) {
+        await migrateTable(sqlite, projectsSchema);
+    }
+    const userCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='users'").get();
+    if (userCheck) {
+        await migrateTable(sqlite, usersSchema);
+    }
+}
+//# sourceMappingURL=projects.js.map

package/dist/db/migrations/tier-conversion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tier conversion migration
+ * Converts deprecated 'warm' tier memories to 'cold'
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runTierConversion(sqlite: Database): Promise<void>;
+//# sourceMappingURL=tier-conversion.d.ts.map

package/dist/db/migrations/tier-conversion.js

@@ -0,0 +1,20 @@
+/**
+ * Tier conversion migration
+ * Converts deprecated 'warm' tier memories to 'cold'
+ */
+import { logger } from '../../core/logger.js';
+export async function runTierConversion(sqlite) {
+    const warmMemories = sqlite.prepare("SELECT COUNT(*) as count FROM memories WHERE tier = 'warm'").get();
+    if (warmMemories && warmMemories.count > 0) {
+        logger.info(`Migration: Converting ${warmMemories.count} warm-tiered memories to cold`);
+        try {
+            sqlite.exec("UPDATE memories SET tier = 'cold' WHERE tier = 'warm'");
+            logger.info('Migration: Tier conversion complete (warm -> cold)');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.warn(`Migration: Could not convert warm tier: ${msg}`);
+        }
+    }
+}
+//# sourceMappingURL=tier-conversion.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Beliefs table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const beliefsSchema: TableSchema;
+export declare const beliefMemorySourcesSchema: TableSchema;
+export declare const beliefEdgesSchema: TableSchema;
+//# sourceMappingURL=beliefs.d.ts.map

package/dist/db/schema/beliefs.js

@@ -0,0 +1,46 @@
+/**
+ * Beliefs table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const beliefsSchema = {
+    name: 'beliefs',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        belief_type: { type: 'TEXT' },
+        statement: { type: 'TEXT' },
+        normalized_key: { type: 'TEXT' },
+        confidence: { type: 'REAL', default: '0.5' },
+        belief_decay_rate: { type: 'INTEGER', default: '30' },
+        last_confirmed_at: { type: 'INTEGER' },
+        source_count: { type: 'INTEGER', default: '1' },
+        status: { type: 'TEXT', default: "'active'" },
+        reason: { type: 'TEXT' },
+        context: { type: 'TEXT' },
+        evidence_summary: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+export const beliefMemorySourcesSchema = {
+    name: 'belief_memory_sources',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        belief_id: { type: 'TEXT' },
+        memory_id: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+    },
+};
+export const beliefEdgesSchema = {
+    name: 'belief_edges',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        from_belief_id: { type: 'TEXT' },
+        to_belief_id: { type: 'TEXT' },
+        edge_type: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=beliefs.js.map

package/dist/db/schema/generator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Migration Generator - Creates migrations from schema definitions
+ *
+ * This utility generates ALTER TABLE statements from schema column definitions,
+ * eliminating the need for inline column arrays in migration files.
+ */
+import type { Database } from 'better-sqlite3';
+export interface ColumnDefinition {
+    type: string;
+    primary?: boolean;
+    references?: string;
+    default?: string;
+    notNull?: boolean;
+}
+export interface IndexDefinition {
+    name: string;
+    columns: string[];
+    using?: string;
+    unique?: boolean;
+}
+export interface TableSchema {
+    name: string;
+    columns: Record<string, ColumnDefinition>;
+    indexes?: IndexDefinition[];
+}
+/**
+ * Generate and run column migrations for a table schema
+ */
+export declare function migrateTable(sqlite: Database, schema: TableSchema): Promise<void>;
+/**
+ * Generate and run index migrations
+ */
+export declare function migrateIndexes(sqlite: Database, tableName: string, indexes: IndexDefinition[]): Promise<void>;
+/**
+ * Run all table migrations from schema list
+ */
+export declare function runAllSchemaMigrations(sqlite: Database, schemas: TableSchema[]): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/db/schema/generator.js

@@ -0,0 +1,108 @@
+/**
+ * Migration Generator - Creates migrations from schema definitions
+ *
+ * This utility generates ALTER TABLE statements from schema column definitions,
+ * eliminating the need for inline column arrays in migration files.
+ */
+import { logger } from '../../core/logger.js';
+/**
+ * Get existing columns for a table
+ */
+function getExistingColumns(sqlite, tableName) {
+    try {
+        const tableInfo = sqlite.prepare(`PRAGMA table_info(${tableName})`).all();
+        return new Set(tableInfo.map(col => col.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+/**
+ * Get existing indexes for a table
+ */
+function getExistingIndexes(sqlite, tableName) {
+    try {
+        const indexes = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name=?").all(tableName);
+        return new Set(indexes.map(idx => idx.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+/**
+ * Generate and run column migrations for a table schema
+ */
+export async function migrateTable(sqlite, schema) {
+    const existingColumns = getExistingColumns(sqlite, schema.name);
+    for (const [columnName, definition] of Object.entries(schema.columns)) {
+        if (!existingColumns.has(columnName)) {
+            const sql = generateAlterTable(schema.name, columnName, definition);
+            try {
+                sqlite.exec(sql);
+                logger.info(`Migration: Added column ${columnName} to ${schema.name}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                if (msg.includes('duplicate column name')) {
+                    logger.debug(`Migration skipped for ${schema.name}.${columnName}: already exists`);
+                }
+                else {
+                    throw new Error(`Migration failed for ${schema.name}.${columnName}: ${msg}`);
+                }
+            }
+        }
+    }
+    // Handle indexes
+    if (schema.indexes) {
+        await migrateIndexes(sqlite, schema.name, schema.indexes);
+    }
+}
+/**
+ * Generate and run index migrations
+ */
+export async function migrateIndexes(sqlite, tableName, indexes) {
+    const existingIndexes = getExistingIndexes(sqlite, tableName);
+    for (const indexDef of indexes) {
+        if (!existingIndexes.has(indexDef.name)) {
+            const sql = generateCreateIndex(tableName, indexDef);
+            try {
+                sqlite.exec(sql);
+                logger.info(`Migration: Added index ${indexDef.name}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger.warn(`Index migration failed for ${indexDef.name}: ${msg}`);
+            }
+        }
+    }
+}
+/**
+ * Generate ALTER TABLE ADD COLUMN statement
+ */
+function generateAlterTable(tableName, columnName, definition) {
+    let sql = `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition.type}`;
+    if (definition.default) {
+        sql += ` DEFAULT ${definition.default}`;
+    }
+    return sql;
+}
+/**
+ * Generate CREATE INDEX statement
+ */
+function generateCreateIndex(tableName, indexDef) {
+    const columns = indexDef.columns.join(', ');
+    const unique = indexDef.unique ? 'UNIQUE ' : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${indexDef.name} ON ${tableName}(${columns})`;
+}
+/**
+ * Run all table migrations from schema list
+ */
+export async function runAllSchemaMigrations(sqlite, schemas) {
+    for (const schema of schemas) {
+        const tableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(schema.name);
+        if (tableCheck) {
+            await migrateTable(sqlite, schema);
+        }
+    }
+}
+//# sourceMappingURL=generator.js.map

package/dist/db/schema/index.d.ts

@@ -1,40 +1,39 @@
 /**
- * Schema Index - Aggregates all table definitions
+ * Schema Index - Table schema definitions
  *
- * This module exports all table schemas for both SQLite and PostgreSQL.
- * Used by bootstrap.ts to generate database schemas.
+ * DEPRECATED: This module was previously used to aggregate table schemas.
+ * Table definitions are now in db/bootstrap.ts for first-time setup
+ * and db/schema/*.ts for migration column definitions.
+ *
+ * These exports remain for backward compatibility but return empty arrays.
+ */
+import type { TableSchema } from './generator.js';
+export { memoriesSchema } from './memories.js';
+export { learningsSchema } from './learnings.js';
+export { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from './beliefs.js';
+/**
+ * Table schemas for migration utilities
+ * @deprecated Use db/schema/memories.ts, db/schema/learnings.ts, db/schema/beliefs.ts directly
  */
-export { usersTable } from './tables/users.js';
-export { projectsTable } from './tables/projects.js';
-export { memoriesTable } from './tables/memories.js';
-export { memoryAssociationsTable } from './tables/memory-associations.js';
-export { conversationsTable } from './tables/conversations.js';
-export { messagesTable } from './tables/messages.js';
-export { learningsTable } from './tables/learnings.js';
-export { entitiesTable } from './tables/entities.js';
-export { entityRelationsTable } from './tables/entity-relations.js';
-export { contextSessionsTable } from './tables/context-sessions.js';
-export { coreMemoryTable } from './tables/core-memory.js';
-export { memoryHashCacheTable } from './tables/memory-hash-cache.js';
-export { memoryMergeProposalsTable } from './tables/memory-merge-proposals.js';
-export { memoryMergeHistoryTable } from './tables/memory-merge-history.js';
-export { namespacesTable } from './tables/namespaces.js';
+export declare const tableSchemas: TableSchema[];
 /**
  * Generate complete SQLite schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export declare function generateSqliteSchema(): string;
 /**
  * Generate complete PostgreSQL schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export declare function generatePostgresSchema(): string;
 /**
  * Get all SQLite table definitions in order
- * @deprecated Use generateSqliteSchema() instead
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export declare function getAllSqliteTables(): string[];
 /**
  * Get all PostgreSQL table definitions in order
- * @deprecated Use generatePostgresSchema() instead
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export declare function getAllPostgresTables(): string[];
 //# sourceMappingURL=index.d.ts.map

package/dist/db/schema/index.js

@@ -1,105 +1,51 @@
 /**
- * Schema Index - Aggregates all table definitions
+ * Schema Index - Table schema definitions
  *
- * This module exports all table schemas for both SQLite and PostgreSQL.
- * Used by bootstrap.ts to generate database schemas.
+ * DEPRECATED: This module was previously used to aggregate table schemas.
+ * Table definitions are now in db/bootstrap.ts for first-time setup
+ * and db/schema/*.ts for migration column definitions.
+ *
+ * These exports remain for backward compatibility but return empty arrays.
  */
-export { usersTable } from './tables/users.js';
-export { projectsTable } from './tables/projects.js';
-export { memoriesTable } from './tables/memories.js';
-export { memoryAssociationsTable } from './tables/memory-associations.js';
-export { conversationsTable } from './tables/conversations.js';
-export { messagesTable } from './tables/messages.js';
-export { learningsTable } from './tables/learnings.js';
-export { entitiesTable } from './tables/entities.js';
-export { entityRelationsTable } from './tables/entity-relations.js';
-export { contextSessionsTable } from './tables/context-sessions.js';
-export { coreMemoryTable } from './tables/core-memory.js';
-export { memoryHashCacheTable } from './tables/memory-hash-cache.js';
-export { memoryMergeProposalsTable } from './tables/memory-merge-proposals.js';
-export { memoryMergeHistoryTable } from './tables/memory-merge-history.js';
-export { namespacesTable } from './tables/namespaces.js';
-import { usersTable } from './tables/users.js';
-import { projectsTable } from './tables/projects.js';
-import { memoriesTable } from './tables/memories.js';
-import { memoryAssociationsTable } from './tables/memory-associations.js';
-import { conversationsTable } from './tables/conversations.js';
-import { messagesTable } from './tables/messages.js';
-import { learningsTable } from './tables/learnings.js';
-import { entitiesTable } from './tables/entities.js';
-import { entityRelationsTable } from './tables/entity-relations.js';
-import { contextSessionsTable } from './tables/context-sessions.js';
-import { coreMemoryTable } from './tables/core-memory.js';
-import { memoryHashCacheTable } from './tables/memory-hash-cache.js';
-import { memoryMergeProposalsTable } from './tables/memory-merge-proposals.js';
-import { memoryMergeHistoryTable } from './tables/memory-merge-history.js';
-import { namespacesTable } from './tables/namespaces.js';
+// Re-export migration schemas for compatibility
+export { memoriesSchema } from './memories.js';
+export { learningsSchema } from './learnings.js';
+export { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from './beliefs.js';
 /**
- * Table order matters for foreign key constraints
+ * Table schemas for migration utilities
+ * @deprecated Use db/schema/memories.ts, db/schema/learnings.ts, db/schema/beliefs.ts directly
  */
-const SQLITE_TABLE_ORDER = [
-    usersTable,
-    projectsTable,
-    conversationsTable,
-    memoriesTable,
-    memoryAssociationsTable,
-    messagesTable,
-    learningsTable,
-    entitiesTable,
-    entityRelationsTable,
-    contextSessionsTable,
-    coreMemoryTable,
-    memoryHashCacheTable,
-    memoryMergeProposalsTable,
-    memoryMergeHistoryTable,
-    namespacesTable,
-];
-const POSTGRES_TABLE_ORDER = [
-    usersTable,
-    projectsTable,
-    conversationsTable,
-    memoriesTable,
-    memoryAssociationsTable,
-    messagesTable,
-    learningsTable,
-    entitiesTable,
-    entityRelationsTable,
-    contextSessionsTable,
-    coreMemoryTable,
-    memoryHashCacheTable,
-    memoryMergeProposalsTable,
-    memoryMergeHistoryTable,
-    namespacesTable,
-];
+export const tableSchemas = [];
 /**
  * Generate complete SQLite schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export function generateSqliteSchema() {
-    const statements = SQLITE_TABLE_ORDER.map(t => t.sqlite).join('\n\n');
-    return `PRAGMA foreign_keys = ON;\n\n${statements}`;
+    console.warn('DEPRECATED: generateSqliteSchema() - table definitions are in db/bootstrap.ts');
+    return '';
 }
 /**
  * Generate complete PostgreSQL schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export function generatePostgresSchema() {
-    const extensionStmt = `CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE EXTENSION IF NOT EXISTS vector;
-CREATE EXTENSION IF NOT EXISTS pg_trgm;`;
-    const statements = POSTGRES_TABLE_ORDER.map(t => t.postgres).join('\n\n');
-    return `${extensionStmt}\n\n${statements}`;
+    console.warn('DEPRECATED: generatePostgresSchema() - table definitions are in db/bootstrap.ts');
+    return '';
 }
 /**
  * Get all SQLite table definitions in order
- * @deprecated Use generateSqliteSchema() instead
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export function getAllSqliteTables() {
-    return SQLITE_TABLE_ORDER.map(t => t.sqlite);
+    console.warn('DEPRECATED: getAllSqliteTables() - table definitions are in db/bootstrap.ts');
+    return [];
 }
 /**
  * Get all PostgreSQL table definitions in order
- * @deprecated Use generatePostgresSchema() instead
+ * @deprecated Table definitions moved to db/bootstrap.ts
  */
 export function getAllPostgresTables() {
-    return POSTGRES_TABLE_ORDER.map(t => t.postgres);
+    console.warn('DEPRECATED: getAllPostgresTables() - table definitions are in db/bootstrap.ts');
+    return [];
 }
 //# sourceMappingURL=index.js.map

package/dist/db/schema/learnings.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Learnings table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const learningsSchema: TableSchema;
+//# sourceMappingURL=learnings.d.ts.map

package/dist/db/schema/learnings.js

@@ -0,0 +1,30 @@
+/**
+ * Learnings table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const learningsSchema = {
+    name: 'learnings',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        type: { type: 'TEXT' },
+        content: { type: 'TEXT' },
+        summary: { type: 'TEXT' },
+        source: { type: 'TEXT' },
+        confidence: { type: 'INTEGER', default: '50' },
+        confidence_level: { type: 'TEXT', default: "'speculative'" },
+        tags: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        embedding: { type: 'BLOB' },
+        folder_path: { type: 'TEXT' },
+        project_path: { type: 'TEXT' },
+        is_private: { type: 'INTEGER', default: '0' },
+        has_secrets: { type: 'INTEGER', default: '0' },
+        relevance_score: { type: 'INTEGER', default: '50' },
+        memory_id: { type: 'TEXT' },
+        is_imported: { type: 'INTEGER', default: '0' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=learnings.js.map

package/dist/db/schema/memories.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memories table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const memoriesSchema: TableSchema;
+//# sourceMappingURL=memories.d.ts.map

package/dist/db/schema/memories.js

@@ -0,0 +1,81 @@
+/**
+ * Memories table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const memoriesSchema = {
+    name: 'memories',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        user_id: { type: 'TEXT' },
+        type: { type: 'TEXT' },
+        content: { type: 'TEXT' },
+        summary: { type: 'TEXT' },
+        embedding_json: { type: 'TEXT' },
+        embedding: { type: 'BLOB' },
+        source: { type: 'TEXT' },
+        confidence: { type: 'INTEGER', default: '50' },
+        confidence_level: { type: 'TEXT', default: "'speculative'" },
+        tags: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        is_private: { type: 'INTEGER', default: '0' },
+        has_secrets: { type: 'INTEGER', default: '0' },
+        relevance_score: { type: 'INTEGER', default: '50' },
+        is_active: { type: 'INTEGER', default: '1' },
+        expires_at: { type: 'INTEGER' },
+        access_count: { type: 'INTEGER', default: '0' },
+        last_accessed_at: { type: 'INTEGER' },
+        is_merged: { type: 'INTEGER', default: '0' },
+        merged_into_id: { type: 'TEXT' },
+        merged_at: { type: 'INTEGER' },
+        is_canonical: { type: 'INTEGER', default: '0' },
+        merge_source_ids: { type: 'TEXT' },
+        is_mergeable: { type: 'INTEGER', default: '1' },
+        merge_version: { type: 'INTEGER', default: '1' },
+        namespace_id: { type: 'TEXT' },
+        namespace_path: { type: 'TEXT' },
+        has_l0_abstract: { type: 'INTEGER', default: '0' },
+        has_l1_overview: { type: 'INTEGER', default: '0' },
+        last_layer_update: { type: 'INTEGER' },
+        importance_score: { type: 'INTEGER', default: '50' },
+        importance_decay_rate: { type: 'INTEGER', default: '30' },
+        last_importance_recalc: { type: 'INTEGER' },
+        retrieval_priority: { type: 'INTEGER', default: '50' },
+        tokens_estimate: { type: 'INTEGER', default: '0' },
+        consolidated_into: { type: 'TEXT' },
+        consolidated_at: { type: 'INTEGER' },
+        is_consolidated: { type: 'INTEGER', default: '0' },
+        sector: { type: 'TEXT', default: "'episodic'" },
+        tier: { type: 'TEXT', default: "'hot'" },
+        status: { type: 'TEXT', default: "'active'" },
+        encrypted_content: { type: 'TEXT' },
+        encryption_nonce: { type: 'TEXT' },
+        is_encrypted: { type: 'INTEGER', default: '0' },
+        context_status: { type: 'TEXT', default: "'out-of-context'" },
+        decay_rate: { type: 'INTEGER', default: '30' },
+        coactivation_score: { type: 'INTEGER', default: '0' },
+        last_decay_at: { type: 'INTEGER' },
+        agent_id: { type: 'TEXT' },
+        agent_role: { type: 'TEXT' },
+        visibility_scope: { type: 'TEXT', default: "'private'" },
+        is_protected: { type: 'INTEGER', default: '0' },
+        is_pinned: { type: 'INTEGER', default: '0' },
+        is_immutable: { type: 'INTEGER', default: '0' },
+        write_scope: { type: 'TEXT' },
+        read_scope: { type: 'TEXT' },
+        triggered_by: { type: 'TEXT' },
+        capture_reason: { type: 'TEXT' },
+        last_used_at: { type: 'INTEGER' },
+        usage_count: { type: 'INTEGER', default: '0' },
+        valid_from: { type: 'INTEGER' },
+        valid_to: { type: 'INTEGER' },
+        recorded_at: { type: 'INTEGER' },
+        superseded_by: { type: 'TEXT' },
+        version: { type: 'INTEGER', default: '1' },
+        place_id: { type: 'TEXT' },
+        place_sort_order: { type: 'INTEGER', default: '0' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=memories.js.map

package/dist/db/schema/projects.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from '../generator.js';
+export declare const projectsSchema: TableSchema;
+export declare const usersSchema: TableSchema;
+//# sourceMappingURL=projects.d.ts.map