micro-models-agent 0.39.0 → 0.40.0

package/dist/tools/edit-file.js

@@ -57,14 +57,16 @@ export const editFileTool = {
             };
         }
         const updated = content.replace(oldStr, newStr);
-        // Check new content for dangerous patterns
-        const scanResult = scanContent(updated, path, ctx.config.security?.contentScan);
-        if (!scanResult.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] ${scanResult.reason}`,
-            };
+        // Check new content for dangerous patterns — only when security is enabled
+        if (securityConfig?.enabled && securityConfig?.contentScan?.enabled) {
+            const scanResult = scanContent(updated, path, securityConfig.contentScan);
+            if (!scanResult.allowed) {
+                logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
+                return {
+                    success: false,
+                    output: `[SECURITY BLOCKED] ${scanResult.reason}`,
+                };
+            }
         }
         writeFileSync(resolved, updated, "utf-8");
         const diff = generateDiff(content, updated);

package/dist/tools/executor.js

@@ -10,7 +10,32 @@ export class ToolExecutor {
         this.ctx = ctx;
         this.pluginManager = pluginManager;
     }
-    async execute(call) {
+    /**
+     * Execute a tool by name with plain arguments (no call id, no timeout
+     * wiring). Used internally — e.g. bash redirects a mistaken tool-call-as-
+     * command into the real tool. Runs through the same registry and plugin
+     * hooks as a normal call.
+     */
+    async executeByName(name, args, ctx) {
+        const prevCtx = this.ctx;
+        if (ctx)
+            this.ctx = ctx;
+        try {
+            return await this.execute({
+                id: `redirect_${Date.now()}`,
+                name,
+                arguments: args,
+            });
+        }
+        finally {
+            this.ctx = prevCtx;
+        }
+    }
+    /** Whether a tool with this name is registered (used before redirects). */
+    hasTool(name) {
+        return this.registry.has(name);
+    }
+    async execute(call, signal) {
         const tool = this.registry.get(call.name);
         if (!tool) {
             return {
@@ -23,12 +48,16 @@ export class ToolExecutor {
             if (plugin.onBeforeTool) {
                 try {
                     const proceed = await plugin.onBeforeTool(this.ctx, call);
-                    if (!proceed) {
+                    if (proceed === false || typeof proceed === "string") {
+                        const pluginName = plugin.name ||
+                            plugin.constructor?.name ||
+                            "unknown";
+                        const reason = typeof proceed === "string" ? proceed : undefined;
                         return {
                             success: false,
-                            output: t("tool.blocked", {
-                                plugin: plugin.constructor?.name || "unknown",
-                            }),
+                            output: reason
+                                ? t("tool.blocked_reason", { plugin: pluginName, reason })
+                                : t("tool.blocked", { plugin: pluginName }),
                             toolCallId: call.id,
                         };
                     }
@@ -56,10 +85,26 @@ export class ToolExecutor {
                         })));
                     }, TOOL_EXECUTION_TIMEOUT_MS);
                 });
-                result = await Promise.race([
+                const racePromises = [
                     tool.handler(this.ctx, call.arguments),
                     timeoutPromise,
-                ]);
+                ];
+                if (signal) {
+                    const abortPromise = new Promise((_, reject) => {
+                        const onAbort = () => {
+                            killByCallId(call.id);
+                            reject(new Error(t("tool.aborted", { name: call.name })));
+                        };
+                        if (signal.aborted) {
+                            onAbort();
+                        }
+                        else {
+                            signal.addEventListener("abort", onAbort, { once: true });
+                        }
+                    });
+                    racePromises.push(abortPromise);
+                }
+                result = await Promise.race(racePromises);
             }
             result.toolCallId = call.id;
         }
@@ -80,6 +125,8 @@ export class ToolExecutor {
                 }
             }
         }
+        this.ctx.logger.logToolCall(call.name, JSON.stringify(call.arguments)?.slice(0, 200) ?? "", result.success ? "OK" : `FAIL: ${result.output?.slice(0, 200)}`);
+        this.ctx.logger.logToolOutput(call.name, result.output ?? "", result.success ? 0 : 1);
         this.ctx.logger.debug(`Tool ${call.name}: ${result.success ? "OK" : "FAIL"}`);
         return result;
     }
@@ -92,4 +139,7 @@ export class ToolExecutor {
     setScope(scope) {
         this.ctx.scope = scope;
     }
+    updateProvider(provider) {
+        this.ctx.llmProvider = provider;
+    }
 }

package/dist/tools/grep-tool.js

@@ -1,63 +1,85 @@
-import { execFileSync, execSync } from 'child_process';
-import { resolve } from 'path';
-import { t } from '../i18n/index';
-import { logBashCommand } from '../modules/security/audit-log';
-import { MAX_PREVIEW_LINES } from './preview';
+import { execFileSync } from "child_process";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { logBashCommand } from "../modules/security/audit-log";
+import { MAX_PREVIEW_LINES } from "./preview";
 function truncateLines(output) {
-    const lines = output.split('\n');
+    const lines = output.split("\n");
     if (lines.length <= MAX_PREVIEW_LINES)
         return output;
-    return lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+    return (lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+        `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`);
 }
 export const grepTool = {
-    name: 'grep',
+    name: "grep",
     description: `Search file contents using a regular expression. Shows up to ${MAX_PREVIEW_LINES} matching lines by default. Uses ripgrep (rg) if available, otherwise falls back to grep -r.`,
-    tags: ['file', 'code', 'research'],
+    tags: ["file", "code", "research"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            pattern: { type: 'string', description: 'Regex pattern to search' },
-            include: { type: 'string', description: 'File pattern to filter (e.g. *.ts)' },
-            path: { type: 'string', description: 'Directory to search (defaults to baseDir)' },
+            pattern: { type: "string", description: "Regex pattern to search" },
+            include: {
+                type: "string",
+                description: "File pattern to filter (e.g. *.ts)",
+            },
+            path: {
+                type: "string",
+                description: "Directory to search (defaults to baseDir)",
+            },
         },
-        required: ['pattern'],
+        required: ["pattern"],
     },
     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];
+        const rgArgs = ["-n", "--with-filename", pattern, searchPath];
         if (args.include) {
-            rgArgs.push('-g', String(args.include));
+            rgArgs.push("-g", String(args.include));
         }
         // Log the search (sanitized) for audit purposes
-        logBashCommand(ctx.sessionId, `rg ${rgArgs.join(' ')}`, false, 'grep-tool');
+        logBashCommand(ctx.sessionId, `rg ${rgArgs.join(" ")}`, false, "grep-tool");
         try {
-            const output = execFileSync('rg', rgArgs, {
-                encoding: 'utf-8',
+            const output = execFileSync("rg", rgArgs, {
+                encoding: "utf-8",
                 maxBuffer: 1024 * 1024,
                 cwd: ctx.baseDir,
             });
-            return { success: true, output: truncateLines(output || t('file.no_matches')) };
+            return {
+                success: true,
+                output: truncateLines(output || t("file.no_matches")),
+            };
         }
         catch (e) {
             if (e.status === 1)
-                return { success: true, output: t('file.no_matches') };
-            // Fall back to plain grep -r when rg is not available or fails
+                return { success: true, output: t("file.no_matches") };
+            // Fall back to plain grep -r when rg is not available or fails.
+            // Using execFileSync with array args avoids shell injection.
             try {
-                const cmd = `grep -rn "${pattern.replace(/"/g, '\\"')}" "${searchPath}"`;
-                const output = execSync(cmd, {
-                    encoding: 'utf-8',
+                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,
                 });
-                return { success: true, output: truncateLines(output || t('file.no_matches')) };
+                return {
+                    success: true,
+                    output: truncateLines(output || t("file.no_matches")),
+                };
             }
             catch (e2) {
                 if (e2.status === 1)
-                    return { success: true, output: t('file.no_matches') };
-                return { success: false, output: t('error.grep_failed', { message: e2.message }) };
+                    return { success: true, output: t("file.no_matches") };
+                return {
+                    success: false,
+                    output: t("error.grep_failed", { message: e2.message }),
+                };
             }
         }
     },

package/dist/tools/index.js

@@ -1,46 +1,61 @@
-import { ToolRegistry } from './registry';
-import { ToolExecutor } from './executor';
-import { readFileTool } from './read-file';
-import { writeFileTool } from './write-file';
-import { editFileTool } from './edit-file';
-import { globTool } from './glob-tool';
-import { grepTool } from './grep-tool';
-import { listDirTool } from './list-dir';
-import { createDirTool } from './create-dir';
-import { deleteFileTool } from './delete-file';
-import { moveFileTool } from './move-file';
-import { fileInfoTool } from './file-info';
-import { bashTool } from './bash';
-import { processListTool } from './process-list';
-import { processLogTool } from './process-log';
-import { processKillTool } from './process-kill';
-import { subagentTool } from './subagent';
-import { webSearchTool } from './web-search';
-import { webFetchTool } from './web-fetch';
-import { webBrowseTool } from './web-browse';
-import { questionTool } from './question';
-import { approveTool } from './approve';
-import { createLoadSkillTool } from './load-skill';
-import { pipelineRunTool } from './pipeline-run';
-import { mcpCallTool } from './mcp-call';
-import { searchHistoryTool } from './search-history';
-import { rememberTool } from './remember';
-import { recallTool } from './recall';
-import { createBrowserTool } from './browser';
-import { attachImageTool } from './attach-image';
+import { ToolRegistry } from "./registry";
+import { ToolExecutor } from "./executor";
+import { readFileTool } from "./read-file";
+import { writeFileTool } from "./write-file";
+import { editFileTool } from "./edit-file";
+import { globTool } from "./glob-tool";
+import { grepTool } from "./grep-tool";
+import { listDirTool } from "./list-dir";
+import { createDirTool } from "./create-dir";
+import { deleteFileTool } from "./delete-file";
+import { moveFileTool } from "./move-file";
+import { fileInfoTool } from "./file-info";
+import { bashTool } from "./bash";
+import { processListTool } from "./process-list";
+import { processLogTool } from "./process-log";
+import { processKillTool } from "./process-kill";
+import { subagentTool } from "./subagent";
+import { webSearchTool } from "./web-search";
+import { webFetchTool } from "./web-fetch";
+import { webBrowseTool } from "./web-browse";
+// 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'
+// import { approveTool } from './approve'
+import { createLoadSkillTool } from "./load-skill";
+import { pipelineRunTool } from "./pipeline-run";
+import { mcpCallTool } from "./mcp-call";
+import { searchHistoryTool } from "./search-history";
+import { rememberTool } from "./remember";
+import { recallTool } from "./recall";
+import { createBrowserTool } from "./browser";
+import { attachImageTool } from "./attach-image";
 export { ToolRegistry, ToolExecutor };
-export { filterToolsByTags } from './filter-tools';
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
+export { filterToolsByTags } from "./filter-tools";
+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, editFileTool,
-        globTool, grepTool, listDirTool, createDirTool,
-        deleteFileTool, moveFileTool, fileInfoTool,
-        bashTool, subagentTool,
-        processListTool, processLogTool, processKillTool,
-        webSearchTool, webFetchTool, webBrowseTool,
-        questionTool, approveTool,
-        pipelineRunTool, mcpCallTool, searchHistoryTool,
+        readFileTool,
+        writeFileTool,
+        editFileTool,
+        globTool,
+        grepTool,
+        listDirTool,
+        createDirTool,
+        deleteFileTool,
+        moveFileTool,
+        fileInfoTool,
+        bashTool,
+        subagentTool,
+        processListTool,
+        processLogTool,
+        processKillTool,
+        webSearchTool,
+        webFetchTool,
+        webBrowseTool,
+        pipelineRunTool,
+        mcpCallTool,
+        searchHistoryTool,
         attachImageTool,
     ];
     if (skillsModule) {

package/dist/tools/load-skill.js

@@ -3,33 +3,23 @@ export function createLoadSkillTool(skillsModule) {
     return {
         name: "load_skill",
         tags: ["core"],
-        description: "Load a skill by name or task description. Skills provide specialized instructions and workflows. Only use when the task clearly requires domain-specific knowledge. If loading fails because the skill is too large, continue the task without it.",
+        description: "Load a skill by name. Skills provide specialized instructions and workflows. When loaded, the skill content is injected into the system prompt (not conversation history) so it persists through context compaction. Only use when the task clearly requires domain-specific knowledge.",
         parameters: {
             type: "object",
             properties: {
-                name: { type: "string", description: "Skill name to load directly" },
-                task: {
+                name: {
                     type: "string",
-                    description: "Task description to find matching skill",
+                    description: "Exact skill name to load (see [Available Skills] for names)",
                 },
             },
+            required: ["name"],
         },
         handler: async (_ctx, args) => {
             const name = args.name ? String(args.name) : undefined;
-            const task = args.task ? String(args.task) : undefined;
-            if (!name && !task) {
-                return { success: false, output: t("tool.name_or_task") };
-            }
-            let result;
-            if (name) {
-                result = skillsModule.loadByName(name);
-            }
-            else if (task) {
-                result = skillsModule.loadByMatch(task);
-            }
-            else {
+            if (!name) {
                 return { success: false, output: t("tool.invalid_params") };
             }
+            const result = skillsModule.loadByName(name);
             if (!result.success) {
                 const available = skillsModule.getAvailable();
                 const hint = available.length > 0
@@ -37,11 +27,17 @@ export function createLoadSkillTool(skillsModule) {
                     : "";
                 return { success: false, output: result.message + hint };
             }
-            const skill = result.skill;
             const budget = skillsModule.getBudget();
+            const tokens = result.skill
+                ? Math.ceil(result.skill.content.length / 4)
+                : 0;
             return {
                 success: true,
-                output: `${result.message}\n\n--- Skill Content ---\n${skill.content}\n\n${t("tool.skill_budget", { remaining: budget.remaining })}`,
+                output: t("tool.skill_budget", {
+                    name,
+                    tokens,
+                    remaining: budget.remaining,
+                }),
             };
         },
     };

package/dist/tools/move-file.js

@@ -5,6 +5,7 @@ import { isPathWritable } from "../modules/security/path-validator";
 import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { generateMoveDiff } from "../ui/diff";
+import { safeResolvePath } from "./path-utils";
 export const moveFileTool = {
     name: "move_file",
     description: "Move or rename a file or directory.",
@@ -21,8 +22,8 @@ export const moveFileTool = {
         const fromPath = String(args.from);
         const toPath = String(args.to);
         const baseDir = resolve(ctx.baseDir);
-        const fromResolved = resolve(baseDir, normalize(fromPath));
-        const toResolved = resolve(baseDir, normalize(toPath));
+        const fromResolved = safeResolvePath(baseDir, normalize(fromPath));
+        const toResolved = safeResolvePath(baseDir, normalize(toPath));
         // Get session-specific security config
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)

package/dist/tools/pipeline-run.js

@@ -30,7 +30,7 @@ async function runStep(ctx, step, params, outputs) {
                 toolExecutor: ctx.toolExecutor,
                 pluginManager: subPluginManager,
                 contextManager: subContextManager,
-                hallucinationDetector: new HallucinationDetector(),
+                hallucinationDetector: new HallucinationDetector(ctx.baseDir, ctx.llmProvider),
                 logger: ctx.logger,
                 baseDir: ctx.baseDir,
                 scope: ctx.scope,

package/dist/tools/read-file.js

@@ -42,12 +42,17 @@ export const readFileTool = {
             };
         }
         if (!existsSync(resolved)) {
-            return { success: false, output: t("file.notfound", { path }) };
+            // For relative paths, tell the model WHERE the path resolved — the
+            // "not found" alone is confusing (it cannot tell baseDir from cwd).
+            const output = resolved !== path
+                ? t("file.notfound_resolved", {
+                    path,
+                    resolved,
+                })
+                : t("file.notfound", { path });
+            return { success: false, output };
         }
-        ctx.trackReadPath?.(path);
         const content = readFileSync(resolved, "utf-8");
-        // Track file paths mentioned in the document (e.g. structure.md, README)
-        ctx.trackDocumentContent?.(content);
         const lines = content.split("\n");
         const total = lines.length;
         const offset = args.offset || 1;
@@ -68,6 +73,11 @@ export const readFileTool = {
                 next: String(end + 1),
             })
             : "";
-        return { success: true, output: `${header}\n${selected}${truncated}` };
+        const display = truncated ? `${header}${truncated}` : header;
+        return {
+            success: true,
+            output: `${header}\n${selected}${truncated}`,
+            display,
+        };
     },
 };

package/dist/tools/search-history.js

@@ -1,45 +1,56 @@
-import * as fs from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { t } from '../i18n/index';
+import * as fs from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { t } from "../i18n/index";
 function searchFile(filePath, query, maxResults, results) {
     if (!fs.existsSync(filePath))
         return;
-    const content = fs.readFileSync(filePath, 'utf-8');
-    for (const line of content.split('\n').filter(Boolean)) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    for (const line of content.split("\n").filter(Boolean)) {
         if (line.toLowerCase().includes(query)) {
             try {
                 const entry = JSON.parse(line);
                 results.push(`[${filePath}] ${JSON.stringify(entry).slice(0, 200)}`);
             }
-            catch { /* skip */ }
+            catch {
+                /* skip */
+            }
         }
         if (results.length >= maxResults)
             break;
     }
 }
 export const searchHistoryTool = {
-    name: 'search_history',
-    description: 'Search through session history for past interactions across all sessions.',
-    tags: ['research'],
+    name: "search_history",
+    description: "Search through session history for past interactions across all sessions.",
+    tags: ["research"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            query: { type: 'string', description: 'Search query' },
-            maxResults: { type: 'number', description: 'Maximum results (default 5)' },
-            sessionId: { type: 'string', description: 'Optional: limit search to a specific session' },
+            query: { type: "string", description: "Search query" },
+            maxResults: {
+                type: "number",
+                description: "Maximum results (default 5)",
+            },
+            sessionId: {
+                type: "string",
+                description: "Optional: limit search to a specific session",
+            },
         },
-        required: ['query'],
+        required: ["query"],
     },
     handler: async (_ctx, args) => {
-        const query = String(args.query || '').toLowerCase();
+        const query = String(args.query || "").toLowerCase();
         const maxResults = Number(args.maxResults) || 5;
         const sessionId = args.sessionId ? String(args.sessionId) : null;
-        const sessionDir = join(homedir(), '.mma', 'sessions');
+        const sessionDir = join(homedir(), ".mma", "sessions");
         const results = [];
         try {
             if (!fs.existsSync(sessionDir)) {
-                return { success: true, output: t('tool.no_sessions_dir', { dir: sessionDir }) };
+                return {
+                    success: true,
+                    output: t("tool.no_sessions_dir", { dir: sessionDir }),
+                };
             }
             const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
             for (const entry of entries) {
@@ -47,18 +58,27 @@ export const searchHistoryTool = {
                     continue;
                 if (sessionId && entry.name !== sessionId)
                     continue;
-                const historyFile = join(sessionDir, entry.name, 'history.jsonl');
+                const historyFile = join(sessionDir, entry.name, "history.jsonl");
                 searchFile(historyFile, query, maxResults, results);
                 if (results.length >= maxResults)
                     break;
             }
             if (results.length === 0) {
-                return { success: true, output: t('tool.no_history', { query }) };
+                return { success: true, output: t("tool.no_history", { query }) };
             }
-            return { success: true, output: t('tool.history_results', { query, results: results.join('\n') }) };
+            return {
+                success: true,
+                output: t("tool.history_results", {
+                    query,
+                    results: results.join("\n"),
+                }),
+            };
         }
         catch (err) {
-            return { success: true, output: t('tool.history_error', { error: String(err) }) };
+            return {
+                success: false,
+                output: t("tool.history_error", { error: String(err) }),
+            };
         }
     },
 };

package/dist/tools/subagent.js

@@ -98,7 +98,11 @@ export const subagentTool = {
         try {
             const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
             const subPluginManager = new PluginManager();
-            const hallucinationDetector = new HallucinationDetector();
+            const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
+            // Save/restore the shared executor scope so the sub-agent doesn't
+            // permanently mutate the parent's scope.
+            const parentScope = ctx.scope;
+            ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
             const systemPrompt = {
                 content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
                 priority: "critical",
@@ -121,18 +125,23 @@ export const subagentTool = {
             };
             const subAgent = new Agent(subDeps);
             const fullTask = context ? `${task}\n\nContext: ${context}` : task;
-            const result = await subAgent.run(fullTask);
-            if (result.success) {
-                return {
-                    success: true,
-                    output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
-                };
+            let scopeRestored = false;
+            try {
+                const result = await subAgent.run(fullTask);
+                return result.success
+                    ? {
+                        success: true,
+                        output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
+                    }
+                    : {
+                        success: false,
+                        output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
+                    };
             }
-            else {
-                return {
-                    success: false,
-                    output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
-                };
+            finally {
+                if (!scopeRestored) {
+                    ctx.toolExecutor.setScope(parentScope || { allowed_files: [], read_only_files: [] });
+                }
             }
         }
         catch (e) {