@noorm/marie-cli 0.1.17 → 0.1.18

package/dist/monolith/infrastructure/ai/core/MarieEngine.js

@@ -5,11 +5,14 @@ import { MarieToolProcessor } from "./MarieToolProcessor.js";
 import { MarieAscendant } from "../agents/MarieAscendant.js";
 import { MarieLockManager } from "./MarieLockManager.js";
 import { MarieToolMender } from "./MarieToolMender.js";
-import { MariePulseService } from "./MariePulseService.js";
 import { MarieStabilityMonitor } from "./MarieStabilityMonitor.js";
+import { MariePulseService } from "./MariePulseService.js";
 import { ReasoningBudget } from "./ReasoningBudget.js";
 import { SessionLogService } from "./SessionLogService.js";
 import { MarieSemaphore } from "./MarieSemaphore.js";
+import { ConfigService } from "../../config/ConfigService.js";
+import { NoormmeEngine } from "../../persistence/NoormmeEngine.js";
+import { MarieGhostService } from "../../../services/MarieGhostService.js";
 export function getPromptProfileForDepth(depth) {
     return depth > 0 ? "continuation" : "full";
 }
@@ -77,6 +80,30 @@ export class MarieEngine {
         if (this.disposed) {
             throw new Error("MarieEngine has been disposed.");
         }
+        // PHASE 17: Recursive Depth Enforcement
+        const maxDepth = ConfigService.getMaxRecursiveDepth();
+        if (depth > maxDepth) {
+            console.error(`[MarieEngine] ABORT: Maximum recursive depth (${maxDepth}) reached.`);
+            tracker.emitEvent({
+                type: "reasoning",
+                runId: tracker.getRun().runId,
+                text: `🚨 EMERGENCY PROTOCOL: Recursive reasoning ceiling reached (Depth: ${depth}/${maxDepth}). Aborting to prevent systemic depletion.`,
+                elapsedMs: tracker.elapsedMs(),
+            });
+            return accumulatedContent;
+        }
+        // PHASE 22: Emergency Sub-turn Shedding
+        if (depth > 0 && MarieStabilityMonitor.isCriticalPressure()) {
+            const msg = "🚨 RESOURCE DEPLETION: Critical system pressure detected. Shedding recursive sub-turn to preserve stability.";
+            console.warn(`[MarieEngine] ${msg}`);
+            tracker.emitEvent({
+                type: "reasoning",
+                runId: tracker.getRun().runId,
+                text: msg,
+                elapsedMs: tracker.elapsedMs(),
+            });
+            return accumulatedContent;
+        }
         console.log(`[MarieEngine] chatLoop started at depth ${depth}. Accumulated content length: ${accumulatedContent.length}`);
         // TURN COLLISION GUARD (Instance): Wait for any existing turn in this instance to finish
         if (this.activeTurn) {
@@ -84,22 +111,54 @@ export class MarieEngine {
             await this.activeTurn;
         }
         // GLOBAL SEMAPHORE: Acquire slot before proceeding
-        await MarieEngine.globalSemaphore.acquire();
+        await MarieEngine.globalSemaphore.acquire(signal);
         let resolveTurn = () => { };
         this.activeTurn = new Promise((resolve) => {
             resolveTurn = resolve;
         });
         try {
+            tracker.recordLog(`[MarieEngine] chatLoop started at depth ${depth}. Accumulated content length: ${accumulatedContent.length}`);
             const result = await this._executeChatLoop(messages, tracker, saveHistory, signal, consecutiveErrorCount, depth, accumulatedContent);
             console.log(`[MarieEngine] chatLoop finished at depth ${depth}. Final content length: ${result.length}`);
             return result;
         }
+        catch (error) {
+            // PHASE 18: Automated Post-Mortem
+            await this.triggerPostMortem(error, tracker);
+            // PHASE 22: Memory-Aware Ghost Cleanup
+            if (MarieStabilityMonitor.isCriticalPressure()) {
+                MarieGhostService.clearAll();
+            }
+            throw error;
+        }
         finally {
             MarieEngine.globalSemaphore.release();
             resolveTurn();
             this.activeTurn = null;
         }
     }
+    async triggerPostMortem(error, tracker) {
+        console.error(`[MarieEngine] CRITICAL FAILURE. Triggering Automated Post-Mortem.`, error);
+        try {
+            const db = await NoormmeEngine.getInstance();
+            const snapshot = tracker.getDiagnosticSnapshot();
+            await db.execute(`INSERT INTO agent_post_mortems 
+        (session_id, run_id, error_message, stack_trace, event_snapshot, log_snapshot, state_snapshot) 
+        VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                snapshot.runMetadata.sessionId || "default",
+                snapshot.runMetadata.runId,
+                error.message,
+                error.stack || "No stack trace available",
+                JSON.stringify(snapshot.events),
+                JSON.stringify(snapshot.logs),
+                JSON.stringify(this.state)
+            ]);
+            console.log(`[MarieEngine] Post-Mortem snapshot persisted for run: ${snapshot.runMetadata.runId}`);
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Failed to persist post-mortem snapshot", e);
+        }
+    }
     async _executeChatLoop(messages, tracker, saveHistory, signal, consecutiveErrorCount = 0, depth = 0, accumulatedContent = "") {
         if (signal?.aborted) {
             throw new Error("Execution aborted by user.");
@@ -124,6 +183,30 @@ export class MarieEngine {
         const originalEmit = tracker.emitEvent.bind(tracker);
         tracker.emitEvent = (event) => {
             void logService.appendEvent(event);
+            // PHASE 8: Deep NOORMME Telemetry Integration
+            NoormmeEngine.getInstance().then(db => {
+                const typeMap = {
+                    "reasoning": "prompt",
+                    "content_delta": "output",
+                    "checkpoint": "action",
+                    "technique_falter": "error",
+                    "decree": "pivot"
+                };
+                const noormType = typeMap[event.type] || "telemetry";
+                // Extract text content for NOORMME synthesis
+                let content = "";
+                if (event.text && typeof event.text === "string")
+                    content = event.text;
+                else if (event.summary && typeof event.summary === "object")
+                    content = JSON.stringify(event.summary);
+                else
+                    content = JSON.stringify(event);
+                db.agent.cortex.telemetry.track(originatingSessionId, noormType, content, { ...event, runId: tracker.getRun().runId }).catch(e => console.warn("[MarieEngine] NOORMME Telemetry track failed", e));
+                // Track "Magic" for high-confidence breakthroughs
+                if (event.type === "decree" && typeof event.confidence === "number" && event.confidence > 2.0) {
+                    db.agent.cortex.telemetry.track(originatingSessionId, "magic", `High Confidence Breakthrough: ${event.reason || "Unknown"}`, { surpriseScore: event.confidence / 2 }).catch(() => { });
+                }
+            }).catch(() => { });
             originalEmit(event);
         };
         if (depth > 20) {
@@ -137,6 +220,23 @@ export class MarieEngine {
         this.lockManager = new MarieLockManager(tracker);
         const dispatcher = new MarieEventDispatcher(tracker, this.ghostPort);
         MarieStabilityMonitor.start();
+        // PHASE 8.4: Resource Quota Throttling
+        try {
+            const db = await NoormmeEngine.getInstance();
+            const quotaCheck = await db.agent.cortex.quotas.checkQuota("global"); // Global check for safety
+            if (!quotaCheck.allowed) {
+                tracker.emitEvent({
+                    type: "reasoning",
+                    runId: tracker.getRun().runId,
+                    text: `🛑 **GLOBAL QUOTA EXCEEDED**: ${quotaCheck.reason}. Throttling execution for safety.`,
+                    elapsedMs: tracker.elapsedMs(),
+                });
+                return accumulatedContent + "\n\n⚠️ Resource Quota Exceeded. " + quotaCheck.reason;
+            }
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Quota check failed", e);
+        }
         if (tracker.getRun().steps === 0 && !tracker.getRun().isResuming) {
             tracker.emitEvent({
                 type: "reasoning",
@@ -144,6 +244,171 @@ export class MarieEngine {
                 text: "🔥 Ascension protocol initiated. Hero's conviction rising.",
                 elapsedMs: tracker.elapsedMs(),
             });
+            // PHASE 7: Goal Deconstruction & Persistence
+            try {
+                const db = await NoormmeEngine.getInstance();
+                const userMsg = messages.filter(m => m.role === "user").pop();
+                if (userMsg && typeof userMsg.content === "string") {
+                    // START EPISODIC NARRATIVE
+                    const episode = await db.agent.cortex.episodes.startEpisode(originatingSessionId, userMsg.content.substring(0, 50) + "...");
+                    this.state.activeEpisodeId = episode.id;
+                    // PHASE 8: Strategic Evolution & Persona Mutation
+                    try {
+                        tracker.emitEvent({
+                            type: "reasoning",
+                            runId: tracker.getRun().runId,
+                            text: "🧬 **Strategic Alignment**: Auditing performance metrics for evolutionary mutation...",
+                            elapsedMs: tracker.elapsedMs(),
+                        });
+                        const mutations = await db.agent.cortex.strategy.mutateStrategy();
+                        if (mutations.length > 0) {
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `✨ **Evolutionary Mutation Applied**: ${mutations[0]}`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                        }
+                        // PHASE 7: Logical Contradiction Protection
+                        const contradictions = await db.agent.cortex.reasoner.detectContradictions();
+                        if (contradictions.length > 0) {
+                            const conflictContext = contradictions.slice(0, 3).map(c => `> ${c}`).join("\n");
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `⚠️ **LOGICAL CONTRADICTION ALERT**: Detected potential goal conflicts:\n${conflictContext}`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                            messages.push({
+                                role: "system",
+                                content: `[LOGICAL CONTRADICTION ALERT]\nThe sovereign mind has detected contradictions in current objectives. Ensure your next actions resolve or respect these constraints:\n${conflictContext}`
+                            });
+                        }
+                        // Fetch the current active persona to align system prompt
+                        const activePersona = await db.execute("SELECT role, policies FROM agent_personas WHERE status = 'active' LIMIT 1");
+                        if (activePersona?.rows?.[0]) {
+                            const p = activePersona.rows[0];
+                            messages.unshift({
+                                role: "system",
+                                content: `[SOVEREIGN PERSONA ALIGNMENT]\nYour current role has been evolved: ${p.role}\nActive Policies: ${p.policies}`
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Strategic evolution failed", e);
+                    }
+                    // PHASE 9: Alpha Cross-Pollination
+                    try {
+                        if (Math.random() < 0.05) { // 5% chance to cross-pollinate from HiveMind Alpha variants
+                            const alphaVariants = await db.execute("SELECT role FROM agent_personas WHERE metadata LIKE '%\"anchored_reliability\":%' ORDER BY json_extract(metadata, '$.anchored_reliability') DESC LIMIT 3");
+                            if (alphaVariants?.rows?.[0]) {
+                                const alphaRole = alphaVariants.rows[0].role;
+                                tracker.emitEvent({
+                                    type: "reasoning",
+                                    runId: tracker.getRun().runId,
+                                    text: "🐝 **Alpha Cross-Pollination**: Incorporating high-reliability traits from the Hive Alpha...",
+                                    elapsedMs: tracker.elapsedMs(),
+                                });
+                                messages.push({
+                                    role: "system",
+                                    content: `[ALPHA CROSS-POLLINATION]\nIncorporate these verified high-performance traits into your current reasoning chain:\n${alphaRole.substring(0, 200)}...`
+                                });
+                            }
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Alpha cross-pollination failed", e);
+                    }
+                    // PHASE 8: Shadow Trials (Experimental Strategy)
+                    try {
+                        const useShadow = Math.random() < 0.1; // 10% chance for shadow trial
+                        if (useShadow) {
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: "🌓 **Shadow Trial Initiated**: Activating experimental reasoning parameters...",
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                            messages.push({
+                                role: "system",
+                                content: "[SHADOW TRIAL ACTIVE]\nYou are in an experimental reasoning mode. Prioritize direct, high-precision actions and minimize explanation verbosity."
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Shadow Trial initiation failed", e);
+                    }
+                    // PHASE 8: Proactive Curiosity & Knowledge Gaps
+                    try {
+                        tracker.emitEvent({
+                            type: "reasoning",
+                            runId: tracker.getRun().runId,
+                            text: "🕵️ **Internal Reflection**: Sifting for knowledge hotspots and ontological gaps...",
+                            elapsedMs: tracker.elapsedMs(),
+                        });
+                        const proposals = await db.agent.cortex.curiosity.proposeResearch();
+                        if (proposals.length > 0) {
+                            const gapContext = proposals.slice(0, 3).map(p => `- ${p}`).join("\n");
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `🔍 **Identified Knowledge Gaps**:\n${gapContext}`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                            messages.push({
+                                role: "system",
+                                content: `[INTERNAL REFLECTION: KNOWLEDGE GAPS]\nThe sovereign mind has identified these potential gaps in your current understanding of the ecosystem. Prioritize bridging these if relevant to the current quest:\n${gapContext}`
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Curiosity ingestion failed", e);
+                    }
+                    const parentGoal = await db.agent.cortex.sessions.upsertGoal(originatingSessionId, userMsg.content.substring(0, 100) + (userMsg.content.length > 100 ? "..." : ""), { priority: 10 });
+                    // PHASE 12: LLM-Powered Goal Architecture
+                    try {
+                        tracker.emitEvent({
+                            type: "reasoning",
+                            runId: tracker.getRun().runId,
+                            text: "🏗️ **Goal Architecture**: Systemically deconstructing complex objectives...",
+                            elapsedMs: tracker.elapsedMs(),
+                        });
+                        // Use the GoalArchitect to decompose the high-level intent into systemic milestones
+                        // NOORMME's GoalArchitect uses the LLM to slice the intent into atomic, verifiable goals.
+                        const subGoals = await db.agent.cortex.goalArchitect.deconstructGoal(parentGoal.id, userMsg.content);
+                        if (subGoals.length > 0) {
+                            const milestoneSummary = subGoals.map((sg) => `- [ ] ${sg.description}`).join("\n");
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `📍 **System Milestones Established**:\n${milestoneSummary}`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Goal deconstruction failed", e);
+                    }
+                    // PHASE 8.2: Ablation Performance Monitoring
+                    try {
+                        const ablationStatus = await db.agent.cortex.ablation.monitorAblationPerformance();
+                        if (ablationStatus.status === "degraded") {
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `🩻 **Performance Drift Detected**: Success rates dropped. Recovered ${ablationStatus.recoveredCount} high-value memories.`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Ablation monitoring failed", e);
+                    }
+                }
+            }
+            catch (e) {
+                console.warn("[MarieEngine] Failed to deconstruct goals or check conflicts", e);
+            }
         }
         // SPIRIT BURST & AWAKENING DETECTION
         const wasBurstActive = this.state.isSpiritBurstActive;
@@ -201,8 +466,41 @@ export class MarieEngine {
         const MAX_TOOLS_PER_TURN = 30;
         const executeTool = async (toolCall) => {
             const tool = this.toolRegistry.getTool(toolCall.name);
+            const db = await NoormmeEngine.getInstance();
+            let action = null;
+            try {
+                action = await db.agent.cortex.actions.logAction(originatingSessionId, toolCall.name, toolCall.input);
+            }
+            catch (e) {
+                console.warn("[MarieEngine] Failed to log action start to NOORMME", e);
+            }
+            // PHASE 8.4: Capability Sandboxing
+            try {
+                const personaId = this.state.activePersonaId || "default";
+                const access = await db.agent.cortex.capabilities.validateCapabilityAccess(personaId, toolCall.name);
+                if (!access.allowed) {
+                    tracker.emitEvent({
+                        type: "reasoning",
+                        runId: tracker.getRun().runId,
+                        text: `🛡️ **CAPABILITY BLOCKED**: Access to tool '${toolCall.name}' denied. Reason: ${access.reason}`,
+                        elapsedMs: tracker.elapsedMs(),
+                    });
+                    return {
+                        tool_call_id: toolCall.id,
+                        role: "tool",
+                        name: toolCall.name,
+                        content: `Error: Capability Blocked. ${access.reason}`,
+                    };
+                }
+            }
+            catch (e) {
+                console.warn("[MarieEngine] Capability validation failed", e);
+            }
             if (!tool) {
                 const repairResult = await this.toolMender.performFuzzyRepair(toolCall, "Tool not found", tracker, processor, this.state, signal);
+                if (action) {
+                    await db.agent.cortex.actions.recordOutcome(action.id, repairResult && !repairResult.startsWith("Error") ? "success" : "failure", repairResult || "Tool not found");
+                }
                 if (repairResult) {
                     this.toolCallCounter++;
                     return {
@@ -221,6 +519,78 @@ export class MarieEngine {
             const startTime = Date.now();
             pulse.startHeartbeat();
             try {
+                // PHASE 8: Universal Policy Shield
+                try {
+                    const evalContext = {
+                        ...toolCall.input,
+                        tool_name: toolCall.name,
+                        content: JSON.stringify(toolCall.input),
+                        // PHASE 12: Token-based Turn Cost Heuristic
+                        turn_cost: (JSON.stringify(toolCall.input).length / 4) / 1000 // Tokens / 1000 base unit
+                    };
+                    const policyResult = await db.agent.cortex.policies.evaluateContext(evalContext);
+                    if (!policyResult.allowed) {
+                        tracker.emitEvent({
+                            type: "reasoning",
+                            runId: tracker.getRun().runId,
+                            text: `🛑 **AGENTIC INTERCEPTION**: Policy Violation Detected.\n> ${policyResult.violations.join("\n> ")}`,
+                            elapsedMs: tracker.elapsedMs(),
+                        });
+                        // PHASE 8: Track Policy Vetoes in telemetry
+                        const run = tracker.getRun();
+                        run.policyVetoes = (run.policyVetoes || 0) + 1;
+                        if (action) {
+                            await db.agent.cortex.actions.recordOutcome(action.id, "failure", `Policy Veto: ${policyResult.violations.join(", ")}`);
+                        }
+                        return {
+                            type: "tool_result",
+                            tool_use_id: toolCall.id,
+                            content: `Error: Execution blocked by Sovereign Governance. Reason: ${policyResult.violations.join("; ")}`,
+                        };
+                    }
+                }
+                catch (e) {
+                    console.warn("[MarieEngine] Policy enforcement failed, failing safe...", e);
+                }
+                // PHASE 8.2: Mid-Turn Conflict Resolution
+                try {
+                    const conflicts = await db.agent.cortex.conflicts.auditRuleConflicts();
+                    if (conflicts.length > 0) {
+                        // Identify if any conflict applies to the CURRENT tool call (Semantic Shield)
+                        const relevantConflict = conflicts.find(c => c.toLowerCase().includes(toolCall.name.toLowerCase()));
+                        if (relevantConflict) {
+                            tracker.emitEvent({
+                                type: "reasoning",
+                                runId: tracker.getRun().runId,
+                                text: `🛡️ **INTERNAL CONFLICT ALERT**: Tool '${toolCall.name}' may violate cognitive alignment.\n> ${relevantConflict}`,
+                                elapsedMs: tracker.elapsedMs(),
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn("[MarieEngine] Mid-turn conflict resolution failed", e);
+                }
+                // PHASE 8.3: Goal Milestone Verification
+                try {
+                    const activeGoals = await db.agent.cortex.sessions.getGoals(originatingSessionId);
+                    for (const goal of activeGoals) {
+                        if (goal.status === "in_progress" || goal.status === "pending") {
+                            const deps = await db.agent.cortex.goalArchitect.checkGoalDependencies(goal.id);
+                            if (!deps.canComplete) {
+                                tracker.emitEvent({
+                                    type: "reasoning",
+                                    runId: tracker.getRun().runId,
+                                    text: `🚩 **INTERNAL BLOCKER**: Goal "${goal.description.substring(0, 30)}..." has ${deps.pendingSubGoals} pending milestones.`,
+                                    elapsedMs: tracker.elapsedMs(),
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn("[MarieEngine] Milestone verification failed", e);
+                }
                 // Determine if we need to transition objectives
                 if (tracker.getRun().activeObjectiveId === "understand_request") {
                     tracker.setObjectiveStatus("understand_request", "completed");
@@ -228,6 +598,18 @@ export class MarieEngine {
                     tracker.getRun().activeObjectiveId = "execute_plan";
                     tracker.emitProgressUpdate(`Executing technique: ${toolCall.name}`);
                 }
+                // PHASE 13: Active Stability Throttling
+                if (MarieStabilityMonitor.isHighPressure()) {
+                    const metrics = MarieStabilityMonitor.getMetrics();
+                    console.warn(`[MarieEngine] High pressure detected (Lag: ${metrics.lagMs}ms). Throttling execution...`);
+                    tracker.emitEvent({
+                        type: "reasoning",
+                        runId: tracker.getRun().runId,
+                        text: `⚠️ **STABILITY THROTTLE**: System pressure detected (Lag: ${metrics.lagMs}ms). Pausing for 2s to allow event loop recovery...`,
+                        elapsedMs: tracker.elapsedMs(),
+                    });
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                }
                 let toolResult = await processor.process(toolCall, signal);
                 // Buffer Hard-Cap
                 if (typeof toolResult === "string" && toolResult.length > 1024 * 1024) {
@@ -238,13 +620,47 @@ export class MarieEngine {
                 const targetFile = toolCall.input?.path ||
                     toolCall.input?.targetFile ||
                     toolCall.input?.file;
+                let status = "success";
                 if (typeof toolResult === "string" && toolResult.startsWith("Error")) {
                     this.handleFailure(tracker, toolCall.name, toolResult, targetFile);
                     turnFailureCount++;
+                    status = "failure";
                 }
                 else {
                     this.handleSuccess(tracker, toolCall.name, durationMs, targetFile, signal);
                 }
+                try {
+                    await db.agent.cortex.actions.recordOutcome(action.id, status, typeof toolResult === "string"
+                        ? toolResult.substring(0, 500)
+                        : "Success (Object)", durationMs);
+                    // PHASE 9: Shadow Trial Success Metrics
+                    const run = tracker.getRun();
+                    if (run.shadowTrialActive) {
+                        await db.agent.cortex.metrics.recordMetric("experimental_success", status === "success" ? 1 : 0, {
+                            sessionId: originatingSessionId,
+                            metadata: {
+                                trialType: "shadow_reasoning",
+                                toolName: toolCall.name
+                            }
+                        });
+                    }
+                    // PHASE 10: Capability Evolution
+                    await db.agent.cortex.capabilities.reportOutcome(toolCall.name, status === "success");
+                    // Populate 'error' column for ActionRefiner if failure
+                    if (status === "failure") {
+                        await db.execute("UPDATE agent_actions SET error = ? WHERE id = ?", [typeof toolResult === "string" ? toolResult : "Unknown Error", action.id]);
+                    }
+                    // PHASE 11: Structural Bottleneck Detection
+                    if (durationMs > 5000) { // Flag slow operations as hotspots for indexing
+                        await db.agent.cortex.metrics.recordMetric("structural_latency_spike", durationMs, {
+                            sessionId: originatingSessionId,
+                            metadata: { toolName: toolCall.name, complexity: "high" }
+                        });
+                    }
+                }
+                catch (e) {
+                    console.warn("[MarieEngine] Failed to record action outcome to NOORMME", e);
+                }
                 this.toolCallCounter++;
                 return {
                     type: "tool_result",
@@ -265,6 +681,7 @@ export class MarieEngine {
                 const now = Date.now();
                 lastTokenTime = now;
                 pulse.startHeartbeat();
+                tracker.recordLog(`[MarieEngine] AI Event: ${event.type}`);
                 // RESTORE EVENT ROUTING: Dispatch all stream events
                 if (process.env.MARIE_DEBUG) {
                     console.log(`[Engine Debug] AI Event: ${event.type}`, event.type === "content_delta"
@@ -325,6 +742,15 @@ export class MarieEngine {
                 }
                 else if (event.type === "usage") {
                     tracker.getRun().usage = event.usage;
+                    // PHASE 6: Resource Consciousness
+                    try {
+                        const db = await NoormmeEngine.getInstance();
+                        await db.agent.cortex.resources.recordUsage(tracker.getRun().runId, ConfigService.getModel(), event.usage.inputTokens, event.usage.outputTokens, 0 // Cost calculation can be added later or handled by NOORMME if configured
+                        );
+                    }
+                    catch (e) {
+                        console.warn("[MarieEngine] Failed to record resource usage", e);
+                    }
                 }
             }
         }
@@ -401,6 +827,41 @@ export class MarieEngine {
             text: "✨ Convergence achieved. The pattern sparks joy.",
             elapsedMs: tracker.elapsedMs(),
         });
+        // PHASE 8: Sovereign Metrics (Life Satisfaction)
+        try {
+            const db = await NoormmeEngine.getInstance();
+            const turnDurationMs = tracker.elapsedMs(); // Use tracker's elapsed time for full turn intensity
+            await db.agent.cortex.metrics.recordMetric("turn_intensity", turnDurationMs, {
+                sessionId: originatingSessionId,
+                unit: "ms"
+            });
+            const pendingGoals = await db.agent.cortex.sessions.getGoals(originatingSessionId);
+            const goalVelocity = Math.max(0, 100 - (pendingGoals.filter(g => g.status !== 'completed').length * 10));
+            await db.agent.cortex.metrics.recordMetric("goal_velocity", goalVelocity, {
+                sessionId: originatingSessionId,
+                unit: "percent"
+            });
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Performance metrics recording failed", e);
+        }
+        // PHASE 5: Sovereign Governance
+        try {
+            const db = await NoormmeEngine.getInstance();
+            // Performance Audit: Sanity check before finalizing turn
+            const audit = await db.agent.cortex.governor.performAudit();
+            if (!audit.healthy) {
+                tracker.emitEvent({
+                    type: "reasoning",
+                    runId: tracker.getRun().runId,
+                    text: `🛡️ GOVERNANCE ALERT: ${audit.issues.length} compliance issues detected. Autonomous remediation initiated.`,
+                    elapsedMs: tracker.elapsedMs(),
+                });
+            }
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Governance/Distillation cycle failed", e);
+        }
         dispatcher.clear();
         return currentAccumulatedContent;
     }
@@ -423,6 +884,10 @@ export class MarieEngine {
                 text: `✨ Technique Mastery! ${toolName} executed perfectly. Victory Streak: ${this.state.victoryStreak}.`,
                 elapsedMs: tracker.elapsedMs(),
             });
+            // PHASE 8: Hive Skill Propagation
+            NoormmeEngine.getInstance().then(db => {
+                db.agent.cortex.hive.broadcastSkills().catch(e => console.warn("[MarieEngine] Hive Skill Propagation failed", e));
+            });
         }
         if (filePath && !this.state.recentFiles.includes(filePath)) {
             this.state.recentFiles.push(filePath);
@@ -518,15 +983,28 @@ export class MarieEngine {
             const reason = pressure < 40
                 ? "Low spirit pressure (instability detected)"
                 : `Repeated failures in: ${hotspotFiles}`;
-            // Log only - do not force the user/agent into a recovery loop
             console.log(`[MarieEngine] Suggestion: ${reason}. (Auto-recovery disabled for stability)`);
         }
     }
+    /**
+     * REAGENT DISPOSAL: Ensure absolute resource sanctity.
+     */
     dispose() {
         this.disposed = true;
+        if (this.activeTurn) {
+            // We don't await here as dispose is usually synchronous
+        }
         this.pulseService?.cleanup();
         this.pulseService = undefined;
         this.contentBuffer = "";
+        try {
+            // PHASE 17: Definitive Terminal Cleanup
+            const { TerminalService } = require("../../../plumbing/terminal/TerminalService.js");
+            TerminalService.cleanup();
+        }
+        catch (e) {
+            // Ignore errors if TerminalService is not yet loaded or failed
+        }
     }
     ensurePulseService(tracker) {
         if (!this.pulseService)
@@ -583,5 +1061,37 @@ export class MarieEngine {
             }
         }
     }
+    /**
+     * SEMANTIC SOVEREIGNTY: Search Marie's long-term semantic memory.
+     */
+    async searchMemories(query, limit = 5) {
+        try {
+            const db = await NoormmeEngine.getInstance();
+            if (!db.agent.cortex.vectors)
+                return [];
+            const embedding = await this.provider.createEmbedding(query);
+            return await db.agent.cortex.vectors.search(embedding, { limit });
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Semantic memory search failed", e);
+            return [];
+        }
+    }
+    /**
+     * SEMANTIC SOVEREIGNTY: Search Marie's distilled knowledge base.
+     */
+    async searchKnowledge(entity) {
+        try {
+            const db = await NoormmeEngine.getInstance();
+            return await db.agent.cortex.knowledge.getKnowledgeByEntity(entity);
+        }
+        catch (e) {
+            console.warn("[MarieEngine] Knowledge search failed", e);
+            return [];
+        }
+    }
+    isDisposed() {
+        return this.disposed;
+    }
 }
 //# sourceMappingURL=MarieEngine.js.map