micro-models-agent 0.63.0 → 1.1.0

package/dist/tools/attach-image.js

@@ -59,17 +59,17 @@ export const attachImageTool = {
                         output: t("image.not_found", { path: source }),
                     };
                 }
-                // Security: check path scope
-                if (ctx.scope) {
-                    const { isPathInScope } = await import("../modules/security/path-validator");
-                    const validation = isPathInScope(ctx.baseDir, absPath, ctx.scope);
-                    if (!validation.allowed) {
-                        logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
-                        return {
-                            success: false,
-                            output: t("file.path_not_allowed", { path: source }),
-                        };
-                    }
+                // Security: check global path policy AND subagent scope (same
+                // combination as read_file).
+                const { isPathInScope } = await import("../modules/security/path-validator");
+                const { DEFAULT_SECURITY_CONFIG } = await import("../config/security");
+                const validation = isPathInScope(ctx.baseDir, absPath, ctx.scope, ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths);
+                if (!validation.allowed) {
+                    logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
+                    return {
+                        success: false,
+                        output: t("file.path_not_allowed", { path: source }),
+                    };
                 }
                 const result = await loadFileAsDataUrl(absPath);
                 dataUrl = result.dataUrl;

package/dist/tools/auto-fixer.js

@@ -0,0 +1,198 @@
+import { extname } from "path";
+/**
+ * LSP error codes that can be auto-fixed.
+ */
+const AUTO_FIXABLE_CODES = new Set([
+    2307, // Cannot find module (import missing)
+    2440, // Import declaration conflicts with local declaration
+    6133, // Variable is declared but its value is never read
+    2769, // No overload matches this call (simple type mismatches)
+]);
+/**
+ * Extract LSP errors from tsc output.
+ * Format: file(line,col): error TSxxxx: message
+ */
+export function parseTscOutput(output) {
+    const errors = [];
+    const regex = /(.+?)\((\d+),(\d+)\): error TS(\d+): (.+)/g;
+    let match;
+    while ((match = regex.exec(output))) {
+        errors.push({
+            file: match[1],
+            line: parseInt(match[2], 10),
+            column: parseInt(match[3], 10),
+            length: 0, // tsc doesn't provide length
+            code: parseInt(match[4], 10),
+            message: match[5],
+            severity: "error",
+        });
+    }
+    return errors;
+}
+/**
+ * Try to auto-fix LSP errors in TypeScript/JavaScript code.
+ * Only fixes common, safe patterns:
+ * - TS2440: Import conflict → rename import with `as`
+ * - TS6133: Unused import → remove from import list
+ */
+export function autoFixErrors(filePath, content, errors) {
+    const ext = extname(filePath).toLowerCase();
+    const isTsFile = [".ts", ".tsx", ".mts", ".cts"].includes(ext);
+    const isJsFile = [".js", ".jsx", ".mjs", ".cjs"].includes(ext);
+    if (!isTsFile && !isJsFile) {
+        return { fixed: false, newContent: content, applied: [], remaining: errors };
+    }
+    let newContent = content;
+    const applied = [];
+    const remaining = [];
+    for (const error of errors) {
+        if (!AUTO_FIXABLE_CODES.has(error.code)) {
+            remaining.push(error);
+            continue;
+        }
+        try {
+            const result = fixError(newContent, error);
+            if (result.fixed) {
+                newContent = result.newContent;
+                applied.push(`TS${error.code}: ${error.message.slice(0, 50)}`);
+            }
+            else {
+                remaining.push(error);
+            }
+        }
+        catch {
+            remaining.push(error);
+        }
+    }
+    return {
+        fixed: applied.length > 0,
+        newContent,
+        applied,
+        remaining,
+    };
+}
+/**
+ * Try to fix a single LSP error.
+ */
+function fixError(content, error) {
+    const lines = content.split("\n");
+    const lineIndex = error.line - 1;
+    if (lineIndex < 0 || lineIndex >= lines.length) {
+        return { fixed: false, newContent: content };
+    }
+    const line = lines[lineIndex];
+    switch (error.code) {
+        case 2440: // Import declaration conflicts with local declaration
+            return fixImportConflict(lines, lineIndex, error);
+        case 6133: // Variable is declared but its value is never read
+            return fixUnusedImport(lines, lineIndex, error);
+        default:
+            return { fixed: false, newContent: content };
+    }
+}
+/**
+ * Fix TS2440: Import declaration conflicts with local declaration.
+ * Strategy: Add `as LocalName` to the import.
+ *
+ * Example:
+ *   import { foo } from './module';
+ *   export function foo() { ... }
+ * Becomes:
+ *   import { foo as fooImport } from './module';
+ *   export function foo() { ... }
+ */
+function fixImportConflict(lines, lineIndex, error) {
+    const line = lines[lineIndex];
+    // Find the conflicting name in the error message
+    const nameMatch = error.message.match(/Import declaration conflicts with local declaration of '(\w+)'/);
+    if (!nameMatch) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const conflictingName = nameMatch[1];
+    // Find the import line (might be above the current line)
+    let importLineIndex = lineIndex;
+    while (importLineIndex >= 0 && !lines[importLineIndex].includes("import")) {
+        importLineIndex--;
+    }
+    if (importLineIndex < 0) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const importLine = lines[importLineIndex];
+    // Check if this is a named import: import { ... } from '...'
+    const namedImportMatch = importLine.match(/import\s+(?:type\s+)?\{([^}]+)\}\s+from/);
+    if (!namedImportMatch) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const imports = namedImportMatch[1];
+    const importParts = imports.split(",").map((s) => s.trim());
+    // Check if the conflicting name is in the imports
+    const nameIndex = importParts.findIndex((part) => {
+        const baseName = part.split(/\s+as\s+/)[0].trim();
+        return baseName === conflictingName;
+    });
+    if (nameIndex === -1) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    // Check if already has an alias
+    const currentImport = importParts[nameIndex];
+    if (currentImport.includes(" as ")) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    // Add alias
+    importParts[nameIndex] = `${conflictingName} as ${conflictingName}Import`;
+    lines[importLineIndex] = importLine.replace(namedImportMatch[1], importParts.join(", "));
+    return { fixed: true, newContent: lines.join("\n") };
+}
+/**
+ * Fix TS6133: Variable is declared but its value is never read.
+ * Strategy: Remove the unused import from the import list.
+ *
+ * Example:
+ *   import { foo, bar } from './module';
+ *   console.log(bar);
+ * Becomes:
+ *   import { bar } from './module';
+ *   console.log(bar);
+ */
+function fixUnusedImport(lines, lineIndex, error) {
+    const line = lines[lineIndex];
+    // Find the unused name in the error message
+    const nameMatch = error.message.match(/'(\w+)' is declared but its value is never read/);
+    if (!nameMatch) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const unusedName = nameMatch[1];
+    // Find the import line (might be above the current line)
+    let importLineIndex = lineIndex;
+    while (importLineIndex >= 0 && !lines[importLineIndex].includes("import")) {
+        importLineIndex--;
+    }
+    if (importLineIndex < 0) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const importLine = lines[importLineIndex];
+    // Check if this is a named import: import { ... } from '...'
+    const namedImportMatch = importLine.match(/import\s+(?:type\s+)?\{([^}]+)\}\s+from/);
+    if (!namedImportMatch) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    const imports = namedImportMatch[1];
+    const importParts = imports.split(",").map((s) => s.trim());
+    // Find and remove the unused import
+    const nameIndex = importParts.findIndex((part) => {
+        const baseName = part.split(/\s+as\s+/)[0].trim();
+        return baseName === unusedName;
+    });
+    if (nameIndex === -1) {
+        return { fixed: false, newContent: lines.join("\n") };
+    }
+    importParts.splice(nameIndex, 1);
+    // If no imports left, remove the entire import line
+    if (importParts.length === 0) {
+        lines.splice(importLineIndex, 1);
+    }
+    else {
+        lines[importLineIndex] = importLine.replace(namedImportMatch[1], importParts.join(", "));
+    }
+    return { fixed: true, newContent: lines.join("\n") };
+}

package/dist/tools/bash.js

@@ -80,13 +80,13 @@ function adaptCommandForWindows(command) {
     if (/\|\|\s*true\b/.test(command)) {
         command = command.replace(/\s*\|\|\s*true\b/g, "; exit 0");
     }
-    // Windows mkdir does not support -p flag, but creates intermediate dirs by default
+    // Windows mkdir does not support -p/--parents flag, but creates intermediate dirs by default
     const trimmed = command.trim();
-    if (trimmed.startsWith("mkdir -p ")) {
-        return trimmed.replace(/^mkdir -p /, "mkdir ");
+    if (/^mkdir\s+(-p|--parents)\b/.test(trimmed)) {
+        return trimmed.replace(/^mkdir\s+(-p|--parents)\s*/, "mkdir ");
     }
-    if (trimmed === "mkdir -p" || trimmed.startsWith("mkdir -p ")) {
-        return trimmed.replace(/mkdir -p/g, "mkdir");
+    if (/^mkdir\s+(-p|--parents)\s*$/.test(trimmed)) {
+        return "mkdir";
     }
     // Translate simple Unix commands to their cmd.exe equivalents. Only the
     // leading word is rewritten; flags are passed through (ls -la → dir -la,
@@ -112,12 +112,24 @@ const UNIX_TO_WIN_HINTS = {
     mv: "Use the move_file tool instead.",
     rm: "Use the delete_file tool instead.",
     grep: "Use the grep tool instead.",
+    sed: "Use the edit_file tool instead.",
+    awk: "Not available in cmd.exe. Use a Node.js one-liner or the grep tool instead.",
     chmod: "Use the chmod tool instead.",
     touch: "Use the write_file tool instead.",
     find: "Use the glob tool instead.",
     head: "Use the read_file tool with offset/limit instead.",
     tail: "Use the read_file tool instead.",
     wc: "Use the read_file tool instead.",
+    uniq: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    xargs: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    cut: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    tr: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    basename: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    dirname: "Not available in cmd.exe. Use a Node.js one-liner instead.",
+    export: 'cmd.exe has no export - use "set VAR=value" (no spaces around =).',
+    source: 'cmd.exe has no source - use "call script.bat".',
+    sleep: 'Use "timeout /t N" instead.',
+    env: "cmd.exe has no env - use set to list/set variables.",
     diff: "Use the diff tool instead.",
     which: 'Use "where" instead.',
     echo: "echo works on Windows, but avoid pipes (|).",
@@ -298,14 +310,126 @@ export function emptyCliRunHint(command, output, code) {
  * the same failing `npx`/`bunx`/`npm run` command).
  */
 const NPM_EXEC_RE = /could not determine executable to run/i;
+/**
+ * A command that waited for interactive input with no TTY aborts with
+ * "Operation cancelled" (Bun/Node prompt) or "stdin is not a TTY". Common on
+ * bare `bun create`/`npm create` scaffolds. Append a concrete non-interactive
+ * remedy instead of letting the model retry the identical interactive command.
+ */
+const INTERACTIVE_PROMPT_RE = /operation (?:cancelled|canceled|aborted)|stdin is not a tty|not a tty|cannot prompt without a tty/i;
 /** process-management tools hidden behind enable_tools (tag "shell"). */
 const HIDDEN_PROCESS_TOOLS = ["process_list", "process_log", "process_kill"];
+/**
+ * Разрешение bash-security-конфига: session-изоляция поверх глобального,
+ * мастер-выключатель `enabled: false` гасит все под-модули.
+ */
+function resolveBashSecurityConfig(ctx) {
+    const appConfig = ctx.config || {};
+    const fullSecurityConfig = ctx.sessionContext
+        ? getSessionSecurityConfig(appConfig, ctx.sessionContext)
+        : appConfig.security || DEFAULT_SECURITY_CONFIG;
+    return fullSecurityConfig.enabled === false
+        ? { ...(fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash), enabled: false }
+        : fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
+}
+/**
+ * Декорация вывода завершённой команды: подсказки (пустой прогон скрипта,
+ * упавшие тесты, npm-без-bin, Unix-команды в cmd.exe), audit-лог и обрезка.
+ * Вынесена из god-handler'а bash — инкапсулирует всю пост-обработку вывода.
+ */
+function decorateCommandOutput(opts) {
+    let output = opts.output;
+    const { ctx, command, originalCommand, code, testRun, workdir, securityConfig } = opts;
+    // R5: script file ran with exit 0 but empty output — likely a missing
+    // entry point (main is never called with argv).
+    const cliHint = emptyCliRunHint(command, output, code);
+    if (cliHint) {
+        output = `(exit code 0, no output)\n\nHint: ${cliHint}`;
+    }
+    // Auto-verify test runs: a failing suite must not be reported as a clean
+    // success. Inject a prominent marker the model cannot miss (the typical
+    // failure: tests fail but the CLI exit code is 0).
+    if (testRun && testRun.failed > 0) {
+        output =
+            t("exec.test_runner_fail", {
+                framework: testRun.framework,
+                failed: String(testRun.failed),
+                passed: String(testRun.passed),
+            }) +
+                `\n\n${output}`;
+    }
+    else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
+        output = `${t("exec.test_runner_pass", { framework: testRun.framework, passed: String(testRun.passed) })}\n\n${output}`;
+    }
+    if (!output && code !== 0) {
+        output = `(exit code ${code})`;
+    }
+    // npm/npx/bunx: "could not determine executable to run" — the package has
+    // no `bin` entry (or the script does not exist). Cross-platform, so it runs
+    // before the win32 hint block.
+    output = npmExecHint(output);
+    // Interactive prompt with no TTY (Bun/Node "Operation cancelled").
+    output = interactivePromptHint(output);
+    // On Windows, hint about Unix commands that don't work, and hard-stop a
+    // command that keeps failing the same way. The hint keys on the ORIGINAL
+    // command word (before adaptCommandForWindows translated cat→type): the
+    // translation is only for execution, but the model wrote `cat`, and that is
+    // what UNIX_TO_WIN_HINTS knows about. Keying on the translated word left
+    // `cat` invisible to the hint/block (observed: model ran cat 4+ times).
+    if (platform() === "win32") {
+        const originalFirstWord = originalCommand.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
+        if (originalFirstWord && originalFirstWord in UNIX_TO_WIN_HINTS) {
+            if (code === 0) {
+                FAILING_FIRST_WORDS.delete(originalFirstWord);
+            }
+            else {
+                const failures = (FAILING_FIRST_WORDS.get(originalFirstWord) || 0) + 1;
+                FAILING_FIRST_WORDS.set(originalFirstWord, failures);
+                if (failures >= HARD_BLOCK_THRESHOLD) {
+                    output = `STOP using "${originalFirstWord}" — it does not work in this cmd.exe shell and has failed ${failures} times in a row. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
+                }
+                else {
+                    output = `${output}\n\nHint: "${originalFirstWord}" may not work on Windows. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
+                }
+            }
+        }
+    }
+    // Update audit log with result
+    if (securityConfig?.logCommands) {
+        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), code === 0, `Working directory: ${workdir}, Output length: ${output.length}`);
+    }
+    const lines = output.split("\n");
+    if (testRun && testRun.failed > 0) {
+        // Keep the failure details: test runners print passing markers first and
+        // the errors + summary at the very end. A short head preview hides exactly
+        // what the model needs to fix the failures.
+        const TEST_TAIL_LINES = 400;
+        const kept = lines.slice(-TEST_TAIL_LINES);
+        const skipped = lines.length - kept.length;
+        output =
+            (skipped > 0 ? `[... ${skipped} earlier lines omitted — failing tests below]\n` : "") +
+                kept.join("\n");
+    }
+    else if (lines.length > MAX_PREVIEW_LINES) {
+        output =
+            lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+                `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+    }
+    return output;
+}
 export function npmExecHint(output) {
     if (NPM_EXEC_RE.test(output)) {
         return `${output}\n\nHint: ${t("exec.npm_exec_hint")}`;
     }
     return output;
 }
+/** Append a non-interactive remedy when a command aborted waiting on stdin. */
+export function interactivePromptHint(output) {
+    if (INTERACTIVE_PROMPT_RE.test(output)) {
+        return `${output}\n\nHint: ${t("exec.interactive_hint")}`;
+    }
+    return output;
+}
 export const bashTool = {
     name: "bash",
     icon: "💻",
@@ -370,15 +494,8 @@ export const bashTool = {
             }
         }
         const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
-        // Get session-specific security config with defaults
-        const appConfig = ctx.config || {};
-        const fullSecurityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(appConfig, ctx.sessionContext)
-            : appConfig.security || DEFAULT_SECURITY_CONFIG;
-        // Master switch off → all sub-modules off, even when defaults are enabled.
-        const securityConfig = fullSecurityConfig.enabled === false
-            ? { ...(fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash), enabled: false }
-            : fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
+        // Session-specific security config (мастер-выключатель учтён внутри).
+        const securityConfig = resolveBashSecurityConfig(ctx);
         const validation = isCommandAllowed(command, securityConfig);
         if (!validation.allowed) {
             // Log security block
@@ -412,82 +529,18 @@ export const bashTool = {
                 const code = entry.exitCode;
                 let output = entry.log.join("\n");
                 processRegistry.remove(entry.id);
-                // R5: script file ran with exit 0 but empty output — likely a
-                // missing entry point (main is never called with argv).
-                const cliHint = emptyCliRunHint(command, output, code);
-                if (cliHint) {
-                    output = `(exit code 0, no output)\n\nHint: ${cliHint}`;
-                }
-                // Auto-verify test runs: a failing suite must not be reported as a
-                // clean success. Inject a prominent marker the model cannot miss
-                // (the tpical failure: tests fail but the CLI exit code is 0).
+                // Подсказки, аудит и обрезка вывода — единая точка (decorateCommandOutput).
                 const testRun = detectTestResults(output);
-                if (testRun && testRun.failed > 0) {
-                    output =
-                        t("exec.test_runner_fail", {
-                            framework: testRun.framework,
-                            failed: String(testRun.failed),
-                            passed: String(testRun.passed),
-                        }) +
-                            `\n\n${output}`;
-                }
-                else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
-                    output = `${t("exec.test_runner_pass", { framework: testRun.framework, passed: String(testRun.passed) })}\n\n${output}`;
-                }
-                if (!output && code !== 0) {
-                    output = `(exit code ${code})`;
-                }
-                // npm/npx/bunx: "could not determine executable to run" — the
-                // package has no `bin` entry (or the script does not exist).
-                // This is cross-platform, so it runs before the win32 hint block.
-                output = npmExecHint(output);
-                // On Windows, hint about Unix commands that don't work, and
-                // hard-stop a command that keeps failing the same way. The
-                // hint keys on the ORIGINAL command word (before
-                // adaptCommandForWindows translated cat→type): the translation
-                // is only for execution, but the model wrote `cat`, and that is
-                // what UNIX_TO_WIN_HINTS knows about. Keying on the translated
-                // word left `cat` invisible to the hint/block (observed: model
-                // ran cat 4+ times in one session with no guidance).
-                if (platform() === "win32") {
-                    const originalFirstWord = originalCommand.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
-                    if (originalFirstWord && originalFirstWord in UNIX_TO_WIN_HINTS) {
-                        if (code === 0) {
-                            FAILING_FIRST_WORDS.delete(originalFirstWord);
-                        }
-                        else {
-                            const failures = (FAILING_FIRST_WORDS.get(originalFirstWord) || 0) + 1;
-                            FAILING_FIRST_WORDS.set(originalFirstWord, failures);
-                            if (failures >= HARD_BLOCK_THRESHOLD) {
-                                output = `STOP using "${originalFirstWord}" — it does not work in this cmd.exe shell and has failed ${failures} times in a row. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
-                            }
-                            else {
-                                output = `${output}\n\nHint: "${originalFirstWord}" may not work on Windows. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
-                            }
-                        }
-                    }
-                }
-                // Update audit log with result
-                if (securityConfig?.logCommands) {
-                    logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), code === 0, `Working directory: ${workdir}, Output length: ${output.length}`);
-                }
-                const lines = output.split("\n");
-                if (testRun && testRun.failed > 0) {
-                    // Keep the failure details: test runners print passing markers
-                    // first and the errors + summary at the very end. A short head
-                    // preview hides exactly what the model needs to fix the failures.
-                    const TEST_TAIL_LINES = 400;
-                    const kept = lines.slice(-TEST_TAIL_LINES);
-                    const skipped = lines.length - kept.length;
-                    output =
-                        (skipped > 0 ? `[... ${skipped} earlier lines omitted — failing tests below]\n` : "") +
-                            kept.join("\n");
-                }
-                else if (lines.length > MAX_PREVIEW_LINES) {
-                    output =
-                        lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
-                            `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
-                }
+                output = decorateCommandOutput({
+                    ctx,
+                    command,
+                    originalCommand,
+                    code,
+                    output,
+                    testRun,
+                    workdir,
+                    securityConfig,
+                });
                 return { success: code === 0, output };
             }
             // Still running — promote to a background process.

package/dist/tools/chunk-query.js

@@ -1,13 +1,14 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { t } from "../i18n/index";
-import { isPathInScope } from "./scope-check";
+import { isPathInScope } from "../modules/security/path-validator";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
 import { runChunkQuery } from "../modules/context/chunk-query";
 export const chunkQueryTool = {
     name: "chunk_query",
     icon: "🧩",
     description: "Answer a query over a large text (file or inline) by splitting it into chunks and querying the model per chunk in parallel, then optionally synthesizing a final answer. Use when the input is too large for the context window.",
-    tags: ["research", "code"],
+    tags: ["research"],
     /** Multiple LLM calls (parallel chunk queries + synthesis) need a longer budget. */
     timeoutMs: 300000,
     parameters: {
@@ -43,7 +44,7 @@ export const chunkQueryTool = {
             },
             reasoning_effort: {
                 type: "string",
-                enum: ["none", "low", "medium", "high"],
+                enum: ["none", "low", "medium", "high", "max"],
                 description: 'Reasoning effort for chunk/synthesis calls (default "none"). "none" prevents long thinking chains from eating the token budget on reasoning models.',
             },
             synthesize: {
@@ -63,12 +64,15 @@ export const chunkQueryTool = {
             return { success: false, output: t("tool.chunk_query_no_input") };
         let content = text || "";
         if (inputPath) {
-            const check = isPathInScope(ctx.baseDir, inputPath, ctx.scope);
+            // Same policy as read_file: global security paths (denied patterns
+            // like .env/keys) + subagent scope.
+            const resolvedInput = resolve(ctx.baseDir, inputPath);
+            const check = isPathInScope(ctx.baseDir, resolvedInput, ctx.scope, ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths);
             if (!check.allowed) {
                 return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
             }
             try {
-                content = readFileSync(resolve(ctx.baseDir, inputPath), "utf8");
+                content = readFileSync(resolvedInput, "utf8");
             }
             catch (e) {
                 return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
@@ -86,7 +90,7 @@ export const chunkQueryTool = {
             synthesize: typeof args.synthesize === "boolean" ? args.synthesize : undefined,
             maxChunkTokens: typeof args.max_chunk_tokens === "number" ? args.max_chunk_tokens : undefined,
             maxSynthesisTokens: typeof args.max_synthesis_tokens === "number" ? args.max_synthesis_tokens : undefined,
-            reasoningEffort: ["none", "low", "medium", "high"].includes(args.reasoning_effort)
+            reasoningEffort: ["none", "low", "medium", "high", "max"].includes(args.reasoning_effort)
                 ? args.reasoning_effort
                 : undefined,
             logger: ctx.logger,

package/dist/tools/download-file.js

@@ -14,7 +14,7 @@ export const downloadFileTool = {
     name: "download_file",
     icon: "⬇️",
     description: "Download a file (image, archive, binary, font, etc.) from a URL and save it to disk. Returns only the path, size and content type — read the saved file with read_file/attach_image afterwards. Use this for binary files; web_fetch/web_browse return text only and cannot save bytes.",
-    tags: ["file", "research"],
+    tags: ["research"],
     parameters: {
         type: "object",
         properties: {

package/dist/tools/edit-file.js

@@ -6,6 +6,7 @@ import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { generateDiff } from "../ui/diff";
 import { safeResolvePath } from "./path-utils";
+import { preValidateSyntax, detectImportConflicts } from "./syntax-validator";
 export const editFileTool = {
     name: "edit_file",
     icon: "✏️",
@@ -57,7 +58,9 @@ export const editFileTool = {
                 output: t("file.string_not_found", { str: oldStr, path }),
             };
         }
-        const updated = content.replace(oldStr, newStr);
+        // Replacement via function — otherwise newStr is treated as a template
+        // and `$&`, `$1` etc. would silently corrupt the file content.
+        const updated = content.replace(oldStr, () => newStr);
         // Check new content for dangerous patterns — only when security is enabled
         if (securityConfig?.enabled && securityConfig?.contentScan?.enabled) {
             const scanResult = scanContent(updated, path, securityConfig.contentScan);
@@ -69,12 +72,27 @@ export const editFileTool = {
                 };
             }
         }
+        // Pre-validate syntax BEFORE writing — prevents "file written" + syntax error loop
+        const validation = await preValidateSyntax(resolved, updated, ctx.baseDir);
+        if (!validation.valid) {
+            return {
+                success: false,
+                output: t("file.syntax_error", { path, error: validation.error || "Unknown syntax error" }),
+            };
+        }
+        // Detect import/export conflicts — warning only (code may be valid)
+        const conflicts = detectImportConflicts(updated);
         writeFileSync(resolved, updated, "utf-8");
         const diff = generateDiff(content, updated);
         // Increment file operations counter
         ctx.fileOperationsCount = currentCount + 1;
         // Log successful file edit
         logFileWrite(ctx.sessionId, path, true, "File edited");
-        return { success: true, output: t("file.replaced_in", { path }), diff };
+        // Add conflict warning to output if any
+        let output = t("file.replaced_in", { path });
+        if (conflicts.length > 0) {
+            output += `\n[WARNING] Import/export conflicts: ${conflicts.join(", ")}`;
+        }
+        return { success: true, output, diff };
     },
 };