@noorm/marie-cli 0.1.18 → 0.1.25

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

@@ -1,1097 +1,135 @@
-import path from "path";
-import { MarieSession } from "./MarieSession.js";
-import { MarieEventDispatcher } from "./MarieEventDispatcher.js";
-import { MarieToolProcessor } from "./MarieToolProcessor.js";
-import { MarieAscendant } from "../agents/MarieAscendant.js";
-import { MarieLockManager } from "./MarieLockManager.js";
-import { MarieToolMender } from "./MarieToolMender.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";
-}
-/**
- * Entry point for the AI Engine. YOLO Supremacy Edition.
- */
+import { getTool, getRegisteredTools } from "../../tools/SovereignTools.js";
+import { getModel, getMaxRecursiveDepth, } from "../../Configuration.js";
+import { manageContext } from "../../CoreInfrastructure.js";
+import { SYSTEM_CONTINUATION_PROMPT, SYSTEM_PROMPT } from "../../../../prompts.js";
+import { safeStringify, safeSpread } from "../../../plumbing/utils/PlumbingCore.js";
 export class MarieEngine {
     provider;
     toolRegistry;
     approvalRequester;
     providerFactory;
-    fs;
-    ghostPort;
-    static CONTENT_BUFFER_MAX_BYTES = 1024 * 1024;
-    static GLOBAL_CONCURRENCY_LIMIT = 5;
-    static globalSemaphore = new MarieSemaphore(MarieEngine.GLOBAL_CONCURRENCY_LIMIT);
-    ascendant;
     state;
-    lockManager;
-    toolMender;
-    pulseService;
-    reasoningBudget;
-    toolCallCounter = 0;
-    contentBuffer = "";
-    lastContentEmit = 0;
+    pulse;
     activeTurn = null;
     disposed = false;
-    logService;
-    constructor(provider, toolRegistry, approvalRequester, providerFactory, fs, ghostPort) {
+    heartbeatTimer = null;
+    watchdogTimer = null;
+    iterations = [];
+    static toolsInFlight = new Map();
+    logPath;
+    logQueue = [];
+    isWritingLog = false;
+    constructor(provider, toolRegistry, approvalRequester = async () => true, providerFactory) {
         this.provider = provider;
         this.toolRegistry = toolRegistry;
         this.approvalRequester = approvalRequester;
         this.providerFactory = providerFactory;
-        this.fs = fs;
-        this.ghostPort = ghostPort;
-        this.ascendant = new MarieAscendant(this.provider);
-        this.state = this.initializeState();
-        this.lockManager = new MarieLockManager();
-        this.toolMender = new MarieToolMender(this.toolRegistry);
-        this.reasoningBudget = new ReasoningBudget();
-    }
-    initializeState() {
-        return {
-            errorHotspots: {},
-            totalErrorCount: 0,
-            spiritPressure: 50,
-            recentFiles: [],
-            toolHistory: [],
-            techniqueExecutions: [],
-            victoryStreak: 0,
-            shakyResponseDensity: 0,
-            writtenFiles: [],
-            actionDiffs: {},
-            wiringAlerts: [],
-            mood: "STABLE",
-            isSpiritBurstActive: false,
-            isAwakened: false,
-            karmaBond: undefined,
-            panicCoolDown: 0,
-            environment: this.fs?.type === "vscode" ? "vscode" : "cli",
-            lastFailedFile: undefined,
-        };
-    }
-    async chatLoop(messages, tracker, saveHistory, signal, consecutiveErrorCount = 0, depth = 0, accumulatedContent = "") {
-        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) {
-            console.warn("[MarieEngine] INSTANCE RE-ENTRY DETECTED. Waiting for previous turn to finalize...");
-            await this.activeTurn;
-        }
-        // GLOBAL SEMAPHORE: Acquire slot before proceeding
-        await MarieEngine.globalSemaphore.acquire(signal);
-        let resolveTurn = () => { };
-        this.activeTurn = new Promise((resolve) => {
-            resolveTurn = resolve;
-        });
+        this.state = { totalErrorCount: 0, confidenceLevel: 80, recentFiles: [], executionHistory: [] };
+    }
+    async chatLoop(messages, run, callbacks, saveHistory, signal) {
+        if (this.disposed)
+            throw new Error("Engine disposed.");
+        this.pulse = { pendingContent: "", pendingToolDeltas: new Map(), throttleTimer: null, toolThrottleTimer: null, run, callbacks };
+        let depth = 0;
+        let accumulatedContent = "";
+        const maxDepth = getMaxRecursiveDepth();
         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.");
-        }
-        const pulse = this.ensurePulseService(tracker);
-        // Initialize incremental logging
-        const originatingSessionId = tracker.getRun().originatingSessionId || "default";
-        if (!this.logService) {
-            this.logService = new SessionLogService(originatingSessionId);
-        }
-        const logService = this.logService;
-        logService.setProgressCallback((totalBytes, eventCount) => {
-            tracker.emitEvent({
-                type: "session_persistence_update",
-                runId: tracker.getRun().runId,
-                sessionId: originatingSessionId,
-                totalBytes,
-                elapsedMs: tracker.elapsedMs(),
-            });
-        });
-        // Override tracker emit to persist every event
-        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) {
-            // Graceful Stability Limit Reached
-            const msg = "⚠️ Stability Alert: Maximum reasoning depth (20) reached. Returning current accumulation to prevent infinite loop.";
-            console.warn(msg);
-            // Return currently accumulated content so the user sees *something*
-            return accumulatedContent + "\n\n" + msg;
-        }
-        tracker.resetReasoningBudget();
-        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",
-                runId: tracker.getRun().runId,
-                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;
-        const wasAwakened = this.state.isAwakened;
-        this.state.isSpiritBurstActive = this.state.spiritPressure > 85;
-        this.state.isAwakened = this.state.spiritPressure > 95;
-        if (this.state.isAwakened && !wasAwakened) {
-            tracker.emitEvent({
-                type: "reasoning",
-                runId: tracker.getRun().runId,
-                text: "✨ AWAKENED! Ultra Instinct achieved. Full codebase sovereignty established.",
-                elapsedMs: tracker.elapsedMs(),
-            });
-        }
-        else if (this.state.isSpiritBurstActive && !wasBurstActive) {
-            tracker.emitEvent({
-                type: "reasoning",
-                runId: tracker.getRun().runId,
-                text: "💥 SPIRIT BURST! Conviction is absolute. Auto-approval mandate expanded.",
-                elapsedMs: tracker.elapsedMs(),
-            });
-        }
-        // Decay spirit pressure if stale
-        if (Date.now() -
-            (this.state.techniqueExecutions.slice(-1)[0]?.timestamp || 0) >
-            300000) {
-            this.state.spiritPressure = Math.max(30, this.state.spiritPressure - 10);
-        }
-        const processor = new MarieToolProcessor(this.toolRegistry, tracker, async (name, input) => {
-            // YOLO AUTO-APPROVAL: Tiered risk assessment
-            if (this.shouldAutoApprove(name, input)) {
-                tracker.emitEvent({
-                    type: "checkpoint",
-                    runId: tracker.getRun().runId,
-                    status: "approved",
-                    toolName: name,
-                    summary: {
-                        what: "Ascension Auto-Approved",
-                        why: "Heroic Conviction",
-                        impact: "Maximum Speed",
-                    },
-                    elapsedMs: tracker.elapsedMs(),
-                });
-                return true;
-            }
-            return this.approvalRequester(name, input);
-        }, this.state, this.fs);
-        let turnContent = "";
-        const toolBuffer = new Map();
-        const parsedInputCache = new Map();
-        const toolResultBlocks = [];
-        let turnFailureCount = 0;
-        let totalToolCount = 0;
-        let lastTokenTime = Date.now();
-        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 {
-                        type: "tool_result",
-                        tool_use_id: toolCall.id,
-                        content: repairResult,
-                    };
-                }
-                this.updateShakyResponse();
-                return {
-                    type: "tool_result",
-                    tool_use_id: toolCall.id,
-                    content: `Error: Tool "${toolCall.name}" not found.`,
-                };
-            }
-            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");
-                    tracker.setObjectiveStatus("execute_plan", "in_progress");
-                    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) {
-                    toolResult =
-                        toolResult.substring(0, 1024 * 1024) + "\n\n🚨 Truncated at 1MB.";
-                }
-                const durationMs = Date.now() - startTime;
-                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",
-                    tool_use_id: toolCall.id,
-                    content: toolResult,
-                };
-            }
-            finally {
-                pulse.stopHeartbeat();
-            }
-        };
-        const promptProfile = getPromptProfileForDepth(depth);
-        const session = new MarieSession(this.provider, this.toolRegistry, saveHistory, messages, tracker, this.providerFactory, promptProfile);
-        const toolExecutions = [];
-        try {
-            const stream = session.executeLoop(messages, signal);
-            for await (const event of stream) {
-                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"
-                        ? `(${event.text.length} chars)`
-                        : "");
-                }
-                dispatcher.dispatch(event);
-                if (event.type === "content_delta") {
-                    turnContent += event.text;
-                    this.contentBuffer += event.text;
-                    if (this.contentBuffer.length >= MarieEngine.CONTENT_BUFFER_MAX_BYTES)
-                        break;
-                }
-                else if (event.type === "tool_call_delta") {
-                    let tb = toolBuffer.get(event.index);
-                    if (!tb) {
-                        tb = { id: event.id, name: event.name, inputString: "" };
-                        toolBuffer.set(event.index, tb);
-                    }
-                    else {
-                        // UPDATE: Ensure name and id are captured even if they arrive in later deltas
-                        if (event.id && !tb.id)
-                            tb.id = event.id;
-                        if (event.name && !tb.name)
-                            tb.name = event.name;
-                    }
-                    if (event.argumentsDelta)
-                        tb.inputString += event.argumentsDelta;
-                    if (tb.name && this.isLikelyCompleteJson(tb.inputString)) {
-                        const input = this.tryParseToolInput(tb.inputString, tb.name, parsedInputCache);
-                        if (!input)
-                            continue;
-                        toolBuffer.delete(event.index);
-                        totalToolCount++;
-                        if (totalToolCount > MAX_TOOLS_PER_TURN)
-                            break;
-                        const target = input.path || input.targetFile || input.file || "GLOBAL";
-                        const isWrite = [
-                            "write_to_file",
-                            "replace_file_content",
-                            "multi_replace_file_content",
-                            "run_command",
-                            "delete_file",
-                        ].includes(tb.name);
-                        // Execute concurrently
-                        const executionPromise = (async () => {
-                            await this.lockManager.acquireLock(target, isWrite, signal, tracker.getRun().runId);
-                            const promise = executeTool({
-                                id: tb.id,
-                                name: tb.name,
-                                input,
-                            });
-                            this.lockManager.registerExecution(target, isWrite, promise, tracker.getRun().runId);
-                            return await promise;
-                        })();
-                        toolExecutions.push(executionPromise);
-                    }
-                }
-                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);
-                    }
+            while (depth <= maxDepth) {
+                await this.align(messages);
+                const prompt = depth > 0 ? SYSTEM_CONTINUATION_PROMPT : SYSTEM_PROMPT;
+                const tools = this.getEffectiveTools();
+                const managedMessages = await manageContext(messages, this.provider, this.state);
+                let turnContent = "";
+                const toolExecutions = [];
+                const buffer = new Map();
+                await this.provider.createMessageStream({
+                    model: getModel(),
+                    messages: managedMessages,
+                    system: prompt,
+                    tools,
+                }, (event) => {
+                    this.dispatchPulse(event);
+                    if (event.type === "content_delta")
+                        turnContent += event.text;
+                    else if (event.type === "tool_call_delta")
+                        this.onToolDelta(event, buffer, toolExecutions, signal);
+                    else if (event.type === "usage")
+                        this.onUsage(event);
+                }, signal);
+                this.flushPulse();
+                const results = await Promise.all(toolExecutions);
+                accumulatedContent += turnContent;
+                if (results.length > 0) {
+                    messages.push({ role: "user", content: results });
+                    depth++;
                 }
+                else
+                    break;
             }
+            return accumulatedContent;
         }
         finally {
-            pulse.cleanup();
-        }
-        // POST-LOOP FLUSH: Handle any tools that arrived at the very end but missed the stream evaluation
-        for (const [index, tb] of toolBuffer.entries()) {
-            if (tb.name) {
-                const input = this.tryParseToolInput(tb.inputString, tb.name, parsedInputCache);
-                if (input) {
-                    totalToolCount++;
-                    const target = input.path || input.targetFile || input.file || "GLOBAL";
-                    const isWrite = [
-                        "write_to_file",
-                        "replace_file_content",
-                        "multi_replace_file_content",
-                        "run_command",
-                        "delete_file",
-                    ].includes(tb.name);
-                    const executionPromise = (async () => {
-                        await this.lockManager.acquireLock(target, isWrite, signal, tracker.getRun().runId);
-                        const promise = executeTool({ id: tb.id, name: tb.name, input });
-                        this.lockManager.registerExecution(target, isWrite, promise, tracker.getRun().runId);
-                        return await promise;
-                    })();
-                    toolExecutions.push(executionPromise);
-                }
-            }
-        }
-        toolBuffer.clear();
-        const currentAccumulatedContent = accumulatedContent + turnContent;
-        console.log(`[MarieEngine] Depth ${depth}: Turn content length: ${turnContent.length}. New accumulated length: ${currentAccumulatedContent.length}`);
-        if (this.contentBuffer.length > 0) {
-            this.contentBuffer = "";
-        }
-        // Await all concurrent tool executions
-        const results = await Promise.all(toolExecutions);
-        toolResultBlocks.push(...results);
-        await this.lockManager.waitForAll();
-        if (signal?.aborted) {
-            throw new Error("Execution aborted by user after tool execution.");
-        }
-        // Final tool processing if results were returned
-        if (totalToolCount > 0) {
-            messages.push({ role: "user", content: toolResultBlocks });
-            // ASCENSION EVALUATION: Local decree (NO API CALL)
-            const decree = await this.ascendant.evaluate(messages, this.state);
-            this.state.lastDecree = decree;
-            // Visual feedback only — no state mutations from decree
-            tracker.emitEvent({
-                type: "reasoning",
-                runId: tracker.getRun().runId,
-                text: `⚡ Decree: ${decree.strategy} @ ${decree.confidence.toFixed(2)} — ${decree.reason}`,
-                elapsedMs: tracker.elapsedMs(),
-            });
-            if (decree.heroicVow) {
-                tracker.emitEvent({
-                    type: "reasoning",
-                    runId: tracker.getRun().runId,
-                    text: `🗡️ VOW: "${decree.heroicVow}"`,
-                    elapsedMs: tracker.elapsedMs(),
-                });
-            }
-            saveHistory(tracker.getRun()).catch((e) => console.error("History Save Error:", e));
-            return await this._executeChatLoop(messages, tracker, saveHistory, signal, turnFailureCount > 0 ? consecutiveErrorCount + 1 : 0, depth + 1, currentAccumulatedContent);
-        }
-        // End of turn logic
-        tracker.setObjectiveStatus("execute_plan", "completed");
-        tracker.setObjectiveStatus("deliver_result", "completed");
-        tracker.emitEvent({
-            type: "reasoning",
-            runId: tracker.getRun().runId,
-            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;
-    }
-    handleSuccess(tracker, toolName, durationMs, filePath, signal) {
-        this.state.victoryStreak++;
-        this.state.totalErrorCount = 0;
-        this.state.spiritPressure = Math.min(100, this.state.spiritPressure + 10);
-        this.state.techniqueExecutions.push({
-            name: toolName,
-            durationMs,
-            success: true,
-            timestamp: Date.now(),
-            filePath,
-        });
-        this.state.toolHistory.push(toolName);
-        if (this.state.victoryStreak % 3 === 0) {
-            tracker.emitEvent({
-                type: "reasoning",
-                runId: tracker.getRun().runId,
-                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);
-            if (this.state.recentFiles.length > 10)
-                this.state.recentFiles.shift();
-            // ZENITH AUTONOMY: Proactive Context Anchoring
-            this.proactiveContextAnchoring(filePath, tracker, signal);
-        }
-    }
-    handleFailure(tracker, toolName, error, filePath) {
-        this.state.victoryStreak = 0;
-        this.state.spiritPressure = Math.max(0, this.state.spiritPressure - 20);
-        this.state.techniqueExecutions.push({
-            name: toolName,
-            durationMs: 0,
-            success: false,
-            timestamp: Date.now(),
-            filePath,
-        });
-        const hotspotCount = (this.state.errorHotspots[filePath || "system"] || 0) + 1;
-        if (filePath) {
-            this.state.errorHotspots[filePath] = hotspotCount;
-            this.state.totalErrorCount++;
-            this.state.lastFailedFile = filePath;
-        }
-        tracker.emitEvent({
-            type: "reasoning",
-            runId: tracker.getRun().runId,
-            text: `⚠️ Technique Falter! ${toolName} failed in ${filePath || "system"}. Resistance: ${hotspotCount}x. Regrouping...`,
-            elapsedMs: tracker.elapsedMs(),
-        });
-    }
-    updateShakyResponse() {
-        this.state.shakyResponseDensity = Math.min(1, this.state.shakyResponseDensity + 0.2);
-    }
-    shouldAutoApprove(toolName, input) {
-        const safeTools = [
-            "read_file",
-            "view_file",
-            "list_dir",
-            "grep_search",
-            "search_web",
-            "get_file_diagnostics",
-        ];
-        if (safeTools.includes(toolName))
-            return true;
-        // SPIRIT PRESSURE & KARMA NEUTERED:
-        // We no longer auto-approve based on pressure/streak to prevent "crashes" or unintended loops.
-        // The visual feedback remains, but the functional override is disabled.
-        return false;
-    }
-    tryParseToolInput(rawInput, toolName, cache) {
-        try {
-            return JSON.parse(rawInput);
-        }
-        catch (e) {
-            const repaired = this.toolMender.repairJsonString(rawInput);
-            try {
-                return JSON.parse(repaired);
-            }
-            catch (e2) {
-                console.warn(`[MarieEngine] JSON Parse Failed for ${toolName}: ${e instanceof Error ? e.message : String(e)}`);
-                return null;
-            }
-        }
-    }
-    isLikelyCompleteJson(input) {
-        const text = input.trim();
-        if (!text || (!text.startsWith("{") && !text.startsWith("[")))
-            return false;
-        let stack = 0;
-        let inString = false;
-        for (let i = 0; i < text.length; i++) {
-            if (text[i] === '"' && text[i - 1] !== "\\")
-                inString = !inString;
-            if (!inString) {
-                if (text[i] === "{" || text[i] === "[")
-                    stack++;
-                if (text[i] === "}" || text[i] === "]")
-                    stack--;
-            }
-        }
-        return stack === 0 && text.length >= 2;
-    }
-    suggestSelfHealing(tracker, messages) {
-        // SPIRIT PRESSURE & KARMA NEUTERED:
-        // We calculate the values for UI visuals but DO NOT inject mandatory recovery protocols.
-        // This prevents the "crash" loop the user described.
-        const pressure = this.state.spiritPressure;
-        const hotspots = Object.entries(this.state.errorHotspots).filter(([_, count]) => count >= 2);
-        if (pressure < 40 || hotspots.length > 0) {
-            const hotspotFiles = hotspots.map(([f]) => path.basename(f)).join(", ");
-            const reason = pressure < 40
-                ? "Low spirit pressure (instability detected)"
-                : `Repeated failures in: ${hotspotFiles}`;
-            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)
-            this.pulseService = new MariePulseService(tracker);
-        return this.pulseService;
-    }
-    calibrateStrategicTrajectory(decree, tracker) {
-        const run = tracker.getRun();
-        if (decree.strategy === "RESEARCH" ||
-            (decree.urgency === "HIGH" && decree.confidence > 2.0)) {
-            const oldPasses = run.totalPasses || 3;
-            if (oldPasses < 10) {
-                run.totalPasses = oldPasses + 1;
-                tracker.emitEvent({
-                    type: "reasoning",
-                    runId: run.runId,
-                    text: `🌌 ZENITH: Autonomously expanded roadmap to ${run.totalPasses} passes. Focus sharpened: ${decree.reason}`,
-                    elapsedMs: tracker.elapsedMs(),
-                });
-            }
-        }
-    }
-    async proactiveContextAnchoring(filePath, tracker, signal) {
-        // Only anchor critical files
-        const isCritical = /Domain|Config|Service|Interface|types/i.test(filePath);
-        if (isCritical) {
+            this.cleanupPulse();
+        }
+    }
+    dispatchPulse(event) {
+        if (!this.pulse)
+            return;
+        switch (event.type) {
+            case "content_delta":
+                this.pulse.pendingContent += event.text;
+                break;
+            case "tool_call_delta": break;
+        }
+    }
+    flushPulse() {
+        if (!this.pulse || !this.pulse.pendingContent)
+            return;
+        this.pulse.callbacks?.onStream?.(this.pulse.pendingContent, this.pulse.run.runId);
+        this.pulse.pendingContent = "";
+    }
+    cleanupPulse() { this.pulse = undefined; }
+    onToolDelta(event, buffer, executions, signal) {
+        let tb = buffer.get(event.index) || { id: event.id, name: event.name, inputString: "" };
+        if (event.id)
+            tb.id = event.id;
+        if (event.name)
+            tb.name = event.name;
+        if (event.argumentsDelta)
+            tb.inputString += event.argumentsDelta;
+        buffer.set(event.index, tb);
+        if (tb.name && this.isJsonComplete(tb.inputString)) {
             try {
-                if (signal?.aborted)
-                    return;
-                const { ContextArchiveService } = await import("../../../infrastructure/ai/context/ContextArchiveService.js");
-                const { readFile } = await import("../../../plumbing/filesystem/FileService.js");
-                const content = await readFile(filePath, undefined, undefined, signal);
-                if (signal?.aborted)
-                    return;
-                await ContextArchiveService.getInstance().anchor({
-                    id: `proactive_${filePath.split("/").pop()}`,
-                    label: `Strategic: ${filePath.split("/").pop()}`,
-                    content: content.substring(0, 2000), // Cap at 2k chars
-                    type: "file_ref",
-                });
-                if (signal?.aborted)
-                    return;
-                tracker.emitEvent({
-                    type: "reasoning",
-                    runId: tracker.getRun().runId,
-                    text: `⚓ ZENITH: Proactively anchored \`${filePath.split("/").pop()}\` to strategic memory.`,
-                    elapsedMs: tracker.elapsedMs(),
-                });
-            }
-            catch (e) {
-                if (!signal?.aborted) {
-                    console.warn("[Zenith] Failed proactive anchoring", e);
-                }
-            }
-        }
-    }
-    /**
-     * 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;
-    }
+                const input = JSON.parse(tb.inputString);
+                buffer.delete(event.index);
+                executions.push(this.runTool(tb.id, tb.name, input, signal));
+            }
+            catch { }
+        }
+    }
+    async runTool(id, name, input, signal) {
+        const start = Date.now();
+        const tool = this.getTool(name);
+        if (!tool)
+            return { type: "tool_result", tool_use_id: id, content: `Error: Tool ${name} not found.` };
+        this.pulse?.callbacks?.onEvent?.({ type: "tool", runId: this.pulse.run.runId, id, phase: "start", name, input: safeSpread(input), elapsedMs: Date.now() - this.pulse.run.startedAt });
+        const result = await tool.execute(input);
+        const final = typeof result === "string" ? result : safeStringify(result);
+        this.pulse?.callbacks?.onEvent?.({ type: "tool", runId: this.pulse.run.runId, id, phase: "complete", name, message: final.substring(0, 50), elapsedMs: Date.now() - this.pulse.run.startedAt });
+        return { type: "tool_result", tool_use_id: id, content: final };
+    }
+    async align(messages) { }
+    onUsage(e) { if (this.pulse)
+        this.pulse.run.usage = e.usage; }
+    getEffectiveTools() { return this.toolRegistry ? this.toolRegistry.getRegisteredTools() : getRegisteredTools(); }
+    isJsonComplete(s) { try {
+        JSON.parse(s);
+        return true;
+    }
+    catch {
+        return false;
+    } }
+    getTool(name) { return this.toolRegistry ? this.toolRegistry.get(name) : getTool(name); }
+    dispose() { this.disposed = true; }
 }
 //# sourceMappingURL=MarieEngine.js.map