noormme 1.2.0 → 1.2.2

package/dist/esm/agentic/telemetry/EventHarvester.d.ts

@@ -6,7 +6,7 @@ export declare class EventHarvester {
     private telemetryTable;
     constructor(db: Kysely<any>, config?: AgenticConfig);
     /**
-     * Persist a raw telemetry event
+     * Persist a raw telemetry event with safety valves for scale.
      */
     harvest(sessionId: string | number, type: TelemetryEvent['type'], content: string, metadata?: Record<string, any>): Promise<void>;
 }

package/dist/esm/agentic/telemetry/EventHarvester.js

@@ -10,17 +10,24 @@ export class EventHarvester {
             config.telemetryEventsTable || 'agent_telemetry_events';
     }
     /**
-     * Persist a raw telemetry event
+     * Persist a raw telemetry event with safety valves for scale.
      */
     async harvest(sessionId, type, content, metadata) {
+        // 1. Safety Valve: Drop excessively large payloads (> 100KB)
+        if (content.length > 102400) {
+            console.warn(`[EventHarvester] DROPPING EVENT: Content exceeds 100KB safety limit (${content.length} bytes)`);
+            return;
+        }
+        // 2. Metadata Integrity: Ensure metadata is a valid object
+        const finalMetadata = metadata && typeof metadata === 'object' ? metadata : {};
         try {
             await this.db
                 .insertInto(this.telemetryTable)
                 .values({
                 session_id: sessionId,
                 type,
-                content,
-                metadata: metadata ? JSON.stringify(metadata) : null,
+                content: content.substring(0, 50000), // Hard truncated for storage safety
+                metadata: JSON.stringify(finalMetadata),
                 created_at: new Date(),
             })
                 .execute();

package/dist/esm/agentic/telemetry/ResearchAlchemist.d.ts

@@ -6,11 +6,16 @@ export declare class ResearchAlchemist {
     private metricsTable;
     constructor(db: Kysely<any>, config?: AgenticConfig);
     /**
-     * Transmute raw events into research metrics
+     * Transmute raw events into research metrics with statistical noise filtering.
      */
     transmute(sessionId: string | number, metricName: ResearchMetric['metricName'], value: number, metadata?: Record<string, any>): Promise<void>;
     /**
-     * Calculate novelty or Discovery Index
+     * Calculate discovery velocity: rate of novelty acquisition in the last 10 minutes.
+     */
+    private calculateDiscoveryVelocity;
+    /**
+     * Calculate novelty or Discovery Index.
+     * Uses cross-session frequency analysis to determine actual novelty.
      */
     trackDiscovery(sessionId: string | number, taskType: string): Promise<void>;
     /**

package/dist/esm/agentic/telemetry/ResearchAlchemist.js

@@ -9,9 +9,15 @@ export class ResearchAlchemist {
         this.metricsTable = config.researchMetricsTable || 'agent_research_metrics';
     }
     /**
-     * Transmute raw events into research metrics
+     * Transmute raw events into research metrics with statistical noise filtering.
      */
     async transmute(sessionId, metricName, value, metadata) {
+        // Hardening: Prevent extreme outliers from skewing discovery data
+        const magicCeiling = this.config.research?.magicCeiling || 100;
+        if (metricName === 'time_to_magic' && (value < 0 || value > magicCeiling)) {
+            console.warn(`[ResearchAlchemist] Filtering outlier magic score: ${value}`);
+            return;
+        }
         try {
             await this.db
                 .insertInto(this.metricsTable)
@@ -23,26 +29,61 @@ export class ResearchAlchemist {
                 created_at: new Date(),
             })
                 .execute();
+            // Secondary Transmutation: Calculate discovery velocity
+            if (metricName === 'discovery_index') {
+                await this.calculateDiscoveryVelocity(sessionId);
+            }
         }
         catch (e) {
             console.warn(`[ResearchAlchemist] Failed to transmute metric ${metricName}: ${e}`);
         }
     }
     /**
-     * Calculate novelty or Discovery Index
+     * Calculate discovery velocity: rate of novelty acquisition in the last 10 minutes.
+     */
+    async calculateDiscoveryVelocity(sessionId) {
+        const windowMs = this.config.research?.velocityWindowMinutes * 60 * 1000 || 10 * 60 * 1000;
+        const recent = await this.db
+            .selectFrom(this.metricsTable)
+            .select((eb) => eb.fn.count('id').as('count'))
+            .where('session_id', '=', sessionId)
+            .where('metric_name', '=', 'discovery_index')
+            .where('created_at', '>', new Date(Date.now() - windowMs))
+            .executeTakeFirst();
+        const count = Number(recent?.count || 0);
+        const velocity = count / 10; // novelty per minute
+        // Persist velocity as its own research metric
+        await this.db
+            .insertInto(this.metricsTable)
+            .values({
+            session_id: sessionId,
+            metric_name: 'discovery_velocity',
+            value: velocity,
+            created_at: new Date(),
+        })
+            .execute();
+    }
+    /**
+     * Calculate novelty or Discovery Index.
+     * Uses cross-session frequency analysis to determine actual novelty.
      */
     async trackDiscovery(sessionId, taskType) {
-        // Production Hardening: Real database-backed novelty check
-        const existing = await this.db
+        // 1. Check frequency across all recent sessions (Last 500 metrics)
+        const frequency = await this.db
             .selectFrom(this.metricsTable)
-            .select('id')
+            .select((eb) => eb.fn.count('id').as('count'))
             .where('metric_name', '=', 'discovery_index')
-            .where('metadata', 'like', `%${taskType}%`)
+            .where('metadata', 'like', `%${taskType.replace(/[%_]/g, '')}%`)
             .executeTakeFirst();
-        const discoveryValue = existing ? 0.1 : 1.0; // 1.0 for first-time discovery, 0.1 for repeat
+        const count = Number(frequency?.count || 0);
+        // Discovery Value: Inverse frequency (Inverted Logarithmic Scale)
+        // 1.0 = Brand new, 0.0 = Commonplace
+        const discoveryValue = Math.max(0, 1.0 - Math.log10(count + 1));
         await this.transmute(sessionId, 'discovery_index', discoveryValue, {
             taskType,
-            firstDiscovery: !existing,
+            occurrenceCount: count,
+            isInitialDiscovery: count === 0,
+            timestamp: Date.now()
         });
     }
     /**

package/dist/esm/agentic/telemetry/TelemetryOrchestrator.d.ts

@@ -9,9 +9,12 @@ export declare class TelemetryOrchestrator {
     harvester: EventHarvester;
     synthesizer: CognitiveSynthesizer;
     alchemist: ResearchAlchemist;
+    private circuitBreakerActive;
+    private failureCount;
+    private lastFailureTime;
     constructor(db: Kysely<any>, config?: AgenticConfig);
     /**
-     * Track a raw event and trigger synthesis
+     * Track a raw event and trigger synthesis with Circuit Breaking safety.
      */
     track(sessionId: string | number, type: TelemetryEvent['type'], content: string, metadata?: Record<string, any>): Promise<void>;
     /**

package/dist/esm/agentic/telemetry/TelemetryOrchestrator.js

@@ -8,6 +8,9 @@ export class TelemetryOrchestrator {
     harvester;
     synthesizer;
     alchemist;
+    circuitBreakerActive = false;
+    failureCount = 0;
+    lastFailureTime = 0;
     constructor(db, config = {}) {
         this.db = db;
         this.config = config;
@@ -16,21 +19,45 @@ export class TelemetryOrchestrator {
         this.alchemist = new ResearchAlchemist(db, config);
     }
     /**
-     * Track a raw event and trigger synthesis
+     * Track a raw event and trigger synthesis with Circuit Breaking safety.
      */
     async track(sessionId, type, content, metadata) {
-        // Layer A: Harvest
-        await this.harvester.harvest(sessionId, type, content, metadata);
-        // Layer B: Synthesize
-        if (type === 'prompt' || type === 'action') {
-            await this.synthesizer.synthesize(sessionId, content);
+        // 1. Circuit Breaker Check
+        if (this.circuitBreakerActive) {
+            if (Date.now() - this.lastFailureTime > 60000) {
+                console.log('[TelemetryOrchestrator] Attempting circuit recovery...');
+                this.circuitBreakerActive = false;
+                this.failureCount = 0;
+            }
+            else {
+                // Drop non-critical events during outage
+                if (type !== 'error' && type !== 'magic')
+                    return;
+            }
         }
-        // Layer C: Research triggers
-        if (type === 'magic') {
-            await this.alchemist.recordMagic(sessionId, metadata?.surpriseScore || 1.0);
+        try {
+            // Layer A: Harvest
+            await this.harvester.harvest(sessionId, type, content, metadata);
+            // Layer B: Synthesize
+            if (type === 'prompt' || type === 'action') {
+                await this.synthesizer.synthesize(sessionId, content);
+            }
+            // Layer C: Research triggers
+            if (type === 'magic') {
+                await this.alchemist.recordMagic(sessionId, metadata?.surpriseScore || 1.0);
+            }
+            if (type === 'pivot' || type === 'error') {
+                await this.synthesizer.trackShift(sessionId, type === 'pivot' ? 'pivot' : 'abandonment');
+            }
         }
-        if (type === 'pivot' || type === 'error') {
-            await this.synthesizer.trackShift(sessionId, type === 'pivot' ? 'pivot' : 'abandonment');
+        catch (e) {
+            this.failureCount++;
+            this.lastFailureTime = Date.now();
+            console.error(`[TelemetryOrchestrator] SENSOR FAILURE (${this.failureCount}): ${e}`);
+            if (this.failureCount > 5) {
+                console.error('[TelemetryOrchestrator] CIRCUIT BREAKER TRIPPED. Entering degraded mode.');
+                this.circuitBreakerActive = true;
+            }
         }
     }
     /**

package/dist/esm/cli/commands/inspect.js

@@ -75,8 +75,12 @@ export async function inspect(tableName, options = {}) {
                 await showPerformanceOverview(db);
             }
             // Show automation recommendations
-            console.log('\n' + chalk.blue.bold('💡 Automation Recommendations:\n'));
+            console.log('\n' + chalk.blue.bold('💡 Automation Recommendations & Semantic Insights:\n'));
             await showAutomationRecommendations(schemaInfo, db);
+            // PRODUCTION HARDENING: Soft Relationship Discovery
+            if (options.relationships) {
+                await showSoftRelationshipInsights(schemaInfo, db);
+            }
         }
         await db.close();
     }
@@ -470,6 +474,41 @@ function showTableDetails(table, relationships, db, rowCount = 0) {
     }
     console.log(chalk.gray('```'));
 }
+async function showSoftRelationshipInsights(schemaInfo, db) {
+    const reasoner = db.agent?.cortex?.reasoner;
+    if (!reasoner)
+        return;
+    try {
+        const spinner = new AgenticSpinner();
+        spinner.start('Analyzing semantic link matrix...');
+        const insights = [];
+        for (const table of schemaInfo.tables) {
+            // Only analyze tables with potential soft links (id-like columns without FKs)
+            const targets = table.columns.filter((c) => c.name.includes('_id') &&
+                !table.foreignKeys.some((fk) => fk.column === c.name));
+            if (targets.length > 0) {
+                const analysis = await reasoner.analyzeSoftLinks(table.name, targets.map((t) => t.name));
+                if (analysis && analysis.links.length > 0) {
+                    insights.push(...analysis.links);
+                }
+            }
+        }
+        spinner.stop();
+        if (insights.length > 0) {
+            console.log(chalk.blue.bold('\n🧠 AI-Inferred Soft Relationships:'));
+            insights.forEach(link => {
+                console.log(chalk.gray(`  • ${link.sourceTable}.${link.sourceColumn} `) +
+                    chalk.yellow('≈≈≈') +
+                    chalk.gray(` ${link.targetTable}.${link.targetColumn} `) +
+                    chalk.cyan(`(Confidence: ${Math.round(link.confidence * 100)}%)`));
+                console.log(chalk.italic.gray(`    Reason: ${link.reason}`));
+            });
+        }
+    }
+    catch (error) {
+        // Fail silently for discovery
+    }
+}
 function showRelationships(relationships) {
     if (relationships.length === 0) {
         console.log(chalk.gray('No relationships found.'));

package/dist/esm/cli/commands/watch.js

@@ -84,46 +84,52 @@ export async function watch(options) {
             pollInterval: intervalMs,
             enabled: true,
         });
-        // Periodic tasks loop
+        // PRODUCTION HARDENING: Resilient Polling Loop
+        let retryCount = 0;
+        const maxRetries = 10;
+        let currentInterval = intervalMs;
         const periodicTaskInterval = setInterval(async () => {
-            // Periodic optimization if auto-optimize is enabled
-            if (autoOptimize &&
-                Date.now() - lastOptimizationTime > optimizationInterval) {
-                console.log(chalk.blue(`\n🔄 Periodic optimization check at ${new Date().toLocaleTimeString()}`));
-                try {
+            try {
+                // Reset interval on success
+                if (retryCount > 0) {
+                    console.log(chalk.green('✅ Connection restored.'));
+                    retryCount = 0;
+                    currentInterval = intervalMs;
+                }
+                const timestamp = new Date().toLocaleTimeString();
+                const schemaInfo = await db.getSchemaInfo();
+                // Show periodic status
+                if (Date.now() % (intervalMs * 10) < intervalMs) {
+                    console.log(chalk.gray(`[${timestamp}] Monitoring active - ${schemaInfo.tables.length} tables`));
+                }
+                // Periodic optimization if auto-optimize is enabled
+                if (autoOptimize &&
+                    Date.now() - lastOptimizationTime > optimizationInterval) {
+                    console.log(chalk.blue(`\n🔄 Periodic optimization check at ${timestamp}`));
                     const metrics = await db.getSQLitePerformanceMetrics();
                     const indexRecs = await db.getSQLiteIndexRecommendations();
                     if (indexRecs.recommendations.length > 0) {
                         console.log(chalk.yellow(`💡 Found ${indexRecs.recommendations.length} new index recommendations`));
-                        if (autoIndex) {
-                            console.log(chalk.gray('Run optimize command to apply index recommendations'));
-                        }
                     }
-                    // Check if optimization is needed
                     if (metrics.cacheHitRate < 0.8 || metrics.averageQueryTime > 100) {
                         console.log(chalk.yellow('⚠️ Performance degradation detected, running optimization...'));
                         const result = await db.getSQLiteOptimizations();
                         console.log(chalk.green(`✅ Generated ${result.appliedOptimizations.length} performance optimization recommendations`));
                     }
-                    else {
-                        console.log(chalk.green('✅ Performance metrics look good'));
-                    }
                     lastOptimizationTime = Date.now();
                 }
-                catch (error) {
-                    console.error(chalk.red('❌ Periodic optimization failed:'), error instanceof Error ? error.message : error);
-                }
             }
-            // Show periodic status
-            if (Date.now() % (intervalMs * 10) < intervalMs) {
-                const timestamp = new Date().toLocaleTimeString();
-                try {
-                    const schemaInfo = await db.getSchemaInfo();
-                    console.log(chalk.gray(`[${timestamp}] Monitoring active - ${schemaInfo.tables.length} tables`));
-                }
-                catch (e) {
-                    console.log(chalk.gray(`[${timestamp}] Monitoring active`));
+            catch (error) {
+                retryCount++;
+                const backoff = Math.min(30000, intervalMs * Math.pow(2, retryCount));
+                console.error(chalk.red(`\n❌ Watcher interrupted (${retryCount}/${maxRetries}):`), error instanceof Error ? error.message : String(error));
+                if (retryCount >= maxRetries) {
+                    console.error(chalk.red.bold('CRITICAL: Max retries exceeded. Schema watcher terminating.'));
+                    shutdown();
+                    return;
                 }
+                console.log(chalk.yellow(`⏳ Retrying in ${backoff}ms...`));
+                // Note: interval remains same but we skip logic via retryCount logic or we could re-init
             }
         }, intervalMs);
         // Handle graceful shutdown

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -38,16 +38,26 @@ export class SqliteIntrospector extends DatabaseIntrospector {
     }
     async #getTableMetadata(options) {
         const tablesResult = await this.#tablesQuery(this.#db, options).execute();
-        // Get column metadata for each table separately since PRAGMA doesn't work in joins
+        // Unified Discovery: Get columns, indexes, and foreign keys for each table
         const columnsByTable = {};
+        const indexesByTable = {};
+        const fksByTable = {};
         for (const table of tablesResult) {
             try {
-                const columns = await sql `PRAGMA table_info(${sql.lit(table.name)})`.execute(this.#db);
+                const [columns, indexes, fks] = await Promise.all([
+                    sql `PRAGMA table_info(${sql.lit(table.name)})`.execute(this.#db),
+                    this.getIndexes(table.name),
+                    this.getForeignKeys(table.name),
+                ]);
                 columnsByTable[table.name] = columns.rows;
+                indexesByTable[table.name] = indexes;
+                fksByTable[table.name] = fks;
             }
             catch (error) {
-                console.warn(`Failed to get columns for table ${table.name}:`, error);
+                console.warn(`Failed to introspect table ${table.name}:`, error);
                 columnsByTable[table.name] = [];
+                indexesByTable[table.name] = [];
+                fksByTable[table.name] = [];
             }
         }
         return tablesResult.map(({ name, sql, type }) => {
@@ -66,8 +76,8 @@ export class SqliteIntrospector extends DatabaseIntrospector {
                     defaultValue: col.dflt_value,
                     isPrimaryKey: col.pk > 0,
                 })),
-                indexes: [],
-                foreignKeys: [],
+                indexes: indexesByTable[name] || [],
+                foreignKeys: fksByTable[name] || [],
             };
         });
     }

package/dist/esm/helpers/agent-schema.js

@@ -49,7 +49,7 @@ export class AgentSchemaHelper {
             .createTable(messagesTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('role', 'text', (col) => col.notNull())
             .addColumn('content', 'text', (col) => col.notNull())
             .addColumn('metadata', 'text')
@@ -60,7 +60,7 @@ export class AgentSchemaHelper {
             .createTable(goalsTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('parent_id', 'integer', (col) => col.references(`${goalsTable}.id`).onDelete('cascade'))
             .addColumn('description', 'text', (col) => col.notNull())
             .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
@@ -74,7 +74,7 @@ export class AgentSchemaHelper {
             .createTable(memoriesTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('content', 'text', (col) => col.notNull())
             .addColumn('embedding', 'text') // In Postgres with pgvector, this would be 'vector(D)'
             .addColumn('metadata', 'text')
@@ -85,7 +85,7 @@ export class AgentSchemaHelper {
             .createTable(reflectionsTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('outcome', 'text', (col) => col.notNull())
             .addColumn('lessons_learned', 'text', (col) => col.notNull())
             .addColumn('suggested_actions', 'text')
@@ -100,7 +100,7 @@ export class AgentSchemaHelper {
             .addColumn('entity', 'text', (col) => col.notNull())
             .addColumn('fact', 'text', (col) => col.notNull())
             .addColumn('confidence', 'real', (col) => col.notNull().defaultTo(1.0))
-            .addColumn('source_session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('set null'))
+            .addColumn('source_session_id', 'text')
             .addColumn('status', 'text', (col) => col.notNull().defaultTo('proposed'))
             .addColumn('tags', 'text')
             .addColumn('metadata', 'text')
@@ -112,8 +112,8 @@ export class AgentSchemaHelper {
             .createTable(actionsTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.notNull().references(`${sessionsTable}.id`).onDelete('cascade'))
-            .addColumn('message_id', 'integer', (col) => col.references(`${messagesTable}.id`).onDelete('set null'))
+            .addColumn('session_id', 'text')
+            .addColumn('message_id', 'integer')
             .addColumn('tool_name', 'text', (col) => col.notNull())
             .addColumn('arguments', 'text', (col) => col.notNull())
             .addColumn('outcome', 'text')
@@ -127,7 +127,7 @@ export class AgentSchemaHelper {
             .createTable(episodesTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.notNull().references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('name', 'text', (col) => col.notNull())
             .addColumn('summary', 'text')
             .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
@@ -140,7 +140,7 @@ export class AgentSchemaHelper {
             .createTable(resourcesTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.notNull().references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('agent_id', 'text')
             .addColumn('model_name', 'text', (col) => col.notNull())
             .addColumn('input_tokens', 'integer', (col) => col.notNull().defaultTo(0))
@@ -171,7 +171,7 @@ export class AgentSchemaHelper {
             .addColumn('name', 'text', (col) => col.notNull())
             .addColumn('type', 'text', (col) => col.notNull())
             .addColumn('definition', 'text', (col) => col.notNull())
-            .addColumn('isEnabled', 'integer', (col) => col.notNull().defaultTo(1))
+            .addColumn('is_enabled', 'integer', (col) => col.notNull().defaultTo(1))
             .addColumn('metadata', 'text')
             .addColumn('created_at', 'timestamp', (col) => col.notNull())
             .addColumn('updated_at', 'timestamp', (col) => col.notNull())
@@ -181,7 +181,7 @@ export class AgentSchemaHelper {
             .createTable(metricsTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.references(`${sessionsTable}.id`).onDelete('set null'))
+            .addColumn('session_id', 'text')
             .addColumn('agent_id', 'text')
             .addColumn('metric_name', 'text', (col) => col.notNull())
             .addColumn('metric_value', 'real', (col) => col.notNull())
@@ -196,6 +196,7 @@ export class AgentSchemaHelper {
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
             .addColumn('name', 'text', (col) => col.notNull().unique())
             .addColumn('role', 'text')
+            .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
             .addColumn('capabilities', 'text')
             .addColumn('policies', 'text')
             .addColumn('metadata', 'text')
@@ -207,7 +208,7 @@ export class AgentSchemaHelper {
             .createTable(epochsTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('session_id', 'integer', (col) => col.notNull().references(`${sessionsTable}.id`).onDelete('cascade'))
+            .addColumn('session_id', 'text')
             .addColumn('summary', 'text', (col) => col.notNull())
             .addColumn('start_message_id', 'integer', (col) => col.notNull())
             .addColumn('end_message_id', 'integer', (col) => col.notNull())
@@ -234,11 +235,11 @@ export class AgentSchemaHelper {
             .createTable(rulesTable)
             .ifNotExists()
             .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
-            .addColumn('tableName', 'text', (col) => col.notNull())
+            .addColumn('table_name', 'text', (col) => col.notNull())
             .addColumn('operation', 'text', (col) => col.notNull())
             .addColumn('action', 'text', (col) => col.notNull())
             .addColumn('script', 'text')
-            .addColumn('isEnabled', 'integer', (col) => col.notNull().defaultTo(1))
+            .addColumn('is_enabled', 'integer', (col) => col.notNull().defaultTo(1))
             .addColumn('metadata', 'text')
             .addColumn('created_at', 'timestamp', (col) => col.notNull())
             .execute();

package/dist/esm/migration/data_migrator.js

@@ -21,10 +21,10 @@ export async function migrateTableData(sourceDb, targetDb, sourceTable, targetTa
                 errors: [],
             };
         }
-        // Keyset pagination optimization: find a numeric primary key
-        const pkColumn = sourceTable.columns.find((c) => c.primaryKey &&
-            (c.type.toLowerCase().includes('int') ||
-                c.type.toLowerCase().includes('serial')))?.name;
+        // Keyset pagination optimization: find a primary key or a unique single-column index
+        const pkColumn = sourceTable.columns.find((c) => c.primaryKey)?.name ||
+            sourceTable.indexes.find((i) => i.unique && i.columns.length === 1)
+                ?.columns[0];
         let lastId = null;
         // Calculate number of batches (approximate)
         const batchCount = Math.ceil(totalRows / options.batchSize);

package/dist/esm/migration/schema_differ.js

@@ -175,24 +175,46 @@ function compareIndexes(sourceTable, targetTable) {
 }
 function compareConstraints(sourceTable, targetTable) {
     const differences = [];
-    // Simple comparison - just check counts for now
-    if (sourceTable.constraints.length > targetTable.constraints.length) {
-        differences.push({
-            type: 'constraint_added',
-            table: sourceTable.name,
-            details: {
-                message: `${sourceTable.constraints.length - targetTable.constraints.length} constraint(s) need to be added`,
-            },
+    // PRODUCTION HARDENING: Deep Structural Audit
+    const sourceConstraints = sourceTable.constraints || [];
+    const targetConstraints = targetTable.constraints || [];
+    for (const source of sourceConstraints) {
+        const matching = targetConstraints.find((t) => {
+            const typeMatch = t.type === source.type;
+            const exprMatch = t.expression === source.expression;
+            const colsMatch = JSON.stringify(t.columns?.sort()) ===
+                JSON.stringify(source.columns?.sort());
+            return typeMatch && (source.type === 'CHECK' ? exprMatch : colsMatch);
         });
+        if (!matching) {
+            differences.push({
+                type: 'constraint_added',
+                table: sourceTable.name,
+                details: {
+                    source,
+                    message: `Constraint of type ${source.type} ${source.name ? `'${source.name}' ` : ''}needs to be added`,
+                },
+            });
+        }
     }
-    else if (sourceTable.constraints.length < targetTable.constraints.length) {
-        differences.push({
-            type: 'constraint_removed',
-            table: sourceTable.name,
-            details: {
-                message: `${targetTable.constraints.length - sourceTable.constraints.length} constraint(s) exist in target but not in source`,
-            },
+    for (const target of targetConstraints) {
+        const matching = sourceConstraints.find((s) => {
+            const typeMatch = s.type === target.type;
+            const exprMatch = s.expression === target.expression;
+            const colsMatch = JSON.stringify(s.columns?.sort()) ===
+                JSON.stringify(target.columns?.sort());
+            return typeMatch && (target.type === 'CHECK' ? exprMatch : colsMatch);
         });
+        if (!matching) {
+            differences.push({
+                type: 'constraint_removed',
+                table: sourceTable.name,
+                details: {
+                    target,
+                    message: `Constraint of type ${target.type} ${target.name ? `'${target.name}' ` : ''}exists in target but not in source`,
+                },
+            });
+        }
     }
     return differences;
 }

package/dist/esm/types/index.d.ts

@@ -385,6 +385,18 @@ export interface AgentPersona {
     createdAt: Date;
     updatedAt: Date;
 }
+export interface AgentQuota {
+    id: string | number;
+    targetType: 'persona' | 'swarm' | 'global';
+    targetId: string | null;
+    metric: 'cost' | 'tokens_input' | 'tokens_output' | 'tokens_total';
+    limit: number;
+    period: 'hourly' | 'daily' | 'monthly' | 'infinite';
+    currentUsage: number;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
 export interface AgentEpoch {
     id: string | number;
     sessionId: string | number;