micro-models-agent 0.39.1 → 0.40.0

package/dist/core/agent.js

@@ -1,15 +1,35 @@
+import { join } from "path";
 import { t } from "../i18n/index";
 import { pc } from "../ui/colors";
 import { PromptBuilder } from "./prompt-builder";
 import { processRegistry } from "../modules/processes";
 import { SessionLogger } from "./session-logger";
 import { runWithMoE } from "./agent-moe";
+import { MemoryStore } from "../modules/memory/store";
+import { StepVerifier } from "../modules/execution/verifier";
 const TOOL_RESULT_MAX_TOKENS_RATIO = 0.3;
 const TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
+const QUALITY_TRIGGER_THRESHOLD = 40;
+/** True when the text looks like a raw JSON tool payload (garbage to display). */
+function isToolCallJson(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            JSON.parse(trimmed);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
 export class Agent {
     deps;
     systemPromptAdded = false;
     shutdownRequested = false;
+    abortController = null;
+    lastCompactionShown = 0;
     constructor(deps) {
         this.deps = deps;
     }
@@ -31,19 +51,45 @@ export class Agent {
         if (dynamic.length > 0) {
             builder.addBlocks(dynamic);
         }
-        const pluginBlocks = (this.deps.pluginManager.runOnBuildPrompt?.() ?? [])
-            .filter((s) => Boolean(s && s.trim() !== ""))
-            .map((content) => ({
-            content,
-            priority: "low",
-            essential: false,
-            estimatedTokens: this.deps.llmProvider.countTokens(content),
-        }));
+        const pluginBlocks = (this.deps.pluginManager.runOnBuildPrompt?.() ?? []).flatMap((content) => content && content.trim() !== ""
+            ? [
+                {
+                    content,
+                    priority: "low",
+                    essential: false,
+                    estimatedTokens: this.deps.llmProvider.countTokens(content),
+                },
+            ]
+            : []);
         if (pluginBlocks.length > 0) {
             builder.addBlocks(pluginBlocks);
         }
         return builder.build();
     }
+    getSystemPromptInfo() {
+        const { prompt, excluded } = this.buildSystemPrompt();
+        const tokenCount = this.deps.llmProvider.countTokens(prompt);
+        return { text: prompt, tokenCount, excluded };
+    }
+    /**
+     * Some OpenAI-compatible backends (llama.cpp) omit `usage` from responses,
+     * leaving apiPromptTokens/apiCompletionTokens at 0. Fall back to local
+     * estimates so JSON results still carry meaningful token metrics.
+     */
+    resolveUsageTokens(apiPromptTokens, apiCompletionTokens, estimatedPromptTokens, completionChars) {
+        if (apiPromptTokens > 0 || apiCompletionTokens > 0) {
+            return {
+                prompt: apiPromptTokens,
+                completion: apiCompletionTokens,
+                total: apiPromptTokens + apiCompletionTokens,
+            };
+        }
+        // ~4 chars per token is a reasonable heuristic when the backend gives
+        // us nothing (matches the pre-tiktoken fallback elsewhere in the code).
+        const prompt = Math.max(1, estimatedPromptTokens);
+        const completion = Math.max(0, Math.ceil(completionChars / 4));
+        return { prompt, completion, total: prompt + completion };
+    }
     refreshSystemPrompt() {
         const { prompt } = this.buildSystemPrompt();
         const current = this.deps.contextManager
@@ -71,8 +117,8 @@ export class Agent {
     }
     async run(input, onChunk, onMeta, onTool, onPhase) {
         this.setScope();
-        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, } = this.deps;
-        const slog = new SessionLogger(sessionManager);
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, baseDir, } = this.deps;
+        const slog = new SessionLogger(sessionManager, logger);
         if (sessionManager && !sessionManager.getActive()) {
             sessionManager.create();
             logger.debug(`Session started: ${sessionManager.getActive()}`);
@@ -90,6 +136,18 @@ export class Agent {
                 logger,
                 sessionManager: sessionManager?.getActiveMeta(),
             });
+            if (config.session?.baselineCheck !== false) {
+                const verifier = new StepVerifier(baseDir);
+                verifier
+                    .runTypeCheck()
+                    .then((tc) => {
+                    if (!tc.passed) {
+                        logger.warn(`Baseline typecheck has issues: ${tc.message?.slice(0, 500)}`);
+                        onMeta?.(pc.yellow(`\n⚠ Baseline typecheck has issues\n`));
+                    }
+                })
+                    .catch(() => { });
+            }
         }
         contextManager.addMessage({ role: "user", content: input });
         slog.logUser(input);
@@ -105,25 +163,43 @@ export class Agent {
         return this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase);
     }
     async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
-        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, } = this.deps;
-        const slog = new SessionLogger(sessionManager);
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, baseDir, } = this.deps;
+        const slog = new SessionLogger(sessionManager, logger);
+        this.abortController = new AbortController();
         let iteration = 0;
         let lastText = "";
         let hallucinationRetries = 0;
         let lastToolSignature = "";
         let apiPromptTokens = 0;
         let apiCompletionTokens = 0;
+        let apiCompletionChars = 0;
         const MAX_HALLUCINATION_RETRIES = 3;
         let consecutiveToolFailures = 0;
         const MAX_CONSECUTIVE_TOOL_FAILURES = 5;
+        let auditRetries = 0;
+        const MAX_AUDIT_RETRIES = 3;
+        let emptyResponseRetries = 0;
+        const MAX_EMPTY_RESPONSE_RETRIES = 2;
+        let emptyResponseExhausted = false;
+        let repeatedToolCount = 0;
+        const MAX_REPEATED_TOOL_CALLS = 2;
+        // Account for tool definitions in context budget (they're sent via body.tools, not messages)
+        const allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
+        const toolTokenEstimate = allToolsForBudget.reduce((sum, t) => sum +
+            Math.ceil((t.description.length + JSON.stringify(t.parameters).length) / 4), 0);
+        contextManager.setToolTokens(toolTokenEstimate);
         while (iteration < config.maxToolIterations && !this.shutdownRequested) {
             iteration++;
+            contextManager.noteIteration();
             pluginManager.runOnBeforeThink({
                 iteration,
                 logger,
                 lastUserMessage: input,
                 contextManager,
                 onMeta,
+                sessionLog: {
+                    plan: (event, detail, iter) => slog.logPlan(event, detail, iter),
+                },
             });
             if (contextManager.needsCompaction()) {
                 contextManager.compact();
@@ -132,6 +208,13 @@ export class Agent {
             }
             const currentTokens = contextManager.getEstimatedTokens();
             const budget = contextManager.getBudget();
+            const quality = contextManager.getQuality();
+            if (quality < QUALITY_TRIGGER_THRESHOLD &&
+                contextManager.getCompactionCount() > 0) {
+                contextManager.compact();
+                logger.warn(`Low context quality (${quality}%) — forced compaction`);
+                slog.logCompaction(`quality-triggered compaction (${quality}% < ${QUALITY_TRIGGER_THRESHOLD}%), iteration ${iteration}`, iteration, currentTokens, budget.history);
+            }
             if (currentTokens > budget.history) {
                 contextManager.compact();
                 logger.warn(`Context overflow (${currentTokens} > ${budget.history}), forced compaction`);
@@ -139,8 +222,7 @@ export class Agent {
             }
             this.refreshSystemPrompt();
             const history = contextManager.getActiveHistory();
-            const allTools = toolExecutor.getToolDefinitions(this.deps.toolTags);
-            slog.logToolDefs(allTools.length, allTools.map((t) => t.name), iteration);
+            slog.logToolDefs(allToolsForBudget.length, allToolsForBudget.map((t) => t.name), iteration);
             let textContent = "";
             let reasoningContent = "";
             const toolCalls = [];
@@ -148,8 +230,12 @@ export class Agent {
             let emittedReasoning = false;
             const textChunks = [];
             this.emitPhase(iteration, "thinking", onPhase);
+            const llmStart = Date.now();
+            logger.logLLMRequest(config.model, history.length, input, "agent");
             try {
-                for await (const chunk of llmProvider.chat(history, allTools)) {
+                for await (const chunk of llmProvider.chat(history, allToolsForBudget, this.abortController?.signal)) {
+                    if (this.shutdownRequested)
+                        break;
                     if (chunk.type === "text" && chunk.content) {
                         if (emittedReasoning && !textContent) {
                             onMeta?.("\n\n");
@@ -189,6 +275,11 @@ export class Agent {
                 }
             }
             catch (err) {
+                if (this.shutdownRequested || err?.name === "AbortError") {
+                    logger.info("LLM call aborted (interrupt)");
+                    break;
+                }
+                logger.logLLMResponse(config.model, textContent.length, Date.now() - llmStart, err.message, "agent");
                 logger.error(`LLM call failed: ${err.message}`);
                 slog.logError(err.message);
                 pluginManager.runOnError({ iteration, logger }, err);
@@ -202,10 +293,22 @@ export class Agent {
             finally {
                 this.emitPhase(iteration, "done", onPhase);
             }
-            // Display buffered text only if no tool call in this response.
-            // When a tool call is present, text is just the model describing
-            // its tool call (e.g. raw JSON args) — suppress it.
-            if (!sawToolCall && textChunks.length > 0) {
+            // Track response length so token metrics stay meaningful even when
+            // the backend omits `usage` from the response.
+            apiCompletionChars += (textContent || reasoningContent).length;
+            logger.logLLMResponse(config.model, (textContent || reasoningContent).length, Date.now() - llmStart, undefined, "agent");
+            if (this.shutdownRequested) {
+                break;
+            }
+            // Show the model's commentary text. When a tool call accompanies the
+            // response, keep the text too (opencode-like narration), unless it is
+            // a raw JSON payload that small models sometimes emit instead of
+            // describing the call. `toolComments: false` restores the old behavior
+            // of suppressing text next to a tool call.
+            const toolComments = this.deps.config.ui?.toolComments ?? true;
+            const showText = textChunks.length > 0 &&
+                (!sawToolCall || (toolComments && !isToolCallJson(textContent)));
+            if (showText) {
                 for (const chunk of textChunks) {
                     const textOut = pluginManager.runOnText({ iteration, logger }, chunk);
                     onChunk?.(textOut);
@@ -227,8 +330,19 @@ export class Agent {
                     .map((tc) => `${tc.name}:${JSON.stringify(tc.arguments)}`)
                     .join("|");
                 if (signature && signature === lastToolSignature) {
-                    logger.debug("Exit-on-complete: repeated identical tool call, stopping");
-                    break;
+                    // A repeated identical tool call is often the model re-running
+                    // a command after a confusing result. Give it one more chance
+                    // to produce a final text answer instead of stopping with
+                    // text: "" (observed on 08-r4: bash re-run → empty result).
+                    repeatedToolCount++;
+                    if (repeatedToolCount >= MAX_REPEATED_TOOL_CALLS) {
+                        logger.debug("Exit-on-complete: repeated identical tool call, stopping");
+                        break;
+                    }
+                    contextManager.addMessage({
+                        role: "user",
+                        content: `<system-summary>You just called the same tool with identical arguments. If the task is done, answer with a final text response NOW. If the command failed, try a different approach.</system-summary>`,
+                    });
                 }
                 lastToolSignature = signature;
             }
@@ -260,26 +374,35 @@ export class Agent {
                     pluginManager.runOnToolStart({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments });
                     onTool?.({ type: "start", tool: call.name, args: call.arguments });
                     slog.logToolCall(call, iteration);
-                    const result = await toolExecutor.execute(call);
+                    const tokensBeforeTool = contextManager.getEstimatedTokens();
+                    const result = await toolExecutor.execute(call, this.abortController?.signal);
                     const duration = Date.now() - startTime;
                     if (!result.success)
                         anyToolFailed = true;
+                    if (result.success && call.arguments.path) {
+                        const filePath = String(call.arguments.path);
+                        if (call.name === "write_file" || call.name === "edit_file") {
+                            hallucinationDetector
+                                .getConsistencyCheck()
+                                .trackCreatedFile(filePath);
+                        }
+                        else if (call.name === "delete_file") {
+                            hallucinationDetector
+                                .getConsistencyCheck()
+                                .trackDeletedFile(filePath);
+                        }
+                    }
                     pluginManager.runOnToolEnd({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
                     if (result.display) {
                         onMeta?.("\n" + result.display + "\n");
                     }
-                    const metaOut = pluginManager.runOnMeta({ iteration, logger }, result.output);
-                    onMeta?.("\n" + pc.dim(metaOut) + "\n");
+                    else {
+                        const metaOut = pluginManager.runOnMeta({ iteration, logger }, result.output);
+                        onMeta?.("\n" + pc.dim(metaOut) + "\n");
+                    }
                     if (result.diff) {
                         onMeta?.("\n" + result.diff + "\n");
                     }
-                    onTool?.({
-                        type: "end",
-                        tool: call.name,
-                        args: call.arguments,
-                        duration,
-                        error: !result.success,
-                    });
                     const currentTokens = contextManager.getEstimatedTokens();
                     const budget = contextManager.getBudget();
                     const truncatedOutput = this.truncateToolOutput(result.output, budget, currentTokens);
@@ -288,6 +411,17 @@ export class Agent {
                         content: truncatedOutput,
                         name: call.name,
                         tool_call_id: call.id,
+                        success: result.success,
+                        arguments: call.arguments,
+                    });
+                    const tokensAfterTool = contextManager.getEstimatedTokens();
+                    onTool?.({
+                        type: "end",
+                        tool: call.name,
+                        args: call.arguments,
+                        duration,
+                        error: !result.success,
+                        ctxDelta: tokensAfterTool - tokensBeforeTool,
                     });
                     summaries.push(`[Tool: ${call.name} (${JSON.stringify(call.arguments)}) → ${truncatedOutput.slice(0, 200)}]`);
                     if (config.session.autoSave) {
@@ -305,7 +439,9 @@ export class Agent {
                     consecutiveToolFailures = 0;
                 }
                 if (consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
-                    const recoveryMsg = t("exec.consecutive_failures_recovery", { count: consecutiveToolFailures });
+                    const recoveryMsg = t("exec.consecutive_failures_recovery", {
+                        count: consecutiveToolFailures,
+                    });
                     logger.warn(`Consecutive tool failures: ${consecutiveToolFailures}`);
                     const taskSnippet = input.length > 200 ? input.slice(0, 200) + "..." : input;
                     const taskReminder = t("exec.task_reminder", { task: taskSnippet });
@@ -313,14 +449,44 @@ export class Agent {
                         role: "user",
                         content: `<system-summary>${recoveryMsg}\n${taskReminder}</system-summary>`,
                     });
+                    if (sessionManager) {
+                        const activeSession = sessionManager.getActiveMeta();
+                        if (activeSession) {
+                            const memDir = join(baseDir, ".mma", "memory");
+                            const memStore = new MemoryStore(memDir);
+                            memStore.appendRule("errors", `${consecutiveToolFailures} consecutive tool failures`, "Multiple tools failing suggests environment or configuration issue", "Check dependencies, verify file paths, try write_file directly instead of shell commands");
+                        }
+                    }
                 }
                 contextManager.addMessage({
                     role: "user",
                     content: `<system-summary>${summaries.join("\n")}</system-summary>`,
                 });
+                const ui = this.deps.config.ui;
+                if (ui?.showContextStats) {
+                    const ctxTokens = contextManager.getEstimatedTokens();
+                    const ctxBudget = contextManager.getBudget();
+                    const ctxPct = Math.min(100, Math.round((ctxTokens / ctxBudget.history) * 100));
+                    const barLen = 10;
+                    const filled = Math.round((ctxPct / 100) * barLen);
+                    const ctxBar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
+                    const pctColor = ctxPct >= 75 ? pc.yellow : pc.dim;
+                    const compCount = contextManager.getCompactionCount();
+                    const quality = contextManager.getQuality();
+                    const qualityColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
+                    onMeta?.(`\n  ${ctxBar}  ${pctColor(`${ctxPct}%`)}  ${pc.dim(`ctx: ${ctxTokens}/${ctxBudget.history}`)}  ${pc.dim(`compactions: ${compCount}`)}  ${qualityColor(`quality: ${quality}%`)}\n`);
+                }
+                else if (ui?.showCompaction) {
+                    const compCount = contextManager.getCompactionCount();
+                    if (compCount > this.lastCompactionShown) {
+                        this.lastCompactionShown = compCount;
+                        onMeta?.(pc.dim(`\n  ⟳ Context compacted (${compCount})\n`));
+                    }
+                }
                 continue;
             }
-            const hallucinationResult = hallucinationDetector.validate(textContent);
+            hallucinationDetector.getConfidenceCheck().setPreviousResponse(lastText);
+            const hallucinationResult = await hallucinationDetector.validate(textContent);
             if (hallucinationResult.status === "block") {
                 logger.warn(`Response blocked: ${hallucinationResult.reason}`);
                 return {
@@ -334,17 +500,27 @@ export class Agent {
             }
             if (hallucinationResult.status === "warn") {
                 logger.warn(`Hallucination warning: ${hallucinationResult.reason}`);
-                const warnPrefix = t("hall.uncertainty_prefix");
-                if (onChunk) {
-                    onChunk(warnPrefix);
+                const warnLine = `${t("hall.uncertainty_prefix").trim()} ${hallucinationResult.reason ?? ""}`;
+                if (onMeta) {
+                    onMeta(`\n${pc.yellow(warnLine)}\n`);
+                }
+                else if (onChunk) {
+                    onChunk(`\n${warnLine}\n`);
                 }
-                lastText = warnPrefix + lastText;
             }
             if (hallucinationResult.status === "retry") {
-                if (this.deps.exitOnComplete) {
+                if (this.deps.exitOnComplete && textContent?.trim()) {
                     logger.debug("Exit-on-complete: stopping on first response");
+                    // Save the response BEFORE breaking — lastText is still the
+                    // previous (tool-only) iteration's text, so without this the
+                    // final answer is lost (reported text: "").
+                    lastText = textContent;
                     break;
                 }
+                // NOTE: with exitOnComplete and an EMPTY text we deliberately do NOT
+                // break — the model produced no usable answer yet (same case as the
+                // empty-response guard below). Falling through to the retry path
+                // keeps us from finishing with text: "".
                 if (hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
                     logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
                     return {
@@ -372,11 +548,40 @@ export class Agent {
             }
             if (textContent) {
                 contextManager.addMessage({ role: "assistant", content: textContent });
-                slog.saveAssistantMessage(textContent);
+                if (config.session.autoSave) {
+                    slog.saveAssistantMessage(textContent);
+                }
                 slog.logAssistant(textContent, reasoningContent, undefined, iteration);
             }
             lastText = textContent;
+            {
+                const decisionPatterns = [
+                    ...textContent.matchAll(/(?:plan|decided|decision|решено|план|решение):\s*(.+?)(?:\n|$)/gi),
+                ];
+                for (const match of decisionPatterns) {
+                    hallucinationDetector
+                        .getConsistencyCheck()
+                        .trackDecision(match[1].trim(), "agent_response");
+                }
+            }
             if (!sawToolCall) {
+                // Guard: the model returned an EMPTY final response (no text, no
+                // tool calls — often just reasoning content after context
+                // compaction). Nudge it to produce a real answer instead of
+                // silently finishing with text: "".
+                if (!textContent?.trim()) {
+                    if (emptyResponseRetries < MAX_EMPTY_RESPONSE_RETRIES) {
+                        emptyResponseRetries++;
+                        logger.warn(`Empty response on iteration ${iteration} (retry ${emptyResponseRetries}/${MAX_EMPTY_RESPONSE_RETRIES})`);
+                        contextManager.addMessage({
+                            role: "user",
+                            content: `<system-summary>Your previous response was empty. Answer the user's task now with a final text response or call a tool. Do not reply with reasoning only.</system-summary>`,
+                        });
+                        continue;
+                    }
+                    emptyResponseExhausted = true;
+                    logger.warn(`Empty response retries exhausted after ${MAX_EMPTY_RESPONSE_RETRIES} attempts`);
+                }
                 if (this.deps.finalAudit) {
                     const audit = await this.deps.finalAudit();
                     if (audit && !audit.passed) {
@@ -390,7 +595,10 @@ export class Agent {
                             })}</system-summary>`,
                         });
                         slog.logAudit(audit.summary, iteration);
-                        if (iteration >= config.maxToolIterations - 1) {
+                        auditRetries++;
+                        if (auditRetries >= MAX_AUDIT_RETRIES ||
+                            iteration >= config.maxToolIterations - 1) {
+                            logger.warn(`Final audit still incomplete after ${auditRetries} retries — finishing anyway`);
                             break;
                         }
                         continue;
@@ -401,6 +609,7 @@ export class Agent {
         }
         const tokensUsed = contextManager.getEstimatedTokens();
         const budget = contextManager.getBudget();
+        const usageTokens = this.resolveUsageTokens(apiPromptTokens, apiCompletionTokens, tokensUsed, apiCompletionChars);
         if (iteration >= config.maxToolIterations) {
             return {
                 success: false,
@@ -409,26 +618,49 @@ export class Agent {
                 iterationCount: iteration,
                 contextUsed: tokensUsed,
                 contextLimit: budget.history,
-                promptTokens: apiPromptTokens,
-                completionTokens: apiCompletionTokens,
-                totalTokens: apiPromptTokens + apiCompletionTokens,
+                promptTokens: usageTokens.prompt,
+                completionTokens: usageTokens.completion,
+                totalTokens: usageTokens.total,
+                compactionCount: contextManager.getCompactionCount(),
+                contextQuality: contextManager.getQuality(),
             };
         }
         return {
-            success: true,
+            success: emptyResponseExhausted ? false : true,
             text: lastText,
+            error: emptyResponseExhausted ? t("error.empty_response") : undefined,
             iterationCount: iteration,
             contextUsed: tokensUsed,
             contextLimit: budget.history,
-            promptTokens: apiPromptTokens,
-            completionTokens: apiCompletionTokens,
-            totalTokens: apiPromptTokens + apiCompletionTokens,
+            promptTokens: usageTokens.prompt,
+            completionTokens: usageTokens.completion,
+            totalTokens: usageTokens.total,
+            compactionCount: contextManager.getCompactionCount(),
+            contextQuality: contextManager.getQuality(),
         };
     }
     clearContext() {
         this.deps.contextManager.clear();
         this.systemPromptAdded = false;
     }
+    async reconfigure(config) {
+        const { OpenAICompatProvider } = await import("../llm/openai-compat");
+        const { TokenCounter } = await import("../llm/token-counter");
+        const newProvider = new OpenAICompatProvider({
+            model: config.model,
+            baseUrl: config.provider.baseUrl,
+            apiKey: config.provider.apiKey,
+            contextWindow: config.contextWindow,
+            retry: config.retry,
+            rateLimits: config.security?.rateLimits,
+        });
+        this.deps.llmProvider = newProvider;
+        this.deps.toolExecutor.updateProvider(newProvider);
+        this.deps.toolExecutor.ctx.llmProvider = newProvider;
+        const newTokenCounter = new TokenCounter(config.model);
+        this.deps.contextManager.resize(config.contextWindow, config.contextBudget, newTokenCounter);
+        this.deps.config = config;
+    }
     setContext(messages) {
         const { contextManager } = this.deps;
         contextManager.clear();
@@ -447,12 +679,14 @@ export class Agent {
     }
     shutdown() {
         this.shutdownRequested = true;
+        this.abortController?.abort();
         const { pluginManager, logger, sessionManager, contextManager } = this.deps;
         contextManager.onCompact = null;
         const killed = processRegistry.killAll();
         if (killed > 0) {
             logger.info(`Killed ${killed} background process(es) on shutdown`);
         }
+        logger.closeSessionLog();
         pluginManager.runOnSessionEnd({
             logger,
             sessionManager: sessionManager?.getActiveMeta(),