micro-models-agent 0.63.0 → 1.1.0

package/dist/core/bootstrap.js

@@ -1,7 +1,7 @@
 import { loadConfig } from "../config/config";
 import { Logger } from "../logger/app-logger";
-import { ProviderManager } from "../modules/providers/index";
-import { FallbackProvider } from "../modules/providers/fallback";
+import { buildActiveProvider } from "../modules/providers/factory";
+import { BUILTIN_PROVIDERS } from "../modules/providers/presets";
 import { ModelLoader } from "../llm/model-loader";
 import { ToolRegistry, registerAllTools } from "../tools/index";
 import { buildHiddenToolsBlock } from "../tools/hidden-tools-block";
@@ -12,7 +12,7 @@ import { PluginLoader } from "../modules/plugins/loader";
 import { plugin as lintOnWritePlugin } from "../modules/plugins/builtin/lint-on-write";
 import { plugin as notifyPlugin } from "../modules/plugins/builtin/notify";
 import { ContextManager } from "../modules/context/manager";
-import { TokenCounter } from "../llm/token-counter";
+import { TokenCounter, estimateTokens } from "../llm/token-counter";
 import { HallucinationDetector } from "../modules/hallucination/detector";
 import { ExecutionModule } from "../modules/execution/module";
 import { SessionStore, SessionManager, SessionModule } from "../modules/session/index";
@@ -25,13 +25,85 @@ import { IndexerModule } from "../modules/indexer/index";
 import { MCPModule } from "../modules/mcp/index";
 import { MemoryModule } from "../modules/memory/module";
 import { MemoryStore } from "../modules/memory/store";
-import { setLocale } from "../i18n/index";
+import { t, setLocale } from "../i18n/index";
 import { Agent } from "./agent";
 import { homedir } from "os";
 import { join, resolve } from "path";
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { readMmaVersion } from "./version";
 import { collectEnvironment, logEnvironment } from "./environment";
+import { dryRunOverflow, overflowHint } from "./prompt-overflow";
+import { getLoadedContextLength } from "../llm/model-loader";
+/**
+ * CLI --reasoning переопределяет конфигурационный режим
+ * (приоритет: CLI > config > default). "auto" пропускается — полагаемся
+ * на конфиг. Строка CLI приводится к типизированному ReasoningLevel.
+ */
+export function applyReasoningCliOverride(config, reasoningLevel) {
+    if (!reasoningLevel || reasoningLevel === "auto")
+        return;
+    if (!config.reasoning) {
+        config.reasoning = {
+            mode: reasoningLevel,
+            min: "low",
+            max: "high",
+            overrideCooldown: 3,
+        };
+    }
+    else {
+        config.reasoning.mode = reasoningLevel;
+    }
+}
+/** Регистрация встроенного плагина модуля: пометка + регистрация. */
+function registerBuiltinPlugin(pm, plugin) {
+    if (!plugin)
+        return;
+    plugin.isBuiltin = true;
+    pm.register(plugin);
+}
+/**
+ * Загрузка AGENTS.md из базового каталога проекта и конфиг-каталога
+ * (в порядке приоритета). Каждый найденный непустой файл — prompt-блок
+ * высокого приоритета.
+ */
+function loadAgentsMdBlocks(baseDir, dir, skip) {
+    if (skip)
+        return [];
+    const blocks = [];
+    const candidates = [
+        join(baseDir, "AGENTS.md"),
+        join(baseDir, ".mma", "AGENTS.md"),
+        join(dir, "AGENTS.md"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8").trim();
+            if (content) {
+                blocks.push({
+                    content,
+                    priority: "high",
+                    essential: false,
+                    estimatedTokens: estimateTokens(content),
+                    kind: "instructions",
+                });
+            }
+        }
+    }
+    return blocks;
+}
+/** Reject `promise` after `ms`; the winner's timer is cleared. */
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
 export function buildSystemInfo(config, baseDir, profileCompressed) {
     const now = new Date().toISOString().replace("T", " ").slice(0, 19);
     const isWin = profileCompressed.toLowerCase().includes("win32");
@@ -40,6 +112,7 @@ export function buildSystemInfo(config, 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.`,
+        `INPUT PRIORITY: the current user message outranks stored memory/preferences/facts. Never override, reinterpret, or "correct" an explicit value the user states now (city, path, name, language, choice) because a stored preference disagrees — follow the user's current message. If they truly conflict or look like a typo, ask the user instead of assuming.`,
         `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) {
@@ -98,11 +171,24 @@ export function buildSystemInfo(config, baseDir, profileCompressed) {
     }
     return lines.join("\n");
 }
-export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
+/**
+ * One-shot CLI subcommands (`session show`, `usage`, `config` …) paint a result
+ * and exit. The background startup health check spawns a child (LSP server /
+ * tsc) that `process.exit` does not reap — on Windows the orphan keeps the
+ * stdout pipe open, so piping the command (`mma session show <id> | cat`)
+ * hangs. Subcommands never run an agent, so the check is skipped there.
+ */
+let oneShotMode = false;
+export function setOneShotMode(value) {
+    oneShotMode = value;
+}
+export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete, reasoningLevel) {
     const dir = configDir || process.env.MMA_CONFIG_DIR || join(homedir(), ".mma");
     const projectConfigPath = projectDir ? join(projectDir, ".mmrc") : join(process.cwd(), ".mmrc");
     const { config, legacyDetected } = loadConfig({ configDir: dir, projectConfigPath });
     setLocale(config.locale);
+    // CLI --reasoning overrides config mode (priority: CLI > config > default)
+    applyReasoningCliOverride(config, reasoningLevel);
     // Update global audit notifier with config
     try {
         const { globalAuditNotifier } = await import("../modules/security/audit-notifier");
@@ -119,6 +205,19 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         version: config.version,
         model: config.model,
     });
+    // Sync the manifest bundled with this package version into
+    // ~/.mma/certifications.json (bundled entries overwrite their keys on
+    // update; user-local certifications are preserved). Best-effort, silent.
+    try {
+        const { syncGlobalManifest } = await import("../modules/certification/manifest");
+        const syncResult = syncGlobalManifest();
+        if (syncResult.synced) {
+            logger.debug("Certification manifest synced from package");
+        }
+    }
+    catch {
+        // Certification marks are cosmetic — never block startup.
+    }
     if (config.modelLoad.autoLoad) {
         const modelLoader = new ModelLoader(config.provider.baseUrl, logger);
         const loadResult = await modelLoader.ensureModelLoaded({
@@ -129,34 +228,84 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             autoLoad: config.modelLoad.autoLoad,
         });
         if (!loadResult.success) {
-            logger.warn(`Model auto-load failed: ${loadResult.error}. Continuing with manual load.`);
+            logger.warn(t("env.model_autoload_failed", { error: String(loadResult.error ?? "") }));
         }
         else if (loadResult.alreadyLoaded) {
             logger.debug(`Model ${config.model} already loaded`);
         }
         else {
-            logger.info(`Model ${config.model} loaded in ${loadResult.loadTime}s`);
+            logger.info(t("env.model_loaded", { model: config.model, seconds: String(loadResult.loadTime) }));
         }
     }
+    // Context probe (background): ask the provider (LM Studio native API) for
+    // the context length the model is ACTUALLY loaded with and compare it with
+    // the configured contextWindow. Never blocks the banner; null = probe not
+    // applicable (not LM Studio / model not loaded / transient error).
+    const contextProbePromise = (async () => {
+        try {
+            const probe = await getLoadedContextLength(config.provider.baseUrl, config.model);
+            if (!probe)
+                return null;
+            if (probe.actual < config.contextWindow) {
+                logger.logSilent("warn", `Context probe: model "${probe.model}" is loaded with ${probe.actual} tokens, but contextWindow is configured as ${config.contextWindow} — overflow/429 risk. Lower contextWindow or reload the model with a larger context.`);
+            }
+            else if (probe.actual > config.contextWindow) {
+                logger.logSilent("info", `Context probe: model "${probe.model}" supports ${probe.actual} tokens — consider "mma context ${probe.actual}" to use the full window.`);
+            }
+            else {
+                logger.logSilent("debug", `Context probe: configured contextWindow matches loaded context (${probe.actual})`);
+            }
+            return probe;
+        }
+        catch {
+            return null;
+        }
+    })();
     const profile = new UserProfile(join(dir));
     profile.load() || profile.collect();
     profile.save();
-    // 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)})`);
-        });
+    // Multi-provider manager (Phase 2) + optional transparent failover wrapper
+    // (Phase 4.2). Built through the shared factory so a hot-swap via
+    // Agent.setProvider gets the SAME fallback behavior as startup instead of
+    // rebuilding a bare manager that silently drops failover (B4).
+    //
+    // Session id is resolved lazily: the session manager is created further down,
+    // and providers must read the CURRENT session at request time (hot-swap,
+    // session switch). OpenCode Go rejects requests without `x-opencode-session`.
+    let activeSessionManager;
+    const getSessionId = () => activeSessionManager?.getActiveMeta()?.id;
+    const llmProvider = buildActiveProvider(config, logger, { getSessionId }).provider;
+    // Resolve reasoning strategy from provider preset + probe
+    const providerSpec = BUILTIN_PROVIDERS.find((p) => p.type === config.provider.type);
+    const reasoningStrategy = providerSpec?.capabilities.reasoningStrategy ?? "none";
+    // Reasoning probe runs in the BACKGROUND (B2). It used to block bootstrap
+    // with an extra LLM round-trip on every launch; the agent now consumes it
+    // lazily before the first LLM call (same pattern as the startup health
+    // check) and treats the mechanism as NOT passed until it resolves. The 24h
+    // TTL disk cache in probe.ts already avoids re-probing a stable backend.
+    let reasoningProbePromise = Promise.resolve(false);
+    if (config.reasoning && config.reasoning.mode !== "none" && reasoningStrategy !== "none") {
+        reasoningProbePromise = (async () => {
+            try {
+                const { probeReasoningSupport, getCachedProbeResult, setCachedProbeResult } = await import("../modules/reasoning/probe");
+                const cacheK = `${config.provider.baseUrl ?? ""}|${config.model}`;
+                const cached = getCachedProbeResult(cacheK);
+                const passed = cached !== undefined ? cached : await probeReasoningSupport(llmProvider, reasoningStrategy);
+                // Only cache a definitive result — a transient probe error (null) must
+                // NOT pin "reasoning not supported" for the 24h TTL.
+                if (cached === undefined && passed !== null)
+                    setCachedProbeResult(cacheK, passed);
+                logger.logSilent("info", t("env.reasoning_probe", {
+                    strategy: reasoningStrategy,
+                    result: passed === true ? t("env.reasoning_respected") : t("env.reasoning_ignored"),
+                }));
+                // null (transient error) falls back to "not passed" for this session.
+                return passed === true;
+            }
+            catch {
+                return false;
+            }
+        })();
     }
     const baseDir = projectDir ? resolve(projectDir) : process.cwd();
     // Cross-device diagnosis: log a full environment report (OS, runtime,
@@ -177,10 +326,20 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         cacheDir: projectMapCacheDir,
     });
     try {
-        await indexerModule.buildIndex();
+        // Build (or load from cache) the project index. On a large workspace the
+        // first walk can pause startup with no other output — announce both ends
+        // so the silence is explained.
+        logger.info(t("env.indexing"));
+        const index = await indexerModule.buildIndex();
+        if (index) {
+            logger.info(t("env.indexed", { files: String(index.files.length) }));
+        }
+        else {
+            logger.warn(t("env.indexing_failed", { error: "no index produced" }));
+        }
     }
     catch (err) {
-        logger.warn(`Project indexing failed: ${err.message}`);
+        logger.warn(t("env.indexing_failed", { error: String(err?.message ?? err) }));
     }
     const skillsLoader = new SkillsLoader();
     const builtinDir = join(import.meta.dirname, "skills", "builtin");
@@ -199,12 +358,8 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         content: systemInfoContent,
         priority: "critical",
         essential: true,
-        estimatedTokens: Math.ceil(systemInfoContent.length / 4),
+        estimatedTokens: estimateTokens(systemInfoContent),
     };
-    const agentsMdGlobal = join(dir, "AGENTS.md");
-    if (!existsSync(agentsMdGlobal)) {
-        writeFileSync(agentsMdGlobal, "", "utf-8");
-    }
     const sessionDir = join(dir, "sessions");
     const sessionStore = new SessionStore(sessionDir);
     sessionStore.init();
@@ -215,6 +370,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         maxSessions: config.session.maxSessions,
         isolation: config.sessionIsolation,
     });
+    activeSessionManager = sessionManager;
     if (config.session.autoSave && !sessionManager.getActive()) {
         sessionManager.create();
     }
@@ -231,8 +387,13 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             : []
         : [];
     const contextManager = new ContextManager(config.contextWindow, config.contextBudget, tokenCounter);
+    // Shared box for the LIVE config. `Agent.reconfigure` replaces deps.config
+    // AND this box, so anything that captured the reference at bootstrap —
+    // toolCtx.config, security validators, tool rules — keeps seeing the CURRENT
+    // settings after /model use or the wizard. Pinning the value once meant
+    // tools enforced the pre-reconfigure security/maxTool settings all session.
+    const configRef = { current: config };
     const toolCtx = {
-        config,
         baseDir,
         logger,
         exitOnComplete,
@@ -265,6 +426,12 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             },
         },
     };
+    // `config` is exposed as a LIVE getter over the shared configRef so tools
+    // and security validators see the CURRENT settings after a reconfigure.
+    Object.defineProperty(toolCtx, "config", {
+        get: () => configRef.current,
+        configurable: true,
+    });
     // `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
@@ -281,10 +448,16 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         get: () => sessionManager.getSessionContext() ?? undefined,
         configurable: true,
     });
+    Object.defineProperty(toolCtx, "sessionManager", {
+        get: () => sessionManager,
+        configurable: true,
+    });
     const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
     toolCtx.llmProvider = llmProvider;
     toolCtx.toolExecutor = toolExecutor;
-    const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider);
+    const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider, {
+        judgeEnabled: config.hallucination?.judge?.enabled ?? false,
+    });
     const moduleRegistry = new ModuleRegistry();
     const execModule = new ExecutionModule(baseDir, config.stuckThreshold, config.errorWebSearch?.threshold ?? 5);
     // A plan in .mma/plans/active.json is PROJECT state, not session state —
@@ -298,7 +471,15 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     moduleRegistry.register(sessionModule);
     moduleRegistry.register(indexerModule);
     const mcpModule = new MCPModule(config);
-    await mcpModule.initialize();
+    try {
+        // Bound the MCP init so one slow/hung MCP server can't block boot forever
+        // (B5): on timeout, log-and-continue — MCP tools appear late or not at all
+        // instead of stalling startup.
+        await withTimeout(mcpModule.initialize(), 10_000);
+    }
+    catch (err) {
+        logger.warn(`MCP init failed or timed out (${err instanceof Error ? err.message.slice(0, 120) : String(err)}) — continuing without MCP tools.`);
+    }
     moduleRegistry.register(mcpModule);
     const memoryStore = new MemoryStore(join(dir, "memory"));
     const memoryModule = new MemoryModule(memoryStore);
@@ -306,20 +487,12 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     if (config.browser.enabled) {
         const browserModule = new BrowserModule();
         moduleRegistry.register(browserModule);
-        const browserPlugin = browserModule.getPlugin();
-        if (browserPlugin) {
-            browserPlugin.isBuiltin = true;
-            pluginManager.register(browserPlugin);
-        }
+        registerBuiltinPlugin(pluginManager, browserModule.getPlugin());
     }
     const lspLogger = new FileOnlyLogger(logger);
     const lspModule = new LspModule(config.lsp, undefined, lspLogger);
     moduleRegistry.register(lspModule);
-    const lspPlugin = lspModule.getPlugin();
-    if (lspPlugin) {
-        lspPlugin.isBuiltin = true;
-        pluginManager.register(lspPlugin);
-    }
+    registerBuiltinPlugin(pluginManager, lspModule.getPlugin());
     // Startup health check: scan project for existing errors so the model
     // knows the baseline before it starts working. Skip for one-shot runs and
     // test environments. Started in the background (never awaited) so the REPL
@@ -327,7 +500,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     // it before the first LLM call via `lazyPromptBlocks` (already resolved by
     // the time the user types in the interactive REPL).
     let startupCheckBlock = null;
-    const startupCheckPromise = !exitOnComplete && process.env.NODE_ENV !== "test"
+    const startupCheckPromise = !oneShotMode && !exitOnComplete && process.env.NODE_ENV !== "test"
         ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir, { logger: lspLogger })
         : Promise.resolve(null);
     const moduleTools = moduleRegistry.collectToolDefinitions();
@@ -335,30 +508,11 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         toolRegistry.register(tool);
     }
     const plugin = execModule.getPlugin();
-    if (plugin) {
-        plugin.isBuiltin = true;
-        pluginManager.register(plugin);
-    }
-    const sessionPlugin = sessionModule.getPlugin();
-    if (sessionPlugin) {
-        sessionPlugin.isBuiltin = true;
-        pluginManager.register(sessionPlugin);
-    }
-    const skillsPlugin = skillsModule.getPlugin();
-    if (skillsPlugin) {
-        skillsPlugin.isBuiltin = true;
-        pluginManager.register(skillsPlugin);
-    }
-    const indexerPlugin = indexerModule.getPlugin();
-    if (indexerPlugin) {
-        indexerPlugin.isBuiltin = true;
-        pluginManager.register(indexerPlugin);
-    }
-    const mcpPlugin = mcpModule.getPlugin();
-    if (mcpPlugin) {
-        mcpPlugin.isBuiltin = true;
-        pluginManager.register(mcpPlugin);
-    }
+    registerBuiltinPlugin(pluginManager, plugin);
+    registerBuiltinPlugin(pluginManager, sessionModule.getPlugin());
+    registerBuiltinPlugin(pluginManager, skillsModule.getPlugin());
+    registerBuiltinPlugin(pluginManager, indexerModule.getPlugin());
+    registerBuiltinPlugin(pluginManager, mcpModule.getPlugin());
     pluginManager.register(lintOnWritePlugin);
     pluginManager.register(notifyPlugin);
     const pluginLoader = new PluginLoader();
@@ -389,35 +543,62 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     // compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) discarded for a
     // fresh plan_xzq9xe the same iteration the old plan was still visible).
     contextManager.setPlanSummaryProvider(() => execModule.getPlanSummary());
-    const agentsMdBlocks = [];
-    const skipAgentsMd = noAgentsMd === true;
-    if (!skipAgentsMd) {
-        const agentsMdCandidates = [
-            join(baseDir, "AGENTS.md"),
-            join(baseDir, ".mma", "AGENTS.md"),
-            join(dir, "AGENTS.md"),
-        ];
-        for (const p of agentsMdCandidates) {
-            if (existsSync(p)) {
-                const content = readFileSync(p, "utf-8").trim();
-                if (content) {
-                    agentsMdBlocks.push({
-                        content,
-                        priority: "high",
-                        essential: false,
-                        estimatedTokens: Math.ceil(content.length / 4),
-                    });
-                }
+    const agentsMdBlocks = loadAgentsMdBlocks(baseDir, dir, noAgentsMd === true);
+    const promptBlocks = [systemInfoPrompt,
+        ...moduleRegistry.collectPromptBlocks(["indexer", "session"]),
+        ...agentsMdBlocks,
+        // Static plan reminder: always present so the model knows to check for an
+        // active plan before creating a new one (even on the first iteration before
+        // the <system-summary> envelope appears).
+        {
+            content: "[Plan Reminder] An active plan may exist for this session. Before creating a new plan, check with `plan show`. If a plan is active, continue it — do NOT create a new plan.",
+            priority: "high",
+            essential: false,
+            estimatedTokens: 50,
+        },
+    ];
+    // Startup overflow warning (banner, A3): dry-run the system-prompt budget
+    // with the same block set the Agent's first build will use (static + skills
+    // + project map + hidden tools) and surface instructions/project-map blocks
+    // that will not fit. The Agent compresses them before the first LLM call;
+    // this warning tells the USER why and how to get the full text included.
+    {
+        const dynamicBlocks = [];
+        const skillsBlock = skillsModule.getSystemPromptBlock();
+        if (skillsBlock)
+            dynamicBlocks.push(skillsBlock);
+        const mapBlock = indexerModule.getSystemPromptBlock();
+        if (mapBlock)
+            dynamicBlocks.push(mapBlock);
+        const hiddenToolsBlock = buildHiddenToolsBlock(toolRegistry.getAll(), activeToolTags);
+        if (hiddenToolsBlock) {
+            dynamicBlocks.push({
+                content: hiddenToolsBlock,
+                priority: "low",
+                essential: false,
+                estimatedTokens: estimateTokens(hiddenToolsBlock),
+            });
+        }
+        const systemBudget = Math.floor(config.contextWindow * config.contextBudget.systemPrompt);
+        const dry = dryRunOverflow([...promptBlocks, ...dynamicBlocks], systemBudget);
+        if (dry.overflow.length > 0) {
+            const overflowTokens = dry.overflow.reduce((s, b) => s + b.estimatedTokens, 0);
+            const needed = dry.includedTokens + overflowTokens;
+            const hint = overflowHint(config, dir, needed);
+            for (const b of dry.overflow) {
+                logger.warn(t("prompt.overflow.startup", {
+                    block: b.kind === "instructions" ? "AGENTS.md" : "project map",
+                    original: String(b.estimatedTokens),
+                    needed: String(needed),
+                    budget: String(systemBudget),
+                    hint,
+                }));
             }
         }
     }
-    const promptBlocks = [
-        systemInfoPrompt,
-        ...moduleRegistry.collectPromptBlocks(["indexer"]),
-        ...agentsMdBlocks,
-    ];
     const agentDeps = {
         config,
+        configRef,
         llmProvider,
         toolExecutor,
         pluginManager,
@@ -425,17 +606,25 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         hallucinationDetector,
         logger,
         baseDir,
+        configDir: dir,
         toolTags: activeToolTags,
         promptBlocks,
         envReport,
         getDynamicPromptBlocks: () => {
             const blocks = [];
-            const planBlock = execModule.getSystemPromptBlock();
-            if (planBlock)
-                blocks.push(planBlock);
+            // Plan block removed: it mutates every iteration (step status changes),
+            // invalidating the local KV-cache. The plan status is now injected into
+            // the <system-summary> envelope after each tool batch instead.
             const skillsBlock = skillsModule.getSystemPromptBlock();
             if (skillsBlock)
                 blocks.push(skillsBlock);
+            // Session metadata (id/name/model/context) is collected here, not at
+            // bootstrap: the session is created during bootstrap with messageCount 0,
+            // so a static collect would always yield null. Content is stable per
+            // session (no per-turn fields) to preserve prefix KV-cache.
+            const sessionBlock = sessionModule.getSystemPromptBlock();
+            if (sessionBlock)
+                blocks.push(sessionBlock);
             const mapBlock = indexerModule.getSystemPromptBlock();
             if (mapBlock)
                 blocks.push(mapBlock);
@@ -445,7 +634,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
                     content: hiddenToolsBlock,
                     priority: "low",
                     essential: false,
-                    estimatedTokens: Math.ceil(hiddenToolsBlock.length / 4),
+                    estimatedTokens: estimateTokens(hiddenToolsBlock),
                 });
             }
             return blocks;
@@ -461,8 +650,17 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         memoryStore,
         moduleRegistry,
         exitOnComplete,
+        reasoningProbe: () => reasoningProbePromise,
+        reasoningStrategy,
+        planSummary: () => execModule.getPlanSummary(),
     };
     const agent = new Agent(agentDeps);
+    // Register set_thinking tool (needs agent's shared reasoning state)
+    if (config.reasoning) {
+        const { createSetThinkingTool } = await import("../tools/set-thinking");
+        const setThinkingTool = createSetThinkingTool(agent.reasoningState, config.reasoning, () => agent.currentIteration);
+        toolRegistry.register(setThinkingTool);
+    }
     return {
         agent,
         config,
@@ -474,8 +672,9 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         toolCtx,
         configDir: dir,
         baseDir,
-        noAgentsMd: skipAgentsMd,
+        noAgentsMd: noAgentsMd === true,
         envReport,
         legacyDetected,
+        contextProbe: contextProbePromise,
     };
 }

package/dist/core/crash-handler.js

@@ -4,11 +4,12 @@ import { homedir } from "os";
 import { collectEnvironment } from "./environment";
 import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
 import { t } from "../i18n/index";
+import { errMsg } from "../utils";
 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 message = errMsg(err);
     const stack = err instanceof Error && err.stack ? err.stack : message;
     return {
         ts: new Date().toISOString(),

package/dist/core/prompt-builder.js

@@ -37,6 +37,7 @@ export class PromptBuilder {
         let usedTokens = 0;
         const included = [];
         const excluded = [];
+        const excludedBlocks = [];
         const blocks = [];
         for (const block of essential) {
             included.push(block.content);
@@ -58,6 +59,7 @@ export class PromptBuilder {
             }
             else {
                 excluded.push(block.content);
+                excludedBlocks.push(block);
             }
             blocks.push({
                 label: blockLabel(block.content),
@@ -70,6 +72,7 @@ export class PromptBuilder {
         return {
             prompt: included.join("\n\n"),
             excluded,
+            excludedBlocks,
             blocks,
         };
     }