omnius 1.0.213 → 1.0.214

package/dist/index.js

@@ -4896,6 +4896,29 @@ var init_shell = __esm({
       hasSudoPassword() {
         return this._sudoPassword !== null;
       }
+      isConcurrencySafe(args) {
+        return this.isReadOnly(args);
+      }
+      isReadOnly(args) {
+        const command = String(args["command"] ?? "").trim();
+        if (!command || args["stdin"] !== void 0)
+          return false;
+        const normalized = command.replace(/\s+/g, " ");
+        if (/\bcd\b/.test(normalized))
+          return false;
+        if (/[<>]|\|\s*(?:tee|xargs)\b|\btee\b/.test(normalized))
+          return false;
+        if (/\b(?:sudo|su|rm|mv|cp|touch|mkdir|rmdir|chmod|chown|ln|truncate|dd|patch|apply_patch)\b/.test(normalized)) {
+          return false;
+        }
+        if (/\bgit\s+(?:add|commit|checkout|switch|reset|clean|push|pull|merge|rebase|apply|am|stash|tag)\b/.test(normalized)) {
+          return false;
+        }
+        if (/\b(?:npm|pnpm|yarn|bun)\s+(?:install|i|ci|add|remove|run|test|build)\b/.test(normalized)) {
+          return false;
+        }
+        return /^(?:pwd|ls\b|find\b|rg\b|grep\b|cat\b|head\b|tail\b|wc\b|sed\s+-n\b|awk\b|git\s+(?:status|diff|log|show|branch|rev-parse|ls-files|grep)\b|which\b|command\s+-v\b|node\s+--version\b|node\s+-v\b|python(?:3)?\s+--version\b)/.test(normalized);
+      }
       async execute(args) {
         const start2 = performance.now();
         const command = args["command"];
@@ -6112,6 +6135,7 @@ var init_file_read = __esm({
     ];
     FileReadTool = class {
       name = "file_read";
+      aliases = ["read_file", "read", "cat"];
       description = "Read the contents of a file. For large files (200+ lines), returns a structural preview with signatures — use offset/limit to read specific sections.";
       parameters = {
         type: "object",
@@ -6127,6 +6151,12 @@ var init_file_read = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       /** Set actual context window size for proportional auto-windowing */
       setContextWindowSize(size) {
         this._contextWindowSize = size;
@@ -6662,6 +6692,7 @@ var init_grep_search = __esm({
     MAX_OUTPUT_LINES = 100;
     GrepSearchTool = class {
       name = "grep_search";
+      aliases = ["grep", "ripgrep", "search_text"];
       description = "Search file contents using regex patterns. Returns matching lines with file paths and line numbers.";
       parameters = {
         type: "object",
@@ -6685,6 +6716,12 @@ var init_grep_search = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const pattern = args["pattern"];
         const searchPath = resolve4(this.workingDir, args["path"] ?? ".");
@@ -6767,6 +6804,7 @@ var init_glob_find = __esm({
     MAX_RESULTS = 50;
     GlobFindTool = class {
       name = "find_files";
+      aliases = ["glob", "find"];
       description = "Find files matching a glob pattern. Returns list of matching file paths.";
       parameters = {
         type: "object",
@@ -6786,6 +6824,12 @@ var init_glob_find = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const pattern = args["pattern"];
         const searchPath = resolve5(this.workingDir, args["path"] ?? ".");
@@ -24373,6 +24417,7 @@ var init_list_directory = __esm({
     MAX_ENTRIES = 100;
     ListDirectoryTool = class {
       name = "list_directory";
+      aliases = ["ls", "dir"];
       description = "List files and directories at a given path. Shows file sizes and types. Output includes full relative paths you can use directly in subsequent tool calls.";
       parameters = {
         type: "object",
@@ -24388,6 +24433,12 @@ var init_list_directory = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const rawPath = args["path"];
         const dirPath = typeof rawPath === "string" && rawPath.trim() ? rawPath : ".";
@@ -555233,7 +555284,8 @@ function partitionToolCalls(calls, readOnlyHints) {
   const batches = [];
   let currentConcurrent = [];
   for (const call of calls) {
-    if (isConcurrencySafe(call.name, readOnlyHints)) {
+    const safe = typeof call.concurrencySafe === "boolean" ? call.concurrencySafe : isConcurrencySafe(call.name, readOnlyHints);
+    if (safe) {
       currentConcurrent.push(call);
     } else {
       if (currentConcurrent.length > 0) {
@@ -555891,13 +555943,18 @@ var init_streaming_executor = __esm({
       executeFn = null;
       constructor(config) {
         this.config = {
-          maxConcurrent: config?.maxConcurrent ?? 5
+          maxConcurrent: config?.maxConcurrent ?? 5,
+          concurrencyResolver: config?.concurrencyResolver
         };
       }
       /** Set the tool execution function */
       setExecutor(fn) {
         this.executeFn = fn;
       }
+      /** Update the parsed-input concurrency classifier. */
+      setConcurrencyResolver(fn) {
+        this.config.concurrencyResolver = fn;
+      }
       /** Number of tools tracked */
       get size() {
         return this.tools.size;
@@ -555918,7 +555975,7 @@ var init_streaming_executor = __esm({
           name: name10,
           args: partialArgs ?? {},
           state: "queued",
-          concurrencySafe: isConcurrencySafe(name10),
+          concurrencySafe: this.resolveConcurrencySafe(name10, partialArgs ?? {}),
           finalized: false,
           queuedAt: Date.now()
         });
@@ -555933,6 +555990,7 @@ var init_streaming_executor = __esm({
         if (!entry)
           return;
         entry.args = args;
+        entry.concurrencySafe = this.resolveConcurrencySafe(entry.name, args);
         entry.finalized = true;
         if (entry.state === "queued") {
           this.processQueue();
@@ -556030,6 +556088,15 @@ var init_streaming_executor = __esm({
           return true;
         return false;
       }
+      resolveConcurrencySafe(name10, args) {
+        try {
+          const resolved = this.config.concurrencyResolver?.(name10, args);
+          if (typeof resolved === "boolean")
+            return resolved;
+        } catch {
+        }
+        return isConcurrencySafe(name10);
+      }
       entryFingerprint(entry) {
         return `${entry.name}:${stableValueKey(entry.args)}`;
       }
@@ -559047,6 +559114,7 @@ var init_agenticRunner = __esm({
           skipCrossTaskHandoff: options2?.skipCrossTaskHandoff ?? false
         };
         this._adversaryMode = this.options.adversaryMode;
+        this._streamingExecutor.setConcurrencyResolver((name10, args) => this.resolveToolConcurrencySafe(name10, args));
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
       setContextWindowSize(size) {
@@ -562048,7 +562116,8 @@ ${blob}
         return Object.entries(args ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${this._formatExactArgValue(v)}`).join(",");
       }
       _buildToolFingerprint(name10, args) {
-        return `${name10}:${this._buildExactArgsKey(args)}`;
+        const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
+        return `${canonical}:${this._buildExactArgsKey(args)}`;
       }
       _dedupeToolCallsForResponse(toolCalls, turn) {
         if (toolCalls.length <= 1)
@@ -562254,32 +562323,45 @@ ${blob}
       }
       /** Register a tool for the agent to use */
       registerTool(tool) {
-        if (!this.isToolAllowedByProfile(tool.name))
+        if (!this.isToolAllowedByProfile(tool.name, tool.aliases))
           return;
         this.tools.set(tool.name, tool);
         if (tool.name === "generate_image") {
           this.maybeInstallImagePromptExpander(tool);
         }
       }
-      isToolAllowedByProfile(name10) {
-        const profile = this.options.toolProfile;
-        if (!profile)
-          return true;
+      toolNameVariants(name10) {
         const raw = String(name10 ?? "").trim();
+        if (!raw)
+          return [];
         const lastSegment = raw.split(/[.:/]/).filter(Boolean).pop() ?? raw;
-        const candidates = /* @__PURE__ */ new Set([
+        return Array.from(new Set([
           raw,
           raw.toLowerCase(),
+          raw.replace(/[-\s]+/g, "_"),
           raw.replace(/^functions[._:-]/i, ""),
           raw.replace(/^tools[._:-]/i, ""),
           lastSegment,
-          lastSegment.toLowerCase()
-        ]);
+          lastSegment.toLowerCase(),
+          lastSegment.replace(/[-\s]+/g, "_")
+        ].filter(Boolean)));
+      }
+      isToolAllowedByProfile(name10, aliases) {
+        const profile = this.options.toolProfile;
+        if (!profile)
+          return true;
+        const candidates = /* @__PURE__ */ new Set();
+        for (const value2 of [name10, ...aliases ?? []]) {
+          for (const variant of this.toolNameVariants(value2)) {
+            candidates.add(variant);
+          }
+        }
         const allow = Array.isArray(profile.allow) ? profile.allow.filter(Boolean) : [];
-        if (allow.length > 0)
-          return allow.some((toolName) => candidates.has(toolName));
+        if (allow.length > 0) {
+          return allow.some((toolName) => this.toolNameVariants(toolName).some((candidate) => candidates.has(candidate)));
+        }
         const deny = Array.isArray(profile.deny) ? profile.deny.filter(Boolean) : [];
-        return !deny.some((toolName) => candidates.has(toolName));
+        return !deny.some((toolName) => this.toolNameVariants(toolName).some((candidate) => candidates.has(candidate)));
       }
       toolProfileDenial(name10) {
         const profileName = this.options.toolProfile?.name || "active tool profile";
@@ -562357,20 +562439,14 @@ Rewrite it now for ${ctx3.model}.`;
         const direct = this.tools.get(raw);
         if (direct)
           return { name: raw, tool: direct };
-        const lastSegment = raw.split(/[.:/]/).filter(Boolean).pop() ?? raw;
-        const candidates = /* @__PURE__ */ new Set([
-          raw,
-          raw.toLowerCase(),
-          raw.replace(/[-\s]+/g, "_"),
-          raw.replace(/^functions[._:-]/i, ""),
-          raw.replace(/^tools[._:-]/i, ""),
-          lastSegment,
-          lastSegment.toLowerCase(),
-          lastSegment.replace(/[-\s]+/g, "_")
-        ]);
+        const candidates = new Set(this.toolNameVariants(raw));
         const lowerIndex = /* @__PURE__ */ new Map();
-        for (const registeredName of this.tools.keys()) {
-          lowerIndex.set(registeredName.toLowerCase(), registeredName);
+        for (const [registeredName, tool] of this.tools) {
+          for (const value2 of [registeredName, ...tool.aliases ?? []]) {
+            for (const variant of this.toolNameVariants(value2)) {
+              lowerIndex.set(variant.toLowerCase(), registeredName);
+            }
+          }
         }
         for (const candidate of candidates) {
           const exact = this.tools.get(candidate);
@@ -562382,8 +562458,47 @@ Rewrite it now for ${ctx3.model}.`;
         }
         return null;
       }
+      resolveToolConcurrencySafe(name10, args) {
+        const resolved = this.lookupRegisteredTool(name10);
+        const tool = resolved?.tool;
+        try {
+          if (typeof tool?.isConcurrencySafe === "function") {
+            return !!tool.isConcurrencySafe(args);
+          }
+          if (typeof tool?.isReadOnly === "function") {
+            return !!tool.isReadOnly(args);
+          }
+        } catch {
+        }
+        return isConcurrencySafe(resolved?.name ?? name10);
+      }
+      toolResultMaxSize(tool) {
+        const max = tool?.maxResultSizeChars;
+        return typeof max === "number" && Number.isFinite(max) && max > 0 ? max : void 0;
+      }
+      applyRegisteredToolResultTriage(result, toolName, tool) {
+        return applyToolResultTriage(result, {
+          workingDir: this._workingDirectory || process.cwd(),
+          toolName,
+          maxOutputSize: this.toolResultMaxSize(tool)
+        });
+      }
+      async validateToolInput(tool, args, toolName) {
+        if (typeof tool.validateInput !== "function")
+          return null;
+        const validation = await tool.validateInput(args, {
+          toolName,
+          workingDir: this._workingDirectory || process.cwd()
+        });
+        if (validation?.result === true)
+          return null;
+        if (validation?.result === false) {
+          return validation.message || "custom validation failed";
+        }
+        return null;
+      }
       unknownToolError(name10) {
-        const names = Array.from(this.tools.keys()).sort();
+        const names = Array.from(this.tools.values()).map((tool) => tool.aliases?.length ? `${tool.name} (aliases: ${tool.aliases.join("|")})` : tool.name).sort();
         const preview = names.slice(0, 80).join(", ");
         const suffix = names.length > 80 ? `, ... ${names.length - 80} more` : "";
         return `Unknown tool: ${name10}. Registered tools (${names.length}): ${preview}${suffix}`;
@@ -562397,6 +562512,7 @@ Rewrite it now for ${ctx3.model}.`;
         for (const t2 of this.tools.values()) {
           list.push({
             name: t2.name,
+            ...t2.aliases?.length ? { aliases: t2.aliases } : {},
             description: t2.description,
             parameters: t2.parameters
           });
@@ -562408,10 +562524,10 @@ Rewrite it now for ${ctx3.model}.`;
        * Validates against inputSchema if present and returns the tool result.
        */
       async runToolByName(name10, args) {
-        if (!this.isToolAllowedByProfile(name10)) {
+        const resolved = this.lookupRegisteredTool(name10);
+        if (!this.isToolAllowedByProfile(resolved?.name ?? name10, resolved?.tool.aliases)) {
           return this.toolProfileDenial(name10);
         }
-        const resolved = this.lookupRegisteredTool(name10);
         if (!resolved) {
           return { success: false, output: "", error: this.unknownToolError(name10) };
         }
@@ -562427,12 +562543,17 @@ Rewrite it now for ${ctx3.model}.`;
             error: `Invalid args for ${resolved.name}: ${e2?.message || String(e2)}`
           };
         }
+        const validationError = await this.validateToolInput(tool, args, resolved.name);
+        if (validationError) {
+          return {
+            success: false,
+            output: "",
+            error: `Invalid args for ${resolved.name}: ${validationError}. Check the parameter values and try again.`
+          };
+        }
         try {
           const result = await tool.execute(args);
-          return applyToolResultTriage(result, {
-            workingDir: this._workingDirectory || process.cwd(),
-            toolName: tool.name ?? "tool"
-          });
+          return this.applyRegisteredToolResultTriage(result, resolved.name, tool);
         } catch (e2) {
           return { success: false, output: "", error: e2?.message || String(e2) };
         }
@@ -564804,19 +564925,17 @@ ${memoryLines.join("\n")}`
                     if (jsonMatch) {
                       try {
                         const parsed = JSON.parse(jsonMatch[1]);
-                        if (parsed.tool && this.tools.has(parsed.tool)) {
-                          const tool = this.tools.get(parsed.tool);
+                        const resolvedParsedTool = parsed.tool ? this.lookupRegisteredTool(parsed.tool) : null;
+                        if (parsed.tool && resolvedParsedTool) {
+                          const tool = resolvedParsedTool.tool;
                           const rawResult = await tool.execute(parsed.args ?? {});
-                          const result = applyToolResultTriage(rawResult, {
-                            workingDir: this._workingDirectory || process.cwd(),
-                            toolName: parsed.tool
-                          });
+                          const result = this.applyRegisteredToolResultTriage(rawResult, resolvedParsedTool.name, tool);
                           messages2.push({ role: "assistant", content });
                           messages2.push({
                             role: "user",
                             content: `Tool result (${parsed.tool}): ${result.output.slice(0, 2e3)}`
                           });
-                          if (parsed.tool === "task_complete") {
+                          if (resolvedParsedTool.name === "task_complete") {
                             completed = true;
                             summary = String(parsed.args?.summary ?? content);
                           }
@@ -565473,6 +565592,9 @@ Corrective action: try a different approach first: read relevant files, adjust a
                     }
                   }
                 }
+                if (!validationError) {
+                  validationError = await this.validateToolInput(tool, tc.arguments, resolvedTool?.name ?? tc.name);
+                }
                 if (validationError) {
                   result = {
                     success: false,
@@ -565561,10 +565683,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                         } else {
                           result = await tool.execute(finalArgs);
                         }
-                        result = applyToolResultTriage(result, {
-                          workingDir: this._workingDirectory || process.cwd(),
-                          toolName: tc.name
-                        });
+                        result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                         if (tc.name === "shell" && result.success === true) {
                           const semanticErr = this._detectSemanticShellFailure(result.output ?? "");
                           if (semanticErr) {
@@ -566808,10 +566927,8 @@ Then use file_read on individual FILES inside it.`);
               await this._streamingExecutor.waitAll();
               const streamResults = this._streamingExecutor.drainCompleted();
               for (const sr of streamResults) {
-                sr.result = applyToolResultTriage(sr.result, {
-                  workingDir: this._workingDirectory || process.cwd(),
-                  toolName: sr.name
-                });
+                const resolvedStreamTool = this.lookupRegisteredTool(sr.name);
+                sr.result = this.applyRegisteredToolResultTriage(sr.result, resolvedStreamTool?.name ?? sr.name, resolvedStreamTool?.tool);
               }
               const handledIds = /* @__PURE__ */ new Set();
               for (const sr of streamResults) {
@@ -566928,7 +567045,8 @@ ${sr.result.output}`;
               const batchToolCalls = rawToolCalls.map((tc) => ({
                 name: tc.name,
                 args: tc.arguments,
-                id: tc.id
+                id: tc.id,
+                concurrencySafe: this.resolveToolConcurrencySafe(tc.name, tc.arguments)
               }));
               const batches = partitionToolCalls(batchToolCalls);
               for (const batch2 of batches) {
@@ -567206,6 +567324,9 @@ Call task_complete(summary="...") NOW with whatever you have.`
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
+            const pendingBeforeAdversary = this.pendingUserMessages.length;
+            this.adversaryObserve(messages2, turn);
+            const adversaryAddedGuidance = this.pendingUserMessages.length > pendingBeforeAdversary;
             if (/task.?complete|all tests pass/i.test(content)) {
               const completionArgs = { summary: content };
               if (holdNoProgressTaskComplete(completionArgs, turn) || holdProvenanceTaskComplete(completionArgs, turn)) {
@@ -567321,6 +567442,12 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
                 content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done."
               });
             }
+            if (adversaryAddedGuidance) {
+              while (this.pendingUserMessages.length > 0) {
+                const userMsg = this.pendingUserMessages.shift();
+                await this.appendInjectedUserMessage(userMsg, messages2, turn);
+              }
+            }
           }
           try {
             const turnLogTail = toolCallLog.filter((t2) => t2.turn === turn || t2.turn === void 0);
@@ -567659,10 +567786,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 } else {
                   try {
                     result = await tool.execute(tc.arguments);
-                    result = applyToolResultTriage(result, {
-                      workingDir: this._workingDirectory || process.cwd(),
-                      toolName: tc.name
-                    });
+                    result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                   } catch (err) {
                     result = {
                       success: false,
@@ -567681,10 +567805,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   if (pw2 && tool) {
                     try {
                       result = await tool.execute(tc.arguments);
-                      result = applyToolResultTriage(result, {
-                        workingDir: this._workingDirectory || process.cwd(),
-                        toolName: tc.name
-                      });
+                      result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                     } catch (err) {
                       result = {
                         success: false,
@@ -569969,8 +570090,6 @@ ${trimmedNew}`;
        * that already succeeded, the adversary nudges it to move on.
        */
       adversaryObserve(messages2, turn) {
-        if (this.options.modelTier === "large")
-          return;
         const recent = messages2.slice(-6);
         for (const msg of recent) {
           if (msg.role === "tool" && typeof msg.content === "string") {
@@ -569997,10 +570116,16 @@ ${trimmedNew}`;
             }
             const argsKey = toolArgs ? this._buildExactArgsKey(toolArgs) : void 0;
             const fingerprint = toolArgs ? this._buildToolFingerprint(toolName, toolArgs) : void 0;
-            if (!this._adversaryToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint)) {
+            const alreadySeen = this._adversaryToolOutcomes.some((o2) => {
+              if (msg.tool_call_id && o2.toolCallId === msg.tool_call_id)
+                return true;
+              return o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint;
+            });
+            if (!alreadySeen) {
               this._adversaryToolOutcomes.push({
                 turn,
                 tool: toolName,
+                toolCallId: msg.tool_call_id,
                 argsKey,
                 fingerprint,
                 succeeded,
@@ -570085,7 +570210,8 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
           }
         }
         if (this.options.disableAdversaryCritic !== true) {
-          const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
+          const newestAssistant = [...recent].reverse().find((m2) => m2.role === "assistant");
+          const lastToolCalls = newestAssistant?.tool_calls ?? [];
           for (const tc of lastToolCalls) {
             const name10 = tc.function.name;
             if (this._isStatefulBrowserTool(name10))
@@ -571193,6 +571319,7 @@ ${transcript}`
           }
         }
         const getDesc = (tool) => dynamicDescs.get(tool.name) ?? tool.description;
+        const aliasText = (tool) => Array.isArray(tool.aliases) && tool.aliases.length > 0 ? ` aliases:${tool.aliases.join(",")}` : "";
         const getCustomToolMetadata = (tool) => {
           const meta = tool.customToolMetadata;
           return meta?.isCustomTool === true ? meta : void 0;
@@ -571229,7 +571356,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
         };
         const getIndexLabel = (tool) => {
           const meta = getCustomToolMetadata(tool);
-          const desc = `${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
+          const desc = `${getDesc(tool)} ${aliasText(tool)} ${customToolSearchText(tool)}`.toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
           const keywords2 = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS3.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
           const base3 = keywords2.length > 0 ? `${tool.name}(${keywords2.join(",")})` : tool.name;
           if (!meta)
@@ -571263,7 +571390,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
           if (CORE_TOOLS3.has(tool.name))
             continue;
           const customMeta = getCustomToolMetadata(tool);
-          const toolText = `${tool.name} ${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase();
+          const toolText = `${tool.name} ${aliasText(tool)} ${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase();
           const toolWords = toolText.split(/\s+/).filter((w) => w.length > 2);
           let score = 0;
           for (const tw of toolWords) {
@@ -571274,7 +571401,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
                 score += 1;
             }
           }
-          if (taskText.includes(tool.name.replace(/_/g, " ")) || taskText.includes(tool.name)) {
+          if (taskText.includes(tool.name.replace(/_/g, " ")) || taskText.includes(tool.name) || (tool.aliases ?? []).some((alias) => taskText.includes(alias.toLowerCase()))) {
             score += customMeta ? 16 : 10;
           }
           if (wants3dModelGeneration) {
@@ -571427,6 +571554,9 @@ ${catalog}`,
                       continue;
                     lines.push("");
                     lines.push(`## ${tool.name}`);
+                    if (tool.aliases?.length) {
+                      lines.push(`Aliases: ${tool.aliases.join(", ")}`);
+                    }
                     lines.push(`${getDesc(tool)}${customToolDetails(tool)}`);
                     lines.push(`Parameters: ${JSON.stringify(tool.parameters)}`);
                   }
@@ -571439,7 +571569,7 @@ ${catalog}`,
                 }
                 return { success: true, output: lines.join("\n") };
               }
-              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
+              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
                 const scoreTool = (tool) => {
                   const meta = getCustomToolMetadata(tool);
                   let score = 0;
@@ -571447,6 +571577,10 @@ ${catalog}`,
                     score += 30;
                   if (tool.name.toLowerCase().includes(query))
                     score += 10;
+                  if ((tool.aliases ?? []).some((alias) => alias.toLowerCase() === query))
+                    score += 24;
+                  if ((tool.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)))
+                    score += 8;
                   if (getDesc(tool).toLowerCase().includes(query))
                     score += 4;
                   if (customToolSearchText(tool).toLowerCase().includes(query))
@@ -571477,7 +571611,9 @@ ${catalog}`,
                 activatedToolsRef.add(t2.name);
               const result = matches.map((t2) => {
                 const paramsStr = JSON.stringify(t2.parameters, null, 2);
-                return `## ${t2.name}
+                const aliases = t2.aliases?.length ? `
+Aliases: ${t2.aliases.join(", ")}` : "";
+                return `## ${t2.name}${aliases}
 ${getDesc(t2)}${customToolDetails(t2)}
 
 Parameters:
@@ -681081,15 +681217,31 @@ function adaptTool6(tool) {
   }
   return {
     name: tool.name,
+    aliases: tool.aliases,
     description: tool.description,
     parameters: tool.parameters,
+    inputSchema: tool.inputSchema,
+    prompt: tool.prompt,
+    executeStream: tool.executeStream,
+    validateInput: tool.validateInput,
+    isConcurrencySafe: tool.isConcurrencySafe,
+    isReadOnly: tool.isReadOnly,
+    maxResultSizeChars: tool.maxResultSizeChars,
     async execute(args) {
       const result = await tool.execute(args);
       return {
         success: result.success,
         output: result.output,
         error: result.error,
-        llmContent: result.llmContent
+        llmContent: result.llmContent,
+        mutated: result.mutated,
+        mutatedFiles: result.mutatedFiles,
+        diff: result.diff,
+        dryRun: result.dryRun,
+        noop: result.noop,
+        partial: result.partial,
+        beforeHash: result.beforeHash,
+        afterHash: result.afterHash
       };
     }
   };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.213",
+  "version": "1.0.214",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.213",
+      "version": "1.0.214",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.213",
+  "version": "1.0.214",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",