noormme 1.0.6 → 1.2.0

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

@@ -20,33 +20,34 @@ class CuriosityEngine {
     }
     /**
      * Analyze current knowledge to identify "Gaps" or contradictions.
-     * Detects entities with low confidence or competing high-confidence facts.
+     * Detects entities with low confidence, unverified status, or competing high-confidence facts.
      */
     async identifyKnowledgeGaps() {
         console.log('[CuriosityEngine] Analyzing knowledge base for gaps and contradictions...');
         const gaps = [];
-        // 1. Find entities with low confidence or unverified facts
-        const weakKnowledge = await this.typedDb
+        // 1. Find entities with low confidence or unverified/proposed status
+        const weakKnowledge = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where((eb) => eb.or([
-            eb('confidence', '<', 0.5),
-            eb('tags', 'is', null),
-            eb.and([
-                eb('tags', 'not like', '%"verified"%'),
-                eb('confidence', '<', 0.8)
-            ])
+            eb('confidence', '<', 0.4), // Critical low confidence
+            eb('status', '=', 'proposed'), // Not yet verified by enough sessions
+            eb('status', '=', 'disputed'), // Flagged by contradiction logic
         ]))
-            .execute();
+            .execute());
         for (const item of weakKnowledge) {
-            const type = item.confidence < 0.5 ? 'low_confidence' : 'unverified';
+            let type = 'unverified';
+            if (item.confidence < 0.4)
+                type = 'low_confidence';
+            if (item.status === 'disputed')
+                type = 'contradiction';
             gaps.push({
                 entity: item.entity,
                 type,
-                details: `Fact "${item.fact}" is ${type}. (Confidence: ${item.confidence})`
+                details: `Fact "${item.fact}" is ${type} (Status: ${item.status}, Confidence: ${item.confidence}).`,
             });
         }
-        // 2. Detect Contradictions: Same entity, multiple high-confidence facts that are different
+        // 2. Detect Contradictions: Same entity, multiple facts with high overlap but different claims
         const entities = await this.typedDb
             .selectFrom(this.knowledgeTable)
             .select('entity')
@@ -54,24 +55,22 @@ 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.6)
-                .execute();
+                .where('confidence', '>', 0.5)
+                .execute());
             if (items.length > 1) {
-                // Semantic check: if they have high similarity but slightly different facts, it's a conflict
                 for (let i = 0; i < items.length; i++) {
                     for (let j = i + 1; j < items.length; j++) {
                         const similarity = (0, similarity_js_1.calculateSimilarity)(items[i].fact, items[j].fact);
-                        // If they are somewhat similar but not identical (0.4 to 0.9 range)
-                        // it might be a subtle contradiction or partial update
-                        if (similarity > 0.4 && similarity < 0.95) {
+                        // Contradiction: Similar enough to be about same topic, but different enough to be conflicting
+                        if (similarity > 0.35 && similarity < 0.85) {
                             gaps.push({
                                 entity: row.entity,
                                 type: 'contradiction',
-                                details: `Entity "${row.entity}" has potentially competing facts: "${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)}%)`,
                             });
                         }
                     }
@@ -88,31 +87,36 @@ 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 row of topEntities) {
-            const entityName = row.entity.replace('entity_hit_', '');
-            // 2. Check factual density for this specific hotspot candidate
-            const knowledgeCountResult = await this.typedDb
+        for (const top of topEntities) {
+            const entityName = top.entity.replace('entity_hit_', '');
+            // 2. Cross-reference with fact density
+            const factCountResult = await this.typedDb
                 .selectFrom(this.knowledgeTable)
                 .select((eb) => eb.fn.count('id').as('count'))
                 .where('entity', '=', entityName)
                 .executeTakeFirst();
-            const factCount = Number(knowledgeCountResult?.count || 0);
-            const refs = Number(row.references || 0);
-            if (factCount < 3 && refs > 5) {
+            const factCount = Number(factCountResult?.count || 0);
+            const refs = Number(top.references);
+            const density = factCount / (refs || 1);
+            // 3. Flag as hotspot if high usage but low knowledge
+            if (density < 0.2 || factCount < 2) {
                 hotspots.push({
                     entity: entityName,
                     references: refs,
-                    density: factCount,
-                    gap: `High-use entity "${entityName}" has only ${factCount} facts but was referenced ${refs} times in metrics.`
+                    density: Number(density.toFixed(2)),
+                    gap: `High cognitive overhead (${refs} refs) vs low factual density (${factCount} facts).`,
                 });
             }
         }
@@ -131,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')) {
@@ -165,39 +169,44 @@ class CuriosityEngine {
     }
     /**
      * Generate "Relationship Hypotheses" between high-confidence entities.
-     * Suggests that entities with similar tags might be related.
+     * Suggests that entities with multi-tag overlaps might be related.
      */
     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.8)
+            .where('confidence', '>', 0.7)
             .where('tags', 'is not', null)
-            .execute();
+            .execute());
         const hypotheses = [];
-        const tagMap = new Map();
+        const entityTagsMap = new Map();
         for (const row of entities) {
-            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : (row.tags || []);
-            for (const tag of tags) {
-                if (!tagMap.has(tag))
-                    tagMap.set(tag, []);
-                tagMap.get(tag).push(row.entity);
+            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : row.tags || [];
+            if (tags.length > 0) {
+                entityTagsMap.set(row.entity, new Set(tags));
             }
         }
-        // 2. Identify entities sharing multiple matching tags
-        for (const [tag, relatedEntities] of tagMap.entries()) {
-            if (relatedEntities.length > 1) {
-                const uniqueEntities = [...new Set(relatedEntities)];
-                for (let i = 0; i < uniqueEntities.length; i++) {
-                    for (let j = i + 1; j < uniqueEntities.length; j++) {
-                        hypotheses.push(`[HYPOTHESIS] "${uniqueEntities[i]}" and "${uniqueEntities[j]}" are both tagged as "${tag}". Is there a direct dependency or shared lifecycle?`);
-                    }
+        const entityNames = Array.from(entityTagsMap.keys());
+        // 2. Identify entities sharing multiple matching tags (Density check)
+        for (let i = 0; i < entityNames.length; i++) {
+            for (let j = i + 1; j < entityNames.length; j++) {
+                const tagsI = entityTagsMap.get(entityNames[i]);
+                const tagsJ = entityTagsMap.get(entityNames[j]);
+                // intersection
+                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)) {
+                    // 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.`);
                 }
             }
         }
-        return hypotheses.slice(0, 5); // Limit to top 5
+        return hypotheses.slice(0, 10); // Limit to top 10
     }
     /**
      * Propose a research ritual based on identified gaps, hotspots, and hypotheses.
@@ -217,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.d.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from '../../kysely.js';
+import type { AgenticConfig } from '../../types/index.js';
+import type { Cortex } from '../Cortex.js';
+/**
+ * EvolutionRitual orchestrates the "Skill Growth" background task.
+ * It combines synthesis, domain synching, and global broadcasting
+ * into a single high-throughput maintenance cycle.
+ */
+export declare class EvolutionRitual {
+    private db;
+    private cortex;
+    private config;
+    constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
+    /**
+     * Execute the full evolution sequence
+     */
+    execute(): Promise<{
+        synthesized: number;
+        broadcasted: number;
+        domainsSynced: string[];
+    }>;
+    private checkDomainMaturity;
+    private identifyActiveDomains;
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvolutionRitual = void 0;
+/**
+ * EvolutionRitual orchestrates the "Skill Growth" background task.
+ * It combines synthesis, domain synching, and global broadcasting
+ * into a single high-throughput maintenance cycle.
+ */
+class EvolutionRitual {
+    db;
+    cortex;
+    config;
+    constructor(db, cortex, config = {}) {
+        this.db = db;
+        this.cortex = cortex;
+        this.config = config;
+    }
+    /**
+     * Execute the full evolution sequence
+     */
+    async execute() {
+        console.log('[EvolutionRitual] Initiating seamless skill growth sequence...');
+        const results = {
+            synthesized: 0,
+            broadcasted: 0,
+            domainsSynced: [],
+        };
+        // 1. Parallel Synthesis: Identify and bridge capability gaps
+        const newSkills = await this.cortex.skillSynthesizer.discoverAndSynthesize();
+        results.synthesized = newSkills.length;
+        // 2. High-Throughput Broadcasting: Propagate verified mutations globally
+        const broadcastedCount = await this.cortex.hive.broadcastSkills();
+        results.broadcasted = broadcastedCount;
+        // 3. Domain Synchronization: Identify "mastery" domains and boost global confidence
+        const activeDomains = await this.identifyActiveDomains();
+        for (const domain of activeDomains) {
+            // High Throughput Pass 5: Wholesale Domain Mastery
+            const isMature = await this.checkDomainMaturity(domain);
+            if (isMature) {
+                console.log(`[EvolutionRitual] Domain '${domain}' is MATURE. Applying wholesale stability boost.`);
+                await this.cortex.hive.syncDomain(domain, 0.15); // Higher boost for mastery
+            }
+            else {
+                await this.cortex.hive.syncDomain(domain, 0.05); // Standard boost
+            }
+            results.domainsSynced.push(domain);
+        }
+        console.log(`[EvolutionRitual] Completed: ${results.synthesized} synthesized, ${results.broadcasted} broadcasted, ${results.domainsSynced.length} domains boosted.`);
+        return results;
+    }
+    async checkDomainMaturity(domain) {
+        const skills = (await this.db
+            .selectFrom(this.config.capabilitiesTable || 'agent_capabilities')
+            .select(['reliability'])
+            .where('name', 'like', `${domain}%`)
+            .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;
+        return avgReliability >= 0.95;
+    }
+    async identifyActiveDomains() {
+        // Production Hardening: Entropy-Based Discovery
+        // Find domains that are currently "hot" (high density of recent knowledge)
+        // This represents areas where the agent is learning fast and needs stabilization.
+        const result = await this.db
+            .selectFrom(this.config.knowledgeTable || 'agent_knowledge_base')
+            .select(['tags', 'confidence'])
+            .where('updated_at', '>', new Date(Date.now() - 24 * 60 * 60 * 1000)) // Last 24h
+            .execute();
+        const domainScores = new Map();
+        for (const row of result) {
+            const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : row.tags || [];
+            for (const t of tags) {
+                if (t === 'hive_mind')
+                    continue;
+                // Score based on confidence density: a mix of volume and high-quality signals
+                const current = domainScores.get(t) || 0;
+                domainScores.set(t, current + (row.confidence || 0));
+            }
+        }
+        // Sort by total confidence density (Entropy/Activity proxy)
+        // Production Hardening: Only boost domains with significant activity (Threshold: 1.0)
+        return Array.from(domainScores.entries())
+            .filter(([_, score]) => score >= 1.0)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([tag]) => tag);
+    }
+}
+exports.EvolutionRitual = EvolutionRitual;

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

@@ -17,6 +17,11 @@ export declare class EvolutionaryPilot {
         evolved: boolean;
         changes: string[];
     }>;
+    /**
+     * Meta-Meta Evolution: Adjusts the hyperparameters of the SkillSynthesizer
+     * based on the systemic success or failure of recently verified skills.
+     */
+    private tuneEmergentSkillHyperparameters;
     private calculateZScore;
     private optimizeLatency;
 }

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);
@@ -54,7 +61,13 @@ class EvolutionaryPilot {
                 evolved = true;
             }
         }
-        // 3. Verify: Perform an audit
+        // 3. Meta-Meta Evolution Tuning
+        const tuned = await this.tuneEmergentSkillHyperparameters(recentMetrics);
+        if (tuned) {
+            changes.push('Self-tuned emergent skill hyperparameters (Meta-Meta Evolution)');
+            evolved = true;
+        }
+        // 4. Verify: Perform an audit
         const audit = await this.cortex.governor.performAudit();
         if (!audit.healthy) {
             console.warn('[EvolutionaryPilot] Evolution resulted in unhealthy state. Reverting may be required.');
@@ -62,6 +75,63 @@ class EvolutionaryPilot {
         }
         return { evolved, changes };
     }
+    /**
+     * Meta-Meta Evolution: Adjusts the hyperparameters of the SkillSynthesizer
+     * based on the systemic success or failure of recently verified skills.
+     */
+    async tuneEmergentSkillHyperparameters(recentMetrics) {
+        console.log(`[EvolutionaryPilot] Running Meta-Meta Evolution tuning...`);
+        // Count how many skills are currently blacklisted vs verified
+        const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
+        const verified = await this.cortex.capabilities.getCapabilities('verified');
+        let tuned = false;
+        const config = this.config.evolution;
+        if (!config)
+            return false;
+        const totalSynthesized = blacklisted.length + verified.length;
+        if (totalSynthesized > 5) {
+            const successRate = verified.length / totalSynthesized;
+            // If we are succeeding often, increase mutation aggressiveness and allow more sandbox skills
+            if (successRate > 0.7) {
+                if ((config.mutationAggressiveness || 0) < 0.9) {
+                    config.mutationAggressiveness = Math.min(1.0, (config.mutationAggressiveness || 0.5) + 0.1);
+                    console.log(`[EvolutionaryPilot] High skill synthesis success. Increased mutation aggressiveness to ${config.mutationAggressiveness.toFixed(2)}`);
+                    tuned = true;
+                }
+                if ((config.maxSandboxSkills || 5) < 15) {
+                    config.maxSandboxSkills = (config.maxSandboxSkills || 5) + 2;
+                    console.log(`[EvolutionaryPilot] High skill synthesis success. Increased sandbox capacity to ${config.maxSandboxSkills}`);
+                    tuned = true;
+                }
+                // We can afford shorter verification windows
+                if ((config.verificationWindow || 20) > 10) {
+                    config.verificationWindow = Math.max(10, (config.verificationWindow || 20) - 2);
+                    console.log(`[EvolutionaryPilot] Shortened verification window to ${config.verificationWindow}`);
+                    tuned = true;
+                }
+            }
+            // If we are failing often, become more conservative
+            else if (successRate < 0.3) {
+                if ((config.mutationAggressiveness || 0) > 0.1) {
+                    config.mutationAggressiveness = Math.max(0.1, (config.mutationAggressiveness || 0.5) - 0.1);
+                    console.log(`[EvolutionaryPilot] Low skill synthesis success. Decreased mutation aggressiveness to ${config.mutationAggressiveness.toFixed(2)}`);
+                    tuned = true;
+                }
+                if ((config.maxSandboxSkills || 5) > 2) {
+                    config.maxSandboxSkills = Math.max(2, (config.maxSandboxSkills || 5) - 1);
+                    console.log(`[EvolutionaryPilot] Low skill synthesis success. Decreased sandbox capacity to ${config.maxSandboxSkills}`);
+                    tuned = true;
+                }
+                // Safety requires longer verification windows
+                if ((config.verificationWindow || 20) < 50) {
+                    config.verificationWindow = Math.min(50, (config.verificationWindow || 20) + 5);
+                    console.log(`[EvolutionaryPilot] Lengthened verification window to ${config.verificationWindow}`);
+                    tuned = true;
+                }
+            }
+        }
+        return tuned;
+    }
     calculateZScore(values) {
         const mean = values.reduce((a, b) => a + b, 0) / values.length;
         const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length;
@@ -74,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.d.ts

@@ -25,7 +25,7 @@ export declare class GovernanceManager {
      */
     private getActivePersona;
     /**
-     * Trigger autonomous remediation steps
+     * Trigger autonomous remediation steps based on specific failure modes
      */
     private triggerRemediation;
     /**