@noorm/marie-cli 0.1.17 → 0.1.25

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

@@ -1,587 +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 { MariePulseService } from "./MariePulseService.js";
-import { MarieStabilityMonitor } from "./MarieStabilityMonitor.js";
-import { ReasoningBudget } from "./ReasoningBudget.js";
-import { SessionLogService } from "./SessionLogService.js";
-import { MarieSemaphore } from "./MarieSemaphore.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,
-        };
+        this.state = { totalErrorCount: 0, confidenceLevel: 80, recentFiles: [], executionHistory: [] };
     }
-    async chatLoop(messages, tracker, saveHistory, signal, consecutiveErrorCount = 0, depth = 0, accumulatedContent = "") {
-        if (this.disposed) {
-            throw new Error("MarieEngine has been disposed.");
-        }
-        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();
-        let resolveTurn = () => { };
-        this.activeTurn = new Promise((resolve) => {
-            resolveTurn = resolve;
-        });
-        try {
-            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;
-        }
-        finally {
-            MarieEngine.globalSemaphore.release();
-            resolveTurn();
-            this.activeTurn = null;
-        }
-    }
-    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);
-            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();
-        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(),
-            });
-        }
-        // 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);
-            if (!tool) {
-                const repairResult = await this.toolMender.performFuzzyRepair(toolCall, "Tool not found", tracker, processor, this.state, signal);
-                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 {
-                // 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}`);
-                }
-                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;
-                if (typeof toolResult === "string" && toolResult.startsWith("Error")) {
-                    this.handleFailure(tracker, toolCall.name, toolResult, targetFile);
-                    turnFailureCount++;
-                }
-                else {
-                    this.handleSuccess(tracker, toolCall.name, durationMs, targetFile, signal);
-                }
-                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 = [];
+    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 {
-            const stream = session.executeLoop(messages, signal);
-            for await (const event of stream) {
-                const now = Date.now();
-                lastTokenTime = now;
-                pulse.startHeartbeat();
-                // 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;
+            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();
+            this.cleanupPulse();
         }
-        // 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(),
-        });
-        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(),
-            });
-        }
-        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);
+    dispatchPulse(event) {
+        if (!this.pulse)
+            return;
+        switch (event.type) {
+            case "content_delta":
+                this.pulse.pendingContent += event.text;
+                break;
+            case "tool_call_delta": break;
         }
     }
-    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(),
-        });
+    flushPulse() {
+        if (!this.pulse || !this.pulse.pendingContent)
+            return;
+        this.pulse.callbacks?.onStream?.(this.pulse.pendingContent, this.pulse.run.runId);
+        this.pulse.pendingContent = "";
     }
-    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);
+    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 {
-                return JSON.parse(repaired);
-            }
-            catch (e2) {
-                console.warn(`[MarieEngine] JSON Parse Failed for ${toolName}: ${e instanceof Error ? e.message : String(e)}`);
-                return null;
+                const input = JSON.parse(tb.inputString);
+                buffer.delete(event.index);
+                executions.push(this.runTool(tb.id, tb.name, input, signal));
             }
+            catch { }
         }
     }
-    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}`;
-            // Log only - do not force the user/agent into a recovery loop
-            console.log(`[MarieEngine] Suggestion: ${reason}. (Auto-recovery disabled for stability)`);
-        }
-    }
-    dispose() {
-        this.disposed = true;
-        this.pulseService?.cleanup();
-        this.pulseService = undefined;
-        this.contentBuffer = "";
-    }
-    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 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 proactiveContextAnchoring(filePath, tracker, signal) {
-        // Only anchor critical files
-        const isCritical = /Domain|Config|Service|Interface|types/i.test(filePath);
-        if (isCritical) {
-            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);
-                }
-            }
-        }
+    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