noormme 1.1.0 → 1.2.0

package/dist/cjs/agentic/improvement/ActionRefiner.js

@@ -22,13 +22,15 @@ class ActionRefiner {
     async refineActions() {
         const recommendations = [];
         // 1. Find tools with high failure rates
-        const failureStats = await this.db
+        const failureStats = (await this.db
             .selectFrom(this.actionsTable)
             .select('tool_name')
             .select((eb) => eb.fn.count('id').as('total'))
-            .select((eb) => eb.fn.sum(eb.case().when('status', '=', 'failure').then(1).else(0).end()).as('failures'))
+            .select((eb) => eb.fn
+            .sum(eb.case().when('status', '=', 'failure').then(1).else(0).end())
+            .as('failures'))
             .groupBy('tool_name')
-            .execute();
+            .execute());
         for (const stat of failureStats) {
             const failures = Number(stat.failures || 0);
             const total = Number(stat.total || 1);
@@ -40,7 +42,7 @@ class ActionRefiner {
             }
         }
         // 2. Discover missing capabilities based on error patterns
-        const missingCapabilities = await this.db
+        const missingCapabilities = (await this.db
             .selectFrom(this.actionsTable)
             .select('tool_name')
             .where('status', '=', 'failure')
@@ -48,10 +50,10 @@ class ActionRefiner {
             eb('error', 'like', '%permission denied%'),
             eb('error', 'like', '%unknown tool%'),
             eb('error', 'like', '%missing capability%'),
-            eb('error', 'like', '%not authorized%')
+            eb('error', 'like', '%not authorized%'),
         ]))
             .groupBy('tool_name')
-            .execute();
+            .execute());
         for (const row of missingCapabilities) {
             recommendations.push(`Detected repeated access/existence failures for tool '${row.tool_name}'. Proposing capability expansion.`);
             await this.proposeCapabilityUpdate(row.tool_name);
@@ -63,14 +65,14 @@ class ActionRefiner {
      */
     async proposeReflectionRule(toolName) {
         const existing = await this.cortex.rules.getActiveRules('agent_actions', 'insert');
-        const hasRule = existing.some(r => r.metadata?.targetTool === toolName);
+        const hasRule = existing.some((r) => r.metadata?.targetTool === toolName);
         if (!hasRule) {
             console.log(`[ActionRefiner] Proposing reflection rule for tool: ${toolName}`);
             await this.cortex.rules.defineRule('agent_actions', 'insert', 'audit', {
                 metadata: {
                     targetTool: toolName,
-                    reason: 'High failure rate detected by ActionRefiner'
-                }
+                    reason: 'High failure rate detected by ActionRefiner',
+                },
             });
         }
     }
@@ -81,7 +83,7 @@ class ActionRefiner {
         console.log(`[ActionRefiner] Proposing capability expansion for tool: ${toolName}`);
         await this.cortex.reflections.reflect('system', 'failure', `Architectural Gap: Missing Capability for '${toolName}'`, [
             `Identified repeated failures using tool '${toolName}'.`,
-            `Resolution: Inspect permission sets and ensure the tool is correctly registered in the CapabilityManager.`
+            `Resolution: Inspect permission sets and ensure the tool is correctly registered in the CapabilityManager.`,
         ]);
     }
 }

package/dist/cjs/agentic/improvement/ConflictResolver.js

@@ -20,11 +20,11 @@ class ConflictResolver {
      */
     async auditRuleConflicts() {
         console.log('[ConflictResolver] Auditing cognitive rules for conflicts and overlaps...');
-        const rules = await this.db
+        const rules = (await this.db
             .selectFrom(this.rulesTable)
             .selectAll()
             .where('is_enabled', '=', true)
-            .execute();
+            .execute());
         const conflicts = [];
         // 1. Direct Conflicts: Same Table + Same Operation
         const seen = new Map();
@@ -75,18 +75,18 @@ class ConflictResolver {
      */
     async resolveConflict(tableName, operation) {
         console.log(`[ConflictResolver] Resolving conflict for ${tableName}:${operation}`);
-        const rules = await this.db
+        const rules = (await this.db
             .selectFrom(this.rulesTable)
             .selectAll()
             .where('table_name', '=', tableName)
             .where('operation', '=', operation)
             .where('is_enabled', '=', true)
             .orderBy('created_at', 'desc')
-            .execute();
+            .execute());
         if (rules.length <= 1)
             return;
         // Keep the first (newest) one, disable the rest
-        const toDisable = rules.slice(1).map(r => r.id);
+        const toDisable = rules.slice(1).map((r) => r.id);
         await this.db
             .updateTable(this.rulesTable)
             .set({ is_enabled: false })

package/dist/cjs/agentic/improvement/CortexJanitor.js

@@ -45,7 +45,10 @@ class CortexJanitor {
             .executeTakeFirst();
         const deletedCount = Number(result.numDeletedRows || 0);
         if (deletedCount > 0) {
-            await this.logRitual('optimization', 'success', { action: 'clean_orphans', deletedCount });
+            await this.logRitual('optimization', 'success', {
+                action: 'clean_orphans',
+                deletedCount,
+            });
         }
         return deletedCount;
     }
@@ -62,7 +65,10 @@ class CortexJanitor {
             .executeTakeFirst();
         const count = Number(result.numUpdatedRows || 0);
         if (count > 0) {
-            await this.logRitual('optimization', 'success', { action: 'archive_sessions', count });
+            await this.logRitual('optimization', 'success', {
+                action: 'archive_sessions',
+                count,
+            });
         }
         return count;
     }
@@ -77,7 +83,10 @@ class CortexJanitor {
             .executeTakeFirst();
         const count = Number(result.numDeletedRows || 0);
         if (count > 0) {
-            await this.logRitual('pruning', 'success', { action: 'prune_metrics', count });
+            await this.logRitual('pruning', 'success', {
+                action: 'prune_metrics',
+                count,
+            });
         }
         return count;
     }
@@ -92,7 +101,10 @@ class CortexJanitor {
         const coreIdentityTables = [
             { table: this.knowledgeTable, col: 'entity' },
             { table: this.config.memoriesTable || 'agent_memories', col: 'entity' },
-            { table: this.config.messagesTable || 'agent_messages', col: 'session_id' }
+            {
+                table: this.config.messagesTable || 'agent_messages',
+                col: 'session_id',
+            },
         ];
         for (const target of coreIdentityTables) {
             try {
@@ -116,11 +128,15 @@ class CortexJanitor {
         const tablesToRemoveFriction = new Set();
         for (const q of slowQueries) {
             try {
-                const meta = typeof q.metadata === 'string' ? JSON.parse(q.metadata) : (q.metadata || {});
+                const meta = typeof q.metadata === 'string'
+                    ? JSON.parse(q.metadata)
+                    : q.metadata || {};
                 if (meta.table)
                     tablesToRemoveFriction.add(meta.table);
             }
-            catch (e) { /* ignore */ }
+            catch (e) {
+                /* ignore */
+            }
         }
         for (const table of tablesToRemoveFriction) {
             // Hotspot logic: if it's high-traffic knowledge, index the status/confidence pair for promoting/demoting
@@ -131,7 +147,10 @@ class CortexJanitor {
             }
         }
         if (applied.length > 0) {
-            await this.logRitual('optimization', 'success', { action: 'autonomous_indexing', applied_count: applied.length });
+            await this.logRitual('optimization', 'success', {
+                action: 'autonomous_indexing',
+                applied_count: applied.length,
+            });
         }
         return applied;
     }
@@ -149,7 +168,9 @@ class CortexJanitor {
         else if (dialect.includes('postgres')) {
             await (0, sql_js_1.sql) `ANALYZE`.execute(this.db);
         }
-        await this.logRitual('optimization', 'success', { action: 'db_maintenance' });
+        await this.logRitual('optimization', 'success', {
+            action: 'db_maintenance',
+        });
     }
     async logRitual(type, status, metadata) {
         try {
@@ -160,7 +181,7 @@ class CortexJanitor {
                 type,
                 status,
                 last_run: new Date(),
-                metadata: metadata ? JSON.stringify(metadata) : null
+                metadata: metadata ? JSON.stringify(metadata) : null,
             })
                 .execute();
         }

package/dist/cjs/agentic/improvement/CuriosityEngine.js

@@ -26,15 +26,15 @@ class CuriosityEngine {
         console.log('[CuriosityEngine] Analyzing knowledge base for gaps and contradictions...');
         const gaps = [];
         // 1. Find entities with low confidence or unverified/proposed status
-        const weakKnowledge = await this.typedDb
+        const weakKnowledge = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where((eb) => eb.or([
             eb('confidence', '<', 0.4), // Critical low confidence
             eb('status', '=', 'proposed'), // Not yet verified by enough sessions
-            eb('status', '=', 'disputed') // Flagged by contradiction logic
+            eb('status', '=', 'disputed'), // Flagged by contradiction logic
         ]))
-            .execute();
+            .execute());
         for (const item of weakKnowledge) {
             let type = 'unverified';
             if (item.confidence < 0.4)
@@ -44,7 +44,7 @@ class CuriosityEngine {
             gaps.push({
                 entity: item.entity,
                 type,
-                details: `Fact "${item.fact}" is ${type} (Status: ${item.status}, Confidence: ${item.confidence}).`
+                details: `Fact "${item.fact}" is ${type} (Status: ${item.status}, Confidence: ${item.confidence}).`,
             });
         }
         // 2. Detect Contradictions: Same entity, multiple facts with high overlap but different claims
@@ -55,12 +55,12 @@ class CuriosityEngine {
             .having((eb) => eb.fn.count('id'), '>', 1)
             .execute();
         for (const row of entities) {
-            const items = await this.typedDb
+            const items = (await this.typedDb
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
                 .where('entity', '=', row.entity)
                 .where('confidence', '>', 0.5)
-                .execute();
+                .execute());
             if (items.length > 1) {
                 for (let i = 0; i < items.length; i++) {
                     for (let j = i + 1; j < items.length; j++) {
@@ -70,7 +70,7 @@ class CuriosityEngine {
                             gaps.push({
                                 entity: row.entity,
                                 type: 'contradiction',
-                                details: `Subtle contradiction: "${items[i].fact}" vs "${items[j].fact}" (Similarity: ${(similarity * 100).toFixed(1)}%)`
+                                details: `Subtle contradiction: "${items[i].fact}" vs "${items[j].fact}" (Similarity: ${(similarity * 100).toFixed(1)}%)`,
                             });
                         }
                     }
@@ -87,14 +87,17 @@ class CuriosityEngine {
     async identifyKnowledgeHotspots() {
         const metricsTable = this.config.metricsTable || 'agent_metrics';
         // 1. Find entities with high hit counts in recent metrics
-        const topEntities = await this.db
+        const topEntities = (await this.db
             .selectFrom(metricsTable)
-            .select(['metric_name as entity', (eb) => eb.fn.sum('metric_value').as('references')])
+            .select([
+            'metric_name as entity',
+            (eb) => eb.fn.sum('metric_value').as('references'),
+        ])
             .where('metric_name', 'like', 'entity_hit_%')
             .groupBy('metric_name')
             .orderBy((eb) => eb.fn.sum('metric_value'), 'desc')
             .limit(10)
-            .execute();
+            .execute());
         const hotspots = [];
         for (const top of topEntities) {
             const entityName = top.entity.replace('entity_hit_', '');
@@ -113,7 +116,7 @@ class CuriosityEngine {
                     entity: entityName,
                     references: refs,
                     density: Number(density.toFixed(2)),
-                    gap: `High cognitive overhead (${refs} refs) vs low factual density (${factCount} facts).`
+                    gap: `High cognitive overhead (${refs} refs) vs low factual density (${factCount} facts).`,
                 });
             }
         }
@@ -132,21 +135,21 @@ class CuriosityEngine {
             return [
                 `What are the core attributes and defining characteristics of ${entity}?`,
                 `How does ${entity} relate to the broader system architecture?`,
-                `What are the primary use cases for ${entity} in the current context?`
+                `What are the primary use cases for ${entity} in the current context?`,
             ];
         }
         const questions = [];
-        const facts = knowledge.map(k => k.fact);
+        const facts = knowledge.map((k) => k.fact);
         // Context-aware questions
         questions.push(`Can we find more supporting evidence for: "${facts[0]}"?`);
-        const lowConfidenceItems = knowledge.filter(k => k.confidence < 0.6);
+        const lowConfidenceItems = knowledge.filter((k) => k.confidence < 0.6);
         if (lowConfidenceItems.length > 0) {
             questions.push(`Verify the accuracy of recent claims about ${entity}, specifically regarding "${lowConfidenceItems[0].fact}".`);
         }
         // Use tags to generate specific questions
         const allTags = new Set();
-        knowledge.forEach(k => {
-            const tags = typeof k.tags === 'string' ? JSON.parse(k.tags) : (k.tags || []);
+        knowledge.forEach((k) => {
+            const tags = typeof k.tags === 'string' ? JSON.parse(k.tags) : k.tags || [];
             tags.forEach((t) => allTags.add(t));
         });
         if (allTags.has('database')) {
@@ -171,16 +174,16 @@ class CuriosityEngine {
     async generateHypotheses() {
         console.log('[CuriosityEngine] Generating relationship hypotheses...');
         // 1. Get high-confidence entities
-        const entities = await this.typedDb
+        const entities = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .select(['entity', 'tags'])
             .where('confidence', '>', 0.7)
             .where('tags', 'is not', null)
-            .execute();
+            .execute());
         const hypotheses = [];
         const entityTagsMap = new Map();
         for (const row of entities) {
-            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : (row.tags || []);
+            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : row.tags || [];
             if (tags.length > 0) {
                 entityTagsMap.set(row.entity, new Set(tags));
             }
@@ -192,11 +195,12 @@ class CuriosityEngine {
                 const tagsI = entityTagsMap.get(entityNames[i]);
                 const tagsJ = entityTagsMap.get(entityNames[j]);
                 // intersection
-                const commonTags = [...tagsI].filter(t => tagsJ.has(t));
+                const commonTags = [...tagsI].filter((t) => tagsJ.has(t));
                 if (commonTags.length >= 2) {
                     hypotheses.push(`[HYPOTHESIS] "${entityNames[i]}" and "${entityNames[j]}" share a dense tag set (${commonTags.join(', ')}). Is there a structural coupling?`);
                 }
-                else if (commonTags.length === 1 && (tagsI.size === 1 || tagsJ.size === 1)) {
+                else if (commonTags.length === 1 &&
+                    (tagsI.size === 1 || tagsJ.size === 1)) {
                     // Specific probe for shared lone-tags
                     hypotheses.push(`[HYPOTHESIS] Both "${entityNames[i]}" and "${entityNames[j]}" are uniquely identified by "${commonTags[0]}". Might be aliases or sub-components.`);
                 }
@@ -222,12 +226,12 @@ class CuriosityEngine {
             proposals.push(hypo);
         }
         // Production Hardening: Check for evolutionary density to suggest publication
-        const evolutionCountResult = await this.db
+        const evolutionCountResult = (await this.db
             .selectFrom(this.config.metricsTable || 'agent_metrics')
             .select((eb) => eb.fn.count('id').as('count'))
             .where('metric_name', '=', 'evolution_applied')
             .where('created_at', '>', new Date(Date.now() - 7 * 24 * 3600000)) // Last 7 days
-            .executeTakeFirst();
+            .executeTakeFirst());
         const evolutions = Number(evolutionCountResult?.count || 0);
         if (evolutions > 5) {
             proposals.push(`[SOVEREIGN RITUAL] The engine has undergone ${evolutions} structural evolutions this week. Consider a 'Sovereign Publication Ritual' to update the registry.`);

package/dist/cjs/agentic/improvement/EvolutionRitual.js

@@ -23,7 +23,7 @@ class EvolutionRitual {
         const results = {
             synthesized: 0,
             broadcasted: 0,
-            domainsSynced: []
+            domainsSynced: [],
         };
         // 1. Parallel Synthesis: Identify and bridge capability gaps
         const newSkills = await this.cortex.skillSynthesizer.discoverAndSynthesize();
@@ -49,11 +49,11 @@ class EvolutionRitual {
         return results;
     }
     async checkDomainMaturity(domain) {
-        const skills = await this.db
+        const skills = (await this.db
             .selectFrom(this.config.capabilitiesTable || 'agent_capabilities')
             .select(['reliability'])
             .where('name', 'like', `${domain}%`)
-            .execute();
+            .execute());
         if (skills.length < 3)
             return false; // Need a minimum population for maturity
         const avgReliability = skills.reduce((sum, s) => sum + s.reliability, 0) / skills.length;
@@ -70,7 +70,7 @@ class EvolutionRitual {
             .execute();
         const domainScores = new Map();
         for (const row of result) {
-            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : (row.tags || []);
+            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : row.tags || [];
             for (const t of tags) {
                 if (t === 'hive_mind')
                     continue;

package/dist/cjs/agentic/improvement/EvolutionaryPilot.js

@@ -23,25 +23,32 @@ class EvolutionaryPilot {
         const changes = [];
         let evolved = false;
         // 1. Full-Spectrum Observation
-        const metrics = ['query_latency', 'success_rate', 'total_cost', 'trust_signal'];
+        const metrics = [
+            'query_latency',
+            'success_rate',
+            'total_cost',
+            'trust_signal',
+        ];
         const recentMetrics = await this.cortex.metrics.getRecentMetrics(100);
         for (const metricName of metrics) {
             const values = recentMetrics
-                .filter(m => m.metricName === metricName)
-                .map(m => Number(m.metricValue));
+                .filter((m) => m.metricName === metricName)
+                .map((m) => Number(m.metricValue));
             if (values.length < 5)
                 continue;
             const stats = this.calculateZScore(values);
             console.log(`[EvolutionaryPilot] Baselining ${metricName}: Mean=${stats.mean.toFixed(2)}, StdDev=${stats.stdDev.toFixed(2)}, Current=${stats.current.toFixed(2)}, Z-Score=${stats.zScore.toFixed(2)}`);
             // 2. Trigger Evolution based on metric-specific thresholds
-            if (metricName === 'query_latency' && (stats.zScore > 2.0 || stats.mean > 1000)) {
+            if (metricName === 'query_latency' &&
+                (stats.zScore > 2.0 || stats.mean > 1000)) {
                 const result = await this.optimizeLatency();
                 if (result) {
                     changes.push(...result);
                     evolved = true;
                 }
             }
-            if (metricName === 'success_rate' && (stats.zScore < -1.5 || stats.mean < 0.7)) {
+            if (metricName === 'success_rate' &&
+                (stats.zScore < -1.5 || stats.mean < 0.7)) {
                 console.warn(`[EvolutionaryPilot] Success rate collapse detected (${stats.mean.toFixed(2)}). Triggering strategic mutation.`);
                 const strategies = await this.cortex.strategy.mutateStrategy();
                 changes.push(...strategies);
@@ -137,7 +144,10 @@ class EvolutionaryPilot {
         const changes = [];
         console.log(`[EvolutionaryPilot] Triggering latency optimization...`);
         const dialect = this.db.getExecutor().dialect;
-        const isSqlite = this.db.getExecutor().adapter.constructor.name.toLowerCase().includes('sqlite') ||
+        const isSqlite = this.db
+            .getExecutor()
+            .adapter.constructor.name.toLowerCase()
+            .includes('sqlite') ||
             (dialect && dialect.constructor.name.toLowerCase().includes('sqlite'));
         if (isSqlite) {
             await (0, sql_js_1.sql) `PRAGMA optimize`.execute(this.db);

package/dist/cjs/agentic/improvement/GoalArchitect.d.ts

@@ -46,8 +46,8 @@ export declare class GoalArchitect {
         pendingSubGoals: number;
     }>;
     /**
-    * Identify goals that have "stalled" (no status changes in > 7 days)
-    */
+     * Identify goals that have "stalled" (no status changes in > 7 days)
+     */
     trackStalledGoals(daysThreshold?: number): Promise<AgentGoal[]>;
     private parseGoal;
 }

package/dist/cjs/agentic/improvement/GoalArchitect.js

@@ -22,11 +22,11 @@ class GoalArchitect {
      */
     async deconstructGoal(goalId, subGoals) {
         return await this.db.transaction().execute(async (trx) => {
-            const goal = await trx
+            const goal = (await trx
                 .selectFrom(this.goalsTable)
                 .selectAll()
                 .where('id', '=', goalId)
-                .executeTakeFirst();
+                .executeTakeFirst());
             if (!goal)
                 throw new Error(`Goal ${goalId} not found`);
             console.log(`[GoalArchitect] Deconstructing goal ${goalId}: "${goal.description}" into ${subGoals.length} steps.`);
@@ -35,7 +35,7 @@ class GoalArchitect {
             const basePriority = (goal.priority || 0) + 1;
             for (let i = 0; i < subGoals.length; i++) {
                 const desc = subGoals[i];
-                const subGoal = await trx
+                const subGoal = (await trx
                     .insertInto(this.goalsTable)
                     .values({
                     session_id: goal.session_id,
@@ -44,10 +44,10 @@ class GoalArchitect {
                     status: 'pending',
                     priority: basePriority + i, // Sequential priority
                     created_at: new Date(),
-                    updated_at: new Date()
+                    updated_at: new Date(),
                 })
                     .returningAll()
-                    .executeTakeFirstOrThrow();
+                    .executeTakeFirstOrThrow());
                 created.push(this.parseGoal(subGoal));
             }
             // Update parent status to in_progress if it was pending
@@ -91,18 +91,18 @@ class GoalArchitect {
         const newMeta = {
             ...currentMeta,
             lastStatusChange: Date.now(),
-            outcome: outcome || currentMeta.outcome
+            outcome: outcome || currentMeta.outcome,
         };
-        const updated = await this.db
+        const updated = (await this.db
             .updateTable(this.goalsTable)
             .set({
             status,
             metadata: JSON.stringify(newMeta),
-            updated_at: new Date()
+            updated_at: new Date(),
         })
             .where('id', '=', goalId)
             .returningAll()
-            .executeTakeFirstOrThrow();
+            .executeTakeFirstOrThrow());
         return this.parseGoal(updated);
     }
     /**
@@ -118,28 +118,28 @@ class GoalArchitect {
         if (subGoals.length === 0) {
             return { canComplete: true, pendingSubGoals: 0 };
         }
-        const pending = subGoals.filter(g => g.status !== 'completed' && g.status !== 'failed').length;
+        const pending = subGoals.filter((g) => g.status !== 'completed' && g.status !== 'failed').length;
         return {
             canComplete: pending === 0,
-            pendingSubGoals: pending
+            pendingSubGoals: pending,
         };
     }
     /**
-    * Identify goals that have "stalled" (no status changes in > 7 days)
-    */
+     * Identify goals that have "stalled" (no status changes in > 7 days)
+     */
     async trackStalledGoals(daysThreshold = 7) {
         console.log('[GoalArchitect] Identifying stalled objectives...');
         const thresholdDate = new Date(Date.now() - daysThreshold * 24 * 3600000);
-        const stalled = await this.typedDb
+        const stalled = (await this.typedDb
             .selectFrom(this.goalsTable)
             .selectAll()
             .where('status', 'in', ['pending', 'in_progress'])
             .where('updated_at', '<', thresholdDate)
-            .execute();
+            .execute());
         if (stalled.length > 0) {
             console.log(`[GoalArchitect] Identified ${stalled.length} stalled goals.`);
         }
-        return stalled.map(g => this.parseGoal(g));
+        return stalled.map((g) => this.parseGoal(g));
     }
     parseGoal(g) {
         return {
@@ -149,9 +149,11 @@ class GoalArchitect {
             description: g.description,
             status: g.status,
             priority: g.priority,
-            metadata: typeof g.metadata === 'string' ? JSON.parse(g.metadata) : (g.metadata || {}),
+            metadata: typeof g.metadata === 'string'
+                ? JSON.parse(g.metadata)
+                : g.metadata || {},
             createdAt: new Date(g.created_at),
-            updatedAt: new Date(g.updated_at)
+            updatedAt: new Date(g.updated_at),
         };
     }
 }

package/dist/cjs/agentic/improvement/GovernanceManager.js

@@ -26,16 +26,18 @@ class GovernanceManager {
     async performAudit() {
         const issues = [];
         // Fetch active policies
-        const policies = await this.db
+        const policies = (await this.db
             .selectFrom(this.policiesTable)
             .selectAll()
             .where('is_enabled', '=', true)
-            .execute();
+            .execute());
         const getPolicyValue = (name, type, fallback) => {
-            const p = policies.find(p => p.name === name || p.type === type);
+            const p = policies.find((p) => p.name === name || p.type === type);
             if (!p)
                 return fallback;
-            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            const def = typeof p.definition === 'string'
+                ? JSON.parse(p.definition)
+                : p.definition;
             return def.threshold ?? fallback;
         };
         // 1. Budgetary Governance: Check for cost spikes in various windows
@@ -88,7 +90,7 @@ class GovernanceManager {
             console.warn(`[GovernanceManager] AUDIT FAILED [${new Date().toISOString()}]: ${issues.length} compliance issues detected.`);
             // Phase 1: Emergency Rollbacks
             const activePersona = await this.getActivePersona();
-            if (activePersona && (success < 0.4 || hCost > (hourlyLimit * 1.5))) {
+            if (activePersona && (success < 0.4 || hCost > hourlyLimit * 1.5)) {
                 console.error(`[GovernanceManager] CRITICAL THRESHOLD BREACH. Initiating emergency containment for persona ${activePersona.id}`);
                 await this.cortex.strategy.rollbackPersona(activePersona.id);
                 issues.push(`Containment: Emergency rollback triggered for persona ${activePersona.id}`);
@@ -100,7 +102,7 @@ class GovernanceManager {
         }
         return {
             healthy: issues.length === 0,
-            issues
+            issues,
         };
     }
     /**
@@ -116,7 +118,9 @@ class GovernanceManager {
             return null;
         return {
             ...active,
-            metadata: typeof active.metadata === 'string' ? JSON.parse(active.metadata) : (active.metadata || {})
+            metadata: typeof active.metadata === 'string'
+                ? JSON.parse(active.metadata)
+                : active.metadata || {},
         };
     }
     /**
@@ -165,11 +169,15 @@ class GovernanceManager {
         const slowTables = new Set();
         for (const q of recentSlowQueries) {
             try {
-                const meta = typeof q.metadata === 'string' ? JSON.parse(q.metadata) : (q.metadata || {});
+                const meta = typeof q.metadata === 'string'
+                    ? JSON.parse(q.metadata)
+                    : q.metadata || {};
                 if (meta.table)
                     slowTables.add(meta.table);
             }
-            catch (e) { /* ignore parse errors */ }
+            catch (e) {
+                /* ignore parse errors */
+            }
         }
         for (const table of slowTables) {
             repairs.push(`Table '${table}' is experiencing periodic latency spikes. Suggesting 'CREATE INDEX' for common filters.`);
@@ -182,11 +190,11 @@ class GovernanceManager {
         // 3. Check for cold storage candidates
         const sessionsTable = this.config.sessionsTable || 'agent_sessions';
         const oldThreshold = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days
-        const oldSessions = await this.db
+        const oldSessions = (await this.db
             .selectFrom(sessionsTable)
             .select((eb) => eb.fn.count('id').as('count'))
             .where('created_at', '<', oldThreshold)
-            .executeTakeFirst();
+            .executeTakeFirst());
         if (Number(oldSessions?.count || 0) > 100) {
             repairs.push(`[STORAGE OPTIMIZATION] Found ${oldSessions.count} sessions older than 30 days. Consider moving to cold storage to reduce primary database size and improve backup speed.`);
         }