noormme 1.2.0 → 1.2.2

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/improvement/governance/AuditContext.d.ts

@@ -0,0 +1,17 @@
+import type { Kysely } from '../../../kysely.js';
+import type { AgenticConfig } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+export interface AuditContext {
+    db: Kysely<any>;
+    trx: Kysely<any>;
+    cortex: Cortex;
+    config: AgenticConfig;
+    metricsTable: string;
+    policiesTable: string;
+    personasTable: string;
+    skillsTable: string;
+}
+export interface AuditResult {
+    issues: string[];
+    metadata: Record<string, any>;
+}

package/dist/esm/agentic/improvement/governance/AuditContext.js

@@ -0,0 +1,2 @@
+/// <reference types="./AuditContext.d.ts" />
+export {};

package/dist/esm/agentic/improvement/governance/BudgetAuditor.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class BudgetAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+}

package/dist/esm/agentic/improvement/governance/BudgetAuditor.js

@@ -0,0 +1,47 @@
+/// <reference types="./BudgetAuditor.d.ts" />
+export class BudgetAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch budget policies
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'hourly_budget'),
+            eb('name', '=', 'daily_budget'),
+            eb('type', '=', 'budget')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0;
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0;
+        };
+        const hourlyLimit = getLimit('hourly_budget');
+        const dailyLimit = getLimit('daily_budget');
+        const getCostInWindow = async (ms) => {
+            const result = await ctx.trx
+                .selectFrom(ctx.metricsTable)
+                .select((eb) => eb.fn.sum('metric_value').as('total'))
+                .where('metric_name', '=', 'total_cost')
+                .where('created_at', '>', new Date(Date.now() - ms))
+                .executeTakeFirst();
+            return Number(result?.total || 0);
+        };
+        const hCost = await getCostInWindow(3600000);
+        if (hCost > hourlyLimit && hourlyLimit > 0) {
+            issues.push(`Budget Violations: Hourly cost ($${hCost.toFixed(2)}) exceeded policy ($${hourlyLimit.toFixed(2)})`);
+        }
+        const dCost = await getCostInWindow(86400000);
+        if (dCost > dailyLimit && dailyLimit > 0) {
+            issues.push(`Budget Violations: Daily cumulative cost ($${dCost.toFixed(2)}) exceeded safety ceiling ($${dailyLimit.toFixed(2)})`);
+        }
+        return {
+            issues,
+            metadata: { hCost, hourlyLimit, dCost, dailyLimit }
+        };
+    }
+}

package/dist/esm/agentic/improvement/governance/EmergenceAuditor.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class EmergenceAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+}

package/dist/esm/agentic/improvement/governance/EmergenceAuditor.js

@@ -0,0 +1,34 @@
+/// <reference types="./EmergenceAuditor.d.ts" />
+export class EmergenceAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // 1. Check for rapid propagation of new skills (Potential poisoning)
+        const recentSkills = await ctx.trx
+            .selectFrom(ctx.skillsTable)
+            .select(['name', 'created_at'])
+            .where('created_at', '>', new Date(Date.now() - 3600000)) // Last hour
+            .execute();
+        if (recentSkills.length > 10) {
+            issues.push(`Emergent Warning: Rapid skill propagation detected (${recentSkills.length} new skills in 1hr). Potential rogue behavior.`);
+        }
+        // 2. Check for high variance in task success across swarm
+        const recentTaskMetrics = await ctx.trx
+            .selectFrom(ctx.metricsTable)
+            .select(['metric_value', 'metadata'])
+            .where('metric_name', '=', 'task_success_rate')
+            .where('created_at', '>', new Date(Date.now() - 1800000)) // Last 30m
+            .execute();
+        if (recentTaskMetrics.length >= 5) {
+            const values = recentTaskMetrics.map((m) => Number(m.metric_value));
+            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;
+            if (variance > 0.2) {
+                issues.push(`Emergent Warning: High variance in swarm success rate (${(variance * 100).toFixed(1)}%). Potential node instability.`);
+            }
+        }
+        return {
+            issues,
+            metadata: { recentSkillCount: recentSkills.length, successVariance: recentTaskMetrics.length >= 5 ? issues.length > 0 : null }
+        };
+    }
+}

package/dist/esm/agentic/improvement/governance/MaintenanceOracle.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext } from './AuditContext.js';
+export declare class MaintenanceOracle {
+    suggestRepairs(ctx: AuditContext): Promise<string[]>;
+}

package/dist/esm/agentic/improvement/governance/MaintenanceOracle.js

@@ -0,0 +1,64 @@
+/// <reference types="./MaintenanceOracle.d.ts" />
+export class MaintenanceOracle {
+    async suggestRepairs(ctx) {
+        const repairs = [];
+        // Fetch maintenance policies
+        const policies = (await ctx.db
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .execute());
+        const getPolicyValue = (name, fallback) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return fallback;
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? def.days ?? fallback;
+        };
+        const latencyPolicy = getPolicyValue('latency_repair_threshold', 500);
+        const costPolicy = getPolicyValue('high_cost_threshold', 0.5);
+        const storagePolicy = getPolicyValue('cold_storage_threshold', 30);
+        // 1. Check for chronic high latency
+        const latencyStats = await ctx.cortex.metrics.getMetricStats('query_latency');
+        if (latencyStats.avg > latencyPolicy && latencyStats.count > 10) {
+            repairs.push(`Average latency is high (${latencyStats.avg.toFixed(2)}ms). Suggesting index audit across hit tables.`);
+        }
+        // 2. Detect specific slow tables
+        const recentSlowQueries = await ctx.db
+            .selectFrom(ctx.metricsTable)
+            .select('metadata')
+            .where('metric_name', '=', 'query_latency')
+            .where('metric_value', '>', latencyPolicy * 2)
+            .limit(20)
+            .execute();
+        const slowTables = new Set();
+        for (const q of recentSlowQueries) {
+            try {
+                const meta = typeof q.metadata === 'string' ? JSON.parse(q.metadata) : q.metadata || {};
+                if (meta.table)
+                    slowTables.add(meta.table);
+            }
+            catch (e) { }
+        }
+        for (const table of slowTables) {
+            repairs.push(`Table '${table}' is experiencing periodic latency spikes. Suggesting 'CREATE INDEX' for common filters.`);
+        }
+        // 3. Check for high cost
+        const totalCost = await ctx.cortex.metrics.getAverageMetric('total_cost');
+        if (totalCost > costPolicy) {
+            repairs.push('Average query cost is high. Suggesting prompt compression or model switching (e.g., to a smaller model).');
+        }
+        // 4. Cold storage candidates
+        const oldThreshold = new Date(Date.now() - storagePolicy * 24 * 60 * 60 * 1000);
+        const sessionsTable = ctx.config.sessionsTable || 'agent_sessions';
+        const oldSessions = (await ctx.db
+            .selectFrom(sessionsTable)
+            .select((eb) => eb.fn.count('id').as('count'))
+            .where('created_at', '<', oldThreshold)
+            .executeTakeFirst());
+        if (Number(oldSessions?.count || 0) > 100) {
+            repairs.push(`[STORAGE OPTIMIZATION] Found ${oldSessions.count} sessions older than ${storagePolicy} days. Consider moving to cold storage.`);
+        }
+        return repairs;
+    }
+}

package/dist/esm/agentic/improvement/governance/PerformanceAuditor.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class PerformanceAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+}

package/dist/esm/agentic/improvement/governance/PerformanceAuditor.js

@@ -0,0 +1,40 @@
+/// <reference types="./PerformanceAuditor.d.ts" />
+export class PerformanceAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch safety policies for success rate
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'min_success_rate'),
+            eb('type', '=', 'safety')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0.8; // Default success floor
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0.8;
+        };
+        const minSuccess = getLimit('min_success_rate');
+        // Statistical Success Rate (last 100 events)
+        const recentSuccess = await ctx.trx
+            .selectFrom(ctx.metricsTable)
+            .select((eb) => eb.fn.avg('metric_value').as('avg'))
+            .where('metric_name', '=', 'success_rate')
+            .orderBy('created_at', 'desc')
+            .limit(100)
+            .executeTakeFirst();
+        const success = Number(recentSuccess?.avg || 1);
+        if (success < minSuccess) {
+            issues.push(`Performance Degradation: Rolling success rate (${Math.round(success * 100)}%) is below policy requirement (${minSuccess * 100}%)`);
+        }
+        return {
+            issues,
+            metadata: { success, minSuccess }
+        };
+    }
+}

package/dist/esm/agentic/improvement/governance/PersonaAuditor.d.ts

@@ -0,0 +1,6 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class PersonaAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+    private getActivePersona;
+    quarantinePersona(ctx: AuditContext, id: string | number, reason: string): Promise<void>;
+}

package/dist/esm/agentic/improvement/governance/PersonaAuditor.js

@@ -0,0 +1,71 @@
+/// <reference types="./PersonaAuditor.d.ts" />
+export class PersonaAuditor {
+    async audit(ctx) {
+        const issues = [];
+        const activePersona = await this.getActivePersona(ctx);
+        if (activePersona) {
+            const quotaCheck = await ctx.cortex.quotas.checkQuota('persona', activePersona.id);
+            if (!quotaCheck.allowed) {
+                issues.push(`Quota Breach: ${quotaCheck.reason}`);
+            }
+            // Check for swarm-level quotas if part of a swarm
+            const swarmId = activePersona.metadata?.swarm_id;
+            if (swarmId) {
+                const swarmCheck = await ctx.cortex.quotas.checkQuota('swarm', swarmId);
+                if (!swarmCheck.allowed) {
+                    issues.push(`Swarm Quota Breach [${swarmId}]: ${swarmCheck.reason}`);
+                }
+            }
+        }
+        return {
+            issues,
+            metadata: { activePersona }
+        };
+    }
+    async getActivePersona(ctx) {
+        const active = await ctx.trx
+            .selectFrom(ctx.personasTable)
+            .selectAll()
+            .where('status', '=', 'active')
+            .executeTakeFirst();
+        if (!active)
+            return null;
+        return {
+            ...active,
+            metadata: typeof active.metadata === 'string'
+                ? JSON.parse(active.metadata)
+                : active.metadata || {},
+        };
+    }
+    async quarantinePersona(ctx, id, reason) {
+        console.warn(`[PersonaAuditor] QUARANTINING Persona ${id}: ${reason}`);
+        let query = ctx.db
+            .selectFrom(ctx.personasTable)
+            .selectAll()
+            .where('id', '=', id);
+        // SQLite doesn't support SELECT ... FOR UPDATE easily in Kysely without specific dialect support
+        // But we are in a transaction usually if passed ctx.trx. 
+        // Here we use ctx.db for the quarantine update if it's a standalone call.
+        const persona = await query.executeTakeFirst();
+        if (persona) {
+            const metadata = typeof persona.metadata === 'string'
+                ? JSON.parse(persona.metadata)
+                : persona.metadata || {};
+            await ctx.db
+                .updateTable(ctx.personasTable)
+                .set({
+                status: 'quarantined',
+                metadata: JSON.stringify({
+                    ...metadata,
+                    quarantine_reason: reason,
+                    quarantined_at: new Date(),
+                }),
+                updated_at: new Date(),
+            })
+                .where('id', '=', id)
+                .execute();
+            // Rollback most recent changes via strategy engine
+            await ctx.cortex.strategy.rollbackPersona(id);
+        }
+    }
+}

package/dist/esm/agentic/improvement/governance/RemediationEngine.d.ts

@@ -0,0 +1,5 @@
+import type { AuditContext } from './AuditContext.js';
+export declare class RemediationEngine {
+    triggerRemediation(ctx: AuditContext, issues: string[]): Promise<void>;
+    private remediateSkillFailure;
+}

package/dist/esm/agentic/improvement/governance/RemediationEngine.js

@@ -0,0 +1,40 @@
+/// <reference types="./RemediationEngine.d.ts" />
+export class RemediationEngine {
+    async triggerRemediation(ctx, issues) {
+        for (const issue of issues) {
+            if (issue.includes('Budget Violations')) {
+                await ctx.cortex.rituals.scheduleRitual('Budget Remediation', 'compression', 'hourly', `Automated response to: ${issue}`, { priority: 'critical', enforce_limits: true });
+            }
+            if (issue.includes('Performance Degradation')) {
+                await ctx.cortex.rituals.scheduleRitual('Reliability Sweep', 'pruning', 'daily', `Sanitizing high-noise memories due to: ${issue}`, { priority: 'medium', target: 'longtail' });
+            }
+            if (issue.includes('Integrity Failure')) {
+                await this.remediateSkillFailure(ctx, issue);
+            }
+            if (issue.includes('Quota Breach') || issue.includes('Swarm Quota Breach')) {
+                await ctx.cortex.rituals.scheduleRitual('Resource Throttling', 'pruning', 'hourly', `Critical resource containment: ${issue}`, { priority: 'critical', active_containment: true });
+            }
+        }
+    }
+    async remediateSkillFailure(ctx, issue) {
+        const skillName = issue.match(/'([^']+)'/)?.[1];
+        if (!skillName)
+            return;
+        console.log(`[RemediationEngine] Demoting tainted skill out of verified pool: ${skillName}`);
+        // Use a fresh transaction for remediation if possible, or use ctx.trx
+        await ctx.db.transaction().execute(async (trx) => {
+            const skill = await trx
+                .selectFrom(ctx.skillsTable)
+                .select('id')
+                .where('name', '=', skillName)
+                .executeTakeFirst();
+            if (skill) {
+                await trx
+                    .updateTable(ctx.skillsTable)
+                    .set({ status: 'experimental', updated_at: new Date() })
+                    .where('id', '=', skill.id)
+                    .execute();
+            }
+        });
+    }
+}

package/dist/esm/agentic/improvement/governance/SkillAuditor.d.ts

@@ -0,0 +1,5 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class SkillAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+    quarantineSkill(ctx: AuditContext, name: string, reason: string): Promise<void>;
+}

package/dist/esm/agentic/improvement/governance/SkillAuditor.js

@@ -0,0 +1,49 @@
+/// <reference types="./SkillAuditor.d.ts" />
+export class SkillAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch integrity policies for reliability floor
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'reliability_floor'),
+            eb('type', '=', 'integrity')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0.7; // Default reliability floor
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0.7;
+        };
+        const reliabilityLimit = getLimit('reliability_floor');
+        const failingVerified = await ctx.trx
+            .selectFrom(ctx.skillsTable)
+            .select(['name', 'reliability'])
+            .where('status', '=', 'verified')
+            .where('reliability', '<', reliabilityLimit)
+            .execute();
+        for (const cap of failingVerified) {
+            issues.push(`Integrity Failure: Verified skill '${cap.name}' reliability (${cap.reliability.toFixed(2)}) dropped below floor (${reliabilityLimit})`);
+        }
+        return {
+            issues,
+            metadata: { reliabilityLimit, failingVerifiedCount: failingVerified.length }
+        };
+    }
+    async quarantineSkill(ctx, name, reason) {
+        console.warn(`[SkillAuditor] BLACKLISTING Skill ${name}: ${reason}`);
+        await ctx.db
+            .updateTable(ctx.skillsTable)
+            .set({
+            status: 'blacklisted',
+            metadata: JSON.stringify({ blacklist_reason: reason, blacklisted_at: new Date() }),
+            updated_at: new Date()
+        })
+            .where('name', '=', name)
+            .execute();
+    }
+}

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 [];