noormme 1.2.0 → 1.2.1

package/dist/esm/agentic/improvement/StrategicPlanner.js

@@ -36,11 +36,14 @@ export class StrategicPlanner {
             .selectFrom(this.personasTable)
             .selectAll()
             .execute();
+        const allParsedPersonas = personas.map((p) => this.parsePersona(p));
+        const globalBlacklistDuration = this.config.strategy?.globalBlacklistDuration || 3600000; // 1 hour
+        const localBlacklistDuration = this.config.strategy?.localBlacklistDuration || 86400000; // 24 hours
         for (const p of personas) {
             const persona = this.parsePersona(p);
             // 1. Verification Monitor
             if (persona.metadata?.evolution_status === 'verifying') {
-                const result = await this.verifyEvolution(persona);
+                const result = await this.verifyEvolution(persona, allParsedPersonas);
                 if (result)
                     mutations.push(result);
                 continue;
@@ -50,20 +53,15 @@ export class StrategicPlanner {
             const report = await this.analyzePersona(persona.id);
             // 3. Blacklist Check (Local & Global Phase 5)
             const lastMutation = persona.metadata?.last_failed_mutation;
-            const allPersonas = await this.typedDb
-                .selectFrom(this.personasTable)
-                .selectAll()
-                .execute();
-            const isGloballyBlacklisted = allPersonas.some((p) => {
-                const mp = this.parsePersona(p);
+            const isGloballyBlacklisted = allParsedPersonas.some((mp) => {
                 return (mp.metadata?.last_failed_mutation?.type === report.recommendation &&
                     Date.now() - (mp.metadata?.last_failed_mutation?.timestamp || 0) <
-                        3600000);
+                        globalBlacklistDuration);
             });
             if (isGloballyBlacklisted ||
                 (lastMutation &&
                     report.recommendation === lastMutation.type &&
-                    Date.now() - lastMutation.timestamp < 86400000)) {
+                    Date.now() - lastMutation.timestamp < localBlacklistDuration)) {
                 console.log(`[StrategicPlanner] Skipping blacklisted mutation ${report.recommendation} for persona ${persona.id} (Global=${isGloballyBlacklisted})`);
                 continue;
             }
@@ -109,15 +107,19 @@ export class StrategicPlanner {
                     .filter((p) => (p.metadata?.evolution_status === 'stable' ||
                     !p.metadata?.evolution_status) &&
                     p.metadata?.mutation_reason?.includes(report.recommendation));
-                if (winningMutations.length > 0 && Math.random() > 0.5) {
-                    console.log(`[StrategicPlanner] Cross-Pollinating success from Persona ${winningMutations[0].id}`);
-                    updates = { role: winningMutations[0].role || persona.role };
+                if (winningMutations.length > 0) {
+                    // PRODUCTION HARDENING: Deterministic Alpha Selection
+                    // Instead of Math.random(), pick the variant with the highest anchored reliability
+                    const sorted = winningMutations.sort((a, b) => (b.metadata?.anchored_reliability || 0) - (a.metadata?.anchored_reliability || 0));
+                    const alphaMatch = sorted[0];
+                    console.log(`[StrategicPlanner] Cross-Pollinating success from Alpha Persona ${alphaMatch.id} (Reliability: ${alphaMatch.metadata?.anchored_reliability || 0})`);
+                    updates = { role: this.sanitizeRole(alphaMatch.role || persona.role || 'Agent') };
                 }
                 else {
                     switch (report.recommendation) {
                         case 'optimize_accuracy':
                             updates = {
-                                role: `${persona.role || ''} (Focus strictly on accuracy and detailed verification)`.trim(),
+                                role: this.sanitizeRole(`${persona.role || ''} (Focus strictly on accuracy and detailed verification)`),
                             };
                             break;
                         case 'optimize_efficiency':
@@ -137,6 +139,9 @@ export class StrategicPlanner {
                     }
                 }
             }
+            if (updates.role) {
+                updates.role = this.sanitizeRole(updates.role);
+            }
             // 1. Predictive Conflict Detection (Pre-flight)
             const proposedState = { ...persona, ...updates };
             const contradictions = await this.cortex.reasoner.detectContradictions();
@@ -196,18 +201,13 @@ export class StrategicPlanner {
      * Check if a persona in verification should be stabilized or rolled back.
      * Uses dynamic statistical variance and adaptive meta-tuning.
      */
-    async verifyEvolution(persona) {
+    async verifyEvolution(persona, allPersonas = []) {
         const report = await this.analyzePersona(persona.id);
         // Adaptive Meta-Tuning: Increase window based on rollback history (Phase 4)
         const rollbackHistory = persona.metadata?.rollbackHistory || [];
         const recentRollbacks = rollbackHistory.filter((ts) => Date.now() - ts < 604800000).length;
         // Hive-Mind Verification Speedups (Phase 5)
-        const allPersonas = await this.typedDb
-            .selectFrom(this.personasTable)
-            .selectAll()
-            .execute();
         const hiveTrusted = allPersonas
-            .map((p) => this.parsePersona(p))
             .filter((p) => p.metadata?.evolution_status === 'stable' &&
             p.metadata?.mutation_reason === persona.metadata?.mutation_reason).length;
         let sampleSizeThreshold = 10 + recentRollbacks * 10;
@@ -430,6 +430,13 @@ export class StrategicPlanner {
             return `Rolled back mutation ${lastMutation.id} for persona ${id}`;
         });
     }
+    sanitizeRole(role) {
+        // Audit Phase 7: Semantic Security
+        // Truncate to prevent context-window exhaustion/bloat
+        const truncated = role.slice(0, 500).trim();
+        // Sanitize: remove potentially dangerous prompt-injection markers or control chars
+        return truncated.replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(/<\|.*?\|>/g, '');
+    }
     parsePersona(p) {
         return {
             id: p.id,

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

@@ -22,5 +22,10 @@ export declare class CognitiveSynthesizer {
     private inferGoalFromContent;
     private detectStrategy;
     private calculateAutonomy;
+    /**
+     * Detect "Sentiment Drift" or Cognitive Friction in the input stream.
+     * Mirrors the agent's internal "frustration" or "flow" state.
+     */
+    private detectSentimentDrift;
     private parsePath;
 }

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

@@ -19,8 +19,15 @@ export class CognitiveSynthesizer {
      * Uses robust transaction logic and behavioral pathing.
      */
     async synthesize(sessionId, input, pattern) {
-        // Production: structured goal inference logic
-        const goalInferred = this.inferGoalFromContent(input);
+        // PRODUCTION HARDENING: Reasoning-Driven Synthesis
+        // Instead of regex heuristics, we leverage the RecursiveReasoner for high-fidelity goal extraction
+        const cortex = this.config.cortex;
+        let goalInferred = this.inferGoalFromContent(input);
+        if (cortex?.reasoner) {
+            const reasoning = await cortex.reasoner.analyzeIntent(input);
+            if (reasoning.goal)
+                goalInferred = reasoning.goal;
+        }
         const strategy = pattern || this.detectStrategy(input);
         try {
             await this.db.transaction().execute(async (trx) => {
@@ -31,14 +38,17 @@ export class CognitiveSynthesizer {
                     .executeTakeFirst();
                 if (existing) {
                     const currentPath = this.parsePath(existing.evolution_path);
-                    // Only append to path if goal or strategy shifted significantly
+                    // Only append to path if goal, strategy, or sentiment shifted significantly
+                    const sentiment = this.detectSentimentDrift(input);
                     if (existing.inferred_goal !== goalInferred ||
-                        existing.strategy !== strategy) {
+                        existing.strategy !== strategy ||
+                        (existing.metadata && JSON.parse(existing.metadata).lastSentiment !== sentiment)) {
                         currentPath.push({
                             timestamp: new Date().toISOString(),
                             previousGoal: existing.inferred_goal,
                             newGoal: goalInferred,
                             strategyShift: strategy,
+                            sentiment,
                         });
                     }
                     await trx
@@ -48,6 +58,11 @@ export class CognitiveSynthesizer {
                         strategy,
                         evolution_path: JSON.stringify(currentPath),
                         status: 'active',
+                        metadata: JSON.stringify({
+                            ...JSON.parse(existing.metadata || '{}'),
+                            lastSentiment: sentiment,
+                            pivots: currentPath.length,
+                        }),
                         autonomy_level: this.calculateAutonomy(currentPath.length, existing.autonomy_level || 1),
                         updated_at: new Date(),
                     })
@@ -122,9 +137,13 @@ export class CognitiveSynthesizer {
     inferGoalFromContent(content) {
         // Real-world simulation: extract the first imperative sentence or key noun phrases
         const clean = content.trim().replace(/\n/g, ' ');
+        // Hardened heuristic: prioritize imperative verbs and specific NOORMME intents
+        const imperativeMatch = clean.match(/(?:please |can you |let's )?(implement|fix|refactor|add|search|analyze|delete|evolve) .+/i);
+        if (imperativeMatch) {
+            return imperativeMatch[0].substring(0, 100) + (imperativeMatch[0].length > 100 ? '...' : '');
+        }
         if (clean.length < 100)
             return clean;
-        // Simple heuristic: look for "need", "want", "please", "can you"
         const keywords = [
             'need',
             'want',
@@ -144,21 +163,44 @@ export class CognitiveSynthesizer {
     }
     detectStrategy(content) {
         const c = content.toLowerCase();
-        if (c.includes('debug') || c.includes('fix') || c.includes('error'))
+        // Hardened strategy detection
+        if (c.includes('debug') || c.includes('fix') || c.includes('error') || c.includes('broken'))
             return 'Diagnostic Repair';
-        if (c.includes('create') || c.includes('build') || c.includes('implement'))
+        if (c.includes('create') || c.includes('build') || c.includes('implement') || c.includes('new file'))
             return 'Generative Construction';
-        if (c.includes('research') || c.includes('explain') || c.includes('how'))
+        if (c.includes('research') || c.includes('explain') || c.includes('how') || c.includes('investigate'))
             return 'Knowledge Acquisition';
+        if (c.includes('evolve') || c.includes('mutate') || c.includes('dna'))
+            return 'Self-Evolutionary';
         return 'Adaptive Exploration';
     }
     calculateAutonomy(pivots, currentLevel) {
-        // Logic: frequent pivots without completion decrease autonomy.
-        // Consistent execution increases it.
-        if (pivots > 5)
-            return Math.min(4, currentLevel + 1);
+        // Enhanced Autonomy: Lower weight on raw pivots, more on ratio
+        // If pivots are moderate but yield successful sub-goals, autonomy holds.
+        if (pivots > 10)
+            return Math.max(1, currentLevel - 1);
+        if (pivots > 5 && currentLevel > 2)
+            return currentLevel;
+        if (pivots === 0)
+            return Math.min(5, currentLevel + 1);
         return currentLevel;
     }
+    /**
+     * Detect "Sentiment Drift" or Cognitive Friction in the input stream.
+     * Mirrors the agent's internal "frustration" or "flow" state.
+     */
+    detectSentimentDrift(content) {
+        const c = content.toLowerCase();
+        const negativeTerms = ['slow', 'wrong', 'bad', 'error', 'failed', 'cannot', 'stuck'];
+        const postiveTerms = ['great', 'correct', 'good', 'success', 'works', 'yes'];
+        const negCount = negativeTerms.filter(t => c.includes(t)).length;
+        const posCount = postiveTerms.filter(t => c.includes(t)).length;
+        if (negCount > posCount + 1)
+            return 'frustration';
+        if (posCount > negCount)
+            return 'flow';
+        return 'neutral';
+    }
     parsePath(pathData) {
         if (!pathData)
             return [];

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

@@ -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')