micro-models-agent 0.63.3 → 1.5.0

package/dist/core/prompt-overflow.js

@@ -0,0 +1,307 @@
+// src/core/prompt-overflow.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { PromptBuilder } from "./prompt-builder";
+import { estimateTokens } from "../llm/token-counter";
+import { t } from "../i18n/index";
+/** How many tokens the model-facing hint block costs (upper bound for allocation). */
+export const HINT_BLOCK_TOKENS = 60;
+/** Rough chars-per-token factor used for hard truncation fallback. */
+const CHARS_PER_TOKEN = 4;
+const KIND_ORDER = ["instructions", "project-map"];
+const KIND_LABEL = {
+    instructions: "project instructions (AGENTS.md)",
+    "project-map": "project map",
+};
+const KIND_SOURCE_FILE = {
+    instructions: "AGENTS.md",
+    "project-map": "",
+};
+/**
+ * Static dry-run of the system-prompt budget: which kind-carrying blocks do
+ * not fit. Used by bootstrap for the startup banner and by Agent before the
+ * first LLM call (the real resolution).
+ */
+export function dryRunOverflow(allBlocks, systemBudget) {
+    const builder = new PromptBuilder(systemBudget);
+    builder.addBlocks(allBlocks);
+    const result = builder.build();
+    const includedTokens = result.blocks
+        .filter((b) => b.included)
+        .reduce((sum, b) => sum + b.tokens, 0);
+    const overflow = result.excludedBlocks.filter((b) => Boolean(b.kind));
+    return { includedTokens, overflow };
+}
+function cacheKey(kind, content, maxTokens) {
+    return createHash("sha256").update(`${kind}|${maxTokens}|${content}`).digest("hex").slice(0, 24);
+}
+function readCache(cacheDir, key) {
+    try {
+        const path = join(cacheDir, `${key}.md`);
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, "utf-8").trim();
+        if (!raw)
+            return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if ((parsed.mode === "summary" || parsed.mode === "truncate") && typeof parsed.text === "string" && parsed.text) {
+                return parsed;
+            }
+        }
+        catch {
+            // Legacy plain-text entry — treat as a summary hit
+            return { mode: "summary", text: raw };
+        }
+        return null;
+    }
+    catch {
+        // Corrupted cache — fall through to re-summarize
+    }
+    return null;
+}
+function writeCache(cacheDir, key, entry) {
+    try {
+        mkdirSync(cacheDir, { recursive: true });
+        writeFileSync(join(cacheDir, `${key}.md`), JSON.stringify(entry), "utf-8");
+    }
+    catch {
+        // Best-effort — cache failure must not crash the agent
+    }
+}
+/** Collect a full text response from the streaming provider API. */
+async function collectText(provider, prompt, maxTokens) {
+    let text = "";
+    // Reasoning must be off: a thinking model would burn the completion cap on
+    // <think> before emitting any summary content (observed on qwen3.5-9b).
+    // 2x headroom over the target: token estimates are heuristics, and the
+    // clamp below enforces the real cap no matter what the model returns.
+    for await (const chunk of provider.chat([{ role: "user", content: prompt }], undefined, undefined, {
+        maxTokens: maxTokens * 2,
+        reasoningEffort: "none",
+    })) {
+        if (chunk.type === "text" && chunk.content)
+            text += chunk.content;
+    }
+    return text.trim();
+}
+function truncateToTokens(content, maxTokens) {
+    const maxChars = Math.max(200, maxTokens * CHARS_PER_TOKEN);
+    if (content.length <= maxChars)
+        return content;
+    let cut = content.slice(0, maxChars);
+    const lastBreak = cut.lastIndexOf("\n");
+    if (lastBreak > maxChars * 0.5)
+        cut = cut.slice(0, lastBreak);
+    return `${cut.trimEnd()}\n\n[...truncated — read the full file for details...]`;
+}
+/** One-line first-line label for warnings/logs. */
+function blockLabel(content) {
+    const first = content.split("\n")[0].trim();
+    return first.length > 60 ? `${first.slice(0, 57)}...` : first;
+}
+/**
+ * Summarize (or, failing that, truncate) prompt blocks that exceeded the
+ * system-prompt budget so the project instructions / project map still reach
+ * the model. Summaries are cached on disk keyed by kind + content + budget.
+ * Blocks are resolved in KIND_ORDER priority; the first gets the full
+ * remaining budget, later blocks get whatever is left.
+ */
+export async function resolvePromptOverflow(opts) {
+    const { overflow, includedTokens, systemBudget, provider, cacheDir, logger } = opts;
+    const sorted = [...overflow].sort((a, b) => KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b.kind));
+    const replacements = [];
+    const warnings = [];
+    let used = includedTokens;
+    let unresolved = [];
+    // The bootstrap dry-run only warns that blocks "will be summarized before the
+    // first run". Without a notice here the first prompt appears to hang while
+    // the model rewrites AGENTS.md / the project map — surface it.
+    if (sorted.length > 0) {
+        logger?.warn(t("prompt.overflow.compressing", { count: String(sorted.length) }));
+    }
+    for (const block of sorted) {
+        const kind = block.kind;
+        const maxTokens = systemBudget - used - HINT_BLOCK_TOKENS;
+        if (maxTokens < 100) {
+            unresolved.push(kind);
+            continue;
+        }
+        let mode = "summary";
+        let text = "";
+        const key = cacheKey(kind, block.content, maxTokens);
+        const cached = readCache(cacheDir, key);
+        if (cached) {
+            text = cached.text;
+            mode = cached.mode;
+            logger?.debug(`Prompt overflow: cache hit for ${kind} (${key}, ${mode})`);
+        }
+        else if (provider) {
+            const targetChars = Math.floor(maxTokens * (CHARS_PER_TOKEN - 1));
+            logger?.warn(t("prompt.overflow.summarizing", {
+                label: blockLabel(block.content),
+                original: String(block.estimatedTokens),
+                budget: String(maxTokens),
+            }));
+            try {
+                const prompt = [
+                    `Summarize the following ${KIND_LABEL[kind]} document.`,
+                    // 3 chars/token (not 4): non-Latin text (Cyrillic etc.) is ~2-3 chars
+                    // per token, so a 4x target lands the summary over the clamp.
+                    `Target length: at most ${targetChars} characters (~${maxTokens} tokens). Be strict about it.`,
+                    `Preserve concrete facts: file paths, commands, rules, naming conventions, workflow steps.`,
+                    `Keep the structure (headings / bullet lists). Output ONLY the summary text.`,
+                    ``,
+                    `--- DOCUMENT START ---`,
+                    block.content,
+                    `--- DOCUMENT END ---`,
+                ].join("\n");
+                text = await collectText(provider, prompt, maxTokens);
+                // Small models routinely ignore length instructions (observed: the 9B
+                // model produced ~4700 chars against a 3170-char target). One
+                // self-compression retry on the overshoot — the shorter input makes
+                // compliance much likelier — before falling back to the hard clamp.
+                let retries = 0;
+                while (text && estimateTokens(text) > maxTokens && retries < 1) {
+                    retries++;
+                    logger?.debug(`Prompt overflow: ${kind} summary overshot (${estimateTokens(text)} > ${maxTokens} tok), compressing (retry ${retries})`);
+                    text = await collectText(provider, [
+                        `Compress the following text to at most ${targetChars} characters.`,
+                        `Keep the structure (headings / bullet lists) and all concrete facts: file paths, commands, rules.`,
+                        `Output ONLY the compressed text.`,
+                        ``,
+                        `--- TEXT START ---`,
+                        text,
+                        `--- TEXT END ---`,
+                    ].join("\n"), maxTokens);
+                }
+            }
+            catch (err) {
+                logger?.warn(t("prompt.overflow.summarize_failed", {
+                    label: blockLabel(block.content),
+                    error: String(err?.message ?? err),
+                }));
+                text = "";
+            }
+        }
+        if (!text) {
+            // No provider or summarization failed — hard truncation fallback.
+            mode = "truncate";
+            logger?.warn(t("prompt.overflow.truncating", {
+                label: blockLabel(block.content),
+                original: String(block.estimatedTokens),
+            }));
+            text = truncateToTokens(block.content, maxTokens);
+        }
+        // LLMs overshoot: enforce the cap no matter what produced the text.
+        if (estimateTokens(text) > maxTokens) {
+            if (mode === "summary") {
+                mode = "truncate";
+            }
+            text = truncateToTokens(text, maxTokens);
+        }
+        const resolvedTokens = estimateTokens(text);
+        used += resolvedTokens;
+        writeCache(cacheDir, key, { mode, text });
+        replacements.push({
+            content: text,
+            priority: "high",
+            essential: false,
+            estimatedTokens: resolvedTokens,
+            kind,
+        });
+        warnings.push({
+            kind,
+            label: blockLabel(block.content),
+            originalTokens: block.estimatedTokens,
+            resolvedTokens,
+            mode,
+        });
+    }
+    const hintBlock = replacements.length > 0
+        ? {
+            content: [
+                `[Instructions note] Some project blocks exceeded the system-prompt budget and were compressed:`,
+                ...warnings.map((w) => `- ${KIND_LABEL[w.kind]}: ${w.originalTokens} tokens → ${w.resolvedTokens} tokens (${w.mode})`),
+                ...(unresolved.length > 0
+                    ? unresolved.map((k) => `- ${KIND_LABEL[k]}: did not fit at all — read it yourself if needed`)
+                    : []),
+                ...warnings
+                    .filter((w) => KIND_SOURCE_FILE[w.kind])
+                    .map((w) => `Read the full ${KIND_SOURCE_FILE[w.kind]} with read_file if details are missing.`),
+            ].join("\n"),
+            priority: "high",
+            essential: true,
+            estimatedTokens: HINT_BLOCK_TOKENS,
+        }
+        : null;
+    return { replacements, hintBlock, warnings };
+}
+export function resolveContextWindowSource(config) {
+    const entries = config.provider.entries ?? [];
+    const activeLabel = config.provider.active;
+    const activeEntry = entries.find((e) => e.label && e.label === activeLabel) ??
+        (entries.length === 1 ? entries[0] : undefined);
+    if (activeEntry?.contextWindow) {
+        return { source: "entry", label: activeEntry.label, value: activeEntry.contextWindow };
+    }
+    return { source: "global", value: config.contextWindow };
+}
+/**
+ * Human-facing hint on how to raise the context window, aware of whether the
+ * active value comes from the global config (`mma context <N>`) or from a
+ * provider entry override (must be edited in the provider domain file).
+ */
+export function contextWindowHint(config, configDir, recommended) {
+    const src = resolveContextWindowSource(config);
+    if (src.source === "global") {
+        return `run "mma context ${recommended}"`;
+    }
+    return `edit "${join(configDir, "config", "provider.json")}" → provider.entries[label="${src.label}"].contextWindow = ${recommended}`;
+}
+/**
+ * Recommend the next standard context size whose system budget (10%)
+ * accommodates `neededSystemTokens`. Falls back to the largest known size.
+ */
+export function recommendContextSize(neededSystemTokens) {
+    const sizes = [8192, 16384, 32768, 65536, 131072, 262144];
+    return (sizes.find((s) => Math.floor(s * 0.1) >= neededSystemTokens) ?? sizes[sizes.length - 1]);
+}
+/** Context window needed so that `systemFraction` of it covers `neededTokens`. */
+export function requiredContextWindow(neededTokens, systemFraction) {
+    const fraction = systemFraction > 0 ? systemFraction : 0.1;
+    return Math.ceil(neededTokens / fraction);
+}
+/** System-prompt share of the CURRENT window needed to cover `neededTokens`. */
+export function requiredSystemFraction(neededTokens, contextWindow) {
+    if (contextWindow <= 0)
+        return 1;
+    return Math.min(1, Math.ceil((neededTokens / contextWindow) * 100) / 100);
+}
+/**
+ * Localized, concrete fix for an oversized system prompt. Instead of only
+ * snapping to a coarse standard size (which makes a 32K project jump straight
+ * to 131072), it states the raw requirement and both levers: a bigger window
+ * or a bigger share of the current window.
+ */
+export function overflowHint(config, configDir, neededTokens) {
+    const fraction = config.contextBudget?.systemPrompt ?? 0.1;
+    const budget = Math.floor(config.contextWindow * fraction);
+    const recommended = recommendContextSize(neededTokens);
+    const requiredWindow = requiredContextWindow(neededTokens, fraction);
+    const requiredFraction = requiredSystemFraction(neededTokens, config.contextWindow);
+    const how = configDir
+        ? contextWindowHint(config, configDir, recommended)
+        : `increase contextWindow (e.g. to ${recommended})`;
+    return [
+        t("prompt.overflow.hint_needed", {
+            needed: neededTokens,
+            window: config.contextWindow,
+            fraction,
+            budget,
+        }),
+        t("prompt.overflow.hint_window", { required: requiredWindow, recommended, how }),
+        t("prompt.overflow.hint_fraction", { fraction: requiredFraction }),
+    ].join(" ");
+}

package/dist/core/session-logger.js

@@ -88,7 +88,7 @@ export class SessionLogger {
         const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "assistant",
-            content: content.slice(0, 500),
+            content,
             timestamp: new Date().toISOString(),
             provider: caller?.provider,
             model: caller?.model,
@@ -117,7 +117,7 @@ export class SessionLogger {
         const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "tool",
-            content: sanitizeLogMessage(result.output.slice(0, 500)),
+            content: sanitizeLogMessage(result.output),
             name: call.name,
             timestamp: new Date().toISOString(),
             provider: caller?.provider,
@@ -191,6 +191,11 @@ export class SessionLogger {
             totalTokens: usage.totalTokens,
             source: usage.source,
             durationMs: usage.durationMs,
+            cacheStable: usage.prefix ? Number(usage.prefix.stableRatio.toFixed(4)) : undefined,
+            cacheCause: usage.prefix?.cause,
+            cachedTokens: usage.cache?.cachedTokens,
+            cacheWriteTokens: usage.cache?.cacheWriteTokens,
+            cacheSource: usage.cache?.source,
         });
     }
     logError(message) {
@@ -248,4 +253,31 @@ export class SessionLogger {
             skills: data.skills,
         });
     }
+    /**
+     * Log a reasoning control event (level set, policy evaluation).
+     */
+    logReasoningControl(data) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "reasoning_control",
+            content: `reasoning level: ${data.level} (source: ${data.source ?? "policy"})`,
+            iteration: data.iteration,
+            level: data.level,
+            strategy: data.strategy,
+            probePassed: data.probePassed,
+            source: data.source,
+        });
+    }
+    /**
+     * Log a MoE observability event (moe_plan / moe_subtask / moe_replan /
+     * moe_verify). Emitted by runWithMoE and MoEExecutor (Plan 4.2).
+     */
+    logMoE(event, data) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: event,
+            content: data.detail ?? data.explanation ?? event,
+            ...data,
+        });
+    }
 }

package/dist/i18n/en.json

@@ -11,6 +11,10 @@
   "file.is_directory": "Is a directory, use rmdir: {path}",
   "file.replaced_in": "Replaced in {path}",
   "file.string_not_found": "String not found in file:\n{str}\n\nUse read_file on {path} to see the current content before editing — the target may differ (whitespace, line endings) or was already replaced.",
+  "file.edit_args_invalid": "edit_file requires string \"old\" and \"new\" arguments. Received: old={oldType}, new={newType}.",
+  "file.read_failed": "Could not read {path}: {error}",
+  "file.write_failed": "Could not write {path}: {error}",
+  "file.protected_path_ask": "Protected path \"{path}\" (matches {pattern}). Do NOT modify it. Ask the user for explicit confirmation before proceeding and wait for their answer — do not retry around this.",
   "file.moved": "Moved {from} → {to}",
   "file.not_found_short": "Not found: {path}",
   "file.notfound_resolved": "File not found: {path} (resolved to {resolved})\nThe path was joined onto the working directory because it does not exist as given. Run list_dir to find the correct path.",
@@ -47,6 +51,8 @@
   "error.llm_output_truncated": "The response hit the completion token limit ({tokens}) and was cut off — this answer is incomplete. Raise \"maxCompletionTokens\" in the config to allow longer replies",
   "error.llm_provider_stream_error": "Provider returned an error mid-stream: {error}",
   "error.llm_timeout": "LLM request timed out ({timeout}ms)",
+  "error.context_log_init": "Context log is enabled but could not be initialized: {error}. No context diff will be written.",
+  "error.provider_build": "Could not build provider \"{name}\": {error}",
   "env.runtime_node": "Running under Node (v{version}) — clipboard image paste, subagent performance and LSP spawn on Windows degrade. Install Bun (https://bun.sh) for full features.",
   "env.runtime_old": "Runtime version {version} is below the required engines {engine}.",
   "env.tool_missing": "Tool not found on PATH: {tool}",
@@ -92,6 +98,8 @@
   "tool.failed": "Tool {name} failed: {error}",
   "tool.unknown": "Unknown tool: {name}",
   "tool.blocked": "Blocked by plugin: {plugin}",
+  "tool.ui.security_blocked": "Blocked by security policy",
+  "tool.ui.protected_path": "Protected path — confirmation needed",
   "tool.blocked_reason": "Blocked by plugin: {plugin}. Reason: {reason}",
   "tool.using": "[{label}]",
   "tool.friendly.write_file": "Writing file",
@@ -340,6 +348,7 @@
   "cli.show_details": "Show session details",
   "cli.delete_session": "Delete a session",
   "cli.first_run": "First run detected. Running setup wizard...",
+  "cli.setup_saved_restart": "Settings saved. Restarting with the new configuration...",
   "cli.unknown_cmd": "Unknown command: {name}.",
   "cli.unknown_command": "Unknown command \"{input}\". Did you mean \"{suggestion}\"?",
   "cli.help_hint": "Type /help for available commands.",
@@ -350,6 +359,8 @@
   "cli.exit_on_complete": "Exit immediately when the task is done; interactive tools (question/approve) fail fast instead of blocking on stdin",
   "cli.reasoning_level": "Set reasoning effort level (auto|none|low|medium|high|max)",
   "cli.json": "Output the result as JSON (single-run mode)",
+  "cli.context_log": "Write the full LLM context to <session>/context.diff as a git-style diff (first snapshot full, then +/- changes)",
+  "cli.verbose": "Show full chat detail (tool bodies, lists); default is quiet",
   "cli.security.description": "Manage security settings",
   "cli.security.status": "Show current security configuration",
   "cli.security.policies": "List available security policies",
@@ -410,6 +421,11 @@
   "repl.reasoning_usage": "Usage: /reasoning [auto|none|low|medium|high|max]",
   "repl.reasoning_level_set": "Reasoning level set to: {level}",
   "repl.reasoning_invalid_level": "Invalid level '{level}'. Valid: {valid}",
+  "repl.verbose": "Chat verbosity: quiet, normal, or verbose",
+  "repl.verbose_usage": "Usage: /verbose [quiet|normal|verbose]",
+  "repl.verbose_set": "Chat verbosity: {level}",
+  "repl.verbose_invalid_level": "Invalid level '{level}'. Valid: {valid}",
+  "repl.last_action_none": "No recent action to show.",
   "repl.status": "Show agent status",
   "repl.status_usage": "Usage: /status",
   "repl.plugins": "List loaded plugins",
@@ -441,6 +457,8 @@
   "repl.skill_usage": "Usage: /skill [list|loaded|load|unload|search]",
   "repl.agent": "Agent: ",
   "repl.you": "You: ",
+  "repl.you_reasoning": "You [{level}]: ",
+  "repl.you_reasoning_cont": "You [{level}]… ",
   "repl.interrupt": "Interrupted (Esc)",
   "repl.title": "MMA REPL v{version}",
   "repl.model": "Model:",
@@ -509,6 +527,7 @@
   "setup.title": "\n  MMA Setup Wizard v2\n",
   "setup.select_provider": "\n  Select provider type:",
   "setup.select_provider_num": "\n  Select provider (1-{max})",
+  "setup.select_language_num": "\n  Select language (1-{max})",
   "setup.scanning": "  Scanning local LLM servers...",
   "setup.found_servers": "  Found {count} server(s):",
   "setup.no_servers": "  No local servers found. Enter URL manually.",
@@ -533,8 +552,6 @@
   "setup.scanning_spinner": "Scanning local LLM servers…",
   "setup.fetching_spinner": "Fetching model list…",
   "setup.testing_spinner": "Testing chat with \"{model}\"…",
-  "setup.summary_setting": "Setting",
-  "setup.summary_value": "Value",
   "setup.security_header": "\n  --- Security ---",
   "setup.security_status_off": "  Security: OFF (default — all commands allowed)",
   "setup.security_status_on": "  Security: ON (balanced policy by default)",
@@ -578,6 +595,9 @@
   "exec.audit_incomplete": "❗ Final audit incomplete: {summary}. Task is NOT finished. Remaining steps: {steps}. Resolve them - pick ONE path: (a) if the step's deliverable already exists on disk, mark it done (plan update step=N status=done); (b) if the step is no longer needed, mark it skipped; (c) if the plan drifted from reality (wrong file names, changed approach), re-plan to align it. Do NOT retry plan update repeatedly without changing anything.",
   "exec.mass_edit_warning": "⚠️ Plan affects {count} files — review the full list before proceeding.",
   "exec.escalation": "\n\n⚠️ Agent stuck on step {stepId} ({description}). Escalating to user — please provide guidance.",
+  "exec.escalation_directive": "You have been stuck for several attempts. Stop repeating the same action and pick ONE of these: (1) switch to a fundamentally different approach, (2) search the exact error text with web_search (or the error-search tool), (3) ask the user a short clarifying question, or (4) if the step cannot be completed, use plan update step=<n> status=skipped with a note (or re-plan). Explain your choice briefly.",
+  "exec.test_churn_nudge": "You have edited the test/spec file \"{file}\" several times in a row without changing any production code. If the tests fail, fix the PRODUCTION code under test (not the test) unless the test itself is genuinely wrong — and if so, explain why. If you intended test-first, now write the implementation.",
+  "exec.script_workaround_nudge": "A security restriction already blocked one of your commands. Writing a shell script (.bat/.cmd/.sh/.ps1) to run it another way does NOT lift the restriction and usually just fails. Instead: use write_file for file output, run one plain command per call, pass \"workdir\" instead of \"cd\", or ask the user.",
   "exec.hints": "\n[Hints]\n{hints}",
   "exec.file_rewrite_warning": "⚠️ File {file} has been rewritten {count} times. Consider a different approach — the current fix strategy is not working.",
   "exec.forbidden_cmd": "STOP using \"{cmd}\" via the bash tool — it is not a native Windows cmd.exe command and has failed repeatedly this session. Use the dedicated tool instead: grep → the grep tool, ls/dir → list_dir, find → glob, rm → delete_file, sed → edit_file, touch → write_file, which → `where`, cp/mv → move_file, diff → read_file. Do NOT call bash for this purpose again.",
@@ -585,6 +605,7 @@
   "exec.error_search_failed": "Web search returned nothing for \"{query}\".",
   "exec.error_search_no_query": "Error output is not meaningful — skipping the web search.",
   "exec.npm_exec_hint": "\"could not determine executable to run\" — no \"bin\" for that package/script. Use \"npm run <script>\" (script must exist in package.json) or \"bunx <pkg>\" for a package that declares a bin.",
+  "exec.interactive_hint": "the command needed interactive input but the shell has no TTY (prompt aborted). Re-run it non-interactively — pass every required flag/argument (e.g. `bun create vite <name> --template react-ts` instead of a bare interactive scaffold).",
   "exec.hidden_tool_hint": "\"{tool}\" is not a shell command — it is an MMA tool that is currently hidden. Call the enable_tools tool with tags [\"shell\"] to unlock it; it becomes available on the next iteration.",
   "exec.task_reminder": "Task: {task}. Continue making progress — do not repeat failed actions.",
   "hall.max_retries_exhausted": "Model returned empty or insufficient responses after multiple retries",
@@ -629,10 +650,18 @@
   "migration.dir_bak": "- .mma/ → .mma.bak/ ({count} files)",
   "migration.migrated": "Migrated:",
   "migration.not_needed": "No migration needed",
-  "ui.error_prefix": "Error: ",
+  "ui.error_prefix": "✗ ",
   "ui.success_prefix": "✓ ",
   "ui.warning_prefix": "⚠ ",
   "ui.thinking": "Thinking…",
+  "ui.thinking_label": "thinking",
+  "ui.thinking_label_1": "thinking",
+  "ui.thinking_label_2": "working it out",
+  "ui.thinking_label_3": "considering",
+  "ui.action_fallback": "Action",
+  "ui.actions_summary": "{count} actions",
+  "ui.plan_update": "step {step} → {status}",
+  "ui.todo_action": "{action} · {count}",
   "ui.tool_running": "{tool}…",
   "ui.step_context": "step {id}: {desc}",
   "indexer.map_header": "Project map",
@@ -735,6 +764,7 @@
   "cli.usage_account": "Account: {credits} purchased · {used} used",
   "cli.usage_empty": "No balance information returned.",
   "repl.ctrl_c_interrupt": "\n[Ctrl+C] Stopping agent... (press again to force)",
+  "repl.force_exit": "\nForcing exit — background cleanup may be incomplete.",
   "exec.stop_directive": "STOP. Step {stepId} (\"{description}\") took {iterations} iterations with no progress. DO NOT continue this step. Immediately call: plan update step={stepId} status=done (if code works despite warnings) OR plan update step={stepId} status=skipped note=\"reason\". Do NOT make any other tool calls before updating the plan.",
   "exec.test_runner_fail": "[test-runner] {framework}: {failed} test(s) FAILING, {passed} passing — do NOT mark verification steps as done while tests fail. Investigate the failures, fix the code, then re-run the tests.",
   "exec.test_runner_pass": "[test-runner] {framework}: all {passed} test(s) passing.",
@@ -753,6 +783,11 @@
   "moe.execution_complete": "Execution complete: {succeeded}/{total} succeeded",
   "moe.cycles_exhausted": "Max re-plan cycles ({max}) reached — returning partial results",
   "moe.partial_result": "Partial result",
+  "moe.planning": "🤖 Planning with MoE mode...\n",
+  "moe.plan_fallback": "⚠️ Plan validation failed. Falling back to single-agent mode.\n",
+  "moe.plan_autofixed": "🔧 Auto-fixed {count} plan issues.\n",
+  "moe.plan_failed": "MoE plan failed: {error} — falling back to single-agent",
+  "moe.no_orchestrator": "MoE enabled but no orchestrator model configured — falling back to single-agent. Set orchestrator.model to activate MoE.",
   "moe.scope_approved": "🔓 Scope expanded for \"{subtask}\": {files}",
   "moe.scope_rejected": "⛔ Scope request rejected for \"{subtask}\"",
   "prompt.overflow.compressing": "System prompt overflow: compressing {count} block(s) before the first run — this may take a while on a local model.",
@@ -762,9 +797,9 @@
   "prompt.overflow.hint_needed": "the prompt needs ~{needed} system tokens (current budget: {window} × {fraction} = {budget})",
   "prompt.overflow.hint_window": "raise contextWindow to at least {required} (standard size {recommended}) — {how}",
   "prompt.overflow.hint_fraction": "or keep the window and raise contextBudget.systemPrompt to ~{fraction} (run: mma context --system {fraction})",
-  "prompt.overflow.exceeded": "Prompt overflow: \"{label}\" ({original} tok) exceeded the system-prompt budget ({budget} tok) — {mode} to {resolved} tok. To fit fully, {hint}.",
+  "prompt.overflow.exceeded": "Prompt overflow: the system prompt needs ~{needed} tok (budget {budget} tok); \"{label}\" ({original} tok) was {mode} to {resolved} tok. To fit everything fully, {hint}.",
   "prompt.overflow.failed": "Prompt overflow resolution failed: {error} — oversized blocks will be dropped.",
-  "prompt.overflow.startup": "Startup check: {block} ({original} tok) exceeds the system-prompt budget ({budget} tok) — it will be summarized/truncated before the first run. To include it fully, {hint}.",
+  "prompt.overflow.startup": "Startup check: the system prompt needs ~{needed} tok (budget: {budget} tok); {block} ({original} tok) will be summarized/truncated before the first run. To include everything fully, {hint}.",
   "tool.session_info.no_active": "No active session",
   "tool.session_info.result": "Session: \"{name}\" ({id})\nModel: {model}\nProvider: {provider}\nContext window: {contextWindow} tokens\nMessages: {messages}\nCreated: {createdAt}\nUpdated: {updatedAt}",
   "tool.session_info.context": "Context used: {used} / {budget} tokens ({percent}%)",