micro-models-agent 0.39.0 → 0.40.0

package/dist/core/bootstrap.js

@@ -15,8 +15,9 @@ import { HallucinationDetector } from "../modules/hallucination/detector";
 import { ExecutionModule } from "../modules/execution/module";
 import { SessionStore, SessionManager, SessionModule, } from "../modules/session/index";
 import { UserProfile } from "../modules/user-profile/profile";
-import { SkillsLoader, SkillsMatcher, SkillsModule, } from "../modules/skills/index";
+import { SkillsLoader, SkillsModule } from "../modules/skills/index";
 import { BrowserModule } from "../modules/browser/index";
+import { LspModule } from "../modules/lsp/index";
 import { IndexerModule } from "../modules/indexer/index";
 import { MCPModule } from "../modules/mcp/index";
 import { MemoryModule } from "../modules/memory/module";
@@ -25,36 +26,30 @@ import { Agent } from "./agent";
 import { homedir } from "os";
 import { join, resolve } from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
-function buildSystemInfo(config, baseDir, profileCompressed) {
+export function buildSystemInfo(config, baseDir, profileCompressed) {
     const now = new Date().toISOString().replace("T", " ").slice(0, 19);
     const isWin = profileCompressed.toLowerCase().includes("win32");
     const lines = [
-        `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 filesystem, bash, web access.`,
-        `When you need to act, call a tool immediately. Do not describe your plans in text — use tools to perform operations.`,
-        `After every tool call, check whether the user's request is fully satisfied. If any files, commands, or checks are still missing, call the next needed tool right away. Do not stop with an empty or "done" response until the task is complete.`,
-        `If you create a directory, continue creating the files that belong inside it. A created folder alone is not a completed task.`,
-        `If a tool call fails (e.g., a skill is too large), try an alternative approach or continue without it. Do not reply with empty text when the task is unfinished.`,
-        ``,
-        `Design principles — apply them automatically without naming them:`,
-        `- Do not add code, files, or abstractions that are not needed right now (YAGNI — You Ain't Gonna Need It). If something is not required by the current task, omit it.`,
-        `- Prefer simple, straightforward solutions over clever or complex ones (KISS — Keep It Simple, Stupid). Flat code beats nested, minimal config beats flexible, explicit beats generic.`,
-        `- Do not duplicate code, logic, or configuration (DRY — Don't Repeat Yourself). Extract shared logic into a single place, reuse existing utilities and patterns before writing new ones.`,
+        `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).`,
     ];
     if (isWin) {
-        lines.push(``, `Windows environment — use Windows-compatible commands:`, `- Use "dir" instead of "ls". Use "dir /b" for bare listing.`, `- Use "type" or "Get-Content" instead of "cat".`, `- Use "cd" instead of "pwd". Use "echo %cd%" to print working directory.`, `- Use "copy" instead of "cp", "move" instead of "mv", "del" instead of "rm".`, `- Do not use "mkdir -p" — Windows mkdir creates intermediate dirs by default. Use the create_dir tool instead.`, `- Use forward slashes (/) or escaped backslashes (\\\\) in file paths.`, `- Your working directory is: ${baseDir}`);
+        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}`);
     }
-    lines.push(``, `Bash tool rules:`, `- Use the "workdir" parameter to run commands in a specific directory. Do NOT chain "cd dir && cmd" — the security module blocks the "&&" operator.`, `- Run one command per tool call. Split multi-step shell operations into separate bash calls.`);
+    // MMA is a Bun-only project (package.json scripts, Bun API in code) — the
+    // model should prefer bun over node/tsx/ts-node for running TypeScript
+    // files and tests (observed: model wasted 10+ iterations installing tsx
+    // instead of running `bun file.ts`).
+    lines.push(`Runtime: Bun is available — run TypeScript directly with "bun <file.ts>" and tests with "bun test" (no tsx/ts-node/npm install needed for that).`);
+    lines.push(`Bash: use "workdir" param instead of "cd dir && cmd". One command per call. Long-running processes: pass "background: true" (id immediately), otherwise auto-backgrounded after a few seconds — check with process_log.`, `DEVELOPMENT RULES (strict): 1) install deps BEFORE writing source (npm/pip/cargo, verify lockfile exists; never import uninstalled packages); 2) framework/toolkit init BEFORE app code; 3) follow plan sequentially, after each step verify deliverables exist with real content, then "plan update step=N status=done"; 4) verify work on disk + command output — don't assume success; 5) no premature work (no files/imports for future steps); 6) stuck after 2+ failures: STOP, try a different approach, write files directly, ask the user.`, `PLAN QUALITY: each step = CONCRETE deliverables (exact file paths with extensions, exact packages, exact commands). Vague steps ("Setup the project") forbidden. Cover init → deps → framework → code → verification. 5-8 steps.`);
     if (config.autoPlan) {
-        lines.push(``, `Plan rule: For any task with 2+ steps, create a plan first using the "plan" tool. After each step, call "plan update" to mark progress. Stay focused on the current step.`);
+        lines.push(`Plan rule (MANDATORY): any task creating files, installing packages, or requiring multiple actions MUST create a plan with the "plan" tool BEFORE starting. Each step = a concrete deliverable.`);
     }
     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 with mcp__) to query external services.`);
+        lines.push(`MCP servers are available — use the named MCP tools (prefixed mcp__) to query external services.`);
     }
     return lines.join("\n");
 }
@@ -128,17 +123,17 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     const globalDir = join(homedir(), ".agents", "skills");
     const projectSkillsDir = join(baseDir, ".mma", "skills");
     const availableSkills = skillsLoader.loadFromAllSources(builtinDir, globalDir, projectSkillsDir);
-    const skillsMatcher = new SkillsMatcher();
-    const skillsBudget = Math.floor(config.contextWindow * 0.1);
-    const skillsModule = new SkillsModule(availableSkills, skillsMatcher, skillsBudget);
+    const skillsBudget = Math.floor(config.contextWindow * config.skills.budget);
+    const skillsModule = new SkillsModule(availableSkills, skillsBudget);
     const toolRegistry = new ToolRegistry();
     registerAllTools(toolRegistry, skillsModule);
     const pluginManager = new PluginManager();
+    const systemInfoContent = buildSystemInfo(config, baseDir, profile.compress());
     const systemInfoPrompt = {
-        content: buildSystemInfo(config, baseDir, profile.compress()),
+        content: systemInfoContent,
         priority: "critical",
         essential: true,
-        estimatedTokens: 250,
+        estimatedTokens: Math.ceil(systemInfoContent.length / 4),
     };
     const agentsMdGlobal = join(dir, "AGENTS.md");
     if (!existsSync(agentsMdGlobal)) {
@@ -182,28 +177,36 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
                 });
             },
         },
+        sessionLog: {
+            plan: (event, detail, iteration) => {
+                sessionManager.appendLog({
+                    ts: new Date().toISOString(),
+                    type: "plan",
+                    tool: event,
+                    content: detail,
+                    ...(iteration !== undefined ? { iteration } : {}),
+                });
+            },
+        },
     };
     const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
     toolCtx.llmProvider = llmProvider;
     toolCtx.toolExecutor = toolExecutor;
-    const hallucinationDetector = new HallucinationDetector();
-    const factualCheck = hallucinationDetector.getFactualCheck();
-    factualCheck.setBaseDir(baseDir);
-    toolCtx.trackReadPath = (p) => factualCheck.trackReadPath(p);
-    toolCtx.trackCreatedPath = (p) => factualCheck.trackCreatedPath(p);
-    toolCtx.trackDeletedPath = (p) => factualCheck.trackDeletedPath(p);
-    toolCtx.trackDocumentContent = (c) => factualCheck.trackDocumentContent(c);
+    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();
+    }
     moduleRegistry.register(execModule);
     const sessionModule = new SessionModule(sessionManager);
     moduleRegistry.register(sessionModule);
-    moduleRegistry.register(skillsModule);
     moduleRegistry.register(indexerModule);
     const mcpModule = new MCPModule(config);
     await mcpModule.initialize();
     moduleRegistry.register(mcpModule);
-    const memoryModule = new MemoryModule(join(dir, 'memory'));
+    const memoryModule = new MemoryModule(join(dir, "memory"));
     moduleRegistry.register(memoryModule);
     if (config.browser.enabled) {
         const browserModule = new BrowserModule();
@@ -214,6 +217,13 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
             pluginManager.register(browserPlugin);
         }
     }
+    const lspModule = new LspModule(config.lsp);
+    moduleRegistry.register(lspModule);
+    const lspPlugin = lspModule.getPlugin();
+    if (lspPlugin) {
+        lspPlugin.isBuiltin = true;
+        pluginManager.register(lspPlugin);
+    }
     const moduleTools = moduleRegistry.collectToolDefinitions();
     for (const tool of moduleTools) {
         toolRegistry.register(tool);
@@ -247,7 +257,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     pluginManager.register(notifyPlugin);
     const pluginLoader = new PluginLoader();
     const globalPluginsDir = join(homedir(), ".mma", "plugins");
-    const projectPluginsDir = join(dir, ".mma", "plugins");
+    const projectPluginsDir = join(baseDir, ".mma", "plugins");
     pluginLoader.loadFromDir(globalPluginsDir, pluginManager, logger);
     pluginLoader.loadFromDir(projectPluginsDir, pluginManager, logger);
     contextManager.onCompact = (summary) => {
@@ -299,8 +309,14 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         baseDir,
         promptBlocks,
         getDynamicPromptBlocks: () => {
+            const blocks = [];
             const planBlock = execModule.getSystemPromptBlock();
-            return planBlock ? [planBlock] : [];
+            if (planBlock)
+                blocks.push(planBlock);
+            const skillsBlock = skillsModule.getSystemPromptBlock();
+            if (skillsBlock)
+                blocks.push(skillsBlock);
+            return blocks;
         },
         finalAudit: () => execModule.runFinalAudit(),
         sessionManager,

package/dist/core/session-logger.js

@@ -1,12 +1,30 @@
+import { setAuditSessionDir } from "../modules/security/audit-log";
 /**
  * Thin wrapper around SessionManager that eliminates repetitive
  * `if (sessionManager)` + `new Date().toISOString()` boilerplate
  * from the agent loop.
+ *
+ * When constructed, it configures the app logger and audit log to write into
+ * the session directory (instead of global ~/.mma/logs/).
  */
 export class SessionLogger {
     session;
-    constructor(session) {
+    logger;
+    constructor(session, logger) {
         this.session = session;
+        this.logger = logger;
+        this.bindSessionDir();
+    }
+    bindSessionDir() {
+        const meta = this.session?.getActiveMeta();
+        if (!meta)
+            return;
+        const dir = this.session.getSessionDirectory(meta.id);
+        if (this.logger) {
+            this.logger.setSessionDir(dir);
+            this.logger.initSessionLog(meta.id);
+        }
+        setAuditSessionDir(dir);
     }
     get active() {
         return !!this.session?.getActive();
@@ -44,7 +62,13 @@ export class SessionLogger {
             type: "assistant",
             content,
             ...(toolCalls
-                ? { tool_calls: toolCalls.map((tc) => ({ id: tc.id, name: tc.name, arguments: tc.arguments })) }
+                ? {
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    })),
+                }
                 : {}),
             iteration,
         });
@@ -119,4 +143,13 @@ export class SessionLogger {
             iteration,
         });
     }
+    logPlan(event, detail, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "plan",
+            content: detail,
+            tool: event,
+            ...(iteration !== undefined ? { iteration } : {}),
+        });
+    }
 }

package/dist/core/workspace.js

@@ -0,0 +1,76 @@
+import { existsSync, readdirSync } from "fs";
+import { resolve, isAbsolute, join } from "path";
+/** Files/dirs that mark a directory as a project root. */
+const PROJECT_MANIFESTS = [
+    "package.json",
+    "bun.lockb",
+    "bun.lock",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "go.mod",
+    "Cargo.toml",
+    "pyproject.toml",
+    "requirements.txt",
+    "Gemfile",
+    "composer.json",
+];
+/** Immediate subdirectories that are never candidate project roots. */
+const SKIP_DIRS = new Set(["node_modules", "dist", ".git", ".hg", ".svn"]);
+const subdirCache = new Map();
+function scanSubdirs(baseDir) {
+    const cached = subdirCache.get(baseDir);
+    if (cached)
+        return cached;
+    let dirs = [];
+    try {
+        dirs = readdirSync(baseDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .filter((name) => !SKIP_DIRS.has(name));
+    }
+    catch {
+        dirs = [];
+    }
+    if (dirs.length > 0)
+        subdirCache.set(baseDir, dirs);
+    return dirs;
+}
+export function hasProjectManifest(dir) {
+    return PROJECT_MANIFESTS.some((m) => existsSync(join(dir, m)));
+}
+/**
+ * Resolve a file/dir path inside a workspace, tolerating the common case
+ * where the agent runs from a parent directory while the actual project
+ * lives in a single immediate subdirectory (e.g. baseDir=<repo>,
+ * project=<repo>/app). Resolution order:
+ *   1. absolute path as-is;
+ *   2. baseDir/<p> тАФ project rooted directly at baseDir;
+ *   3. <subdir>/<p> for each immediate project subdirectory of baseDir
+ *      (manifest-bearing subdirectories are preferred).
+ * Returns baseDir/<p> as a fallback when nothing exists, so callers that
+ * check existsSync() still correctly report the path as missing.
+ */
+export function resolveProjectPath(baseDir, p) {
+    const abs = isAbsolute(p) ? p : resolve(baseDir, p);
+    if (existsSync(abs))
+        return abs;
+    // baseDir itself is a project root тАФ paths are relative to it. Probing
+    // subdirectories here would match files in unrelated nested packages.
+    if (hasProjectManifest(baseDir))
+        return abs;
+    let fallback = abs;
+    for (const name of scanSubdirs(baseDir)) {
+        const candidate = resolve(baseDir, name, p);
+        if (existsSync(candidate)) {
+            if (hasProjectManifest(join(baseDir, name)))
+                return candidate;
+            if (fallback === abs)
+                fallback = candidate;
+        }
+    }
+    return fallback;
+}
+/** Clear the internal subdirectory cache (used by tests). */
+export function clearWorkspaceCache() {
+    subdirCache.clear();
+}

package/dist/i18n/en.json

@@ -12,6 +12,7 @@
     "file.string_not_found": "String not found in file:\n{str}",
     "file.moved": "Moved {from} \u2192 {to}",
     "file.not_found_short": "Not found: {path}",
+    "file.notfound_resolved": "File not found: {path} (resolved to {resolved})",
     "file.empty": "(empty)",
     "file.no_matches": "No matches",
     "file.truncated": "\n... (truncated)",
@@ -26,6 +27,7 @@
     "error.llm": "LLM error: {message}",
     "error.response_blocked": "Response blocked: {reason}",
     "error.max_iters": "Max iterations ({max}) reached",
+    "error.empty_response": "Model returned an empty response after retries",
     "error.grep_failed": "Grep failed: {message}",
     "error.search_failed": "Search failed: {message}",
     "error.fetch_failed": "Fetch failed: {message}",
@@ -63,6 +65,7 @@
     "tool.failed": "Tool {name} failed: {error}",
     "tool.unknown": "Unknown tool: {name}",
     "tool.blocked": "Blocked by plugin: {plugin}",
+    "tool.blocked_reason": "Blocked by plugin: {plugin}. Reason: {reason}",
     "tool.using": "[{label}]",
     "tool.friendly.write_file": "Writing file",
     "tool.friendly.read_file": "Reading file",
@@ -75,6 +78,7 @@
     "tool.friendly.glob": "Searching files",
     "tool.friendly.grep": "Searching content",
     "tool.friendly.bash": "Running command",
+    "bash.echo_write_blocked": "Writing files via echo/printf is unreliable in Windows cmd.exe (quotes and multi-line break). Use the write_file tool instead (target: {path}).",
     "tool.friendly.load_skill": "Loading skill",
     "tool.friendly.plan": "Planning",
     "tool.friendly.todo": "Updating tasks",
@@ -82,6 +86,9 @@
     "tool.friendly.web_search": "Web search",
     "tool.friendly.web_fetch": "Fetching page",
     "tool.friendly.web_browse": "Browsing page",
+    "tool.web_fetch_result": "Fetched page: {url} — {chars} chars, {lines} lines{truncated}",
+    "tool.web_browse_result": "Browsed page: {url} — {chars} chars, {lines} lines{truncated}",
+    "tool.web_search_result": "Search results for \"{query}\" — {count} results",
     "tool.friendly.browser": "Browser",
     "tool.friendly.subagent": "Sub-agent task",
     "tool.friendly.question": "Question to user",
@@ -112,7 +119,7 @@
     "tool.question.answered": "User has answered your questions: {formatted}. You can now continue with the user's answers in mind.",
     "tool.name_or_task": "Provide either \"name\" or \"task\" parameter",
     "tool.invalid_params": "Invalid parameters",
-    "tool.skill_budget": "[Skill loaded. {remaining} tokens remaining in skills budget]",
+    "tool.skill_budget": "Skill \"{name}\" loaded ({tokens} tokens, {remaining} remaining in skills budget). Skill content is now in system prompt — no need to reload after context compaction.",
     "tool.skill_available_hint": "Available skills",
     "tool.no_results": "No results found for \"{query}\"",
     "tool.search_results": "Search results for \"{query}\":\n{results}",
@@ -123,9 +130,10 @@
     "tool.memory_error": "Memory error: {error}",
     "tool.screenshot_unavailable": "[Screenshot captured \u2014 image not available for text-only model]",
     "tool.timeout": "Tool {name} timed out after {seconds} seconds",
+    "tool.aborted": "Tool {name} was interrupted by user",
     "tool.interactive_disabled": "Interactive tool is disabled in exit-on-complete mode. Proceed without asking the user.",
     "proc.started": "Started background process {id} (PID {pid}).\nCommand: {command}",
-    "proc.detected_hint": "[Long-running command detected — started in background]",
+    "proc.promoted_hint": "Command still running after {ms} ms — moved to the background",
     "proc.manage_hint": "Check output: process_log id={id}. Stop it: process_kill id={id}. List all: process_list.",
     "proc.none": "No background processes running.",
     "proc.not_found": "Process not found: {id}",
@@ -134,7 +142,6 @@
     "proc.list_header": "Background processes",
     "proc.log_header": "Process {id} ({status}) output:",
     "proc.log_empty": "(no output yet)",
-    "proc.timed_out": "Command timed out after {ms} ms and was killed.",
     "proc.hint": "Manage them with {list}, {log}, {kill}.",
     "proc.status_running": "running",
     "proc.status_exited": "exited",
@@ -142,19 +149,29 @@
     "tool.friendly.process_list": "Listing background processes",
     "tool.friendly.process_log": "Process output",
     "tool.friendly.process_kill": "Stopping process",
+    "plan.no_steps": "No plan steps specified. Provide concrete steps with files and commands.",
     "plan.created": "Plan created: {title} ({steps} steps)",
+    "plan.coverage_warning": "Plan may be missing required files from the task: {missing}. Add steps covering them.",
     "plan.step_done": "Step {n}/{total}: {description} \u2713",
     "plan.complete": "Task complete: {summary}",
     "plan.title_steps": "Plan \"{title}\" created with {count} steps",
     "plan.step_marked": "Step {step} marked as {status}",
     "plan.aborted": "Plan aborted",
     "plan.unknown_action": "Unknown plan action: {action}",
+    "plan.updated": "Plan updated: {title} ({steps} steps)",
     "plan.acknowledged": "Plan {action}: acknowledged",
     "plan.step_status": "Step {step}: {status}",
     "plan.no_active": "No active plan",
     "plan.step_not_found": "Step not found",
     "plan.show_header": "Plan status:",
     "plan.show_empty": "(plan has no steps)",
+    "plan.list_header": "Plans:",
+    "plan.list_empty": "No plans",
+    "plan.switch_no_id": "Provide a plan id to switch to",
+    "plan.not_found": "Plan not found: {id}",
+    "plan.switched": "Switched to plan {id}: {title}",
+    "plan.replanned": "Plan re-planned: {kept} completed steps kept, {steps} new steps added",
+    "plan.replan_no_steps": "Provide new steps for re-planning",
     "todo.added": "Added {count} todo(s): {items}",
     "todo.marked_done": "Marked {count} item(s) as done",
     "todo.no_active": "No active todos",
@@ -192,6 +209,35 @@
     "repl.reloaded": "Agent reloaded",
     "cli.set_model": "Set default model",
     "cli.model_set": "Model set to: {name}",
+    "cli.certify": "Run certification suite for a model",
+    "cli.cert_provider_url": "Provider base URL to certify against (default: current config)",
+    "cli.cert_provider_key": "Provider API key (optional)",
+    "cli.cert_context_window": "Context window size in tokens",
+    "cli.cert_tags": "Comma-separated scenario tags (core, security, image, network, browser)",
+    "cli.cert_reps": "Default repetitions per scenario (overridden by scenario)",
+    "cli.cert_force": "Re-run an existing certification",
+    "cli.cert_clean": "Remove sandbox directories after a successful run",
+    "cli.cert_security_required": "Security is disabled. Enable it first (e.g. `mma security set-policy balanced`) to run the security suite.",
+    "cli.cert_no_scenarios": "No scenarios match tags: {tags}",
+    "cli.cert_exists": "A certification for {model} already exists on this provider.",
+    "cli.cert_exists_hint": "Use --force to re-run.",
+    "cli.cert_started": "Certifying {model} on {provider}...",
+    "cli.cert_done": "Certification complete: {passed} pass, {failed} fail, {skipped} skipped ({total} total)",
+    "cli.cert_rep_pass": "pass",
+    "cli.cert_rep_fail": "fail",
+    "cli.cert_status": "Show certification status for a model",
+    "cli.cert_list": "List all certifications",
+    "cli.cert_uncertify": "Remove a certification",
+    "cli.cert_not_found": "No certification found for {model}",
+    "cli.cert_uncertified": "Certification removed for {model}",
+    "cli.cert_empty": "No certifications yet. Run `mma model certify <model>` first.",
+    "cli.cert_provider_col": "provider",
+    "cli.cert_suite_col": "suite",
+    "cli.cert_date_col": "date",
+    "cli.cert_version_col": "MMA version",
+    "cli.cert_stale_hint": "Run `mma model certify --force` to refresh.",
+    "cli.cert_fixture_missing": "Fixture missing for {id}: {path}",
+    "cli.cert_marks_hint": "Markers: ✔ certified on this provider, ○ certified on an older MMA version, · not certified",
     "cli.manage_providers": "Manage providers",
     "cli.list_providers": "List providers",
     "cli.current_provider": "Current provider:",
@@ -290,10 +336,14 @@
     "repl.skill_unknown_sub": "Unknown skill subcommand: {subcmd}",
     "repl.skill_usage": "Usage: /skill [list|loaded|load|unload|search]",
     "repl.agent": "Agent: ",
-    "repl.title": "MMA REPL v2",
+    "repl.interrupt": "Interrupted (Esc)",
+    "repl.title": "MMA REPL v{version}",
     "repl.model": "Model:",
     "repl.provider": "Provider:",
     "repl.context": "Context:",
+    "repl.sysprompt_label": "System prompt:",
+    "repl.sysprompt_size": "{used} / {budget} tokens",
+    "repl.sysprompt_desc": "Show system prompt",
     "repl.max_iters": "Max iters:",
     "repl.stuck_thresh": "Stuck thresh:",
     "repl.reasoning_label": "Reasoning:",
@@ -371,25 +421,34 @@
     "skill.prompt_hint": "Do NOT load skills automatically. Only load a skill when the user explicitly asks for it (e.g. 'use skill X' or 'load the Y skill'). Skills are listed below for reference only — do not guess which skill to use based on the task description.",
     "skill.prompt_fallback": "If load_skill fails because a skill is too large, continue the task without it — do not stop.",
     "skill.loaded_content": "[Skill loaded: {name}]\n{content}\n\nUse this knowledge to answer the user's question.",
-    "exec.stuck": "Stuck on step {stepId}. Current: {description}. No progress for {iterations} iterations.",
-    "exec.stuck_recovery": "[Stuck detected: {iterations} iterations without progress. Stop repeating the same approach. Try a fundamentally different strategy: use a different tool (e.g., 'browser' tool for JavaScript-heavy websites instead of 'web_browse'), break the task into smaller parts, or explain to the user what went wrong and ask for guidance.]",
-    "exec.tool_errors": "Tool {tool} failed {count} times. Suggest alternative approach.",
-    "exec.tool_errors_recovery": "[Tool {tool} failed {count} times. Stop using this tool and try a different approach or explain the issue to the user.]",
-    "exec.repetitive_tool": "[You called {tool} {count} times in a row with the same arguments and result. Stop repeating — try a different approach: create files, change arguments, or explain the problem to the user.]",
-    "exec.consecutive_failures_recovery": "[{count} consecutive tool calls failed. You are going in circles — stop trying commands that keep failing. Explain the problem to the user, or try a completely different approach: write files directly, use a different tool, or break the task into smaller parts.]",
-    "exec.task_reminder": "[Remember the original task: {task}. Do not switch to unrelated tasks. If you cannot complete the original task, explain why to the user and ask for guidance.]",
-    "exec.plan_warning": "[\u26a0 Warning: you are working on step {step} - \"{description}\". Your {tool} call touches files not mentioned in the current step. Focus on the current step or update the plan via plan update.]",
-    "exec.off_track": "[\u26a0 Outside plan: step {stepId} is \"{description}\", but you're using {tool} on a different path. Explain or return.]",
+    "exec.stuck": "No progress on step {stepId} ({description}) for {iterations} iterations.",
+    "exec.stuck_recovery": "Step {stepId} — \"{description}\" — has had no progress for {iterations} iterations. Try a different approach: review what this step needs, check if dependencies are installed, or create files directly via write_file instead of shell commands. After completing the step call plan update step={stepId} status=done.",
+    "exec.tool_errors": "Tool {tool} failed {count} times. Consider using a different tool.",
+    "exec.tool_errors_recovery": "Tool {tool} has failed {count} times in a row. Try an alternative: create files directly via write_file, use a different command, or if nothing works — skip this step via plan update step=N status=skipped with a note explaining why.",
+    "exec.repetitive_tool": "Called {tool} {count} times with identical arguments and result. Try a different approach — create files directly, change arguments, or check process status via process_log.",
+    "exec.consecutive_failures_recovery": "{count} consecutive tool failures. Create files directly via write_file instead of terminal commands. Check that dependencies are installed (npm install). Do not run build/tests until all files are created.",
+    "exec.plan_warning": "Current plan step {step} is \"{description}\", but {tool} is being called for files outside this step. Complete the current step first, then call plan update step={step} status=done before moving to the next step.",
+    "exec.plan_blocked": "{max} consecutive calls outside the current step. Finish step {step} before proceeding — other steps should wait until this one is complete.",
+    "exec.off_track": "Step {stepId} — \"{description}\" — but you are using {tool} on a different path. Return to the current step.",
+    "exec.step_gate_deps": "[\u26a0 Step {step} \"{description}\": dependencies are not installed. First run the install command (npm install, pip install, etc.). Verify the lock file or dependency directory exists. If this step is NOT actually needed (no external dependencies), skip it: plan update step={step} status=skipped note=\"deps not needed\".]",
+    "exec.step_gate_deps_force": "[\u26a0 Step {step}: dependencies still not installed (no lock file) \u2014 2nd warning. If this step is NOT needed, IMMEDIATELY call: plan update step={step} status=skipped note=\"deps not needed\". If it IS needed, run the install command right now. Do NOT make other tool calls before updating the plan.]",
+    "exec.step_gate_empty": "[\u26a0 Step {step}: files exist but appear empty: {files}. Add real code to these files before advancing to the next step.]",
+    "exec.step_gate_ok": "[\u2713] Step {step} completed and verified. MOVING to step {nextStep}: \"{nextDesc}\". Work ONLY on this step.",
+    "exec.step_gate_last": "[\u2713] Step {step} completed — that was the final step. Verify everything together and provide the final answer.]",
     "exec.audit_pass": "[\u2713] Task complete: {done}/{total} steps done, {files} files verified",
     "exec.audit_fail": "[\u2717] Task incomplete: {done}/{total} steps done, {files} files missing",
     "exec.audit_fail_typecheck": "[\u2717] Task incomplete: {done}/{total} steps done, {missing} files missing, typecheck error: {typeError}",
     "exec.audit_incomplete": "[\u26a0 Final audit incomplete: {summary}. Task is NOT finished \u2014 continue working. Remaining steps: {steps}]",
+    "exec.mass_edit_warning": "\u26a0\ufe0f Plan affects {count} files \u2014 review the full list before proceeding.",
+    "exec.escalation": "\n\n\u26a0\ufe0f Agent stuck on step {stepId} ({description}). Escalating to user \u2014 please provide guidance.",
+    "exec.hints": "\n[Hints]\n{hints}",
+    "exec.file_rewrite_warning": "\u26a0\ufe0f File {file} has been rewritten {count} times. Consider a different approach \u2014 the current fix strategy is not working.",
     "hall.max_retries_exhausted": "Model returned empty or insufficient responses after multiple retries",
     "hall.short_response": "Response too short or empty",
     "hall.repetitive": "Response too repetitive ({pct}% overlap)",
     "hall.uncertainty": "Uncertainty markers: {markers}",
     "hall.unknown_paths": "Mentioned file paths not found in known files: {paths}",
-    "hall.contradiction": "Contradicts previous decision: \"{decision}\" in {location}",
+    "hall.contradiction_llm": "Contradicts an earlier decision{reason}",
     "hall.uncertainty_prefix": "\n\n[\u26a0\ufe0f Uncertainty] ",
     "browser.repeated_action": "You have repeated the same action ({action}) {threshold} times. Try a different approach: use \"snapshot\" to re-read the page, try different element numbers, or navigate to a different URL.",
     "browser.unknown_action": "Unknown action: {action}",
@@ -457,5 +516,10 @@
     "tool.remember.entry_required": "Entry text is required",
     "tool.recall.empty": "Nothing found for \"{query}\"",
     "tool.recall.no_memory": "Memory is empty",
-    "tool.recall.search_results": "{category} results:\n{results}"
+    "tool.recall.search_results": "{category} results:\n{results}",
+    "ctx.compactions": "compactions: {count}",
+    "ctx.quality": "quality: {percent}%",
+    "ctx.delta_pos": "ctx +{tokens}",
+    "ctx.delta_neg": "ctx -{tokens} ↓",
+    "ctx.delta_zero": "ctx ±0"
 }

package/dist/i18n/index.js

@@ -1,16 +1,19 @@
-import en from './en.json';
-import ru from './ru.json';
+import en from "./en.json";
+import ru from "./ru.json";
 const locales = { en, ru };
-let currentLocale = 'en';
-function flatten(obj, prefix = '') {
+let currentLocale = "en";
+function flatten(obj, prefix = "") {
     let result = {};
     for (const [key, val] of Object.entries(obj)) {
         const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (typeof val === 'string') {
+        if (typeof val === "string") {
             result[fullKey] = val;
         }
-        else if (typeof val === 'object' && val !== null) {
-            result = { ...result, ...flatten(val, fullKey) };
+        else if (typeof val === "object" && val !== null) {
+            result = {
+                ...result,
+                ...flatten(val, fullKey),
+            };
         }
     }
     return result;
@@ -30,8 +33,8 @@ export function loadLocale(name, dict) {
 }
 export function t(key, params) {
     const localeDict = flat[currentLocale];
-    const enDict = flat['en'];
-    let template = localeDict?.[key] || enDict?.[key];
+    const enDict = flat["en"];
+    let template = localeDict?.[key] ?? enDict?.[key] ?? key;
     if (!template)
         return key;
     if (params) {