micro-models-agent 0.47.1 → 0.48.2

package/dist/main.js

@@ -1942,9 +1942,9 @@ function mergeSecurityConfig(userConfig) {
 var DEFAULT_SECURITY_CONFIG;
 var init_security = __esm(() => {
   DEFAULT_SECURITY_CONFIG = {
-    enabled: false,
+    enabled: true,
     bash: {
-      enabled: false,
+      enabled: true,
       blacklist: [
         "rm",
         "dd",
@@ -1983,10 +1983,24 @@ var init_security = __esm(() => {
         "umount",
         "powershell",
         "pwsh",
-        "cmd"
+        "cmd",
+        "bash",
+        "sh",
+        "zsh",
+        "dash",
+        "python",
+        "python3",
+        "node",
+        "bun",
+        "perl",
+        "ruby",
+        "del",
+        "rd",
+        "erase",
+        "taskkill"
       ],
       whitelist: [],
-      blockDangerousFlags: false,
+      blockDangerousFlags: true,
       logCommands: true,
       dangerousFlags: [
         "--force",
@@ -2003,7 +2017,7 @@ var init_security = __esm(() => {
         "-y",
         "--no-confirm"
       ],
-      dangerousOperators: [">", ">>", "2>", "2>>", "`"]
+      dangerousOperators: [">", ">>", "2>", "2>>", ";", "&&", "||", "|", "`", "$("]
     },
     paths: {
       enabled: false,
@@ -2026,7 +2040,7 @@ var init_security = __esm(() => {
       allowed: []
     },
     network: {
-      enabled: false,
+      enabled: true,
       deniedDomains: ["localhost", "127.0.0.1", "::1"],
       allowedDomains: [],
       requestTimeout: 15000,
@@ -2357,7 +2371,8 @@ var init_en = __esm(() => {
     "file.deleted": "Deleted {path}",
     "file.updated": "Updated {path}",
     "file.written": "Written {path}",
-    "file.notfound": "File not found: {path}",
+    "file.notfound": `File not found: {path}
+This does NOT mean the project is missing — the path may be wrong. Run list_dir on the working directory first; create files only after confirming what exists.`,
     "file.dir_notfound": "Directory not found: {path}",
     "file.path_not_allowed": "Path not allowed: {path}",
     "file.path_not_allowed_short": "Path not allowed",
@@ -2369,7 +2384,8 @@ var init_en = __esm(() => {
 Use read_file on {path} to see the current content before editing — the target may differ (whitespace, line endings) or was already replaced.`,
     "file.moved": "Moved {from} → {to}",
     "file.not_found_short": "Not found: {path}",
-    "file.notfound_resolved": "File not found: {path} (resolved to {resolved})",
+    "file.notfound_resolved": `File not found: {path} (resolved to {resolved})
+The path was joined onto the working directory because it does not exist as given. Run list_dir to find the correct path.`,
     "file.empty": "(empty)",
     "file.no_matches": "No matches",
     "file.truncated": `
@@ -2867,6 +2883,7 @@ Available commands:`,
     "setup.security_header": `
   --- Security ---`,
     "setup.security_status_off": "  Security: OFF (default — all commands allowed)",
+    "setup.security_status_on": "  Security: ON (balanced policy by default)",
     "setup.security_configure": "  Configure security? (y/N)",
     "setup.security_bash_block": "  Block dangerous commands (rm, sudo, ssh, etc.)? (y/N)",
     "setup.security_flags_block": "  Block dangerous flags (--force, -rf, etc.)? (y/N)",
@@ -2922,6 +2939,7 @@ Apply a matching solution from these results. If none is relevant — do NOT rep
     "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.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",
     "hall.short_response": "Response too short or empty",
     "hall.repetitive": "Response too repetitive ({pct}% overlap)",
@@ -3030,7 +3048,22 @@ Apply a matching solution from these results. If none is relevant — do NOT rep
     "tool.friendly.enable_tools": "Enable tools",
     "cli.provider_base_hint": "Base URL set to: {baseUrl}",
     "repl.cost": "Total cost: {cost}",
-    "repl.tokens": "Tokens used: {tokens}"
+    "repl.tokens": "Tokens used: {tokens}",
+    "repl.ctrl_c_interrupt": `
+[Ctrl+C] Stopping agent... (press again to force)`,
+    "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.",
+    "plan.subtasks_done": "All sub-tasks done — call plan update step={stepId} status=done to complete this step.",
+    "plan.no_subtasks": "(no sub-tasks)",
+    "plan.step_label": "Step {stepId}: {description}",
+    "exec.hint_deps": "Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.",
+    "exec.hint_test": "Make sure the source files exist and have real code before running tests.",
+    "exec.hint_build": "Check that all dependencies are installed and source files are not empty.",
+    "exec.hint_deploy": "Verify credentials and network access before deploying.",
+    "exec.hint_repetitive": "You are calling the same tool repeatedly with the same arguments. Try a different approach.",
+    "exec.hint_consecutive": "Multiple different tools are failing. Check if the environment is set up correctly.",
+    "exec.hint_read_only": "You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps."
   };
 });
 
@@ -3042,8 +3075,10 @@ var init_ru = __esm(() => {
     "file.deleted": "Удалён {path}",
     "file.updated": "Обновлён {path}",
     "file.written": "Записан {path}",
-    "file.notfound": "Файл не найден: {path}",
-    "file.dir_notfound": "Каталог не найден: {path}",
+    "file.notfound": `Файл не найден: {path}
+Это НЕ значит, что проект отсутствует — возможно, путь неверный. Выполни list_dir по рабочей директории; создавай файлы только после проверки того, что уже есть.`,
+    "file.dir_notfound": `Каталог не найден: {path}
+Это НЕ значит, что проект отсутствует — возможно, путь неверный. Выполни list_dir по рабочей директории (и родителю этого пути), чтобы найти реальное расположение, прежде что-то создавать.`,
     "file.path_not_allowed": "Путь недопустим: {path}",
     "file.path_not_allowed_short": "Путь недопустим",
     "file.is_directory": "Это каталог, используйте rmdir: {path}",
@@ -3550,6 +3585,7 @@ var init_ru = __esm(() => {
     "setup.security_header": `
   --- Безопасность ---`,
     "setup.security_status_off": "  Безопасность: ВЫКЛ (по умолчанию — все команды разрешены)",
+    "setup.security_status_on": "  Безопасность: ВКЛ (по умолчанию — политика balanced)",
     "setup.security_configure": "  Настроить безопасность? (y/N)",
     "setup.security_bash_block": "  Блокировать опасные команды (rm, sudo, ssh и т.д.)? (y/N)",
     "setup.security_flags_block": "  Блокировать опасные флаги (--force, -rf и т.д.)? (y/N)",
@@ -3605,6 +3641,7 @@ var init_ru = __esm(() => {
     "exec.error_search_failed": 'Поиск в интернете для "{query}" ничего не дал.',
     "exec.error_search_no_query": "Текст ошибки незначимый — поиск в интернете пропущен.",
     "exec.npm_exec_hint": '"could not determine executable to run" — у пакета/скрипта нет "bin". Используй "npm run <script>" (скрипт должен быть в package.json) или "bunx <pkg>" для пакета с объявленным bin.',
+    "exec.task_reminder": "Задача: {task}. Продолжай работу — не повторяй неудачные действия.",
     "hall.max_retries_exhausted": "Модель вернула пустой или недостаточный ответ после нескольких попыток",
     "hall.short_response": "Слишком короткий или пустой ответ",
     "hall.repetitive": "Слишком повторяющийся ответ ({pct}% совпадение)",
@@ -3700,7 +3737,8 @@ var init_ru = __esm(() => {
     "ctx.delta_pos": "контекст +{tokens}",
     "ctx.delta_neg": "контекст -{tokens} ↓",
     "ctx.delta_zero": "контекст ±0",
-    "file.notfound_resolved": "Файл не найден: {path} (резолвится в {resolved})",
+    "file.notfound_resolved": `Файл не найден: {path} (резолвится в {resolved})
+Путь был склеен с рабочей директорией, потому что в исходном виде он не существует. Выполни list_dir, чтобы найти корректный путь.`,
     "bash.echo_write_blocked": "Запись файлов через echo/printf ненадёжна в Windows cmd.exe (кавычки и многострочность ломаются). Используй инструмент write_file вместо этого (цель: {path}).",
     "updater.check_error": "[updater] Ошибка проверки обновления: {error}",
     "updater.available": "[updater] Доступно обновление: {current} → {latest}. Выполните `npm install -g micro-models-agent` для обновления.",
@@ -3715,7 +3753,22 @@ var init_ru = __esm(() => {
     "tool.friendly.enable_tools": "Включить тулы",
     "cli.provider_base_hint": "Базовый URL установлен: {baseUrl}",
     "repl.cost": "Итого потрачено: {cost}",
-    "repl.tokens": "Потрачено токенов: {tokens}"
+    "repl.tokens": "Потрачено токенов: {tokens}",
+    "repl.ctrl_c_interrupt": `
+[Ctrl+C] Остановка агента... (ещё раз — принудительно)`,
+    "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.",
+    "plan.subtasks_done": "All sub-tasks done — call plan update step={stepId} status=done to complete this step.",
+    "plan.no_subtasks": "(no sub-tasks)",
+    "plan.step_label": "Step {stepId}: {description}",
+    "exec.hint_deps": "Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.",
+    "exec.hint_test": "Make sure the source files exist and have real code before running tests.",
+    "exec.hint_build": "Check that all dependencies are installed and source files are not empty.",
+    "exec.hint_deploy": "Verify credentials and network access before deploying.",
+    "exec.hint_repetitive": "You are calling the same tool repeatedly with the same arguments. Try a different approach.",
+    "exec.hint_consecutive": "Multiple different tools are failing. Check if the environment is set up correctly.",
+    "exec.hint_read_only": "You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps."
   };
 });
 
@@ -3886,7 +3939,7 @@ function validateExpertConfig(config, allToolTags) {
 }
 
 // src/modules/security/encryption.ts
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
 import { homedir } from "os";
 import { join as join3 } from "path";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
@@ -3903,8 +3956,8 @@ function getOrCreateEncryptionKey(config) {
     try {
       writeFileSync2(keyPath, key.toString("base64"), { mode: 384 });
       return key;
-    } catch {
-      return key;
+    } catch (e) {
+      throw new Error(`Cannot write encryption key to ${keyPath}: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
   try {
@@ -3949,7 +4002,7 @@ function decryptString(encryptedText, key) {
   hmac.update(iv);
   hmac.update(Buffer.from(encrypted, "base64"));
   const computedTag = hmac.digest();
-  if (!computedTag.equals(authTag)) {
+  if (computedTag.length !== authTag.length || !timingSafeEqual(computedTag, authTag)) {
     throw new Error("Authentication failed: invalid tag");
   }
   const decipher = createDecipheriv("aes-256-cbc", encKey, iv);
@@ -4133,6 +4186,22 @@ function normalizeLspServerArgs(config) {
     }
   }
 }
+function normalizeStaleSecurityConfig(config) {
+  const sec = config.security;
+  if (!sec || sec.enabled !== false)
+    return;
+  const bash = sec.bash;
+  if (!bash || bash.enabled !== false || bash.blockDangerousFlags !== false)
+    return;
+  const LEGACY_OPERATORS = [">", ">>", "2>", "2>>", "`"];
+  if (JSON.stringify(bash.dangerousOperators ?? []) !== JSON.stringify(LEGACY_OPERATORS))
+    return;
+  const defaultCmds = new Set(DEFAULT_SECURITY_CONFIG.bash.blacklist);
+  const blacklist = Array.isArray(bash.blacklist) ? bash.blacklist : [];
+  if (blacklist.some((cmd) => !defaultCmds.has(cmd)))
+    return;
+  config.security = JSON.parse(JSON.stringify(DEFAULT_SECURITY_CONFIG));
+}
 function loadJSON(path) {
   try {
     if (existsSync4(path)) {
@@ -4206,6 +4275,7 @@ function loadConfig(options) {
     config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
   }
   normalizeLspServerArgs(config);
+  normalizeStaleSecurityConfig(config);
   config = applyEnvVars(config);
   try {
     const encryptor = new ConfigEncryptor;
@@ -4568,19 +4638,19 @@ class Logger {
     this.fileLog.cleanupOldLogs(maxDays, maxFiles);
   }
   logLLMRequest(model, messagesCount, promptPreview, caller) {
-    this.fileLog.logLLMRequest(model, messagesCount, promptPreview, caller);
+    this.fileLog.logLLMRequest(model, messagesCount, sanitizeLogMessage(promptPreview), caller);
   }
   logLLMResponse(model, responseLength, genTimeMs, error, caller) {
     this.fileLog.logLLMResponse(model, responseLength, genTimeMs, error, caller);
   }
   logToolCall(tool, preview, result) {
-    this.fileLog.logToolCall(tool, preview, result);
+    this.fileLog.logToolCall(tool, sanitizeLogMessage(preview), result !== undefined ? sanitizeLogMessage(result) : undefined);
   }
   logToolOutput(tool, output, exitCode) {
-    this.fileLog.logToolOutput(tool, output, exitCode);
+    this.fileLog.logToolOutput(tool, sanitizeLogMessage(output), exitCode);
   }
   logREPL(tag, content) {
-    this.fileLog.logREPL(tag, content);
+    this.fileLog.logREPL(tag, sanitizeLogMessage(content));
   }
   child(prefix) {
     const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
@@ -4651,6 +4721,24 @@ class Logger {
         type,
         meta: this.sanitizeMeta(data)
       }) + `
+`, "utf-8");
+    } catch {}
+  }
+  logSilent(level, msg, meta) {
+    const logTarget = this.sessionDir ?? this.logDir;
+    if (!logTarget)
+      return;
+    const ts = new Date().toISOString();
+    const sanitizedMsg = sanitizeLogMessage(msg);
+    const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
+    try {
+      appendFileSync2(join6(logTarget, "app.jsonl"), JSON.stringify({
+        level,
+        ts,
+        prefix: this.prefix,
+        msg: sanitizedMsg,
+        meta: sanitizedMeta ?? null
+      }) + `
 `, "utf-8");
     } catch {}
   }
@@ -5244,15 +5332,11 @@ class OpenAICompatProvider {
     const streamResult = this.doStream(messages, tools, signal, options);
     let hasToolCall = false;
     let hasText = false;
-    let reasoningAcc = "";
     for await (const chunk of streamResult) {
       if (chunk.type === "tool_call")
         hasToolCall = true;
       if (chunk.type === "text")
         hasText = true;
-      if (chunk.type === "reasoning" && chunk.content) {
-        reasoningAcc += chunk.content;
-      }
       yield chunk;
     }
     if (!hasToolCall && !hasText) {
@@ -5297,30 +5381,7 @@ class OpenAICompatProvider {
       maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
       reasoningEffort: options?.reasoningEffort
     });
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.config.apiKey && this.config.apiKey !== "not-needed") {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    const controller = new AbortController;
-    let timedOut = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      controller.abort();
-    }, REQUEST_TIMEOUT_MS);
-    const abortSignal = (() => {
-      if (!signal)
-        return controller.signal;
-      try {
-        return AbortSignal.any([controller.signal, signal]);
-      } catch {
-        signal.addEventListener("abort", () => controller.abort(), {
-          once: true
-        });
-        return controller.signal;
-      }
-    })();
+    const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
     let response;
     try {
       response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
@@ -5337,7 +5398,7 @@ class OpenAICompatProvider {
       throw wrapped;
     }
     if (!response.ok) {
-      clearTimeout(timeoutId);
+      cleanup();
       const errorText = await response.text();
       const err = new Error(t("error.llm_api", {
         status: response.status,
@@ -5349,7 +5410,7 @@ class OpenAICompatProvider {
     }
     const reader = response.body?.getReader();
     if (!reader) {
-      clearTimeout(timeoutId);
+      cleanup();
       throw new Error(t("error.no_response_body"));
     }
     const decoder = new TextDecoder;
@@ -5359,18 +5420,18 @@ class OpenAICompatProvider {
     let sawDone = false;
     const readIdle = () => new Promise((resolve, reject) => {
       const idleTimer = setTimeout(() => {
-        timedOut = true;
+        flagTimeout();
         controller.abort();
       }, idleTimeoutMs);
       reader.read().then((result) => {
         clearTimeout(idleTimer);
-        if (timedOut)
+        if (isTimeout())
           reject(new Error(t("error.llm_stream_idle", { timeout: idleTimeoutMs })));
         else
           resolve(result);
       }, (err) => {
         clearTimeout(idleTimer);
-        if (timedOut)
+        if (isTimeout())
           reject(new Error(t("error.llm_stream_idle", { timeout: idleTimeoutMs })));
         else
           reject(err);
@@ -5457,20 +5518,12 @@ class OpenAICompatProvider {
         yield { type: "done", usage };
       }
     } finally {
-      clearTimeout(timeoutId);
+      cleanup();
       reader.releaseLock();
     }
     return sawDone;
   }
-  async doNonStreaming(messages, tools, signal, options) {
-    const body = buildRequestBody({
-      model: this.model,
-      messages,
-      tools,
-      stream: false,
-      maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
-      reasoningEffort: options?.reasoningEffort
-    });
+  buildRequestSetup(signal) {
     const headers = {
       "Content-Type": "application/json"
     };
@@ -5495,6 +5548,27 @@ class OpenAICompatProvider {
         return controller.signal;
       }
     })();
+    return {
+      headers,
+      abortSignal,
+      cleanup: () => clearTimeout(timeoutId),
+      isTimeout: () => timedOut,
+      flagTimeout: () => {
+        timedOut = true;
+      },
+      controller
+    };
+  }
+  async doNonStreaming(messages, tools, signal, options) {
+    const body = buildRequestBody({
+      model: this.model,
+      messages,
+      tools,
+      stream: false,
+      maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
+      reasoningEffort: options?.reasoningEffort
+    });
+    const { headers, abortSignal, cleanup, isTimeout } = this.buildRequestSetup(signal);
     try {
       const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
         method: "POST",
@@ -5547,12 +5621,12 @@ class OpenAICompatProvider {
       }
       return chunks;
     } catch (err) {
-      if (timedOut && err?.name === "AbortError") {
+      if (isTimeout() && err?.name === "AbortError") {
         throw new Error(t("error.llm_timeout", { timeout: REQUEST_TIMEOUT_MS }));
       }
       throw err instanceof Error ? err : new Error(String(err));
     } finally {
-      clearTimeout(timeoutId);
+      cleanup();
     }
   }
   countTokens(text) {
@@ -5920,17 +5994,76 @@ var init_executor = __esm(() => {
   init_i18n();
 });
 
+// src/tools/path-utils.ts
+import { resolve, normalize, dirname as dirname2, basename, sep, relative, isAbsolute } from "path";
+import { existsSync as existsSync7 } from "fs";
+function isInsideDir(targetPath, dirPath) {
+  const norm = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+  const t2 = norm(resolve(targetPath));
+  const d = norm(resolve(dirPath));
+  if (t2 === d)
+    return true;
+  const rel = relative(d, t2);
+  return rel.length > 0 && !isAbsolute(rel) && !rel.startsWith("..");
+}
+function matchesScopeEntry(targetResolved, entryResolved) {
+  if (targetResolved === entryResolved)
+    return true;
+  return isInsideDir(targetResolved, entryResolved);
+}
+function safeResolvePath(baseDir, userPath) {
+  const asIs = resolve(normalize(userPath));
+  if (userPath.startsWith("/") || userPath.startsWith("\\")) {
+    if (existsSync7(asIs) || existsSync7(dirname2(asIs)))
+      return asIs;
+  }
+  const norm = normalize(userPath);
+  const stripped = norm.replace(/^[/\\]/, "");
+  const resolved = resolve(baseDir, stripped);
+  if (existsSync7(resolved) || existsSync7(dirname2(resolved)))
+    return resolved;
+  const baseNorm = normalize(baseDir);
+  let cur = baseNorm;
+  while (cur && cur !== dirname2(cur)) {
+    const name = basename(cur);
+    if (!name) {
+      cur = dirname2(cur);
+      continue;
+    }
+    let idx = stripped.toLowerCase().indexOf(name.toLowerCase());
+    while (idx >= 0) {
+      const afterIdx = idx + name.length;
+      const afterChar = stripped[afterIdx];
+      if (afterChar && afterChar !== "\\" && afterChar !== "/") {
+        const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
+        const fixedResolved = resolve(baseDir, normalize(fixed));
+        if (existsSync7(fixedResolved) || existsSync7(dirname2(fixedResolved))) {
+          return fixedResolved;
+        }
+        const fromParent = resolve(dirname2(cur), normalize(fixed));
+        if (existsSync7(fromParent) || existsSync7(dirname2(fromParent))) {
+          return fromParent;
+        }
+      }
+      idx = stripped.toLowerCase().indexOf(name.toLowerCase(), idx + 1);
+    }
+    cur = dirname2(cur);
+  }
+  return resolved;
+}
+var init_path_utils = () => {};
+
 // src/modules/security/path-validator.ts
 var exports_path_validator = {};
 __export(exports_path_validator, {
   isPathWritable: () => isPathWritable,
   isPathInScope: () => isPathInScope
 });
-import { resolve, normalize } from "path";
+import { resolve as resolve2, normalize as normalize2 } from "path";
 function isPathInScope(baseDir, targetPath, scope, securityConfig) {
-  const baseResolved = resolve(baseDir);
-  const targetResolved = resolve(baseDir, normalize(targetPath));
-  if (!targetResolved.startsWith(baseResolved)) {
+  const baseResolved = resolve2(baseDir);
+  const targetResolved = resolve2(baseDir, normalize2(targetPath));
+  if (!isInsideDir(targetResolved, baseResolved)) {
     return {
       allowed: false,
       reason: "Path is outside the base working directory"
@@ -5938,8 +6071,8 @@ function isPathInScope(baseDir, targetPath, scope, securityConfig) {
   }
   if (!securityConfig?.enabled) {
     if (scope) {
-      const isReadScope = scope.read_only_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
-      const isWriteScope = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+      const isReadScope = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
+      const isWriteScope = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
       if (isWriteScope)
         return { allowed: true };
       if (isReadScope)
@@ -5979,8 +6112,8 @@ function isPathInScope(baseDir, targetPath, scope, securityConfig) {
   if (!scope) {
     return { allowed: true };
   }
-  const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
-  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+  const isRead = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
+  const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
   if (isWrite)
     return { allowed: true };
   if (isRead)
@@ -5991,9 +6124,9 @@ function isPathInScope(baseDir, targetPath, scope, securityConfig) {
   };
 }
 function isPathWritable(baseDir, targetPath, scope, securityConfig) {
-  const baseResolved = resolve(baseDir);
-  const targetResolved = resolve(baseDir, normalize(targetPath));
-  if (!targetResolved.startsWith(baseResolved)) {
+  const baseResolved = resolve2(baseDir);
+  const targetResolved = resolve2(baseDir, normalize2(targetPath));
+  if (!isInsideDir(targetResolved, baseResolved)) {
     return {
       allowed: false,
       reason: "Path is outside the base working directory"
@@ -6001,7 +6134,7 @@ function isPathWritable(baseDir, targetPath, scope, securityConfig) {
   }
   if (!securityConfig?.enabled) {
     if (scope) {
-      const isWriteScope = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+      const isWriteScope = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
       if (isWriteScope)
         return { allowed: true };
       return {
@@ -6039,7 +6172,7 @@ function isPathWritable(baseDir, targetPath, scope, securityConfig) {
   if (!scope) {
     return { allowed: true };
   }
-  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+  const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve2(baseDir, f)));
   if (isWrite)
     return { allowed: true };
   return {
@@ -6048,25 +6181,19 @@ function isPathWritable(baseDir, targetPath, scope, securityConfig) {
   };
 }
 function matchesGlobPattern(targetPath, baseDir, pattern) {
-  const resolvedBaseDir = resolve(baseDir);
-  const resolvedTargetPath = resolve(targetPath);
+  const resolvedBaseDir = resolve2(baseDir);
+  const resolvedTargetPath = resolve2(targetPath);
   if (pattern.endsWith("/")) {
     const dirPattern = pattern.slice(0, -1);
-    const resolvedDirPattern = resolve(baseDir, dirPattern);
-    if (resolvedTargetPath === resolvedDirPattern) {
-      return true;
-    }
-    if (resolvedTargetPath.startsWith(resolvedDirPattern + "/") || resolvedTargetPath.startsWith(resolvedDirPattern + "\\")) {
-      return true;
-    }
-    return false;
+    const resolvedDirPattern = resolve2(baseDir, dirPattern);
+    return isInsideDir(resolvedTargetPath, resolvedDirPattern);
   }
   if (pattern.includes("**/")) {
     const parts = pattern.split("**/");
     const prefix = parts[0];
     const suffix = parts[1];
-    const resolvedPrefix = resolve(baseDir, prefix);
-    if (!resolvedTargetPath.startsWith(resolvedPrefix + "/") && !resolvedTargetPath.startsWith(resolvedPrefix + "\\")) {
+    const resolvedPrefix = resolve2(baseDir, prefix);
+    if (!isInsideDir(resolvedTargetPath, resolvedPrefix)) {
       return false;
     }
     const remainingPath = resolvedTargetPath.slice(resolvedPrefix.length);
@@ -6079,8 +6206,8 @@ function matchesGlobPattern(targetPath, baseDir, pattern) {
     const parts = pattern.split("**");
     const prefix = parts[0];
     const suffix = parts[1];
-    const resolvedPrefix = resolve(baseDir, prefix);
-    if (!resolvedTargetPath.startsWith(resolvedPrefix + "/") && !resolvedTargetPath.startsWith(resolvedPrefix + "\\")) {
+    const resolvedPrefix = resolve2(baseDir, prefix);
+    if (!isInsideDir(resolvedTargetPath, resolvedPrefix)) {
       return false;
     }
     if (!suffix) {
@@ -6094,9 +6221,15 @@ function matchesGlobPattern(targetPath, baseDir, pattern) {
     const relativePath = resolvedTargetPath.slice(resolvedBaseDir.length + 1).replace(/\\/g, "/");
     return regex.test(relativePath);
   }
-  return resolvedTargetPath === resolve(baseDir, pattern);
+  const exactTarget = resolve2(baseDir, pattern);
+  if (process.platform === "win32") {
+    return resolvedTargetPath.toLowerCase() === exactTarget.toLowerCase();
+  }
+  return resolvedTargetPath === exactTarget;
 }
-var init_path_validator = () => {};
+var init_path_validator = __esm(() => {
+  init_path_utils();
+});
 
 // src/modules/security/audit-notifier.ts
 var exports_audit_notifier = {};
@@ -6106,8 +6239,8 @@ __export(exports_audit_notifier, {
   DEFAULT_AUDIT_NOTIFIER_CONFIG: () => DEFAULT_AUDIT_NOTIFIER_CONFIG,
   AuditNotifier: () => AuditNotifier
 });
-import { writeFileSync as writeFileSync4, appendFileSync as appendFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7, dirname as dirname2 } from "path";
+import { writeFileSync as writeFileSync4, appendFileSync as appendFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 import { homedir as homedir2 } from "os";
 import { readFileSync as readFileSync4 } from "fs";
 
@@ -6134,7 +6267,7 @@ class AuditNotifier {
   }
   ensureLogDirectory() {
     if (this.config.filePath) {
-      const dir = dirname2(this.config.filePath);
+      const dir = dirname3(this.config.filePath);
       mkdirSync5(dir, { recursive: true });
     }
   }
@@ -6251,13 +6384,13 @@ class AuditNotifier {
       } catch (error) {
         item.retries++;
         const delay = Math.pow(2, item.retries) * 1000;
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
       }
     }
     this.isProcessing = false;
   }
   readNotifications(limit = 100) {
-    if (!this.config.filePath || !existsSync7(this.config.filePath)) {
+    if (!this.config.filePath || !existsSync8(this.config.filePath)) {
       return [];
     }
     try {
@@ -6331,21 +6464,21 @@ var init_audit_notifier = __esm(() => {
 });
 
 // src/modules/security/audit-log.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, appendFileSync as appendFileSync4 } from "fs";
-import { resolve as resolve2, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, appendFileSync as appendFileSync4 } from "fs";
+import { resolve as resolve3, join as join8 } from "path";
 import { homedir as homedir3 } from "os";
 function getAuditDir() {
   return _sessionAuditDir ?? _globalAuditDir;
 }
 function setAuditSessionDir(dir) {
   _sessionAuditDir = dir;
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     mkdirSync6(dir, { recursive: true, mode: 448 });
   }
 }
 function logAudit(entry) {
   const dir = getAuditDir();
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     mkdirSync6(dir, { recursive: true, mode: 448 });
   }
   try {
@@ -6410,59 +6543,75 @@ function logSecurityBlock(sessionId, action, reason, details) {
 var _globalAuditDir, _sessionAuditDir = null;
 var init_audit_log = __esm(() => {
   init_audit_notifier();
-  _globalAuditDir = resolve2(homedir3(), ".mma", "logs");
+  _globalAuditDir = resolve3(homedir3(), ".mma", "logs");
 });
 
-// src/tools/path-utils.ts
-import { resolve as resolve3, normalize as normalize2, dirname as dirname3, basename, sep } from "path";
-import { existsSync as existsSync9 } from "fs";
-function safeResolvePath(baseDir, userPath) {
-  const norm = normalize2(userPath);
-  const stripped = norm.replace(/^[/\\]/, "");
-  const resolved = resolve3(baseDir, stripped);
-  if (existsSync9(resolved) || existsSync9(dirname3(resolved)))
-    return resolved;
-  const baseNorm = normalize2(baseDir);
-  let cur = baseNorm;
-  while (cur && cur !== dirname3(cur)) {
-    const name = basename(cur);
-    if (!name) {
-      cur = dirname3(cur);
-      continue;
-    }
-    let idx = stripped.toLowerCase().indexOf(name.toLowerCase());
-    while (idx >= 0) {
-      const afterIdx = idx + name.length;
-      const afterChar = stripped[afterIdx];
-      if (afterChar && afterChar !== "\\" && afterChar !== "/") {
-        const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
-        const fixedResolved = resolve3(baseDir, normalize2(fixed));
-        if (existsSync9(fixedResolved) || existsSync9(dirname3(fixedResolved))) {
-          return fixedResolved;
-        }
-        const fromParent = resolve3(dirname3(cur), normalize2(fixed));
-        if (existsSync9(fromParent) || existsSync9(dirname3(fromParent))) {
-          return fromParent;
+// src/tools/read-file.ts
+import { readFileSync as readFileSync5, existsSync as existsSync10, statSync as statSync2, openSync, readSync, closeSync } from "fs";
+import { extname } from "path";
+function readLineSlice(path, offset, limit) {
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(STREAM_CHUNK);
+    let pos = 0;
+    let carry = "";
+    let lineNumber = 1;
+    let total = 0;
+    const collected = [];
+    const endLine = offset + limit;
+    while (true) {
+      const bytes = readSync(fd, buf, 0, STREAM_CHUNK, pos);
+      if (bytes === 0)
+        break;
+      pos += bytes;
+      const chunk = carry + buf.toString("utf-8", 0, bytes);
+      const parts = chunk.split(`
+`);
+      carry = parts.pop() ?? "";
+      for (const line of parts) {
+        total++;
+        if (lineNumber >= offset && lineNumber < endLine)
+          collected.push(line);
+        lineNumber++;
+      }
+      if (lineNumber >= endLine && collected.length >= limit) {
+        const rest = [];
+        while (true) {
+          const n = readSync(fd, buf, 0, STREAM_CHUNK, pos);
+          if (n === 0)
+            break;
+          pos += n;
+          rest.push(Buffer.from(buf.subarray(0, n)));
         }
+        const tail = Buffer.concat([...rest, Buffer.from(carry, "utf-8")]);
+        for (let i = 0;i < tail.length; i++)
+          if (tail[i] === 10)
+            total++;
+        total++;
+        return { selected: collected.join(`
+`), total };
       }
-      idx = stripped.toLowerCase().indexOf(name.toLowerCase(), idx + 1);
     }
-    cur = dirname3(cur);
+    if (carry.length > 0 || total === 0) {
+      total++;
+      if (lineNumber >= offset && lineNumber < endLine)
+        collected.push(carry);
+    }
+    return { selected: collected.join(`
+`), total };
+  } finally {
+    closeSync(fd);
   }
-  return resolved;
 }
-var init_path_utils = () => {};
-
-// src/tools/read-file.ts
-import { readFileSync as readFileSync5, existsSync as existsSync10 } from "fs";
-import { extname } from "path";
-var DEFAULT_LIMIT = 300, readFileTool;
+var DEFAULT_LIMIT = 300, LARGE_FILE_BYTES, STREAM_CHUNK, readFileTool;
 var init_read_file = __esm(() => {
   init_i18n();
   init_path_validator();
   init_security();
   init_audit_log();
   init_path_utils();
+  LARGE_FILE_BYTES = 1024 * 1024;
+  STREAM_CHUNK = 256 * 1024;
   readFileTool = {
     name: "read_file",
     icon: "\uD83D\uDC40",
@@ -6506,15 +6655,25 @@ var init_read_file = __esm(() => {
         }) : t("file.notfound", { path });
         return { success: false, output };
       }
-      const content = readFileSync5(resolved, "utf-8");
-      const lines = content.split(`
-`);
-      const total = lines.length;
       const offset = args.offset || 1;
       const limit = args.limit || DEFAULT_LIMIT;
-      const end = Math.min(offset - 1 + limit, total);
-      const selected = lines.slice(offset - 1, end).join(`
+      let lines;
+      let total;
+      let selected;
+      if (statSync2(resolved).size > LARGE_FILE_BYTES) {
+        const slice = readLineSlice(resolved, offset, limit);
+        total = slice.total;
+        selected = slice.selected;
+      } else {
+        const content = readFileSync5(resolved, "utf-8");
+        lines = content.split(`
+`);
+        total = lines.length;
+        const end2 = Math.min(offset - 1 + limit, total);
+        selected = lines.slice(offset - 1, end2).join(`
 `);
+      }
+      const end = Math.min(offset - 1 + limit, total);
       const ext = extname(resolved) || "(no extension)";
       const header = t("file.read_header", {
         path,
@@ -6583,6 +6742,16 @@ var init_content_scanner = __esm(() => {
 });
 
 // src/modules/security/session-isolation.ts
+var exports_session_isolation = {};
+__export(exports_session_isolation, {
+  isPathInSessionScope: () => isPathInSessionScope,
+  getSessionTempDir: () => getSessionTempDir,
+  getSessionSecurityConfig: () => getSessionSecurityConfig,
+  createSessionFilePath: () => createSessionFilePath,
+  createSessionContext: () => createSessionContext,
+  cleanupSessionTempDir: () => cleanupSessionTempDir,
+  DEFAULT_SESSION_ISOLATION: () => DEFAULT_SESSION_ISOLATION
+});
 import { join as join9, resolve as resolve5 } from "path";
 import { homedir as homedir4 } from "os";
 import { mkdirSync as mkdirSync7, existsSync as existsSync11 } from "fs";
@@ -6618,6 +6787,26 @@ function getSessionSecurityConfig(globalConfig, sessionContext) {
     contentScan: { ...globalSecurity.contentScan, ...sessionOverrides.contentScan }
   };
 }
+function getSessionTempDir(sessionContext) {
+  return sessionContext.tempDir;
+}
+function cleanupSessionTempDir(sessionContext) {}
+function createSessionFilePath(sessionContext, relativePath, useTempDir = false) {
+  const baseDir = useTempDir ? sessionContext.tempDir : sessionContext.workingDir;
+  return resolve5(baseDir, relativePath);
+}
+function isPathInSessionScope(sessionContext, path) {
+  const resolvedPath = resolve5(path);
+  const workingDir = resolve5(sessionContext.workingDir);
+  const tempDir = resolve5(sessionContext.tempDir);
+  if (resolvedPath.startsWith(workingDir + "/") || resolvedPath.startsWith(workingDir + "\\")) {
+    return true;
+  }
+  if (resolvedPath.startsWith(tempDir + "/") || resolvedPath.startsWith(tempDir + "\\")) {
+    return true;
+  }
+  return false;
+}
 var DEFAULT_SESSION_ISOLATION;
 var init_session_isolation = __esm(() => {
   init_security();
@@ -7010,7 +7199,7 @@ var init_glob_tool = __esm(() => {
 });
 
 // src/tools/grep-tool.ts
-import { execFileSync } from "child_process";
+import { spawn } from "child_process";
 import { resolve as resolve7 } from "path";
 function truncateLines(output) {
   const lines = output.split(`
@@ -7021,6 +7210,40 @@ function truncateLines(output) {
 `) + `
 ... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
 }
+function runSearch(bin, args, cwd, timeoutMs = 30000) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(bin, args, { cwd, windowsHide: true });
+    let out = "";
+    let err = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, timeoutMs);
+    child.stdout?.on("data", (d) => {
+      out += d;
+    });
+    child.stderr?.on("data", (d) => {
+      err += d;
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(new Error(`search timed out after ${timeoutMs}ms`));
+      } else if (code === 1) {
+        resolvePromise("");
+      } else if (code === 0) {
+        resolvePromise(out);
+      } else {
+        reject(new Error(err || `exit ${code}`));
+      }
+    });
+  });
+}
 var grepTool;
 var init_grep_tool = __esm(() => {
   init_i18n();
@@ -7054,28 +7277,23 @@ var init_grep_tool = __esm(() => {
       }
       logBashCommand(ctx.sessionId, `rg ${rgArgs.join(" ")}`, false, "grep-tool");
       try {
-        const output = execFileSync("rg", rgArgs, {
-          encoding: "utf-8",
-          maxBuffer: 1024 * 1024,
-          cwd: ctx.baseDir
-        });
+        const output = await runSearch("rg", rgArgs, ctx.baseDir);
         return {
           success: true,
           output: truncateLines(output || t("file.no_matches"))
         };
       } catch (e) {
-        if (e.status === 1)
+        if (e.code === "ENOENT") {} else if (/timed out/.test(e.message)) {
+          return { success: false, output: t("error.grep_failed", { message: e.message }) };
+        } else if (e.status === 1) {
           return { success: true, output: t("file.no_matches") };
+        }
         try {
           const grepArgs = ["-rn", pattern, searchPath];
           if (args.include) {
             grepArgs.push("--include", String(args.include));
           }
-          const output = execFileSync("grep", grepArgs, {
-            encoding: "utf-8",
-            maxBuffer: 1024 * 1024,
-            cwd: ctx.baseDir
-          });
+          const output = await runSearch("grep", grepArgs, ctx.baseDir);
           return {
             success: true,
             output: truncateLines(output || t("file.no_matches"))
@@ -7094,7 +7312,7 @@ var init_grep_tool = __esm(() => {
 });
 
 // src/tools/list-dir.ts
-import { readdirSync as readdirSync4, statSync as statSync2, existsSync as existsSync13 } from "fs";
+import { readdirSync as readdirSync4, statSync as statSync3, existsSync as existsSync13 } from "fs";
 import { resolve as resolve8 } from "path";
 var listDirTool;
 var init_list_dir = __esm(() => {
@@ -7132,7 +7350,7 @@ var init_list_dir = __esm(() => {
       const entries = readdirSync4(resolved);
       const lines = entries.map((e) => {
         const full = resolve8(resolved, e);
-        return statSync2(full).isDirectory() ? `${e}/` : e;
+        return statSync3(full).isDirectory() ? `${e}/` : e;
       });
       if (lines.length === 0) {
         return { success: true, output: t("file.empty") };
@@ -7200,7 +7418,7 @@ var init_create_dir = __esm(() => {
 });
 
 // src/tools/delete-file.ts
-import { unlinkSync as unlinkSync3, existsSync as existsSync15, statSync as statSync3, readFileSync as readFileSync8 } from "fs";
+import { unlinkSync as unlinkSync3, existsSync as existsSync15, statSync as statSync4, readFileSync as readFileSync8 } from "fs";
 var deleteFileTool;
 var init_delete_file = __esm(() => {
   init_i18n();
@@ -7247,7 +7465,7 @@ var init_delete_file = __esm(() => {
       if (!existsSync15(resolved)) {
         return { success: false, output: t("file.notfound", { path }) };
       }
-      if (statSync3(resolved).isDirectory()) {
+      if (statSync4(resolved).isDirectory()) {
         return { success: false, output: t("file.is_directory", { path }) };
       }
       const content = readFileSync8(resolved, "utf-8");
@@ -7344,7 +7562,7 @@ var init_move_file = __esm(() => {
 });
 
 // src/tools/file-info.ts
-import { statSync as statSync4, existsSync as existsSync17 } from "fs";
+import { statSync as statSync5, existsSync as existsSync17 } from "fs";
 var fileInfoTool;
 var init_file_info = __esm(() => {
   init_i18n();
@@ -7378,7 +7596,7 @@ var init_file_info = __esm(() => {
       if (!existsSync17(resolved)) {
         return { success: false, output: t("file.not_found_short", { path }) };
       }
-      const stat = statSync4(resolved);
+      const stat = statSync5(resolved);
       return {
         success: true,
         output: JSON.stringify({
@@ -7450,6 +7668,16 @@ function isCommandAllowed(command, securityConfig) {
       reason: `Shell wrapper "${baseForShellCheck}" is blocked — use the bash tool directly`
     };
   }
+  const INTERPRETER_FLAGS = /(?:^|\s)(?:bash|sh|zsh|dash|python|python3|node|bun|perl|ruby)\s+(?:-c|-e|--command|--eval)\b/;
+  if (INTERPRETER_FLAGS.test(trimmedCommand)) {
+    return { allowed: false, reason: "Interpreter -c/-e invocation is blocked" };
+  }
+  if (/\r?\n/.test(trimmedCommand)) {
+    return { allowed: false, reason: "Multi-line commands are blocked" };
+  }
+  if (/[;&|]/.test(trimmedCommand) && /(^|[;&|\s])(rm|del|rd|dd|chmod|chown|wget|curl|nc|netcat|shutdown|reboot|mkfs|fdisk)\b/.test(trimmedCommand)) {
+    return { allowed: false, reason: "Command chaining to a dangerous command is blocked" };
+  }
   if (config.blockDangerousFlags) {
     for (const op of config.dangerousOperators || []) {
       if (containsOperator(trimmedCommand, op)) {
@@ -7550,7 +7778,7 @@ var init_command_validator = __esm(() => {
 });
 
 // src/modules/processes/registry.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn as spawn2, spawnSync } from "child_process";
 import { platform } from "os";
 function getOemDecoder() {
   if (oemDecoder !== undefined)
@@ -7646,7 +7874,7 @@ class ProcessRegistry {
     this.procs.set(id, entry);
     let child;
     try {
-      child = spawn(command, {
+      child = spawn2(command, {
         cwd,
         shell: true,
         windowsHide: true,
@@ -8071,7 +8299,7 @@ ${redirected.output}`
       const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
       const appConfig = ctx.config || {};
       const fullSecurityConfig = ctx.sessionContext ? getSessionSecurityConfig(appConfig, ctx.sessionContext) : appConfig.security || DEFAULT_SECURITY_CONFIG;
-      const securityConfig = fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
+      const securityConfig = fullSecurityConfig.enabled === false ? { ...fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash, enabled: false } : fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
       const validation = isCommandAllowed(command, securityConfig);
       if (!validation.allowed) {
         logSecurityBlock(ctx.sessionId, "bash_command", validation.reason || "Command blocked by security policy", sanitizeCommandForLog(originalCommand));
@@ -8111,11 +8339,15 @@ Hint: ${cliHint}`;
           }
           const testRun = detectTestResults(output2);
           if (testRun && testRun.failed > 0) {
-            output2 = `[test-runner] ${testRun.framework}: ${testRun.failed} test(s) FAILING, ${testRun.passed} passing — do NOT mark verification steps as done while tests fail. Investigate the failures, fix the code, then re-run the tests.
+            output2 = t("exec.test_runner_fail", {
+              framework: testRun.framework,
+              failed: String(testRun.failed),
+              passed: String(testRun.passed)
+            }) + `
 
-` + output2;
+${output2}`;
           } else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
-            output2 = `[test-runner] ${testRun.framework}: all ${testRun.passed} test(s) passing.
+            output2 = `${t("exec.test_runner_pass", { framework: testRun.framework, passed: String(testRun.passed) })}
 
 ${output2}`;
           }
@@ -8432,15 +8664,16 @@ class SessionLogger {
     });
   }
   logUser(content) {
+    const sanitized = sanitizeLogMessage(content);
     this.session?.appendMessage({
       role: "user",
-      content,
+      content: sanitized,
       timestamp: new Date().toISOString()
     });
     this.session?.appendLog({
       ts: new Date().toISOString(),
       type: "user",
-      content
+      content: sanitized
     });
   }
   logAssistant(content, reasoning, toolCalls, iteration) {
@@ -8488,14 +8721,14 @@ class SessionLogger {
       type: "tool_call",
       tool: call.name,
       tool_call_id: call.id,
-      args: call.arguments,
+      args: JSON.parse(sanitizeLogMessage(JSON.stringify(call.arguments))),
       iteration
     });
   }
   logToolResult(call, result, duration, iteration) {
     this.session?.appendMessage({
       role: "tool",
-      content: result.output.slice(0, 500),
+      content: sanitizeLogMessage(result.output.slice(0, 500)),
       name: call.name,
       timestamp: new Date().toISOString()
     });
@@ -8505,7 +8738,7 @@ class SessionLogger {
       tool: call.name,
       tool_call_id: call.id,
       success: result.success,
-      content: result.output.slice(0, 1000),
+      content: sanitizeLogMessage(result.output.slice(0, 1000)),
       diff: result.diff,
       duration,
       iteration
@@ -8610,6 +8843,7 @@ class SessionLogger {
 }
 var init_session_logger = __esm(() => {
   init_audit_log();
+  init_data_sanitizer();
 });
 
 // node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
@@ -9950,26 +10184,26 @@ class StuckDetector {
     const hints = [];
     const desc = this.currentStepDescription.toLowerCase();
     if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
-      hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
+      hints.push(t("exec.hint_deps"));
     }
     if (desc.includes("test") || desc.includes("spec")) {
-      hints.push("Make sure the source files exist and have real code before running tests.");
+      hints.push(t("exec.hint_test"));
     }
     if (desc.includes("build") || desc.includes("compile")) {
-      hints.push("Check that all dependencies are installed and source files are not empty.");
+      hints.push(t("exec.hint_build"));
     }
     if (desc.includes("deploy") || desc.includes("publish")) {
-      hints.push("Verify credentials and network access before deploying.");
+      hints.push(t("exec.hint_deploy"));
     }
     const primary = this.getPrimaryReason();
     if (this.hasRepetitiveToolCalls() && primary !== "repetitive") {
-      hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
+      hints.push(t("exec.hint_repetitive"));
     }
     if (this.hasConsecutiveFailures() && primary !== "consecutive") {
-      hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
+      hints.push(t("exec.hint_consecutive"));
     }
     if (this.hasReadOnlyLoop() && primary !== "read-only") {
-      hints.push("You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps.");
+      hints.push(t("exec.hint_read_only"));
     }
     return hints;
   }
@@ -10264,7 +10498,7 @@ var init_stuck_detector = __esm(() => {
 
 // src/modules/artifacts/store.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { resolve as resolve10, relative, isAbsolute } from "node:path";
+import { resolve as resolve10, relative as relative2, isAbsolute as isAbsolute2 } from "node:path";
 
 class ArtifactStore {
   root;
@@ -10281,10 +10515,10 @@ class ArtifactStore {
     return cleaned;
   }
   static isInside(root, candidate) {
-    const rel = relative(root, candidate);
+    const rel = relative2(root, candidate);
     if (rel === "")
       return true;
-    return !rel.startsWith("..") && !isAbsolute(rel);
+    return !rel.startsWith("..") && !isAbsolute2(rel);
   }
   save(name, content, ext = "md") {
     const safe = ArtifactStore.sanitizeName(name);
@@ -10383,7 +10617,6 @@ async function executeSubtask(subtask, deps, _sharedContext) {
   }
   const maxAttempts = expertConfig.max_attempts || 3;
   let lastError = "";
-  let lastResult = null;
   const stuckDetector = new StuckDetector(maxAttempts * 2, maxAttempts);
   for (let attempt = 1;attempt <= maxAttempts; attempt++) {
     stuckDetector.recordIteration(1);
@@ -10447,7 +10680,6 @@ ${(subtask.success_criteria || []).map((c) => `- ${c}`).join(`
         };
       }
       lastError = result.output;
-      lastResult = result;
       stuckDetector.recordToolError("subagent", result.output);
       if (attempt < maxAttempts) {
         const hints2 = stuckDetector.getActionableHints();
@@ -10566,21 +10798,36 @@ class MoEExecutor {
     }
     for (let waveIdx = 0;waveIdx < waves.length; waveIdx++) {
       const wave = waves[waveIdx];
-      const wavePromises = wave.map((subtask) => executeSubtask(subtask, this.deps, plan.shared_context).then((result) => {
+      const maxParallel = this.deps.config?.security?.rateLimits?.maxParallelTasks ?? 5;
+      let active = 0;
+      const waiters = [];
+      const acquire = () => active < maxParallel ? Promise.resolve(active++) : new Promise((resolve11) => waiters.push(() => resolve11(active++)));
+      const release = () => {
+        active--;
+        const next = waiters.shift();
+        if (next)
+          next();
+      };
+      const wavePromises = wave.map(async (subtask) => {
+        await acquire();
+        let result;
+        try {
+          result = await executeSubtask(subtask, this.deps, plan.shared_context);
+        } catch (e) {
+          result = {
+            subtaskId: subtask.id,
+            success: false,
+            summary: `Unhandled error: ${subtask.id}`,
+            result: "",
+            error: e instanceof Error ? e.message : String(e),
+            durationMs: 0
+          };
+        } finally {
+          release();
+        }
         results.push(result);
         return result;
-      }).catch((e) => {
-        const errResult = {
-          subtaskId: subtask.id,
-          success: false,
-          summary: `Unhandled error: ${subtask.id}`,
-          result: "",
-          error: e.message,
-          durationMs: 0
-        };
-        results.push(errResult);
-        return errResult;
-      }));
+      });
       await Promise.all(wavePromises);
     }
     const failed = results.filter((r) => !r.success);
@@ -10589,9 +10836,6 @@ class MoEExecutor {
     }
     return { success: failed.length === 0, results, errors, warnings };
   }
-  getChainMaxAttempts() {
-    return 3;
-  }
 }
 var TRANSIENT_ERROR_PATTERNS;
 var init_moe_executor = __esm(() => {
@@ -11179,7 +11423,7 @@ var init_auditor = __esm(() => {
 // src/modules/execution/verifier.ts
 import { existsSync as existsSync23 } from "fs";
 import { resolve as resolve13, extname as extname2, join as join14 } from "path";
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 class StepVerifier {
   baseDir;
@@ -11341,7 +11585,7 @@ class StepVerifier {
   }
   runAsync(command, cwd, timeoutMs) {
     return new Promise((resolve14, reject) => {
-      const child = spawn2(command, {
+      const child = spawn3(command, {
         cwd,
         shell: true,
         windowsHide: true,
@@ -11664,6 +11908,9 @@ class Agent {
   get contextManager() {
     return this.deps.contextManager;
   }
+  getModule(name) {
+    return this.deps.moduleRegistry?.get(name);
+  }
   setScope() {
     if (this.deps.scope) {
       this.deps.toolExecutor.setScope(this.deps.scope);
@@ -12397,7 +12644,6 @@ ${warnLine}
     });
     this.deps.llmProvider = newProvider;
     this.deps.toolExecutor.updateProvider(newProvider);
-    this.deps.toolExecutor.ctx.llmProvider = newProvider;
     const newTokenCounter = new TokenCounter2(config.model);
     this.deps.contextManager.resize(config.contextWindow, config.contextBudget, newTokenCounter);
     this.deps.config = config;
@@ -12734,6 +12980,15 @@ class ContextManager {
   getMessageCount() {
     return this.messages.length;
   }
+  tokenCache = new WeakMap;
+  estimateMessageTokensCached(m) {
+    let t2 = this.tokenCache.get(m);
+    if (t2 === undefined) {
+      t2 = this.estimateMessageTokens(m);
+      this.tokenCache.set(m, t2);
+    }
+    return t2;
+  }
   estimateMessageTokens(m) {
     const text = getMessageText(m.content);
     if (this.tokenCounter) {
@@ -12778,7 +13033,7 @@ class ContextManager {
   needsCompaction() {
     if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
       return true;
-    const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+    const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0);
     return totalTokens > this.budget.history * this.compactionThreshold;
   }
   compact() {
@@ -12889,7 +13144,7 @@ ${lines.join(`
     this.sessionMission = "";
   }
   getEstimatedTokens() {
-    return this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) + this.toolTokens;
+    return this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0) + this.toolTokens;
   }
   setToolTokens(tokens) {
     this.toolTokens = tokens;
@@ -13000,7 +13255,7 @@ var init_confidence = __esm(() => {
 
 // src/modules/hallucination/factual.ts
 import { existsSync as existsSync24, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve14, isAbsolute as isAbsolute2, join as join15 } from "path";
+import { resolve as resolve14, isAbsolute as isAbsolute3, join as join15 } from "path";
 
 class FactualCheck {
   baseDir;
@@ -13039,7 +13294,7 @@ class FactualCheck {
     return { status: "pass" };
   }
   pathExists(fp) {
-    if (isAbsolute2(fp))
+    if (isAbsolute3(fp))
       return existsSync24(fp);
     if (this.knownFiles.has(fp))
       return true;
@@ -13705,7 +13960,6 @@ var init_subagent = __esm(() => {
         const fullTask = context ? `${task}
 
 Context: ${context}` : task;
-        let scopeRestored = false;
         try {
           const result = await subAgent.run(fullTask);
           if (!result.success) {
@@ -13742,9 +13996,7 @@ ${result.text}
 Iterations: ${result.iterationCount}`
           };
         } finally {
-          if (!scopeRestored) {
-            ctx.toolExecutor.setScope(parentScope || { allowed_files: [], read_only_files: [] });
-          }
+          ctx.toolExecutor.setScope(parentScope);
         }
       } catch (e) {
         return { success: false, output: `Sub-agent error: ${e.message}` };
@@ -13758,20 +14010,22 @@ import { resolve as resolve15, normalize as normalize4 } from "path";
 function isPathInScope2(baseDir, targetPath, scope) {
   const baseResolved = resolve15(baseDir);
   const targetResolved = resolve15(baseDir, normalize4(targetPath));
-  if (!targetResolved.startsWith(baseResolved)) {
+  if (!isInsideDir(targetResolved, baseResolved)) {
     return { allowed: false, reason: "Path is outside the base working directory" };
   }
   if (!scope)
     return { allowed: true };
-  const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve15(baseDir, f)));
-  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve15(baseDir, f)));
+  const isRead = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve15(baseDir, f)));
+  const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve15(baseDir, f)));
   if (isWrite)
     return { allowed: true };
   if (isRead)
     return { allowed: true, reason: "Read-only file" };
   return { allowed: false, reason: "Path is not within the allowed scope for this sub-agent" };
 }
-var init_scope_check = () => {};
+var init_scope_check = __esm(() => {
+  init_path_utils();
+});
 
 // src/modules/context/chunk-query.ts
 function splitTextIntoChunks(text, chunkChars) {
@@ -13978,6 +14232,16 @@ ${res.synthesis || res.answers.join(`
 });
 
 // src/modules/security/network-validator.ts
+var exports_network_validator = {};
+__export(exports_network_validator, {
+  sanitizeUrl: () => sanitizeUrl,
+  isUrlAllowed: () => isUrlAllowed,
+  isIpPrivate: () => isIpPrivate
+});
+function isIpPrivate(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  return /^(localhost|127\.0\.0\.1|0\.0\.0\.0|10\.|192\.168\.|169\.254\.|172\.(1[6-9]|2\d|3[01])\.)/.test(h) || h === "::1" || /^(fc|fd)/.test(h) || h.includes(":") && h.startsWith("fe80");
+}
 function isUrlAllowed(url, securityConfig) {
   if (!securityConfig?.enabled) {
     return { allowed: true };
@@ -13985,6 +14249,13 @@ function isUrlAllowed(url, securityConfig) {
   try {
     const urlObj = new URL(url);
     const domain = urlObj.hostname.toLowerCase();
+    const scheme = urlObj.protocol.toLowerCase();
+    if (scheme !== "http:" && scheme !== "https:") {
+      return { allowed: false, reason: `Scheme "${scheme}" is not allowed` };
+    }
+    if (isIpPrivate(domain)) {
+      return { allowed: false, reason: `Private address "${domain}" is blocked (SSRF)` };
+    }
     if (securityConfig.deniedDomains?.length) {
       for (const deniedDomain of securityConfig.deniedDomains) {
         const denied = deniedDomain.toLowerCase();
@@ -14177,21 +14448,40 @@ var init_web_fetch = __esm(() => {
       }
       try {
         const response = await fetch(url, {
-          signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000)
+          signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+          redirect: "manual"
         });
-        if (!response.ok) {
+        let finalResponse = response;
+        let finalUrl = url;
+        if (response.status >= 300 && response.status < 400) {
+          const loc = response.headers.get("location");
+          if (!loc) {
+            return { success: false, output: t("error.fetch_failed", { message: "Redirect without location" }) };
+          }
+          finalUrl = new URL(loc, url).toString();
+          const recheck = isUrlAllowed(finalUrl, securityConfig);
+          if (!recheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", recheck.reason || "redirect blocked", sanitizeUrl(finalUrl));
+            return { success: false, output: `[SECURITY BLOCKED] redirect: ${recheck.reason}` };
+          }
+          finalResponse = await fetch(finalUrl, {
+            signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+            redirect: "follow"
+          });
+        }
+        if (!finalResponse.ok) {
           return {
             success: false,
             output: t("error.http", {
-              status: response.status,
-              statusText: response.statusText
+              status: finalResponse.status,
+              statusText: finalResponse.statusText
             })
           };
         }
-        const contentType = response.headers.get("content-type") || "";
-        const text = await response.text();
+        const contentType = finalResponse.headers.get("content-type") || "";
+        const text = await finalResponse.text();
         const cleaned = contentType.includes("html") ? stripHtml(text) : text;
-        logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+        logNetworkRequest(ctx.sessionId, sanitizeUrl(finalUrl), true, `Status: ${finalResponse.status}`);
         const fullChars = cleaned.length;
         const fullLines = cleaned.split(`
 `).length;
@@ -14753,7 +15043,7 @@ ${logs.join(`
 });
 
 // src/modules/mcp/client.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 
 class MCPClient {
   serverName;
@@ -14860,7 +15150,7 @@ class MCPClient {
   }
   connectStdio() {
     return new Promise((resolve17, reject) => {
-      const child = spawn3(this.config.command, this.config.args || [], {
+      const child = spawn4(this.config.command, this.config.args || [], {
         env: { ...process.env, ...this.config.env },
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -15657,7 +15947,7 @@ var exports_bridge_client = {};
 __export(exports_bridge_client, {
   BridgeDriver: () => BridgeDriver
 });
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { createInterface } from "readline";
 import { dirname as dirname10, join as join22 } from "path";
 import { fileURLToPath } from "url";
@@ -15733,7 +16023,7 @@ class BridgeDriver {
   }
   spawnBridge() {
     const script = bridgeScriptPath();
-    const proc = spawn4("node", [script], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    const proc = spawn5("node", [script], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
     this.proc = proc;
     this.lastStderr = [];
     proc.stderr.on("data", (chunk) => {
@@ -16427,6 +16717,9 @@ class BrowserSession {
   async open(url) {
     if (!url)
       return { success: false, output: t("browser.url_required") };
+    if (/^(file|chrome|about|data|javascript|view-source):/i.test(url)) {
+      return { success: false, output: `[SECURITY BLOCKED] scheme not allowed: ${url}` };
+    }
     if (!url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("file://")) {
       const isLocalhost = /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?$/i.test(url);
       url = isLocalhost ? "http://" + url : "https://" + url;
@@ -16854,6 +17147,14 @@ var init_attach_image = __esm(() => {
           const result = await bufferToDataUrl(clipBuf);
           dataUrl = result.dataUrl;
         } else if (source.startsWith("http://") || source.startsWith("https://")) {
+          const { isUrlAllowed: isUrlAllowed2 } = await Promise.resolve().then(() => (init_network_validator(), exports_network_validator));
+          const { getSessionSecurityConfig: getSessionSecurityConfig2 } = await Promise.resolve().then(() => (init_session_isolation(), exports_session_isolation));
+          const networkConfig = ctx.sessionContext ? getSessionSecurityConfig2(ctx.config, ctx.sessionContext).network : ctx.config?.security?.network;
+          const urlCheck = isUrlAllowed2(source, networkConfig);
+          if (!urlCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", urlCheck.reason ?? "attach_image URL blocked", source);
+            return { success: false, output: `[SECURITY BLOCKED] ${urlCheck.reason}` };
+          }
           const result = await loadUrlAsDataUrl(source);
           dataUrl = result.dataUrl;
         } else {
@@ -17070,6 +17371,7 @@ class ModuleRegistry {
   modules = new Map;
   register(mod) {
     this.modules.set(mod.name, mod);
+    return this;
   }
   get(name) {
     return this.modules.get(name);
@@ -17115,7 +17417,7 @@ class ModuleRegistry {
 }
 
 // src/modules/plugins/loader.ts
-import { readdirSync as readdirSync9, existsSync as existsSync31, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync9, existsSync as existsSync31, statSync as statSync6 } from "fs";
 import { join as join25, basename as basename3 } from "path";
 
 class PluginLoader {
@@ -17125,7 +17427,7 @@ class PluginLoader {
     const entries = readdirSync9(dirPath).sort();
     for (const entry of entries) {
       const fullPath = join25(dirPath, entry);
-      const stat = statSync5(fullPath);
+      const stat = statSync6(fullPath);
       if (stat.isFile()) {
         if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
           continue;
@@ -17182,7 +17484,7 @@ var init_loader = __esm(() => {
 });
 
 // src/modules/plugins/builtin/lint-on-write.ts
-import { spawn as spawn5, execSync } from "child_process";
+import { spawn as spawn6, execSync } from "child_process";
 import { existsSync as existsSync32, readFileSync as readFileSync17 } from "fs";
 import { resolve as resolve18, extname as extname4, join as join26 } from "path";
 import { platform as platform5 } from "os";
@@ -17365,7 +17667,7 @@ class LintOnWritePlugin {
 }
 function runAsync(command, cwd, timeoutMs, signal) {
   return new Promise((resolve19, reject) => {
-    const child = spawn5(command, {
+    const child = spawn6(command, {
       cwd,
       shell: true,
       windowsHide: true,
@@ -17989,7 +18291,11 @@ Last compile error: ${first[1]}`;
             const step = deps.trackerRef.current?.getCurrentStep();
             ctx.contextManager.addMessage({
               role: "user",
-              content: `<system-summary>STOP. Step ${step?.id ?? "?"} ("${step?.description ?? ""}") took ${deps.stuckDetector.getIterationsOnCurrentStep()} iterations with no progress. DO NOT continue this step. Immediately call: plan update step=${step?.id ?? "?"} status=done (if code works despite warnings) OR plan update step=${step?.id ?? "?"} status=skipped note="reason". Do NOT make any other tool calls before updating the plan.</system-summary>`
+              content: `<system-summary>${t("exec.stop_directive", {
+                stepId: String(step?.id ?? "?"),
+                description: step?.description ?? "",
+                iterations: String(deps.stuckDetector.getIterationsOnCurrentStep())
+              })}</system-summary>`
             });
           }
         }
@@ -18669,16 +18975,16 @@ ${progress}${vacuousNote}`,
           output += ` (${doneCount}/${subs.length})`;
           if (doneCount === subs.length) {
             output += `
-All sub-tasks done — call plan update step=${currentStep.id} status=done to complete this step.`;
+${t("plan.subtasks_done", { stepId: String(currentStep.id) })}`;
           }
           return { success: true, output, display };
         }
         if (action === "list") {
           const subs = currentStep.subtasks ?? [];
-          const lines = subs.length ? subs.map((s) => `${s.done ? "[x]" : "[ ]"} ${s.text}`) : ["(no sub-tasks)"];
+          const lines = subs.length ? subs.map((s) => `${s.done ? "[x]" : "[ ]"} ${s.text}`) : [t("plan.no_subtasks")];
           return {
             success: true,
-            output: `Step ${currentStep.id}: ${currentStep.description}
+            output: `${t("plan.step_label", { stepId: String(currentStep.id), description: currentStep.description })}
 ${lines.join(`
 `)}`
           };
@@ -19373,7 +19679,7 @@ class SessionStore {
     return this.encryptor?.isEnabled() ?? false;
   }
   init() {
-    mkdirSync15(this.baseDir, { recursive: true });
+    mkdirSync15(this.baseDir, { recursive: true, mode: 448 });
   }
   sessionDir(id) {
     return join29(this.baseDir, id);
@@ -19393,12 +19699,12 @@ class SessionStore {
   saveMeta(id, meta) {
     this._metaCache.set(id, meta);
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true, mode: 448 });
     const content = JSON.stringify(meta, null, 2);
     if (this.encryptor) {
-      writeFileSync12(this.metaPath(id), this.encryptor.encryptFileContent(content), "utf-8");
+      writeFileSync12(this.metaPath(id), this.encryptor.encryptFileContent(content), { encoding: "utf-8", mode: 384 });
     } else {
-      writeFileSync12(this.metaPath(id), content, "utf-8");
+      writeFileSync12(this.metaPath(id), content, { encoding: "utf-8", mode: 384 });
     }
   }
   loadMeta(id) {
@@ -19420,14 +19726,14 @@ class SessionStore {
   }
   appendMessage(id, msg) {
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true, mode: 448 });
     const line = JSON.stringify(msg);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.historyPath(id), this.encryptor.encryptFileContent(line) + `
-`, "utf-8");
+`, { encoding: "utf-8", mode: 384 });
     } else {
       appendFileSync6(this.historyPath(id), line + `
-`, "utf-8");
+`, { encoding: "utf-8", mode: 384 });
     }
     const meta = this.loadMeta(id);
     if (meta) {
@@ -19467,14 +19773,14 @@ class SessionStore {
   }
   appendSessionLog(id, entry) {
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true, mode: 448 });
     const line = JSON.stringify(entry);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + `
-`, "utf-8");
+`, { encoding: "utf-8", mode: 384 });
     } else {
       appendFileSync6(this.sessionLogPath(id), line + `
-`, "utf-8");
+`, { encoding: "utf-8", mode: 384 });
     }
   }
   loadSessionLog(id) {
@@ -19819,7 +20125,7 @@ class UserProfile {
 var init_profile = () => {};
 
 // src/modules/skills/loader.ts
-import { readdirSync as readdirSync13, readFileSync as readFileSync23, existsSync as existsSync38, statSync as statSync6 } from "fs";
+import { readdirSync as readdirSync13, readFileSync as readFileSync23, existsSync as existsSync38, statSync as statSync7 } from "fs";
 import { join as join31 } from "path";
 
 class SkillsLoader {
@@ -19834,7 +20140,7 @@ class SkillsLoader {
     const entries = readdirSync13(dirPath);
     for (const entry of entries) {
       const fullPath = join31(dirPath, entry);
-      const stat = statSync6(fullPath);
+      const stat = statSync7(fullPath);
       if (stat.isDirectory()) {
         this.scanDir(fullPath, skills);
         continue;
@@ -20077,10 +20383,29 @@ var init_browser2 = __esm(() => {
 });
 
 // src/modules/lsp/client.ts
-import { spawn as spawn6, execSync as execSync2 } from "child_process";
+import { spawn as spawn7, execSync as execSync2 } from "child_process";
 import { resolve as resolve20 } from "path";
 import { platform as platform8 } from "os";
 
+class FileOnlyLogger {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  debug(msg, meta) {
+    this.logger.logSilent("debug", msg, meta);
+  }
+  info(msg, meta) {
+    this.logger.logSilent("info", msg, meta);
+  }
+  warn(msg, meta) {
+    this.logger.logSilent("warn", msg, meta);
+  }
+  error(msg, meta) {
+    this.logger.logSilent("error", msg, meta);
+  }
+}
+
 class LspClient {
   logger = null;
   setLogger(logger) {
@@ -20175,10 +20500,26 @@ class LspClient {
         throw new Error(`${config.command} not found in PATH`);
       }
     }
+    let effectiveCommand = config.command;
+    let effectiveArgs = config.args ?? [];
+    if (config.command === "npx" && effectiveArgs.length > 0) {
+      const binaryName = this.extractBinaryFromNpxArgs(effectiveArgs);
+      if (binaryName) {
+        const whichCmd = platform8() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
+        try {
+          execSync2(whichCmd, { stdio: "pipe", timeout: 3000 });
+          effectiveCommand = binaryName;
+          effectiveArgs = effectiveArgs.filter((a) => a !== "--yes" && a !== "--package" && a !== binaryName && !this.isPackageVersion(a));
+          this.logger?.debug(`LSP: using globally installed ${binaryName} (skipped npx)`);
+        } catch {
+          this.logger?.debug(`LSP: ${binaryName} not found globally, falling back to npx`);
+        }
+      }
+    }
     return new Promise((resolve21, reject) => {
-      const args = config.args ?? [];
+      const args = effectiveArgs;
       const isWin = platform8() === "win32";
-      let spawnCommand = resolveSpawnCommand(config.command);
+      let spawnCommand = resolveSpawnCommand(effectiveCommand);
       let spawnArgs = args;
       const spawnOpts = {
         stdio: ["pipe", "pipe", "pipe"],
@@ -20190,7 +20531,7 @@ class LspClient {
         spawnArgs = [];
         spawnOpts.shell = true;
       }
-      const proc = spawn6(spawnCommand, spawnArgs, spawnOpts);
+      const proc = spawn7(spawnCommand, spawnArgs, spawnOpts);
       proc.on("error", reject);
       proc.stdout.on("data", (chunk) => {
         this.handleData(chunk);
@@ -20368,6 +20709,22 @@ class LspClient {
     };
     return map[ext ?? ""] ?? "plaintext";
   }
+  extractBinaryFromNpxArgs(args) {
+    for (let i = args.length - 1;i >= 0; i--) {
+      const arg = args[i];
+      if (arg === "--stdio")
+        continue;
+      if (arg.startsWith("--"))
+        return null;
+      if (this.isPackageVersion(arg))
+        continue;
+      return arg;
+    }
+    return null;
+  }
+  isPackageVersion(s) {
+    return /^[\w-]+@[\d.+*-]/.test(s);
+  }
 }
 var DEFAULT_TIMEOUT = 15000;
 var init_client2 = __esm(() => {
@@ -20377,7 +20734,7 @@ var init_client2 = __esm(() => {
 
 // src/modules/lsp/check-tool.ts
 import { readdir, stat } from "fs/promises";
-import { resolve as resolve21, relative as relative2 } from "path";
+import { resolve as resolve21, relative as relative3 } from "path";
 async function collectCheckFiles(resolved, config) {
   const info = await stat(resolved).catch(() => null);
   if (!info)
@@ -20406,7 +20763,7 @@ async function walkDir(dir, depth, out, config) {
 }
 function formatCheckDiagnostics(items, baseDir) {
   return items.slice(0, 40).map(({ file, diag }) => {
-    const rel = relative2(baseDir, file).replace(/\\/g, "/");
+    const rel = relative3(baseDir, file).replace(/\\/g, "/");
     const line = diag.range.start.line + 1;
     const col = diag.range.start.character + 1;
     const sev = severityLabels[diag.severity] ?? "unknown";
@@ -20428,7 +20785,7 @@ var init_check_tool = __esm(() => {
 
 // src/modules/lsp/module.ts
 import { existsSync as existsSync39 } from "fs";
-import { relative as relative3, resolve as resolve22 } from "path";
+import { relative as relative4, resolve as resolve22 } from "path";
 
 class LspModule {
   name = "lsp";
@@ -20595,7 +20952,7 @@ ${items}`;
         const diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
         this.failuresByServer.set(key, 0);
         checked++;
-        checkedFiles.push(relative3(ctx.baseDir, file).replace(/\\/g, "/"));
+        checkedFiles.push(relative4(ctx.baseDir, file).replace(/\\/g, "/"));
         for (const d of diags) {
           if (d.severity === 1)
             errors.push({ file, diag: d });
@@ -20676,7 +21033,7 @@ var init_lsp = __esm(() => {
 // src/modules/lsp/startup-check.ts
 import { existsSync as existsSync40 } from "fs";
 import { join as join32 } from "path";
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 async function runStartupHealthCheck(config, baseDir, deps = {}) {
   if (!config.enabled)
     return null;
@@ -20738,7 +21095,7 @@ async function runCheck(config, baseDir, deps) {
 }
 async function runTscDefault(projectRoot, timeoutMs) {
   return new Promise((resolve23) => {
-    const child = spawn7("npx", ["tsc", "--noEmit", "--skipLibCheck"], {
+    const child = spawn8("npx", ["tsc", "--noEmit", "--skipLibCheck"], {
       cwd: projectRoot,
       shell: true,
       windowsHide: true,
@@ -20802,8 +21159,8 @@ var init_startup_check = __esm(() => {
 });
 
 // src/modules/indexer/walker.ts
-import { readdirSync as readdirSync14, readFileSync as readFileSync24, statSync as statSync7, existsSync as existsSync41, watch } from "fs";
-import { join as join33, relative as relative4, extname as extname5 } from "path";
+import { readdirSync as readdirSync14, readFileSync as readFileSync24, statSync as statSync8, existsSync as existsSync41, watch } from "fs";
+import { join as join33, relative as relative5, extname as extname5 } from "path";
 
 class Indexer {
   baseDir;
@@ -20842,8 +21199,8 @@ class Indexer {
         if (count >= this.MAX_FILES)
           return;
         const fullPath = join33(dir, entry);
-        const relPath = relative4(this.baseDir, fullPath);
-        const stat2 = statSync7(fullPath);
+        const relPath = relative5(this.baseDir, fullPath);
+        const stat2 = statSync8(fullPath);
         if (stat2.isDirectory()) {
           if (!IGNORE_DIRS.has(entry)) {
             walkDir2(fullPath);
@@ -21817,7 +22174,9 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
   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 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).`
+    `Design: YAGNI (no unneeded code), KISS (simple over clever), DRY (reuse existing utilities).`,
+    `SCOPE DISCIPLINE: do ONLY what the user explicitly asked — no extra features, files, refactors, "improvements", or fixes beyond the request. Read-only requests ("расскажи", "покажи", "объясни", "check") mean READ-ONLY: inspect and answer, never create/modify/delete anything. If the task is ambiguous (what to create, where, which variant) or the request implies action on something you could not find — STOP and ask the user a short clarifying question in plain text instead of guessing.`,
+    `NOT FOUND ≠ MISSING PROJECT: a "not found" tool result means the PATH was wrong (typo, different location), not that the project does not exist. Before creating or scaffolding ANY project/files: first run list_dir on the working directory to see what is already there; if a user-named path is not found, list its parent directory to locate the real path. NEVER create a new project when the user asked about an existing one — inspect first, create only after confirming the workspace is empty AND the user asked for creation.`
   ];
   if (isWin) {
     lines.push(`Windows (PowerShell): use list_dir/read_file/delete_file/create_dir tools instead of dir/type/del/mkdir. No PowerShell cmdlets (Get-Content, Select-Object, Write-Output), no head/tail/grep/cat. Use forward slashes in paths. CWD: ${baseDir}`);
@@ -22013,7 +22372,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       pluginManager.register(browserPlugin);
     }
   }
-  const lspModule = new LspModule(config.lsp, undefined, logger);
+  const lspLogger = new FileOnlyLogger(logger);
+  const lspModule = new LspModule(config.lsp, undefined, lspLogger);
   moduleRegistry.register(lspModule);
   const lspPlugin = lspModule.getPlugin();
   if (lspPlugin) {
@@ -22021,7 +22381,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     pluginManager.register(lspPlugin);
   }
   let startupCheckBlock = null;
-  const startupCheckPromise = !exitOnComplete ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir, { logger }) : Promise.resolve(null);
+  const startupCheckPromise = !exitOnComplete ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir, { logger: lspLogger }) : Promise.resolve(null);
   const moduleTools = moduleRegistry.collectToolDefinitions();
   for (const tool of moduleTools) {
     toolRegistry.register(tool);
@@ -22147,6 +22507,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     },
     sessionManager,
     memoryStore,
+    moduleRegistry,
     exitOnComplete
   };
   const agent = new Agent(agentDeps);
@@ -22879,7 +23240,7 @@ async function runSetup(externalRl) {
   const contextWindow = parseInt(await ask(rl, t("setup.context_window"), "32768"));
   const maxIterations = parseInt(await ask(rl, t("setup.max_iters"), "1000"));
   console.log(t("setup.security_header"));
-  console.log(pc2.dim(t("setup.security_status_off")));
+  console.log(pc2.dim(t("setup.security_status_on")));
   const configureSecurity = await ask(rl, t("setup.security_configure"), "n");
   let securityBashBlock = false;
   let securityFlagsBlock = false;
@@ -30240,7 +30601,7 @@ var init_loader3 = __esm(() => {
 });
 
 // src/modules/certification/fact-checker.ts
-import { existsSync as existsSync49, readFileSync as readFileSync32, statSync as statSync8 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync32, statSync as statSync9 } from "fs";
 import { join as join43 } from "path";
 function checkSandbox(sandboxDir, checks, exitCode, output) {
   const failures = [];
@@ -30286,14 +30647,14 @@ function runCheck2(sandboxDir, check, exitCode, output) {
 }
 function isFile(p) {
   try {
-    return existsSync49(p) && statSync8(p).isFile();
+    return existsSync49(p) && statSync9(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return existsSync49(p) && statSync8(p).isDirectory();
+    return existsSync49(p) && statSync9(p).isDirectory();
   } catch {
     return false;
   }
@@ -30323,7 +30684,7 @@ function describe(check) {
 var init_fact_checker = () => {};
 
 // src/modules/certification/runner.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 import { existsSync as existsSync50, mkdirSync as mkdirSync19, rmSync as rmSync4, cpSync as cpSync2 } from "fs";
 import { platform as platform10 } from "os";
 import { join as join44, resolve as resolve24, dirname as dirname15 } from "path";
@@ -30434,7 +30795,7 @@ function killTree2(child) {
   if (!pid)
     return;
   if (platform10() === "win32") {
-    spawn8("taskkill", ["/pid", String(pid), "/T", "/F"], {
+    spawn9("taskkill", ["/pid", String(pid), "/T", "/F"], {
       windowsHide: true,
       stdio: "ignore"
     });
@@ -30449,7 +30810,7 @@ function killTree2(child) {
   }
 }
 var defaultRunner2 = (env3, cwd, args, timeoutMs) => new Promise((resolvePromise) => {
-  const child = spawn8(process.execPath, args, {
+  const child = spawn9(process.execPath, args, {
     cwd,
     env: env3,
     windowsHide: true,
@@ -30659,24 +31020,8 @@ __export(exports_repl_commands, {
   registerAllCommands: () => registerAllCommands,
   COMMAND_GROUPS: () => COMMAND_GROUPS
 });
-import { join as join47, dirname as dirname18 } from "path";
+import { join as join47 } from "path";
 import { homedir as homedir17 } from "os";
-import { existsSync as existsSync53, readFileSync as readFileSync35 } from "fs";
-import { fileURLToPath as fileURLToPath6 } from "url";
-function readVersion3() {
-  const here = dirname18(fileURLToPath6(import.meta.url));
-  const candidates = [join47(here, "..", "..", "package.json"), join47(here, "..", "package.json")];
-  for (const p of candidates) {
-    if (existsSync53(p)) {
-      try {
-        const raw = JSON.parse(readFileSync35(p, "utf8"));
-        if (raw.version)
-          return raw.version;
-      } catch {}
-    }
-  }
-  return "0.0.0";
-}
 function registerAllCommands(ctx) {
   registerBuiltinCommands(ctx);
   registerMmaCommands(ctx);
@@ -30733,7 +31078,7 @@ function registerMmaCommands(ctx) {
       }
       try {
         const { loadFileAsDataUrl: loadFileAsDataUrl2, loadUrlAsDataUrl: loadUrlAsDataUrl2, readClipboardImage: readClipboardImage2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
-        const { existsSync: existsSync54 } = await import("fs");
+        const { existsSync: existsSync52 } = await import("fs");
         const { resolve: resolve25 } = await import("path");
         let dataUrl;
         let label;
@@ -30753,7 +31098,7 @@ function registerMmaCommands(ctx) {
           label = source;
         } else {
           const absPath = resolve25(process.cwd(), source);
-          if (!existsSync54(absPath)) {
+          if (!existsSync52(absPath)) {
             console.log(pc2.red(t("image.not_found", { path: source })));
             return;
           }
@@ -30979,10 +31324,7 @@ Excluded blocks: ${info.excluded.length}`));
     usage: t("repl.reload_usage"),
     action: async () => {
       console.log(pc2.yellow(t("repl.reloading")));
-      if (ctx.sessionManager && ctx.config.session.autoSave) {
-        const active = ctx.sessionManager.getActiveMeta();
-        if (active) {}
-      }
+      if (ctx.sessionManager && ctx.config.session.autoSave) {}
       ctx.agent.shutdown();
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), exports_config));
       const { homedir: homedir18 } = await import("os");
@@ -31046,7 +31388,7 @@ Excluded blocks: ${info.excluded.length}`));
     usage: t("repl.lsp_usage"),
     action: async (args) => {
       const subcommand = args[0] || "status";
-      const lspModule = ctx.agent.deps?.moduleRegistry?.getModules?.()?.find((m) => m.name === "lsp");
+      const lspModule = ctx.agent.getModule("lsp");
       if (!lspModule) {
         console.log(pc2.yellow(t("repl.lsp_not_available")));
         return;
@@ -31338,11 +31680,12 @@ function registerSkillCommands(ctx) {
 var version2, COMMAND_GROUPS;
 var init_repl_commands = __esm(() => {
   init_colors();
+  init_version();
   init_table();
   init_i18n();
   init_setup();
   init_config2();
-  version2 = readVersion3();
+  version2 = readMmaVersion();
   COMMAND_GROUPS = {
     help: "general",
     exit: "general",
@@ -31390,9 +31733,8 @@ init_bootstrap();
 init_config2();
 init_setup();
 init_i18n();
-import { join as join46, dirname as dirname17 } from "path";
+import { join as join46 } from "path";
 import { homedir as homedir16 } from "os";
-import { existsSync as existsSync52, readFileSync as readFileSync34 } from "fs";
 
 // src/cli/security-commands.ts
 init_bootstrap();
@@ -32028,22 +32370,8 @@ function createPluginCommand(program2) {
 
 // src/cli/commands.ts
 init_setup();
-import { fileURLToPath as fileURLToPath5 } from "url";
-function readVersion2() {
-  const here = dirname17(fileURLToPath5(import.meta.url));
-  const candidates = [join46(here, "..", "..", "package.json"), join46(here, "..", "package.json")];
-  for (const p of candidates) {
-    if (existsSync52(p)) {
-      try {
-        const raw = JSON.parse(readFileSync34(p, "utf8"));
-        if (raw.version)
-          return raw.version;
-      } catch {}
-    }
-  }
-  return "0.0.0";
-}
-var version = readVersion2();
+init_version();
+var version = readMmaVersion();
 function createProgram() {
   const program2 = new Command().name("mma").description(t("cli.description")).version(version).option("--no-agents-md", t("cli.no_agents_md")).option("-d, --dir <path>", t("cli.dir")).option("-e, --exit-on-complete", t("cli.exit_on_complete")).option("-j, --json", t("cli.json"));
   program2.command("init").description(t("cli.init")).action(async () => {
@@ -32058,9 +32386,9 @@ function createProgram() {
     config.maxToolIterations = answers.maxToolIterations;
     config.locale = answers.locale;
     if (config.security) {
-      config.security.enabled = answers.securityBashBlock || answers.securityFlagsBlock || !answers.securityPathsDeny;
-      config.security.bash.enabled = config.security.enabled;
-      config.security.bash.blockDangerousFlags = answers.securityFlagsBlock;
+      config.security.enabled = true;
+      config.security.bash.enabled = true;
+      config.security.bash.blockDangerousFlags = answers.securityFlagsBlock || config.security.bash.blockDangerousFlags;
       if (answers.securityBashBlock) {
         config.security.bash.blacklist = [
           ...new Set([
@@ -33025,7 +33353,7 @@ class LineEditor {
 }
 
 // src/cli/repl.ts
-import { existsSync as existsSync55, readFileSync as readFileSync37, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync35, writeFileSync as writeFileSync17 } from "fs";
 import { join as join49 } from "path";
 import { homedir as homedir18 } from "os";
 
@@ -33630,6 +33958,7 @@ async function probeLspServers(config, baseDir, deps = {}) {
 }
 
 // src/cli/repl.ts
+init_client2();
 init_config();
 init_session_logger();
 
@@ -33637,14 +33966,14 @@ init_session_logger();
 init_colors();
 init_js_identifiers();
 init_i18n();
-import { existsSync as existsSync54, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync34 } from "fs";
 import { join as join48 } from "path";
 function readActivePlan(baseDir) {
   const p = join48(baseDir, ".mma", "plans", "active.json");
-  if (!existsSync54(p))
+  if (!existsSync52(p))
     return null;
   try {
-    const raw = readFileSync36(p, "utf-8");
+    const raw = readFileSync34(p, "utf-8");
     if (!raw.trim())
       return null;
     const parsed = JSON.parse(raw);
@@ -33771,7 +34100,7 @@ class Repl {
   pendingClipboardImage = null;
   exitOnClose = false;
   activePlan = null;
-  lastPlanSig = "";
+  lastPlanSig = null;
   rl;
   agent;
   config;
@@ -33781,7 +34110,7 @@ class Repl {
   logger;
   slog;
   envReport;
-  constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport) {
+  constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport, historyPath) {
     this.agent = agent;
     this.config = config;
     this.exitOnClose = exitOnClose === true;
@@ -33794,7 +34123,7 @@ class Repl {
     this.configDir = configDir || join49(homedir18(), ".mma");
     this.baseDir = baseDir || process.cwd();
     this.noAgentsMd = noAgentsMd === true;
-    this.historyPath = join49(homedir18(), ".mma", "repl-history");
+    this.historyPath = historyPath ?? join49(homedir18(), ".mma", "repl-history");
     this.loadHistory();
     this.rl = process.stdin.isTTY ? new LineEditor({
       input: process.stdin,
@@ -33827,9 +34156,9 @@ class Repl {
     this.setupListeners();
   }
   loadHistory() {
-    if (existsSync55(this.historyPath)) {
+    if (existsSync53(this.historyPath)) {
       try {
-        const raw = readFileSync37(this.historyPath, "utf-8");
+        const raw = readFileSync35(this.historyPath, "utf-8");
         this.history = raw.split(`
 `).filter(Boolean).slice(-this.maxHistory);
       } catch {
@@ -33942,8 +34271,7 @@ class Repl {
     let forceExitTimer = null;
     process.on("SIGINT", () => {
       if (this.agentRunning) {
-        console.log(pc2.yellow(`
-[Ctrl+C] Остановка агента... (ещё раз — принудительно)`));
+        console.log(pc2.yellow(t("repl.ctrl_c_interrupt")));
         this.agent.shutdown();
         this.agentRunning = false;
         if (forceExitTimer)
@@ -34073,6 +34401,10 @@ ${t("image.clipboard_empty")}`));
       return;
     }
     this.activePlan = plan;
+    if (this.lastPlanSig === null) {
+      this.lastPlanSig = sig;
+      return;
+    }
     if (sig !== this.lastPlanSig) {
       this.lastPlanSig = sig;
       renderer.planBlock(formatPlanChecklist(plan));
@@ -34213,7 +34545,7 @@ ${t("image.clipboard_empty")}`));
         join49(this.baseDir, ".mma", "AGENTS.md"),
         join49(this.configDir, "AGENTS.md")
       ];
-      const foundAgents = agentsMdCandidates.filter((p) => existsSync55(p));
+      const foundAgents = agentsMdCandidates.filter((p) => existsSync53(p));
       if (foundAgents.length > 0) {
         for (const p of foundAgents) {
           row(t("repl.agents_label"), pc2.dim(p));
@@ -34259,7 +34591,8 @@ ${t("image.clipboard_empty")}`));
   async probeLspBanner() {
     const config = this.config.lsp ?? DEFAULT_LSP_CONFIG;
     try {
-      const summary = await probeLspServers(config, this.baseDir, { logger: this.logger });
+      const lspOnlyLogger = this.logger ? new FileOnlyLogger(this.logger) : undefined;
+      const summary = await probeLspServers(config, this.baseDir, { logger: lspOnlyLogger });
       this.slog.logSessionStart({
         environment: this.envReport,
         lspProbe: {
@@ -34322,10 +34655,9 @@ init_setup();
 init_config2();
 init_i18n();
 init_colors();
-import { existsSync as existsSync56, readFileSync as readFileSync38 } from "fs";
-import { join as join51, dirname as dirname19 } from "path";
+import { existsSync as existsSync54 } from "fs";
+import { join as join51 } from "path";
 import { homedir as homedir20 } from "os";
-import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/modules/updater/index.ts
 init_checker();
@@ -34472,23 +34804,10 @@ function installCrashHandlers() {
 }
 
 // src/cli/main.ts
-function readVersion4() {
-  const here = dirname19(fileURLToPath7(import.meta.url));
-  const candidates = [join51(here, "..", "..", "package.json"), join51(here, "..", "package.json")];
-  for (const p of candidates) {
-    if (existsSync56(p)) {
-      try {
-        const raw = JSON.parse(readFileSync38(p, "utf8"));
-        if (raw.version)
-          return raw.version;
-      } catch {}
-    }
-  }
-  return "0.0.0";
-}
+init_version();
 function startAutoUpdate(config) {
   try {
-    const module = new UpdaterModule(config.updater, readVersion4(), "micro-models-agent", {
+    const module = new UpdaterModule(config.updater, readMmaVersion(), "micro-models-agent", {
       info: (m) => process.stderr.write(pc2.dim(m) + `
 `),
       warn: (m) => process.stderr.write(pc2.yellow(m) + `
@@ -34564,7 +34883,7 @@ async function main() {
     process.exit(exitCode);
   } else {
     const configPath = join51(homedir20(), ".mma", "config.json");
-    if (!existsSync56(configPath)) {
+    if (!existsSync54(configPath)) {
       console.log(pc2.yellow(`
   ` + t("cli.first_run") + `
 `));
@@ -34581,9 +34900,9 @@ async function main() {
       config2.maxToolIterations = answers.maxToolIterations;
       config2.locale = answers.locale;
       if (config2.security) {
-        config2.security.enabled = answers.securityBashBlock || answers.securityFlagsBlock || !answers.securityPathsDeny;
-        config2.security.bash.enabled = config2.security.enabled;
-        config2.security.bash.blockDangerousFlags = answers.securityFlagsBlock;
+        config2.security.enabled = true;
+        config2.security.bash.enabled = true;
+        config2.security.bash.blockDangerousFlags = answers.securityFlagsBlock || config2.security.bash.blockDangerousFlags;
         if (answers.securityBashBlock) {
           config2.security.bash.blacklist = [
             ...new Set([