noormme 1.2.0 → 1.2.1

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

@@ -16,41 +16,50 @@ export class ConflictResolver {
     /**
      * Audit rules for direct conflicts and semantic overlaps.
      */
-    async auditRuleConflicts() {
-        console.log('[ConflictResolver] Auditing cognitive rules for conflicts and overlaps...');
-        const rules = (await this.db
-            .selectFrom(this.rulesTable)
-            .selectAll()
-            .where('is_enabled', '=', true)
-            .execute());
+    async auditRuleConflicts(options = {}) {
+        const batchSize = options.batchSize ?? 500;
         const conflicts = [];
-        // 1. Direct Conflicts: Same Table + Same Operation
-        const seen = new Map();
-        for (const rule of rules) {
-            const key = `${rule.tableName}:${rule.operation}`;
-            if (seen.has(key)) {
-                const existing = seen.get(key);
-                // If they have different actions but same triggers, it's a conflict
-                if (existing.action !== rule.action) {
-                    conflicts.push(`Direct Conflict: Multiple actions for '${key}' ('${existing.action}' vs '${rule.action}')`);
+        let offset = 0;
+        console.log(`[ConflictResolver] Auditing cognitive rules (batchSize=${batchSize})...`);
+        const seenDirect = new Map();
+        const tableRules = new Map();
+        while (true) {
+            const rules = (await this.db
+                .selectFrom(this.rulesTable)
+                .selectAll()
+                .where('is_enabled', '=', true)
+                .limit(batchSize)
+                .offset(offset)
+                .execute());
+            if (rules.length === 0)
+                break;
+            for (const rule of rules) {
+                // 1. Direct Conflicts: Same Table + Same Operation
+                const directKey = `${rule.tableName}:${rule.operation}`;
+                if (seenDirect.has(directKey)) {
+                    const existing = seenDirect.get(directKey);
+                    if (existing.action !== rule.action) {
+                        conflicts.push(`Direct Conflict: Multiple actions for '${directKey}' ('${existing.action}' vs '${rule.action}')`);
+                    }
+                    else if (existing.condition === rule.condition) {
+                        conflicts.push(`Redundant Rules: Duplicate rule detected for '${directKey}' with same condition.`);
+                    }
                 }
-                else if (existing.condition === rule.condition) {
-                    conflicts.push(`Redundant Rules: Duplicate rule detected for '${key}' with same condition.`);
+                seenDirect.set(directKey, rule);
+                // Group for semantic check
+                const list = tableRules.get(rule.tableName) || [];
+                if (list.length < 100) { // Audit Phase 16: Quadratic Guard per table
+                    list.push(rule);
+                    tableRules.set(rule.tableName, list);
                 }
             }
-            seen.set(key, rule);
-        }
-        // 2. Semantic Overlaps: Multiple rules targeting same table with potentially overlapping conditions
-        // This is a rudimentary check for similar keywords in conditions
-        const tableRules = new Map();
-        for (const rule of rules) {
-            const list = tableRules.get(rule.tableName) || [];
-            list.push(rule);
-            tableRules.set(rule.tableName, list);
+            if (rules.length < batchSize)
+                break;
+            offset += batchSize;
         }
+        // 2. Semantic Overlaps: Quadratic check with hard limits
         for (const [table, list] of tableRules.entries()) {
             if (list.length > 1) {
-                // Check for overlapping conditions (e.g., both check 'status' or both check 'priority')
                 for (let i = 0; i < list.length; i++) {
                     for (let j = i + 1; j < list.length; j++) {
                         const r1 = list[i];
@@ -58,7 +67,7 @@ export class ConflictResolver {
                         if (r1.condition && r2.condition) {
                             const similarity = calculateSimilarity(r1.condition, r2.condition);
                             if (similarity > 0.6) {
-                                conflicts.push(`Potential Semantic Overlap on '${table}': Rules ${r1.id} and ${r2.id} have high condition similarity (${(similarity * 100).toFixed(1)}%)`);
+                                conflicts.push(`Potential Semantic Overlap on '${table}': Rules ${r1.id} and ${r2.id} have high similarity (${(similarity * 100).toFixed(1)}%)`);
                             }
                         }
                     }
@@ -73,23 +82,26 @@ export class ConflictResolver {
      */
     async resolveConflict(tableName, operation) {
         console.log(`[ConflictResolver] Resolving conflict for ${tableName}:${operation}`);
-        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());
-        if (rules.length <= 1)
-            return;
-        // Keep the first (newest) one, disable the rest
-        const toDisable = rules.slice(1).map((r) => r.id);
-        await this.db
-            .updateTable(this.rulesTable)
-            .set({ is_enabled: false })
-            .where('id', 'in', toDisable)
-            .execute();
-        console.log(`[ConflictResolver] Disabled ${toDisable.length} redundant rules for ${tableName}:${operation}`);
+        return await this.db.transaction().execute(async (trx) => {
+            const rules = (await trx
+                .selectFrom(this.rulesTable)
+                .selectAll()
+                .where('table_name', '=', tableName)
+                .where('operation', '=', operation)
+                .where('is_enabled', '=', true)
+                .orderBy('created_at', 'desc')
+                .forUpdate() // Audit Phase 10: Atomic resolution lock
+                .execute());
+            if (rules.length <= 1)
+                return;
+            // Keep the first (newest) one, disable the rest
+            const toDisable = rules.slice(1).map((r) => r.id);
+            await trx
+                .updateTable(this.rulesTable)
+                .set({ is_enabled: false })
+                .where('id', 'in', toDisable)
+                .execute();
+            console.log(`[ConflictResolver] Disabled ${toDisable.length} redundant rules for ${tableName}:${operation}`);
+        });
     }
 }

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

@@ -172,6 +172,17 @@ export class CortexJanitor {
     }
     async logRitual(type, status, metadata) {
         try {
+            // Audit Phase 18: Prevent log-spam in concurrent swarms
+            const windowStart = new Date(Date.now() - 10 * 60 * 1000); // 10 min window
+            const existing = await this.db
+                .selectFrom(this.ritualsTable)
+                .select('id')
+                .where('name', '=', `Automated ${type}`)
+                .where('type', '=', type)
+                .where('last_run', '>', windowStart)
+                .executeTakeFirst();
+            if (existing)
+                return;
             await this.db
                 .insertInto(this.ritualsTable)
                 .values({

package/dist/esm/agentic/improvement/CuriosityEngine.d.ts

@@ -36,7 +36,7 @@ export declare class CuriosityEngine {
     suggestQuestions(entity: string): Promise<string[]>;
     /**
      * Generate "Relationship Hypotheses" between high-confidence entities.
-     * Suggests that entities with multi-tag overlaps might be related.
+     * Refactored Phase 11: Linear O(N) relationship discovery via tag-to-entity mapping.
      */
     generateHypotheses(): Promise<string[]>;
     /**

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

@@ -53,11 +53,13 @@ export class CuriosityEngine {
             .having((eb) => eb.fn.count('id'), '>', 1)
             .execute();
         for (const row of entities) {
+            // Audit Phase 11: Paginated fact retrieval to prevent OOM on dense entities
             const items = (await this.typedDb
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
                 .where('entity', '=', row.entity)
                 .where('confidence', '>', 0.5)
+                .limit(200) // Prevent OOM on massive entity fact lists
                 .execute());
             if (items.length > 1) {
                 for (let i = 0; i < items.length; i++) {
@@ -167,44 +169,69 @@ export class CuriosityEngine {
     }
     /**
      * Generate "Relationship Hypotheses" between high-confidence entities.
-     * Suggests that entities with multi-tag overlaps might be related.
+     * Refactored Phase 11: Linear O(N) relationship discovery via tag-to-entity mapping.
      */
     async generateHypotheses() {
         console.log('[CuriosityEngine] Generating relationship hypotheses...');
-        // 1. Get high-confidence entities
+        // 1. Get high-confidence entities (Paginated to handle scale)
         const entities = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .select(['entity', 'tags'])
             .where('confidence', '>', 0.7)
             .where('tags', 'is not', null)
+            .limit(2000)
             .execute());
         const hypotheses = [];
-        const entityTagsMap = new Map();
+        const tagToEntities = new Map();
+        // Audit Phase 11: Build inverted index O(N)
         for (const row of entities) {
             const tags = typeof row.tags === 'string' ? JSON.parse(row.tags) : row.tags || [];
-            if (tags.length > 0) {
-                entityTagsMap.set(row.entity, new Set(tags));
+            for (const tag of tags) {
+                const list = tagToEntities.get(tag) || [];
+                list.push(row.entity);
+                tagToEntities.set(tag, list);
             }
         }
-        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.`);
+        // 2. Identify dense tag overlaps via index lookup
+        const pairCouplings = new Map(); // Key: "entity1|entity2", Value: [commonTags]
+        let totalPairs = 0;
+        const MAX_PAIRS = 5000; // Audit Phase 15: Runaway coupling guard
+        for (const [tag, entityList] of tagToEntities.entries()) {
+            if (entityList.length < 2)
+                continue;
+            if (totalPairs >= MAX_PAIRS)
+                break;
+            // Limit inner pairing to prevent explosion on ubiquitous tags
+            const limitedList = entityList.slice(0, 50);
+            for (let i = 0; i < limitedList.length; i++) {
+                if (totalPairs >= MAX_PAIRS)
+                    break;
+                for (let j = i + 1; j < limitedList.length; j++) {
+                    const pairKey = [limitedList[i], limitedList[j]].sort().join('|');
+                    const common = pairCouplings.get(pairKey) || [];
+                    if (common.length === 0)
+                        totalPairs++;
+                    common.push(tag);
+                    pairCouplings.set(pairKey, common);
+                    if (totalPairs >= MAX_PAIRS)
+                        break;
                 }
             }
         }
-        return hypotheses.slice(0, 10); // Limit to top 10
+        // 3. Synthesize hypotheses from dense coupling
+        for (const [pair, common] of pairCouplings.entries()) {
+            const [e1, e2] = pair.split('|');
+            if (common.length >= 2) {
+                hypotheses.push(`[HYPOTHESIS] "${e1}" and "${e2}" share a dense tag set (${common.join(', ')}). Is there a structural coupling?`);
+            }
+            else if (common.length === 1) {
+                // Only flag shared lone tags if they were rare or specific
+                hypotheses.push(`[HYPOTHESIS] Both "${e1}" and "${e2}" are identified by "${common[0]}". Might be aliases or sub-components.`);
+            }
+            if (hypotheses.length >= 20)
+                break;
+        }
+        return hypotheses.slice(0, 10);
     }
     /**
      * Propose a research ritual based on identified gaps, hotspots, and hypotheses.

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

@@ -60,22 +60,34 @@ export class EvolutionRitual {
     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();
+        // Refactored Phase 13: Paginated scanning to handle large knowledge bursts
         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));
+        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        let offset = 0;
+        const limit = 1000;
+        while (true) {
+            const result = await this.db
+                .selectFrom(this.config.knowledgeTable || 'agent_knowledge_base')
+                .select(['tags', 'confidence'])
+                .where('updated_at', '>', cutoff)
+                .orderBy('updated_at', 'asc')
+                .limit(limit)
+                .offset(offset)
+                .execute();
+            if (result.length === 0)
+                break;
+            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;
+                    const current = domainScores.get(t) || 0;
+                    domainScores.set(t, current + (row.confidence || 0));
+                }
             }
+            if (result.length < limit)
+                break;
+            offset += limit;
         }
         // Sort by total confidence density (Entropy/Activity proxy)
         // Production Hardening: Only boost domains with significant activity (Threshold: 1.0)

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

@@ -27,32 +27,44 @@ export class EvolutionaryPilot {
             'total_cost',
             'trust_signal',
         ];
-        const recentMetrics = await this.cortex.metrics.getRecentMetrics(100);
+        const samplingCount = this.config.evolution?.samplingCount || 100;
+        const recentMetrics = await this.cortex.metrics.getRecentMetrics(samplingCount);
         for (const metricName of metrics) {
+            // Audit Phase 17: Bounded metric slice for scale-safe baselining
             const values = recentMetrics
                 .filter((m) => m.metricName === metricName)
+                .slice(0, 500) // Hard boundary for statistical window
                 .map((m) => Number(m.metricValue));
             if (values.length < 5)
                 continue;
             const stats = this.calculateZScore(values);
+            const minSamples = this.config.evolution?.minSamples || 5;
+            if (values.length < minSamples)
+                continue;
+            const policies = await this.cortex.policies.getActivePolicies();
+            const latencyZ = policies.find(p => p.name === 'latency_drift_z')?.definition?.threshold || 2.0;
+            const latencyMean = policies.find(p => p.name === 'latency_mean_ceiling')?.definition?.threshold || 1000;
             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)) {
+                (stats.zScore > latencyZ || stats.mean > latencyMean)) {
                 const result = await this.optimizeLatency();
                 if (result) {
                     changes.push(...result);
                     evolved = true;
                 }
             }
+            const successZ = policies.find(p => p.name === 'success_rate_z')?.definition?.threshold || -1.5;
+            const successMean = policies.find(p => p.name === 'min_success_rate')?.definition?.threshold || 0.7;
             if (metricName === 'success_rate' &&
-                (stats.zScore < -1.5 || stats.mean < 0.7)) {
+                (stats.zScore < successZ || stats.mean < successMean)) {
                 console.warn(`[EvolutionaryPilot] Success rate collapse detected (${stats.mean.toFixed(2)}). Triggering strategic mutation.`);
                 const strategies = await this.cortex.strategy.mutateStrategy();
                 changes.push(...strategies);
                 evolved = true;
             }
-            if (metricName === 'total_cost' && stats.zScore > 2.5) {
+            const costZThreshold = policies.find(p => p.name === 'cost_spike_z')?.definition?.threshold || 2.5;
+            if (metricName === 'total_cost' && stats.zScore > costZThreshold) {
                 console.warn(`[EvolutionaryPilot] Cost spike detected. Triggering emergency compression.`);
                 await this.cortex.rituals.scheduleRitual('Emergency Compression', 'compression', 'hourly', 'High cost spike detected via Z-score analysis.');
                 changes.push('Scheduled emergency compression due to cost spike');

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

@@ -26,11 +26,16 @@ export declare class GoalArchitect {
     private get typedDb();
     /**
      * Deconstruct a goal into multiple sub-goals transactionally.
+     * Includes circular dependency and terminal duplicate protection.
      */
     deconstructGoal(goalId: string | number, subGoals: string[]): Promise<AgentGoal[]>;
+    /**
+     * Recursive check for circular dependencies in the goal tree.
+     * Prevents infinite loops caused by autonomous decomposition.
+     */
+    private detectCircularDependency;
     /**
      * Reorder goals by updating their priorities in batch.
-     * Lower number = higher priority.
      */
     reorderGoals(goalIds: (string | number)[]): Promise<void>;
     /**
@@ -39,7 +44,6 @@ export declare class GoalArchitect {
     markGoalAs(goalId: string | number, status: AgentGoal['status'], outcome?: string): Promise<AgentGoal>;
     /**
      * Check if a goal is blocked by uncompleted sub-goals.
-     * Returns true if all sub-goals are completed, false otherwise.
      */
     checkGoalDependencies(goalId: string | number): Promise<{
         canComplete: boolean;

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

@@ -1,4 +1,5 @@
 /// <reference types="./GoalArchitect.d.ts" />
+import { calculateSimilarity } from '../../util/similarity.js';
 /**
  * GoalArchitect enables agents to autonomously deconstruct complex
  * objectives into manageable sub-goals.
@@ -17,22 +18,35 @@ export class GoalArchitect {
     }
     /**
      * Deconstruct a goal into multiple sub-goals transactionally.
+     * Includes circular dependency and terminal duplicate protection.
      */
     async deconstructGoal(goalId, subGoals) {
         return await this.db.transaction().execute(async (trx) => {
+            // 1. Audit Phase 9: Circular Dependency Protection inside transaction
+            await this.detectCircularDependency(goalId, new Set(), trx);
             const goal = (await trx
                 .selectFrom(this.goalsTable)
                 .selectAll()
                 .where('id', '=', goalId)
+                .forUpdate() // Audit Phase 9: Atomic acquisition
                 .executeTakeFirst());
             if (!goal)
                 throw new Error(`Goal ${goalId} not found`);
-            console.log(`[GoalArchitect] Deconstructing goal ${goalId}: "${goal.description}" into ${subGoals.length} steps.`);
+            // 2. Production Hardening: Semantic Duplicate Detection
+            const existingSubGoals = await trx
+                .selectFrom(this.goalsTable)
+                .select('description')
+                .where('parent_id', '=', goalId)
+                .execute();
             const created = [];
-            // Calculate base priority for sub-goals (higher than parent)
             const basePriority = (goal.priority || 0) + 1;
             for (let i = 0; i < subGoals.length; i++) {
                 const desc = subGoals[i];
+                const isDuplicate = existingSubGoals.some(ex => calculateSimilarity(ex.description, desc) > 0.9);
+                if (isDuplicate) {
+                    console.log(`[GoalArchitect] Skipping duplicate sub-goal: "${desc}"`);
+                    continue;
+                }
                 const subGoal = (await trx
                     .insertInto(this.goalsTable)
                     .values({
@@ -40,7 +54,7 @@ export class GoalArchitect {
                     parent_id: goalId,
                     description: desc,
                     status: 'pending',
-                    priority: basePriority + i, // Sequential priority
+                    priority: basePriority + i,
                     created_at: new Date(),
                     updated_at: new Date(),
                 })
@@ -48,7 +62,6 @@ export class GoalArchitect {
                     .executeTakeFirstOrThrow());
                 created.push(this.parseGoal(subGoal));
             }
-            // Update parent status to in_progress if it was pending
             if (goal.status === 'pending') {
                 await trx
                     .updateTable(this.goalsTable)
@@ -59,12 +72,39 @@ export class GoalArchitect {
             return created;
         });
     }
+    /**
+     * Recursive check for circular dependencies in the goal tree.
+     * Prevents infinite loops caused by autonomous decomposition.
+     */
+    async detectCircularDependency(startId, visited = new Set(), trx) {
+        if (visited.has(startId)) {
+            throw new Error(`Circular dependency detected in goal hierarchy at ID: ${startId}`);
+        }
+        visited.add(startId);
+        const db = trx || this.db;
+        const goal = await db
+            .selectFrom(this.goalsTable)
+            .select('parent_id')
+            .where('id', '=', startId)
+            .executeTakeFirst();
+        if (goal?.parent_id) {
+            await this.detectCircularDependency(goal.parent_id, visited, trx);
+        }
+    }
     /**
      * Reorder goals by updating their priorities in batch.
-     * Lower number = higher priority.
      */
     async reorderGoals(goalIds) {
+        // Audit Phase 9: Sort IDs to prevent deadlocks during batch acquisition
+        const sortedIds = [...goalIds].sort((a, b) => String(a).localeCompare(String(b)));
         await this.db.transaction().execute(async (trx) => {
+            // Pre-lock all rows in deterministic order
+            await trx
+                .selectFrom(this.goalsTable)
+                .select('id')
+                .where('id', 'in', sortedIds)
+                .forUpdate()
+                .execute();
             for (let i = 0; i < goalIds.length; i++) {
                 await trx
                     .updateTable(this.goalsTable)
@@ -78,34 +118,36 @@ export class GoalArchitect {
      * Update a goal's status and optionally log outcome/reason in metadata.
      */
     async markGoalAs(goalId, status, outcome) {
-        const goal = await this.typedDb
-            .selectFrom(this.goalsTable)
-            .selectAll()
-            .where('id', '=', goalId)
-            .executeTakeFirst();
-        if (!goal)
-            throw new Error(`Goal ${goalId} not found`);
-        const currentMeta = goal.metadata ? JSON.parse(goal.metadata) : {};
-        const newMeta = {
-            ...currentMeta,
-            lastStatusChange: Date.now(),
-            outcome: outcome || currentMeta.outcome,
-        };
-        const updated = (await this.db
-            .updateTable(this.goalsTable)
-            .set({
-            status,
-            metadata: JSON.stringify(newMeta),
-            updated_at: new Date(),
-        })
-            .where('id', '=', goalId)
-            .returningAll()
-            .executeTakeFirstOrThrow());
-        return this.parseGoal(updated);
+        return await this.db.transaction().execute(async (trx) => {
+            const goal = (await trx
+                .selectFrom(this.goalsTable)
+                .selectAll()
+                .where('id', '=', goalId)
+                .forUpdate() // Audit Phase 9: Atomic status/meta update
+                .executeTakeFirst());
+            if (!goal)
+                throw new Error(`Goal ${goalId} not found`);
+            const currentMeta = goal.metadata ? JSON.parse(goal.metadata) : {};
+            const newMeta = {
+                ...currentMeta,
+                lastStatusChange: Date.now(),
+                outcome: outcome || currentMeta.outcome,
+            };
+            const updated = (await trx
+                .updateTable(this.goalsTable)
+                .set({
+                status,
+                metadata: JSON.stringify(newMeta),
+                updated_at: new Date(),
+            })
+                .where('id', '=', goalId)
+                .returningAll()
+                .executeTakeFirstOrThrow());
+            return this.parseGoal(updated);
+        });
     }
     /**
      * Check if a goal is blocked by uncompleted sub-goals.
-     * Returns true if all sub-goals are completed, false otherwise.
      */
     async checkGoalDependencies(goalId) {
         const subGoals = await this.typedDb
@@ -126,7 +168,6 @@ export class GoalArchitect {
      * 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
             .selectFrom(this.goalsTable)
@@ -134,9 +175,6 @@ export class GoalArchitect {
             .where('status', 'in', ['pending', 'in_progress'])
             .where('updated_at', '<', thresholdDate)
             .execute());
-        if (stalled.length > 0) {
-            console.log(`[GoalArchitect] Identified ${stalled.length} stalled goals.`);
-        }
         return stalled.map((g) => this.parseGoal(g));
     }
     parseGoal(g) {

package/dist/esm/agentic/improvement/GovernanceManager.d.ts

@@ -20,13 +20,19 @@ export declare class GovernanceManager {
         healthy: boolean;
         issues: string[];
     }>;
+    private getActivePersona;
     /**
-     * Retrieves the currently active persona.
+     * Quarantine a persona that is behaving outside safety parameters.
      */
-    private getActivePersona;
+    quarantinePersona(id: string | number, reason: string): Promise<void>;
+    /**
+     * Blacklist a skill that is causing systemic issues.
+     */
+    quarantineSkill(name: string, reason: string): Promise<void>;
     /**
-     * Trigger autonomous remediation steps based on specific failure modes
+     * Monitor cross-node behaviors and flag sudden spikes or malicious patterns.
      */
+    validateEmergentBehavior(trx?: any): Promise<string[]>;
     private triggerRemediation;
     /**
      * Suggest architectural repairs if performance is degrading