micro-models-agent 0.51.1 → 0.52.0

package/dist/core/agent.js

@@ -1,10 +1,11 @@
+import { ProviderManager } from "../modules/providers/manager";
 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 { StepVerifier } from "../modules/execution/verifier";
+import { CostTracker } from "../modules/pricing/index";
 const TOOL_RESULT_MAX_TOKENS_RATIO = 0.3;
 const TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
 const QUALITY_TRIGGER_THRESHOLD = 40;
@@ -13,6 +14,7 @@ const QUALITY_TRIGGER_THRESHOLD = 40;
  * (observed: 56 compactions in ~28 min) and the compaction itself can't
  * restore quality, so the agent burns the whole budget compacting. */
 const FORCED_COMPACTION_COOLDOWN = 3;
+const MAX_LLM_ERROR_RETRIES = 2;
 /** True when the text looks like a raw JSON tool payload (garbage to display). */
 function isToolCallJson(text) {
     const trimmed = text.trim();
@@ -46,13 +48,25 @@ export class Agent {
     shutdownRequested = false;
     abortController = null;
     lastCompactionShown = 0;
+    costTracker;
     constructor(deps) {
         this.deps = deps;
+        this.costTracker = new CostTracker(deps.config.model, deps.config.pricing);
     }
     /** Expose context manager for REPL image attachment and other direct access. */
     get contextManager() {
         return this.deps.contextManager;
     }
+    callerProvenance() {
+        return {
+            provider: this.deps.config.provider?.type || "unknown",
+            model: this.deps.config.model,
+        };
+    }
+    /** Typed module accessor for CLI/REPL commands (e.g. /lsp). */
+    getModule(name) {
+        return this.deps.moduleRegistry?.get(name);
+    }
     setScope() {
         if (this.deps.scope) {
             this.deps.toolExecutor.setScope(this.deps.scope);
@@ -168,15 +182,25 @@ export class Agent {
         onPhase?.(phase);
     }
     async run(input, onChunk, onMeta, onTool, onPhase) {
+        // Reset shutdown flag from previous interrupt
+        this.shutdownRequested = false;
         this.setScope();
         const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, baseDir, } = this.deps;
-        const slog = new SessionLogger(sessionManager, logger);
+        const slog = new SessionLogger(sessionManager, logger, () => this.callerProvenance());
         if (sessionManager && !sessionManager.getActive()) {
             sessionManager.create();
             logger.debug(`Session started: ${sessionManager.getActive()}`);
         }
         if (!this.systemPromptAdded &&
             !contextManager.getActiveHistory().some((m) => m.role === "system")) {
+            // Log session startup diagnostics (environment, plugins, skills) as the
+            // first entry in session.jsonl so the file is self-describing for
+            // post-mortem analysis. LSP probe is logged separately from repl.ts
+            // since it may complete after this point. Dedup: logSessionStart
+            // checks for existing session_start entry to avoid double-logging.
+            slog.logSessionStart({
+                environment: this.deps.envReport,
+            });
             const lazy = this.deps.lazyPromptBlocks ? await this.deps.lazyPromptBlocks() : [];
             if (lazy.length > 0) {
                 this.deps.promptBlocks.push(...lazy);
@@ -193,18 +217,6 @@ export class Agent {
                 sessionManager: sessionManager?.getActiveMeta(),
                 contextManager,
             });
-            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(() => { });
-            }
         }
         // A new user message starts a fresh compaction interval — iterations
         // from the previous turn must not trigger a compaction on iteration 1
@@ -215,20 +227,50 @@ export class Agent {
         }
         contextManager.addMessage({ role: "user", content: input });
         slog.logUser(input);
-        if (config.moe?.enabled) {
-            return runWithMoE({
-                config,
-                llmProvider,
-                toolExecutor,
+        // Turn lifecycle for plugins: count tool events without touching the loop,
+        // and dispatch onTurnEnd exactly once — success, error or interrupt.
+        const startedAt = Date.now();
+        let toolCalls = 0;
+        const countTool = (ev) => {
+            if (ev.type === "end")
+                toolCalls++;
+            onTool?.(ev);
+        };
+        const emitTurnEnd = (result, err) => {
+            const interrupted = (err instanceof Error && err.name === "AbortError") || this.shutdownRequested;
+            pluginManager.runOnTurnEnd?.({
                 logger,
-                baseDir: this.deps.baseDir,
-            }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase), { onMeta, onTool, onPhase });
+                sessionManager: sessionManager?.getActiveMeta(),
+                contextManager,
+            }, {
+                success: !!result && result.success !== false && !err,
+                durationMs: Date.now() - startedAt,
+                textLength: (result?.text || "").length,
+                toolCalls,
+                interrupted: interrupted || undefined,
+            });
+        };
+        try {
+            const result = config.moe?.enabled === true
+                ? await runWithMoE({
+                    config,
+                    llmProvider,
+                    toolExecutor,
+                    logger,
+                    baseDir: this.deps.baseDir,
+                }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase), { onMeta, onTool: countTool, onPhase })
+                : await this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase);
+            emitTurnEnd(result);
+            return result;
+        }
+        catch (err) {
+            emitTurnEnd(null, err);
+            throw err;
         }
-        return this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase);
     }
     async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
         const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, baseDir, } = this.deps;
-        const slog = new SessionLogger(sessionManager, logger);
+        const slog = new SessionLogger(sessionManager, logger, () => this.callerProvenance());
         this.abortController = new AbortController();
         let iteration = 0;
         let lastText = "";
@@ -263,6 +305,7 @@ export class Agent {
         let suppressRepetitionRetry = false;
         let repeatedToolCount = 0;
         const MAX_REPEATED_TOOL_CALLS = 2;
+        let llmErrorRetries = 0;
         // Account for tool definitions in context budget (they're sent via body.tools, not messages)
         // Tool definitions are recomputed each iteration so `enable_tools`
         // (which mutates the shared activeToolTags array) can grow the
@@ -295,6 +338,8 @@ export class Agent {
                 if (result) {
                     logger.debug("Context compacted");
                     slog.logCompaction({ reason: "interval", iteration, ...result });
+                    // Seed hallucination checker with files from compaction summary
+                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
                 }
             }
             const currentTokens = contextManager.getEstimatedTokens();
@@ -312,6 +357,7 @@ export class Agent {
                         iteration,
                         ...result,
                     });
+                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
                 }
             }
             if (currentTokens > budget.history) {
@@ -323,6 +369,7 @@ export class Agent {
                         iteration,
                         ...result,
                     });
+                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
                 }
             }
             this.refreshSystemPrompt();
@@ -393,6 +440,21 @@ export class Agent {
                     logger.info("LLM call aborted (interrupt)");
                     break;
                 }
+                // Recoverable LLM errors (e.g. the completion hit the token limit
+                // mid-tool_call): feed the localized reason back into context so the
+                // model can adapt (split the write into smaller chunks) instead of
+                // the whole session dying. Bounded to avoid infinite loops.
+                if (err?.recoverableLlm && llmErrorRetries < MAX_LLM_ERROR_RETRIES) {
+                    llmErrorRetries++;
+                    logger.warn(`Recoverable LLM error, feeding back (${llmErrorRetries}/${MAX_LLM_ERROR_RETRIES}): ${err.message}`);
+                    slog.logError(err.message);
+                    pluginManager.runOnError({ iteration, logger, contextManager }, err);
+                    contextManager.addMessage({
+                        role: "user",
+                        content: `<system-summary>${err.message}</system-summary>`,
+                    });
+                    continue;
+                }
                 logger.logLLMResponse(config.model, textContent.length, Date.now() - llmStart, err.message, "agent");
                 logger.error(`LLM call failed: ${err.message}`);
                 slog.logError(err.message);
@@ -430,6 +492,7 @@ export class Agent {
                     source,
                     durationMs: Date.now() - llmStart,
                 });
+                this.costTracker.record(prompt, completion, this.callerProvenance().provider);
             }
             if (this.shutdownRequested) {
                 break;
@@ -497,6 +560,10 @@ export class Agent {
                 });
                 const summaries = [];
                 let anyToolFailed = false;
+                // Informational read-only tools whose "failure" is expected behavior
+                // (e.g. file_info "Not found" after delete_file) — excluded from
+                // per-tool failure counting and consecutive failure tracking.
+                const infoTools = new Set(["file_info"]);
                 for (const call of toolCalls) {
                     this.setScope();
                     const startTime = Date.now();
@@ -505,12 +572,19 @@ export class Agent {
                         args: call.arguments,
                     });
                     pluginManager.runOnToolStart({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments });
-                    onTool?.({ type: "start", tool: call.name, args: call.arguments });
+                    const toolIcon = this.deps.toolExecutor.getRegistry().get(call.name)?.icon;
+                    onTool?.({ type: "start", tool: call.name, args: call.arguments, icon: toolIcon });
                     slog.logToolCall(call, iteration);
                     const tokensBeforeTool = contextManager.getEstimatedTokens();
                     const result = await toolExecutor.execute(call, this.abortController?.signal);
+                    // Interrupt during the tool call: the session is already shutting
+                    // down (Esc/Ctrl+C), so stop immediately — no rendering, no session
+                    // log writes, no context update for a result nobody will see. This
+                    // fixes the "Replaced in ..." lines appearing AFTER "Session ended".
+                    if (this.shutdownRequested)
+                        break;
                     const duration = Date.now() - startTime;
-                    if (!result.success)
+                    if (!result.success && !infoTools.has(call.name))
                         anyToolFailed = true;
                     if (result.success && call.arguments.path) {
                         const filePath = String(call.arguments.path);
@@ -522,8 +596,14 @@ export class Agent {
                         }
                     }
                     pluginManager.runOnToolEnd({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
-                    if (result.display) {
-                        onMeta?.("\n" + result.display + "\n");
+                    // Presence check, not truthiness: read_file returns display ""
+                    // on a full read to suppress output entirely (the tool header
+                    // already shows the path) — falling back on empty string would
+                    // dump the whole file content into the REPL.
+                    if (result.display !== undefined) {
+                        if (result.display.length > 0) {
+                            onMeta?.("\n" + result.display + "\n");
+                        }
                     }
                     else {
                         const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
@@ -551,6 +631,7 @@ export class Agent {
                         duration,
                         error: !result.success,
                         ctxDelta: tokensAfterTool - tokensBeforeTool,
+                        costUsd: this.costTracker.total,
                     });
                     summaries.push(`[Tool: ${call.name} (${JSON.stringify(call.arguments)}) → ${truncatedOutput.slice(0, 200)}]`);
                     if (config.session.autoSave) {
@@ -565,6 +646,7 @@ export class Agent {
                                 iteration,
                                 ...result,
                             });
+                            hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
                         }
                     }
                     // Track per-tool failure counts (NOT just consecutive) so a tool
@@ -572,7 +654,7 @@ export class Agent {
                     // is still learned from (observed: LSP spawn npx ENOENT failed
                     // 8x in one session, never consecutively, so it never reached
                     // memory via the 5-consecutive-failures path).
-                    if (!result.success) {
+                    if (!result.success && !infoTools.has(call.name)) {
                         const key = call.name;
                         const prev = toolFailureCounts.get(key) ?? { count: 0, error: "" };
                         prev.count++;
@@ -588,6 +670,8 @@ export class Agent {
                         }
                     }
                 }
+                if (this.shutdownRequested)
+                    break;
                 if (anyToolFailed) {
                     consecutiveToolFailures++;
                 }
@@ -807,6 +891,8 @@ export class Agent {
                 promptTokens: usageTokens.prompt,
                 completionTokens: usageTokens.completion,
                 totalTokens: usageTokens.total,
+                totalCost: this.costTracker.total,
+                costBreakdown: this.costTracker.breakdown(),
                 compactionCount: contextManager.getCompactionCount(),
                 contextQuality: contextManager.getQuality(),
             };
@@ -825,6 +911,8 @@ export class Agent {
             promptTokens: usageTokens.prompt,
             completionTokens: usageTokens.completion,
             totalTokens: usageTokens.total,
+            totalCost: this.costTracker.total,
+            costBreakdown: this.costTracker.breakdown(),
             compactionCount: contextManager.getCompactionCount(),
             contextQuality: contextManager.getQuality(),
         };
@@ -843,13 +931,56 @@ export class Agent {
             contextWindow: config.contextWindow,
             retry: config.retry,
             rateLimits: config.security?.rateLimits,
+            maxCompletionTokens: config.provider.entries?.find((e) => e.label === config.provider.active)?.maxCompletionTokens ??
+                config.provider.maxCompletionTokens,
         });
         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;
+        this.costTracker.setModel(config.model);
+    }
+    setProvider(name, model) {
+        const manager = new ProviderManager(this.deps.config.provider, {
+            contextWindow: this.deps.config.contextWindow,
+            retry: this.deps.config.retry,
+            rateLimits: this.deps.config.security?.rateLimits,
+        });
+        manager.switch(name, model);
+        const providerCfg = manager.toConfig();
+        this.deps.config.provider = providerCfg;
+        this.deps.llmProvider = manager.active;
+        this.deps.toolExecutor.updateProvider(manager.active);
+        this.deps.toolExecutor.ctx.llmProvider = manager.active;
+    }
+    listProviders() {
+        const manager = new ProviderManager(this.deps.config.provider, {
+            contextWindow: this.deps.config.contextWindow,
+            retry: this.deps.config.retry,
+            rateLimits: this.deps.config.security?.rateLimits,
+        });
+        const activeName = this.deps.config.provider.active;
+        return manager.list().map((e) => ({
+            ...e,
+            active: e.label === activeName || e.type === activeName,
+        }));
+    }
+    /** Build (or get cached) the provider for a named entry — health checks, routing. */
+    getProviderFor(name) {
+        try {
+            const manager = new ProviderManager(this.deps.config.provider, {
+                contextWindow: this.deps.config.contextWindow,
+                retry: this.deps.config.retry,
+                rateLimits: this.deps.config.security?.rateLimits,
+            });
+            manager.setModel(this.deps.config.model);
+            manager.switch(name);
+            return manager.active;
+        }
+        catch {
+            return undefined;
+        }
     }
     setContext(messages) {
         const { contextManager } = this.deps;
@@ -876,7 +1007,8 @@ export class Agent {
         if (killed > 0) {
             logger.info(`Killed ${killed} background process(es) on shutdown`);
         }
-        logger.closeSessionLog();
+        // Note: do NOT close session log here — the session is still active.
+        // Session log is closed only when the session actually ends (exit, session delete).
         pluginManager.runOnSessionEnd({
             logger,
             sessionManager: sessionManager?.getActiveMeta(),

package/dist/core/bootstrap.js

@@ -1,6 +1,7 @@
 import { loadConfig } from "../config/config";
 import { Logger } from "../logger/app-logger";
-import { OpenAICompatProvider } from "../llm/openai-compat";
+import { ProviderManager } from "../modules/providers/index";
+import { FallbackProvider } from "../modules/providers/fallback";
 import { ModelLoader } from "../llm/model-loader";
 import { ToolRegistry, registerAllTools } from "../tools/index";
 import { buildHiddenToolsBlock } from "../tools/hidden-tools-block";
@@ -18,7 +19,7 @@ import { SessionStore, SessionManager, SessionModule } from "../modules/session/
 import { UserProfile } from "../modules/user-profile/profile";
 import { SkillsLoader, SkillsModule } from "../modules/skills/index";
 import { BrowserModule } from "../modules/browser/index";
-import { LspModule, DEFAULT_LSP_CONFIG } from "../modules/lsp/index";
+import { LspModule, FileOnlyLogger, DEFAULT_LSP_CONFIG } from "../modules/lsp/index";
 import { runStartupHealthCheck } from "../modules/lsp/startup-check";
 import { IndexerModule } from "../modules/indexer/index";
 import { MCPModule } from "../modules/mcp/index";
@@ -30,6 +31,7 @@ import { homedir } from "os";
 import { join, resolve } from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { readMmaVersion } from "./version";
+import { collectEnvironment, logEnvironment } from "./environment";
 export function buildSystemInfo(config, baseDir, profileCompressed) {
     const now = new Date().toISOString().replace("T", " ").slice(0, 19);
     const isWin = profileCompressed.toLowerCase().includes("win32");
@@ -37,6 +39,8 @@ export function buildSystemInfo(config, baseDir, profileCompressed) {
         `You are MMA v2, an AI coding agent for small models (${config.model}). Date: ${now}. Workspace: ${baseDir}. ${profileCompressed}.`,
         `Reply in the user's language. Use tools for file ops (read/write/edit/delete), search (glob/grep), shell (bash), web, subagents, browser, MCP. Explain briefly if not obvious. On tool failure: analyze, fix the call, retry up to 2x with different approaches, then ask the user.`,
         `Design: YAGNI (no unneeded code), KISS (simple over clever), DRY (reuse existing utilities).`,
+        `SCOPE DISCIPLINE: do ONLY what the user explicitly asked — no extra features, files, refactors, "improvements", or fixes beyond the request. Read-only requests ("расскажи", "покажи", "объясни", "check") mean READ-ONLY: inspect and answer, never create/modify/delete anything. If the task is ambiguous (what to create, where, which variant) or the request implies action on something you could not find — STOP and ask the user a short clarifying question in plain text instead of guessing.`,
+        `NOT FOUND ≠ MISSING PROJECT: a "not found" tool result means the PATH was wrong (typo, different location), not that the project does not exist. Before creating or scaffolding ANY project/files: first run list_dir on the working directory to see what is already there; if a user-named path is not found, list its parent directory to locate the real path. NEVER create a new project when the user asked about an existing one — inspect first, create only after confirming the workspace is empty AND the user asked for creation.`,
     ];
     if (isWin) {
         lines.push(`Windows (PowerShell): use list_dir/read_file/delete_file/create_dir tools instead of dir/type/del/mkdir. No PowerShell cmdlets (Get-Content, Select-Object, Write-Output), no head/tail/grep/cat. Use forward slashes in paths. CWD: ${baseDir}`);
@@ -59,6 +63,35 @@ export function buildSystemInfo(config, baseDir, profileCompressed) {
     // postcss after the fix was on disk, while a fresh server on 5177 was
     // clean) — the fix is only real when the USER's running server is clean.
     lines.push(`Runtime verification: when a bug is described in terms of runtime behavior (what happens when the app runs), reproduce it — run the app / build / browser tool — and confirm the fix against actual runtime output before calling "plan update step=N status=done". Check existing servers first with process_list/process_log: a stale dev server started BEFORE your change still runs the old pipeline and keeps failing even after the files on disk are fixed. Restart or kill it (process_kill) and verify the exact endpoint/port the user reported — a fresh server on a new port does NOT prove the user's error is gone.`);
+    // Security rules: when security is enabled the model should know the
+    // restrictions up front — a blocked call costs an iteration, while this
+    // block costs ~100 tokens once. Kept compact and capped so a long user
+    // blacklist cannot blow the system budget.
+    const sec = config.security;
+    if (sec?.enabled) {
+        const secLines = [`SECURITY RESTRICTIONS (enforced — blocked calls return "[SECURITY BLOCKED]", do not retry them):`];
+        if (sec.bash?.enabled && sec.bash.blacklist.length > 0) {
+            const cmds = sec.bash.blacklist.slice(0, 15).join(", ");
+            secLines.push(`Forbidden bash commands: ${cmds}${sec.bash.blacklist.length > 15 ? ", …" : ""}.`);
+            if (sec.bash.whitelist.length > 0) {
+                secLines.push(`Only whitelisted bash commands are allowed: ${sec.bash.whitelist.slice(0, 15).join(", ")}.`);
+            }
+            if (sec.bash.blockDangerousFlags) {
+                secLines.push(`Pipes/redirects/chaining (| > >> ; &&) in bash are blocked — one plain command per call.`);
+            }
+        }
+        if (sec.paths?.enabled && sec.paths.denied.length > 0) {
+            const paths = sec.paths.denied.slice(0, 10).join(", ");
+            secLines.push(`Denied paths (read/write): ${paths}${sec.paths.denied.length > 10 ? ", …" : ""}.`);
+        }
+        if (sec.network?.enabled && sec.network.deniedDomains.length > 0) {
+            const domains = sec.network.deniedDomains.slice(0, 10).join(", ");
+            secLines.push(`Denied network domains: ${domains}${sec.network.deniedDomains.length > 10 ? ", …" : ""}.`);
+        }
+        if (secLines.length > 1) {
+            lines.push(...secLines);
+        }
+    }
     const hasMCP = config.mcpServers && Object.values(config.mcpServers).some((s) => s.enabled !== false);
     if (hasMCP) {
         lines.push(`MCP servers are available — use the named MCP tools (prefixed mcp__) to query external services.`);
@@ -66,9 +99,9 @@ export function buildSystemInfo(config, baseDir, profileCompressed) {
     return lines.join("\n");
 }
 export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
-    const dir = configDir || join(homedir(), ".mma");
+    const dir = configDir || process.env.MMA_CONFIG_DIR || join(homedir(), ".mma");
     const projectConfigPath = projectDir ? join(projectDir, ".mmrc") : join(process.cwd(), ".mmrc");
-    const config = loadConfig({ configDir: dir, projectConfigPath });
+    const { config, legacyDetected } = loadConfig({ configDir: dir, projectConfigPath });
     setLocale(config.locale);
     // Update global audit notifier with config
     try {
@@ -108,15 +141,36 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     const profile = new UserProfile(join(dir));
     profile.load() || profile.collect();
     profile.save();
-    const llmProvider = new OpenAICompatProvider({
-        model: config.model,
-        baseUrl: config.provider.baseUrl,
-        apiKey: config.provider.apiKey,
+    // Multi-provider manager (Phase 2). Built from the (possibly legacy flat)
+    // config; the active provider is resolved through it. The initial provider
+    // comes from the manager so the active entry is honored on startup.
+    const providerManager = new ProviderManager(config.provider, {
         contextWindow: config.contextWindow,
         retry: config.retry,
         rateLimits: config.security?.rateLimits,
     });
+    providerManager.setModel(config.model);
+    let llmProvider = providerManager.active;
+    // Phase 4.2: transparent failover to the next configured provider on
+    // 429/5xx/network errors (only with multiple entries + fallback: true).
+    if (config.provider.fallback && providerManager.listNames().length > 1) {
+        llmProvider = new FallbackProvider(providerManager, (from, to, error) => {
+            logger.warn(`provider failover: ${from} -> ${to} (${error.message.slice(0, 120)})`);
+        });
+    }
     const baseDir = projectDir ? resolve(projectDir) : process.cwd();
+    // Cross-device diagnosis: log a full environment report (OS, runtime,
+    // engines, PATH tools, provider/retry, playwright) at every startup.
+    const envReport = collectEnvironment({
+        configDir: dir,
+        baseDir,
+        config,
+        scanTools: process.env.NODE_ENV !== "test",
+    });
+    logEnvironment(envReport, logger);
+    for (const warning of envReport.warnings) {
+        logger.warn(warning);
+    }
     const projectMapCacheDir = join(baseDir, ".mma");
     const indexerModule = new IndexerModule({
         baseDir,
@@ -184,8 +238,6 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         exitOnComplete,
         contextManager,
         activeToolTags,
-        sessionId: sessionManager.getActiveMeta()?.id,
-        sessionContext: sessionManager.getSessionContext() ?? undefined,
         recursionDepth: 0,
         fileOperationsCount: 0,
         sessionHistory: {
@@ -213,17 +265,35 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             },
         },
     };
+    // `sessionId`/`sessionContext` are exposed as LIVE getters over the session
+    // manager instead of being captured once at bootstrap. Capturing the values
+    // pinned them to the session active at startup, so after a REPL /new or
+    // /resume the new session's audit.jsonl entries were tagged with the
+    // PREVIOUS session's id (observed: ses_msyghz8w audit entries carrying
+    // ses_msyg892p_78kqhc) while sessionHistory kept reading the live meta.
+    // Everything that consumes ctx.sessionId — audit log, process registry,
+    // file-ops counters — now always sees the session that is actually active.
+    Object.defineProperty(toolCtx, "sessionId", {
+        get: () => sessionManager.getActiveMeta()?.id,
+        configurable: true,
+    });
+    Object.defineProperty(toolCtx, "sessionContext", {
+        get: () => sessionManager.getSessionContext() ?? undefined,
+        configurable: true,
+    });
     const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
     toolCtx.llmProvider = llmProvider;
     toolCtx.toolExecutor = toolExecutor;
     const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider);
     const moduleRegistry = new ModuleRegistry();
-    const execModule = new ExecutionModule(baseDir, config.stuckThreshold);
-    const activeMeta = sessionManager.getActiveMeta();
-    if (activeMeta && activeMeta.messageCount > 0) {
-        execModule.restorePlan();
-    }
+    const execModule = new ExecutionModule(baseDir, config.stuckThreshold, config.errorWebSearch?.threshold ?? 5);
+    // A plan in .mma/plans/active.json is PROJECT state, not session state —
+    // restore it in every session so `plan show` works and the checklist is
+    // visible. Nothing is printed unprompted: the REPL renders the checklist
+    // only on plan/todo tool events.
+    execModule.restorePlan();
     moduleRegistry.register(execModule);
+    execModule.setHallucinationDetector(hallucinationDetector);
     const sessionModule = new SessionModule(sessionManager);
     moduleRegistry.register(sessionModule);
     moduleRegistry.register(indexerModule);
@@ -242,7 +312,8 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             pluginManager.register(browserPlugin);
         }
     }
-    const lspModule = new LspModule(config.lsp);
+    const lspLogger = new FileOnlyLogger(logger);
+    const lspModule = new LspModule(config.lsp, undefined, lspLogger);
     moduleRegistry.register(lspModule);
     const lspPlugin = lspModule.getPlugin();
     if (lspPlugin) {
@@ -257,7 +328,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     // the time the user types in the interactive REPL).
     let startupCheckBlock = null;
     const startupCheckPromise = !exitOnComplete && process.env.NODE_ENV !== "test"
-        ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir)
+        ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir, { logger: lspLogger })
         : Promise.resolve(null);
     const moduleTools = moduleRegistry.collectToolDefinitions();
     for (const tool of moduleTools) {
@@ -356,6 +427,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         baseDir,
         toolTags: activeToolTags,
         promptBlocks,
+        envReport,
         getDynamicPromptBlocks: () => {
             const blocks = [];
             const planBlock = execModule.getSystemPromptBlock();
@@ -387,6 +459,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         },
         sessionManager,
         memoryStore,
+        moduleRegistry,
         exitOnComplete,
     };
     const agent = new Agent(agentDeps);
@@ -397,8 +470,12 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         sessionManager,
         skillsModule,
         pluginManager,
+        execModule,
+        toolCtx,
         configDir: dir,
         baseDir,
         noAgentsMd: skipAgentsMd,
+        envReport,
+        legacyDetected,
     };
 }

package/dist/core/crash-handler.js

@@ -0,0 +1,51 @@
+import { appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { collectEnvironment } from "./environment";
+import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
+import { t } from "../i18n/index";
+export const CRASH_LOG_DIR = join(homedir(), ".mma", "logs");
+export const CRASH_LOG_FILE = "crash.jsonl";
+/** Build a sanitized crash entry. Environment is captured at crash time (no tool scan). */
+export function formatCrashEntry(type, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error && err.stack ? err.stack : message;
+    return {
+        ts: new Date().toISOString(),
+        type,
+        message: sanitizeLogMessage(message),
+        stack: sanitizeLogMessage(stack),
+        environment: collectEnvironment({ configDir: homedir(), scanTools: false }),
+    };
+}
+export function writeCrashEntry(dir, entry) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        appendFileSync(join(dir, CRASH_LOG_FILE), JSON.stringify(entry) + "\n", "utf-8");
+    }
+    catch {
+        // Best effort — never crash while reporting a crash
+    }
+}
+let installed = false;
+/**
+ * Global crash handlers. uncaughtException is logged + re-raised (exit 1 so the
+ * process never continues in a broken state); unhandledRejection is logged only
+ * (the event loop keeps running). Entries land in ~/.mma/logs/crash.jsonl.
+ */
+export function installCrashHandlers() {
+    if (installed)
+        return;
+    installed = true;
+    process.on("uncaughtException", (err) => {
+        const entry = formatCrashEntry("uncaughtException", err);
+        writeCrashEntry(CRASH_LOG_DIR, entry);
+        process.stderr.write(`${t("env.crash_stderr", { type: entry.type, message: entry.message })}\n`);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        const entry = formatCrashEntry("unhandledRejection", reason);
+        writeCrashEntry(CRASH_LOG_DIR, entry);
+        process.stderr.write(`${t("env.crash_stderr", { type: entry.type, message: entry.message })}\n`);
+    });
+}