micro-models-agent 0.40.1 → 0.41.2

package/dist/tools/chunk-query.js

@@ -0,0 +1,99 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { t } from "../i18n/index";
+import { isPathInScope } from "./scope-check";
+import { runChunkQuery } from "../modules/context/chunk-query";
+export const chunkQueryTool = {
+    name: "chunk_query",
+    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"],
+    /** Multiple LLM calls (parallel chunk queries + synthesis) need a longer budget. */
+    timeoutMs: 300000,
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "The question to answer over the text.",
+            },
+            input_path: {
+                type: "string",
+                description: "Path to the large text file (scope-checked). Preferred over text.",
+            },
+            text: {
+                type: "string",
+                description: "Inline text. Use only when a file path is not available.",
+            },
+            chunk_chars: {
+                type: "number",
+                description: "Approximate chunk size in chars (default 12000).",
+            },
+            max_parallel: {
+                type: "number",
+                description: "Max parallel chunk queries (default from config.subagent.maxParallelChunkQueries).",
+            },
+            max_chunk_tokens: {
+                type: "number",
+                description: "Cap on generated tokens per chunk call (default 1024).",
+            },
+            max_synthesis_tokens: {
+                type: "number",
+                description: "Cap on generated tokens for the synthesis call (default 2048).",
+            },
+            reasoning_effort: {
+                type: "string",
+                enum: ["none", "low", "medium", "high"],
+                description: 'Reasoning effort for chunk/synthesis calls (default "none"). "none" prevents long thinking chains from eating the token budget on reasoning models.',
+            },
+            synthesize: {
+                type: "boolean",
+                description: "Run a final synthesis call over chunk answers (default true).",
+            },
+        },
+        required: ["query"],
+    },
+    handler: async (ctx, args) => {
+        const query = String(args.query || "");
+        const inputPath = args.input_path ? String(args.input_path) : undefined;
+        const text = args.text ? String(args.text) : undefined;
+        if (!query)
+            return { success: false, output: t("tool.chunk_query_no_query") };
+        if (!inputPath && !text)
+            return { success: false, output: t("tool.chunk_query_no_input") };
+        let content = text || "";
+        if (inputPath) {
+            const check = isPathInScope(ctx.baseDir, inputPath, ctx.scope);
+            if (!check.allowed) {
+                return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
+            }
+            try {
+                content = readFileSync(resolve(ctx.baseDir, inputPath), "utf8");
+            }
+            catch (e) {
+                return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
+            }
+        }
+        if (!ctx.llmProvider) {
+            return { success: false, output: "chunk_query: missing llmProvider in context" };
+        }
+        const maxParallel = typeof args.max_parallel === "number"
+            ? args.max_parallel
+            : (ctx.config.subagent?.maxParallelChunkQueries ?? 4);
+        const res = await runChunkQuery(ctx.llmProvider, content, query, {
+            chunkChars: typeof args.chunk_chars === "number" ? args.chunk_chars : undefined,
+            maxParallel,
+            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)
+                ? args.reasoning_effort
+                : undefined,
+            logger: ctx.logger,
+        });
+        ctx.logger.debug(`chunk_query: ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}`);
+        return {
+            success: true,
+            output: `[chunk_query] ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}\n\n${res.synthesis || res.answers.join("\n")}`,
+        };
+    },
+};

package/dist/tools/download-file.js

@@ -0,0 +1,116 @@
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
+import { isPathWritable } from "../modules/security/path-validator";
+import { logNetworkRequest, logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
+import { safeResolvePath } from "./path-utils";
+/** Default cap for a single download (bytes). Chunked responses without a
+ * content-length header are checked after the body is read. */
+export const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
+export const downloadFileTool = {
+    name: "download_file",
+    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"],
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "URL to download" },
+            path: {
+                type: "string",
+                description: "Destination path (relative to the working directory)",
+            },
+            max_bytes: {
+                type: "number",
+                description: "Optional size cap in bytes (default 100 MB)",
+            },
+        },
+        required: ["url", "path"],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url || "").trim();
+        const path = String(args.path || "").trim();
+        if (!url || !path) {
+            return { success: false, output: t("tool.invalid_params") };
+        }
+        // Network security: same rules as web_fetch/web_browse.
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network || DEFAULT_SECURITY_CONFIG.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        // Path safety: resolve against baseDir and verify writability.
+        const resolved = safeResolvePath(ctx.baseDir, path);
+        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        const maxBytes = Number(args.max_bytes) > 0 ? Number(args.max_bytes) : MAX_DOWNLOAD_BYTES;
+        try {
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+            });
+            if (!response.ok) {
+                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Status: ${response.status}`);
+                return {
+                    success: false,
+                    output: t("error.http", {
+                        status: response.status,
+                        statusText: response.statusText,
+                    }),
+                };
+            }
+            const contentLength = Number(response.headers.get("content-length") || "0");
+            if (contentLength > maxBytes) {
+                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Too large: ${contentLength}`);
+                return {
+                    success: false,
+                    output: t("tool.download_too_large", { max: String(maxBytes) }),
+                };
+            }
+            const buffer = Buffer.from(await response.arrayBuffer());
+            if (buffer.byteLength > maxBytes) {
+                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Too large: ${buffer.byteLength}`);
+                return {
+                    success: false,
+                    output: t("tool.download_too_large", { max: String(maxBytes) }),
+                };
+            }
+            mkdirSync(dirname(resolved), { recursive: true });
+            writeFileSync(resolved, buffer);
+            const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || "unknown";
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            logFileWrite(ctx.sessionId, resolved, true, `Downloaded ${buffer.byteLength} bytes`);
+            return {
+                success: true,
+                output: t("tool.downloaded", {
+                    url: sanitizeUrl(url),
+                    path: resolved,
+                    size: String(buffer.byteLength),
+                    type: contentType,
+                }),
+            };
+        }
+        catch (e) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
+            return {
+                success: false,
+                output: t("error.fetch_failed", { message: e.message }),
+            };
+        }
+    },
+};

package/dist/tools/enable-tools.js

@@ -0,0 +1,58 @@
+import { t } from "../i18n/index";
+/**
+ * On-demand tool activation. The main loop exposes only `config.tools.defaultTags`
+ * (+ `alwaysOn` structural tools). Specialized tools (web, browser, memory,
+ * process) are hidden from the schema to shrink the token footprint; the model
+ * activates them by calling this tool with the desired tag. The handler pushes
+ * the tags into the shared mutable `ctx.activeToolTags` array, which the agent
+ * loop re-reads each iteration to recompute the LLM-visible tool set.
+ */
+export const enableToolsTool = {
+    name: "enable_tools",
+    description: "Enable hidden tool categories for the current session. Only the essential tools (file/code/shell) are active by default. Call this with the tags you need and they become available from the next turn. Available tags: file, code, shell, research, browser, vision, image, memory, core. Returns the newly available tools. To run a task in a separate context instead, use subagent with tool_tags.",
+    alwaysOn: true,
+    parameters: {
+        type: "object",
+        properties: {
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: 'Tool tags to enable (e.g. ["research"] for web_search/web_fetch, ["browser"] for the browser, ["memory"] for remember/recall, ["shell"] for process management).',
+            },
+        },
+        required: ["tags"],
+    },
+    handler: async (ctx, args) => {
+        const requested = Array.isArray(args.tags) ? args.tags.map(String).filter(Boolean) : [];
+        if (requested.length === 0) {
+            return { success: false, output: t("tools.enable_no_tags") };
+        }
+        const active = ctx.activeToolTags ?? [];
+        const added = [];
+        for (const tag of requested) {
+            if (!active.includes(tag)) {
+                active.push(tag);
+                added.push(tag);
+            }
+        }
+        if (!ctx.toolExecutor) {
+            return { success: false, output: t("tools.enable_no_executor") };
+        }
+        const nowVisible = ctx.toolExecutor.getToolDefinitions([...active]).map((t) => t.name);
+        if (added.length === 0) {
+            return {
+                success: true,
+                output: t("tools.enable_already_active", {
+                    tags: requested.join(", "),
+                }),
+            };
+        }
+        return {
+            success: true,
+            output: t("tools.enable_added", {
+                tags: added.join(", "),
+                tools: nowVisible.join(", "),
+            }),
+        };
+    },
+};

package/dist/tools/executor.js

@@ -49,9 +49,7 @@ 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,
@@ -75,15 +73,16 @@ 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: TOOL_EXECUTION_TIMEOUT_MS / 1000,
+                            seconds: Math.round(timeoutMs / 1000),
                         })));
-                    }, TOOL_EXECUTION_TIMEOUT_MS);
+                    }, timeoutMs);
                 });
                 const racePromises = [
                     tool.handler(this.ctx, call.arguments),

package/dist/tools/file-info.js

@@ -1,17 +1,18 @@
-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'],
+    name: "file_info",
+    description: "Get metadata about a file or directory (size, creation date, modification date).",
+    tags: ["file"],
+    boundedOutput: true,
     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);
@@ -21,13 +22,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,10 +1,17 @@
+/**
+ * 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 => {
+    return tools.filter((t) => {
+        if (t.alwaysOn)
+            return true;
         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,9 +31,7 @@ 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/hidden-tools-block.js

@@ -0,0 +1,37 @@
+import { t } from "../i18n/index";
+/**
+ * Build a compact system-prompt block listing the tools hidden by the current
+ * tag filter. The model must know these tools exist (and how to reach them)
+ * even though they are absent from the LLM tool schema. Grouped by tag with
+ * short purposes; capped to keep the block small.
+ */
+export function buildHiddenToolsBlock(allTools, activeTags) {
+    if (!allTools.length)
+        return "";
+    const activeSet = new Set(activeTags);
+    const visible = new Set();
+    for (const tool of allTools) {
+        if (tool.alwaysOn || (tool.tags && tool.tags.some((tag) => activeSet.has(tag)))) {
+            visible.add(tool.name);
+        }
+    }
+    const hidden = allTools.filter((tool) => !visible.has(tool.name));
+    if (hidden.length === 0)
+        return "";
+    // Group by tag → tools, then by tool name alphabetically within a tag.
+    const byTag = new Map();
+    for (const tool of hidden) {
+        const tags = tool.tags && tool.tags.length > 0 ? tool.tags : ["other"];
+        for (const tag of tags) {
+            if (!byTag.has(tag))
+                byTag.set(tag, []);
+            byTag.get(tag).push(tool);
+        }
+    }
+    const lines = [t("tools.hidden_header")];
+    for (const [tag, tools] of [...byTag.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const names = [...new Set(tools.map((tool) => tool.name))].sort().join(", ");
+        lines.push(`- [${tag}] ${names}`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/index.js

@@ -15,9 +15,11 @@ 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'
@@ -30,10 +32,11 @@ 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, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
-export function registerAllTools(registry, skillsModule) {
+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) {
     const tools = [
         readFileTool,
         writeFileTool,
@@ -47,17 +50,25 @@ export function registerAllTools(registry, skillsModule) {
         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));
     }

package/dist/tools/list-dir.js

@@ -1,19 +1,20 @@
-import { readdirSync, statSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { t } from '../i18n/index';
-import { isPathInScope } from '../modules/security/path-validator';
-import { safeResolvePath } from './path-utils';
-import { MAX_PREVIEW_LINES } from './preview';
+import { readdirSync, statSync, existsSync } from "fs";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { isPathInScope } from "../modules/security/path-validator";
+import { safeResolvePath } from "./path-utils";
+import { MAX_PREVIEW_LINES } from "./preview";
 export const listDirTool = {
-    name: 'list_dir',
+    name: "list_dir",
     description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
-    tags: ['file'],
+    tags: ["file"],
+    boundedOutput: true,
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            path: { type: 'string', description: 'Directory path' },
+            path: { type: "string", description: "Directory path" },
         },
-        required: ['path'],
+        required: ["path"],
     },
     handler: async (ctx, args) => {
         const path = String(args.path);
@@ -23,25 +24,25 @@ export const listDirTool = {
         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.dir_notfound', { path }) };
+            return { success: false, output: t("file.dir_notfound", { path }) };
         }
         const entries = readdirSync(resolved);
-        const lines = entries.map(e => {
+        const lines = entries.map((e) => {
             const full = resolve(resolved, e);
             return statSync(full).isDirectory() ? `${e}/` : e;
         });
         if (lines.length === 0) {
-            return { success: true, output: t('file.empty') };
+            return { success: true, output: t("file.empty") };
         }
         const truncated = lines.length > MAX_PREVIEW_LINES
             ? `\n... (${lines.length - MAX_PREVIEW_LINES} more entries)`
-            : '';
-        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join('\n') + truncated };
+            : "";
+        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join("\n") + truncated };
     },
 };

package/dist/tools/load-skill.js

@@ -28,9 +28,7 @@ export function createLoadSkillTool(skillsModule) {
                 return { success: false, output: result.message + hint };
             }
             const budget = skillsModule.getBudget();
-            const tokens = result.skill
-                ? Math.ceil(result.skill.content.length / 4)
-                : 0;
+            const tokens = result.skill ? Math.ceil(result.skill.content.length / 4) : 0;
             return {
                 success: true,
                 output: t("tool.skill_budget", {

package/dist/tools/path-utils.js

@@ -1,5 +1,5 @@
-import { resolve, normalize, dirname, basename, sep } from 'path';
-import { existsSync } from 'fs';
+import { resolve, normalize, dirname, basename, sep } from "path";
+import { existsSync } from "fs";
 /**
  * Resolve a user-provided path against baseDir.
  *
@@ -13,7 +13,7 @@ import { existsSync } from 'fs';
  */
 export function safeResolvePath(baseDir, userPath) {
     const norm = normalize(userPath);
-    const stripped = norm.replace(/^[/\\]/, '');
+    const stripped = norm.replace(/^[/\\]/, "");
     const resolved = resolve(baseDir, stripped);
     // Fast path: if it exists (or parent does for new files), return it
     if (existsSync(resolved) || existsSync(dirname(resolved)))
@@ -31,7 +31,7 @@ export function safeResolvePath(baseDir, userPath) {
         while (idx >= 0) {
             const afterIdx = idx + name.length;
             const afterChar = stripped[afterIdx];
-            if (afterChar && afterChar !== '\\' && afterChar !== '/') {
+            if (afterChar && afterChar !== "\\" && afterChar !== "/") {
                 const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
                 const fixedResolved = resolve(baseDir, normalize(fixed));
                 if (existsSync(fixedResolved) || existsSync(dirname(fixedResolved))) {