micro-models-agent 0.41.2 → 0.43.0

package/dist/tools/bash.js

@@ -1,8 +1,8 @@
-import { isCommandAllowed, sanitizeCommandForLog } from "../modules/security/command-validator";
-import { logBashCommand, logSecurityBlock } from "../modules/security/audit-log";
+import { isCommandAllowed, sanitizeCommandForLog, } from "../modules/security/command-validator";
+import { logBashCommand, logSecurityBlock, } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { DEFAULT_SECURITY_CONFIG } from "../config/security";
-import { processRegistry, registerKillable, unregisterKillable } from "../modules/processes";
+import { processRegistry, registerKillable, unregisterKillable, } from "../modules/processes";
 import { t } from "../i18n/index";
 import { platform } from "os";
 import { MAX_PREVIEW_LINES } from "./preview";
@@ -16,26 +16,11 @@ import { MAX_PREVIEW_LINES } from "./preview";
 export const BASH_GRACE_MS = 5000;
 /** Short window for explicit `background: true` — surfaces immediate spawn failures (bad cwd, missing shell). */
 const SPAWN_SETTLE_MS = 100;
-/** Number of already-emitted lines shown in the background start message. */
-const BG_OUTPUT_PREVIEW_LINES = 15;
 let bashGraceMs = BASH_GRACE_MS;
 /** Test hook: override the auto-background grace window. */
 export function setBashGraceMs(ms) {
     bashGraceMs = ms;
 }
-/**
- * Consecutive failures per first command word (resets on success). A model
- * that keeps calling a forbidden Unix command in cmd.exe (head/cat/grep/...)
- * gets a hint the first couple of times; after HARD_BLOCK_THRESHOLD consecutive
- * failures the tool hard-stops with a STOP directive instead of repeating the
- * same hint forever (observed: `head` called 5×, `Select-String` 3× in one run).
- */
-const FAILING_FIRST_WORDS = new Map();
-const HARD_BLOCK_THRESHOLD = 3;
-/** Test hook: clear the consecutive-failure tracking state. */
-export function resetBashFailureTracking() {
-    FAILING_FIRST_WORDS.clear();
-}
 /**
  * Detect a file write via `echo/printf ... > file` — common model habit that
  * breaks in cmd.exe: single quotes are not grouping quotes, `>` only applies
@@ -123,12 +108,6 @@ const UNIX_TO_WIN_HINTS = {
     echo: "echo works on Windows, but avoid pipes (|).",
     "Get-Content": "Use the read_file tool instead.",
     "Select-Object": "Use the read_file tool with offset/limit instead.",
-    "Write-Host": "PowerShell cmdlet — this shell is cmd.exe. Print with plain echo instead.",
-    "Select-String": "Use the grep tool instead.",
-    "Out-File": "Write files with the write_file tool instead.",
-    "Set-Content": "Write files with the write_file tool instead.",
-    "Get-ChildItem": "Use the list_dir tool instead.",
-    "Remove-Item": "Use the delete_file tool instead.",
 };
 /** Unix commands that can be transparently translated to cmd.exe equivalents. */
 const UNIX_TO_WIN_TRANSLATE = {
@@ -219,94 +198,9 @@ export function parseToolArgs(raw) {
     }
     return args;
 }
-/**
- * Detect a test-runner report embedded in command output (bun test / vitest /
- * jest / mocha / `go test` / pytest). Returns null when the output does not
- * look like a test run. Used to inject a warning when tests fail so the model
- * cannot close a "run the tests" step as done.
- */
-export function detectTestResults(output) {
-    if (!output)
-        return null;
-    // Framework-specific quantifiers first (unambiguous).
-    const jest = output.match(/Tests:\s+(\d+)\s+passed,\s*(\d+)\s+failed/i);
-    if (jest) {
-        return { framework: "jest", passed: +jest[1], failed: +jest[2] };
-    }
-    const mochaPass = output.match(/(\d+)\s+passing/i);
-    const mochaFail = output.match(/(\d+)\s+failing/i);
-    if (mochaPass || mochaFail) {
-        return {
-            framework: "mocha",
-            passed: mochaPass ? +mochaPass[1] : 0,
-            failed: mochaFail ? +mochaFail[1] : 0,
-        };
-    }
-    const pytest = output.match(/(\d+)\s+passed[^\n]*?(?:,\s*(\d+)\s+failed)?/i);
-    if (pytest &&
-        /pytest|passed|failed/i.test(output) &&
-        /(=====|short test summary|tests\s+ok)/i.test(output) === false &&
-        /pytest|collect/i.test(output)) {
-        return {
-            framework: "pytest",
-            passed: +pytest[1],
-            failed: pytest[2] ? +pytest[2] : 0,
-        };
-    }
-    // bun test / vitest: per-case markers + trailing "N pass / M fail".
-    const failMarkers = output.match(/\(fail\)/g)?.length ?? 0;
-    const passMarkers = output.match(/\(pass\)/g)?.length ?? 0;
-    const xMarkers = output.match(/\s×\s/g)?.length ?? 0;
-    const summaryMatch = output.match(/^\s*(\d+)\s+pass[^\n]*$/m);
-    const failSummary = output.match(/^\s*(\d+)\s+fail[^\n]*$/m);
-    const ran = output.match(/(?:Ran|ran)\s+\d+\s+tests/i);
-    if (failMarkers > 0 || passMarkers > 0 || xMarkers > 0 || ran) {
-        const failed = Math.max(failMarkers + xMarkers, failSummary ? +failSummary[1] : 0);
-        const passed = Math.max(passMarkers, summaryMatch ? +summaryMatch[1] : 0);
-        return {
-            framework: ran ? "bun/vitest" : "vitest",
-            passed,
-            failed,
-            summary: summaryMatch?.[0] ?? failSummary?.[0],
-        };
-    }
-    return null;
-}
-/**
- * R5: a command that runs a script file (bun/node/python/...) exited 0 but
- * printed nothing. The most common cause in agent sessions: the program has
- * no entry point — nobody calls its main() with the CLI args. Surface a
- * concrete hint instead of letting the model stare at an empty output.
- */
-const CLI_FILE_RUN_RE = /\b(bun|node|deno|python|python3|tsx|ts-node|php|ruby|go\s+run)\S*\s+(run\s+)?["']?[\w./\\-]+\.(ts|js|tsx|jsx|mjs|cjs|py)\b/;
-export function emptyCliRunHint(command, output, code) {
-    if (code !== 0 || output.trim())
-        return null;
-    if (/[>|]/.test(command))
-        return null; // redirection/pipes — output went elsewhere
-    if (/\b(bun test|vitest|pytest|jest|mocha|--test)\b/i.test(command))
-        return null;
-    if (!CLI_FILE_RUN_RE.test(command))
-        return null;
-    return "the command exited 0 but printed NOTHING to stdout. If this should run a CLI program, the file probably has no entry point: read it with read_file and check the code actually calls its main function with command-line arguments (e.g. main(process.argv[2])) and prints results with console.log.";
-}
-/**
- * Detect npm/npx/bunx failing with "could not determine executable to run"
- * — the package declares no `bin` (or `npm run <script>` named a missing
- * script). Append a concrete hint instead of letting the model re-try blindly
- * (observed in two agent sessions: the model burned many iterations re-running
- * the same failing `npx`/`bunx`/`npm run` command).
- */
-const NPM_EXEC_RE = /could not determine executable to run/i;
-export function npmExecHint(output) {
-    if (NPM_EXEC_RE.test(output)) {
-        return `${output}\n\nHint: ${t("exec.npm_exec_hint")}`;
-    }
-    return output;
-}
 export const bashTool = {
     name: "bash",
-    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Commands that are still running after a few seconds are automatically moved to the background and return a process id — manage them with process_list, process_log, process_kill. Set background=true to return a process id immediately for commands you know are long-running (dev servers, watchers).\n\nWindows notes: the shell is cmd.exe — PowerShell cmdlets (Write-Host, Get-Content, Select-String, Out-File) and bash heredocs (cat << EOF) do NOT work there. Use the read_file/write_file tools instead of cat/echo redirection. Sequential commands: use && (a leading ; is auto-converted to &).",
+    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Commands that are still running after a few seconds are automatically moved to the background and return a process id — manage them with process_list, process_log, process_kill. Set background=true to return a process id immediately for commands you know are long-running (dev servers, watchers).",
     tags: ["shell", "code"],
     parameters: {
         type: "object",
@@ -393,55 +287,19 @@ 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).
-                const testRun = detectTestResults(output);
-                if (testRun && testRun.failed > 0) {
-                    output =
-                        `[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.\n\n` +
-                            output;
-                }
-                else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
-                    output = `[test-runner] ${testRun.framework}: all ${testRun.passed} test(s) passing.\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]}`;
-                            }
-                        }
+                // On Windows, hint about Unix commands that don't work
+                if (platform() === "win32" && code !== 0) {
+                    const firstWord = command
+                        .trim()
+                        .split(/\s+/)[0]
+                        ?.split(/[\\/]/)
+                        .pop();
+                    const hint = firstWord ? UNIX_TO_WIN_HINTS[firstWord] : undefined;
+                    if (hint) {
+                        output = `${output}\n\nHint: "${firstWord}" may not work on Windows. ${hint}`;
                     }
                 }
                 // Update audit log with result
@@ -449,18 +307,7 @@ export const bashTool = {
                     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) {
+                if (lines.length > MAX_PREVIEW_LINES) {
                     output =
                         lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
                             `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
@@ -469,19 +316,13 @@ export const bashTool = {
             }
             // Still running — promote to a background process.
             const explicit = args.background === true;
-            const preview = entry.log
-                .filter((l) => l.trim() !== "")
-                .slice(0, BG_OUTPUT_PREVIEW_LINES)
-                .join("\n");
-            let output = `${t("proc.started", {
+            const output = `${t("proc.started", {
                 id: entry.id,
                 pid: entry.pid,
                 command,
-            })}${explicit ? "" : `\n${t("proc.promoted_hint", { ms: settleMs })}`}`;
-            if (preview) {
-                output += `\n\n${t("proc.output_preview", { lines: preview })}`;
-            }
-            output += `\n${t("proc.manage_hint", { id: entry.id })}`;
+            })}${explicit ? "" : `\n${t("proc.promoted_hint", { ms: settleMs })}`}\n${t("proc.manage_hint", {
+                id: entry.id,
+            })}`;
             if (securityConfig?.logCommands) {
                 logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
             }

package/dist/tools/browser.js

@@ -1,18 +1,15 @@
-import { BrowserSession } from "../modules/browser/session";
-import { DEFAULT_BROWSER_CONFIG } from "../modules/browser/types";
-import { t } from "../i18n/index";
-import { join } from "path";
+import { BrowserSession } from '../modules/browser/session';
+import { DEFAULT_BROWSER_CONFIG } from '../modules/browser/types';
+import { t } from '../i18n/index';
+import { join } from 'path';
 let session = null;
 function getSession(ctx) {
     if (!session) {
-        const cookieDir = join(ctx.baseDir, ".mma", "browser");
+        const cookieDir = join(ctx.baseDir, '.mma', 'browser');
         session = new BrowserSession({
             ...DEFAULT_BROWSER_CONFIG,
             headless: ctx.config.browser?.headless ?? true,
             maxElements: ctx.config.browser?.maxElements ?? 30,
-            maxContentChars: ctx.config.browser?.maxContentChars ?? 2500,
-            maxConsoleEntries: ctx.config.browser?.maxConsoleEntries ?? 40,
-            maxConsoleLineChars: ctx.config.browser?.maxConsoleLineChars ?? 400,
             navigationTimeout: ctx.config.browser?.navigationTimeout ?? 15000,
             viewportWidth: ctx.config.browser?.viewportWidth ?? 1280,
             viewportHeight: ctx.config.browser?.viewportHeight ?? 720,
@@ -22,80 +19,66 @@ function getSession(ctx) {
     return session;
 }
 export function formatScreenshotForTextModel(snapshot) {
-    return `${t("tool.screenshot_unavailable")}\n\n${snapshot}`;
+    return `${t('tool.screenshot_unavailable')}\n\n${snapshot}`;
 }
 export function formatScreenshotResult(snapshot, screenshot, supportsVision) {
     if (!supportsVision) {
         return formatScreenshotForTextModel(snapshot);
     }
-    const base64 = screenshot.toString("base64");
+    const base64 = screenshot.toString('base64');
     return `${snapshot}\n\n[Screenshot: data:image/png;base64,${base64}]`;
 }
 export function createBrowserTool() {
     return {
-        name: "browser",
-        tags: ["browser", "vision"],
+        name: 'browser',
+        tags: ['browser', 'vision'],
         description: [
-            "Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.",
-            "Runs a real browser with JavaScript enabled — use it for JS-rendered sites (weather, dashboards, SPAs) where web_fetch/web_browse return empty content.",
-            "Do NOT use it for search queries: search engines (Google, Yandex, Bing) block headless browsers with CAPTCHA/429/redirect pages — use the web_search tool for searching.",
-            "Each snapshot returns: a numbered list of interactive elements, the visible page text (Content section), browser console messages, and network errors.",
-            "Use the Content section to understand what the page says; use element numbers as targets for click/type.",
-            "Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).",
-        ].join(" "),
+            'Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.',
+            'Returns a numbered list of interactive elements — use element numbers as targets for click/type.',
+            'Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).',
+        ].join(' '),
         parameters: {
-            type: "object",
+            type: 'object',
             properties: {
                 action: {
-                    type: "string",
-                    enum: [
-                        "open",
-                        "click",
-                        "type",
-                        "scroll",
-                        "back",
-                        "forward",
-                        "screenshot",
-                        "snapshot",
-                        "close",
-                        "wait",
-                    ],
-                    description: "Browser action to perform",
+                    type: 'string',
+                    enum: ['open', 'click', 'type', 'scroll', 'back', 'forward', 'screenshot', 'snapshot', 'close', 'wait'],
+                    description: 'Browser action to perform',
                 },
                 url: {
-                    type: "string",
+                    type: 'string',
                     description: 'URL to open (for action "open")',
                 },
                 target: {
-                    type: "number",
+                    type: 'number',
                     description: 'Element number from snapshot (for action "click" or "type")',
                 },
                 text: {
-                    type: "string",
+                    type: 'string',
                     description: 'Text to type (for action "type")',
                 },
                 direction: {
-                    type: "string",
-                    enum: ["up", "down", "top", "bottom"],
+                    type: 'string',
+                    enum: ['up', 'down', 'top', 'bottom'],
                     description: 'Scroll direction (for action "scroll", default "down")',
                 },
                 ms: {
-                    type: "number",
+                    type: 'number',
                     description: 'Milliseconds to wait (for action "wait", default 1000)',
                 },
             },
-            required: ["action"],
+            required: ['action'],
         },
         handler: async (ctx, args) => {
-            const action = String(args.action || "");
+            const action = String(args.action || '');
             if (!action) {
-                return { success: false, output: t("tool.action_required") };
+                return { success: false, output: t('tool.action_required') };
             }
             const s = getSession(ctx);
             const result = await s.execute(action, args);
-            const supportsVision = ctx.config.model.includes("vision") ||
-                ctx.config.model.includes("gpt-4o") ||
-                ctx.config.model.includes("claude");
+            const supportsVision = ctx.config.model.includes('vision') ||
+                ctx.config.model.includes('gpt-4o') ||
+                ctx.config.model.includes('claude');
             if (result.screenshot) {
                 return {
                     success: result.success,

package/dist/tools/executor.js

@@ -49,7 +49,9 @@ export class ToolExecutor {
                 try {
                     const proceed = await plugin.onBeforeTool(this.ctx, call);
                     if (proceed === false || typeof proceed === "string") {
-                        const pluginName = plugin.name || plugin.constructor?.name || "unknown";
+                        const pluginName = plugin.name ||
+                            plugin.constructor?.name ||
+                            "unknown";
                         const reason = typeof proceed === "string" ? proceed : undefined;
                         return {
                             success: false,
@@ -73,16 +75,15 @@ export class ToolExecutor {
                 result = await tool.handler(this.ctx, call.arguments);
             }
             else {
-                const timeoutMs = tool.timeoutMs ?? TOOL_EXECUTION_TIMEOUT_MS;
                 const timeoutPromise = new Promise((_, reject) => {
                     setTimeout(() => {
                         // Kill any long-running child process registered for this call.
                         killByCallId(call.id);
                         reject(new Error(t("tool.timeout", {
                             name: call.name,
-                            seconds: Math.round(timeoutMs / 1000),
+                            seconds: TOOL_EXECUTION_TIMEOUT_MS / 1000,
                         })));
-                    }, timeoutMs);
+                    }, TOOL_EXECUTION_TIMEOUT_MS);
                 });
                 const racePromises = [
                     tool.handler(this.ctx, call.arguments),

package/dist/tools/file-info.js

@@ -1,18 +1,17 @@
-import { statSync, existsSync } from "fs";
-import { t } from "../i18n/index";
-import { isPathInScope } from "../modules/security/path-validator";
-import { safeResolvePath } from "./path-utils";
+import { statSync, existsSync } from 'fs';
+import { t } from '../i18n/index';
+import { isPathInScope } from '../modules/security/path-validator';
+import { safeResolvePath } from './path-utils';
 export const fileInfoTool = {
-    name: "file_info",
-    description: "Get metadata about a file or directory (size, creation date, modification date).",
-    tags: ["file"],
-    boundedOutput: true,
+    name: 'file_info',
+    description: 'Get metadata about a file or directory (size, creation date, modification date).',
+    tags: ['file'],
     parameters: {
-        type: "object",
+        type: 'object',
         properties: {
-            path: { type: "string", description: "File path" },
+            path: { type: 'string', description: 'File path' },
         },
-        required: ["path"],
+        required: ['path'],
     },
     handler: async (ctx, args) => {
         const path = String(args.path);
@@ -22,13 +21,13 @@ export const fileInfoTool = {
         if (!scopeCheck.allowed) {
             return {
                 success: false,
-                output: t("file.path_not_allowed", {
+                output: t('file.path_not_allowed', {
                     path: `${path} — ${scopeCheck.reason}`,
                 }),
             };
         }
         if (!existsSync(resolved)) {
-            return { success: false, output: t("file.not_found_short", { path }) };
+            return { success: false, output: t('file.not_found_short', { path }) };
         }
         const stat = statSync(resolved);
         return {

package/dist/tools/filter-tools.js

@@ -1,17 +1,10 @@
-/**
- * Filter tools by a tag set, always keeping `alwaysOn` tools. Used by MoE
- * expert routing and subagent tool_tags so structural tools (plan/todo/verify,
- * project_map, lsp_check, enable_tools) survive narrowing.
- */
 export function filterToolsByTags(tools, toolTags) {
     if (!toolTags || toolTags.length === 0)
         return tools;
     const tagSet = new Set(toolTags);
-    return tools.filter((t) => {
-        if (t.alwaysOn)
-            return true;
+    return tools.filter(t => {
         if (!t.tags || t.tags.length === 0)
             return false;
-        return t.tags.some((tag) => tagSet.has(tag));
+        return t.tags.some(tag => tagSet.has(tag));
     });
 }

package/dist/tools/glob-tool.js

@@ -1,26 +1,26 @@
-import { globSync } from "fs";
-import { t } from "../i18n/index";
-import { MAX_PREVIEW_LINES } from "./preview";
+import { globSync } from 'fs';
+import { t } from '../i18n/index';
+import { MAX_PREVIEW_LINES } from './preview';
 export const globTool = {
-    name: "glob",
+    name: 'glob',
     description: `Search for files matching a glob pattern. Shows up to ${MAX_PREVIEW_LINES} results by default. Uses standard glob syntax (e.g., **/*.ts, src/**/*.test.ts).`,
-    tags: ["file", "code", "research"],
+    tags: ['file', 'code', 'research'],
     parameters: {
-        type: "object",
+        type: 'object',
         properties: {
-            pattern: { type: "string", description: "Glob pattern" },
+            pattern: { type: 'string', description: 'Glob pattern' },
         },
-        required: ["pattern"],
+        required: ['pattern'],
     },
     handler: async (ctx, args) => {
         const pattern = String(args.pattern);
         const results = globSync(pattern, { cwd: ctx.baseDir });
         if (results.length === 0) {
-            return { success: true, output: t("file.no_matches") };
+            return { success: true, output: t('file.no_matches') };
         }
         const truncated = results.length > MAX_PREVIEW_LINES
             ? `\n... (${results.length - MAX_PREVIEW_LINES} more files)`
-            : "";
-        return { success: true, output: results.slice(0, MAX_PREVIEW_LINES).join("\n") + truncated };
+            : '';
+        return { success: true, output: results.slice(0, MAX_PREVIEW_LINES).join('\n') + truncated };
     },
 };

package/dist/tools/grep-tool.js

@@ -31,7 +31,9 @@ export const grepTool = {
     },
     handler: async (ctx, args) => {
         const pattern = String(args.pattern);
-        const searchPath = args.path ? resolve(ctx.baseDir, String(args.path)) : ctx.baseDir;
+        const searchPath = args.path
+            ? resolve(ctx.baseDir, String(args.path))
+            : ctx.baseDir;
         // Build rg arguments as an array to avoid shell interpretation of regex
         // metacharacters like |, (, ) — these are regex patterns, not shell operators.
         const rgArgs = ["-n", "--with-filename", pattern, searchPath];

package/dist/tools/index.js

@@ -15,11 +15,9 @@ import { processListTool } from "./process-list";
 import { processLogTool } from "./process-log";
 import { processKillTool } from "./process-kill";
 import { subagentTool } from "./subagent";
-import { chunkQueryTool } from "./chunk-query";
 import { webSearchTool } from "./web-search";
 import { webFetchTool } from "./web-fetch";
 import { webBrowseTool } from "./web-browse";
-import { downloadFileTool } from "./download-file";
 // questionTool and approveTool removed — interactive menus are too disruptive for small models.
 // The model should ask questions as plain text in its response instead.
 // import { questionTool } from './question'
@@ -32,11 +30,10 @@ import { rememberTool } from "./remember";
 import { recallTool } from "./recall";
 import { createBrowserTool } from "./browser";
 import { attachImageTool } from "./attach-image";
-import { enableToolsTool } from "./enable-tools";
 export { ToolRegistry, ToolExecutor };
 export { filterToolsByTags } from "./filter-tools";
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, chunkQueryTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, downloadFileTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, enableToolsTool, };
-export function registerAllTools(registry, skillsModule, opts) {
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
+export function registerAllTools(registry, skillsModule) {
     const tools = [
         readFileTool,
         writeFileTool,
@@ -50,25 +47,17 @@ export function registerAllTools(registry, skillsModule, opts) {
         fileInfoTool,
         bashTool,
         subagentTool,
-        chunkQueryTool,
         processListTool,
         processLogTool,
         processKillTool,
         webSearchTool,
         webFetchTool,
         webBrowseTool,
-        downloadFileTool,
         pipelineRunTool,
         mcpCallTool,
         searchHistoryTool,
         attachImageTool,
     ];
-    // On-demand tool activation is the default. When explicitly disabled
-    // (enableOnDemand: false), the tool is not registered at all — combined
-    // with an empty defaultTags this restores the legacy all-tools behavior.
-    if (opts?.enableOnDemand !== false) {
-        tools.push(enableToolsTool);
-    }
     if (skillsModule) {
         tools.push(createLoadSkillTool(skillsModule));
     }