micro-models-agent 0.39.0 → 0.40.0

package/dist/modules/session/store.js

@@ -5,12 +5,17 @@ import { SessionFileEncryptor } from "../security/session-encryption";
 export class SessionStore {
     baseDir;
     encryptor = null;
+    // In-memory meta cache to avoid O(N²) disk reads on appendMessage.
+    _metaCache = new Map();
     constructor(baseDir, encryptionConfig) {
         this.baseDir = baseDir;
         if (encryptionConfig?.enabled) {
             this.encryptor = new SessionFileEncryptor(encryptionConfig);
         }
     }
+    getSessionDir(id) {
+        return join(this.baseDir, id);
+    }
     /**
      * Update encryption configuration
      */
@@ -47,6 +52,7 @@ export class SessionStore {
         return existsSync(this.metaPath(id));
     }
     saveMeta(id, meta) {
+        this._metaCache.set(id, meta);
         const dir = this.sessionDir(id);
         mkdirSync(dir, { recursive: true });
         const content = JSON.stringify(meta, null, 2);
@@ -58,13 +64,20 @@ export class SessionStore {
         }
     }
     loadMeta(id) {
+        const cached = this._metaCache.get(id);
+        if (cached)
+            return cached;
         const path = this.metaPath(id);
         if (!existsSync(path))
             return null;
         try {
             const raw = readFileSync(path, "utf-8");
-            const content = this.encryptor ? this.encryptor.decryptFileContent(raw) : raw;
-            return JSON.parse(content);
+            const content = this.encryptor
+                ? this.encryptor.decryptFileContent(raw)
+                : raw;
+            const meta = JSON.parse(content);
+            this._metaCache.set(id, meta);
+            return meta;
         }
         catch {
             return null;
@@ -94,11 +107,31 @@ export class SessionStore {
         try {
             const raw = readFileSync(path, "utf-8");
             const lines = raw.split("\n").filter(Boolean);
+            const parseLine = (line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            };
             if (this.encryptor?.isEnabled()) {
-                const decryptedLines = lines.map(line => this.encryptor.decryptFileContent(line));
-                return decryptedLines.map((line) => JSON.parse(line));
+                return lines
+                    .map((line) => {
+                    try {
+                        return this.encryptor.decryptFileContent(line);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((l) => l !== null)
+                    .map(parseLine)
+                    .filter((m) => m !== null);
             }
-            return lines.map((line) => JSON.parse(line));
+            return lines
+                .map(parseLine)
+                .filter((m) => m !== null);
         }
         catch {
             return [];
@@ -122,11 +155,31 @@ export class SessionStore {
         try {
             const raw = readFileSync(path, "utf-8");
             const lines = raw.split("\n").filter(Boolean);
+            const parseLine = (line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            };
             if (this.encryptor?.isEnabled()) {
-                const decryptedLines = lines.map(line => this.encryptor.decryptFileContent(line));
-                return decryptedLines.map((line) => JSON.parse(line));
+                return lines
+                    .map((line) => {
+                    try {
+                        return this.encryptor.decryptFileContent(line);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((l) => l !== null)
+                    .map(parseLine)
+                    .filter((e) => e !== null);
             }
-            return lines.map((line) => JSON.parse(line));
+            return lines
+                .map(parseLine)
+                .filter((e) => e !== null);
         }
         catch {
             return [];
@@ -148,6 +201,7 @@ export class SessionStore {
         return sessions;
     }
     deleteSession(id) {
+        this._metaCache.delete(id);
         const dir = this.sessionDir(id);
         if (existsSync(dir)) {
             rmSync(dir, { recursive: true, force: true });

package/dist/modules/skills/index.js

@@ -1,3 +1,2 @@
-export { SkillsLoader } from './loader';
-export { SkillsMatcher } from './matcher';
-export { SkillsModule } from './module';
+export { SkillsLoader } from "./loader";
+export { SkillsModule } from "./module";

package/dist/modules/skills/module.js

@@ -3,12 +3,10 @@ export class SkillsModule {
     name = "skills";
     availableSkills;
     loadedSkills = new Map();
-    matcher;
     budget;
     currentTokens = 0;
-    constructor(availableSkills, matcher, budget) {
+    constructor(availableSkills, budget) {
         this.availableSkills = availableSkills;
-        this.matcher = matcher;
         this.budget = budget;
     }
     loadByName(name) {
@@ -17,24 +15,10 @@ export class SkillsModule {
         }
         const skill = this.availableSkills.find((s) => s.name === name);
         if (!skill) {
-            const fuzzyMatches = this.matcher.match(name, this.availableSkills, 1);
-            if (fuzzyMatches.length > 0) {
-                return this.tryLoad(fuzzyMatches[0]);
-            }
             return { success: false, message: t("skill.not_found", { name }) };
         }
         return this.tryLoad(skill);
     }
-    loadByMatch(taskDescription) {
-        const matches = this.matcher.match(taskDescription, this.availableSkills, 1);
-        if (matches.length === 0) {
-            return {
-                success: false,
-                message: t("skill.no_match", { task: taskDescription }),
-            };
-        }
-        return this.tryLoad(matches[0]);
-    }
     unload(name) {
         const skill = this.loadedSkills.get(name);
         if (!skill)
@@ -53,7 +37,9 @@ export class SkillsModule {
         return this.availableSkills.find((s) => s.name === name);
     }
     search(query) {
-        return this.matcher.match(query, this.availableSkills, 10);
+        const q = query.toLowerCase();
+        return this.availableSkills.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q));
     }
     getBudget() {
         return {
@@ -72,16 +58,17 @@ export class SkillsModule {
             lines.push("[Available Skills]");
             lines.push(t("skill.prompt_hint"));
             for (const skill of this.availableSkills) {
-                const desc = skill.description.slice(0, 60);
+                const desc = skill.description.slice(0, 80);
                 lines.push(`- ${skill.name}: ${desc}`);
             }
-            lines.push(t("skill.prompt_fallback"));
         }
         if (this.loadedSkills.size > 0) {
+            lines.push("");
             lines.push("[Loaded Skills]");
             for (const skill of this.loadedSkills.values()) {
-                const desc = skill.description.slice(0, 80);
-                lines.push(`- ${skill.name}: ${desc}`);
+                lines.push(`--- ${skill.name} (${this.estimateTokens(skill.content)} tokens) ---`);
+                lines.push(skill.content);
+                lines.push("");
             }
         }
         if (lines.length === 0)
@@ -90,7 +77,7 @@ export class SkillsModule {
         const tokens = this.estimateTokens(content);
         return {
             content,
-            priority: "normal",
+            priority: "high",
             essential: false,
             estimatedTokens: tokens,
         };

package/dist/tools/bash.js

@@ -1,61 +1,252 @@
-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 { runCommand, processRegistry, isLongRunningCommand } from '../modules/processes';
-import { t } from '../i18n/index';
-import { platform } from 'os';
-import { MAX_PREVIEW_LINES } from './preview';
-const BASH_TIMEOUT_MS = 120_000;
+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 { t } from "../i18n/index";
+import { platform } from "os";
+import { MAX_PREVIEW_LINES } from "./preview";
+/**
+ * A command still running after this window is promoted to the background.
+ * The decision is based on process *behavior* (still alive), not on matching
+ * words in the command text — a command that happens to mention "vite",
+ * "server", etc. runs normally, and any genuinely long-running command is
+ * caught regardless of how it is written.
+ */
+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;
+let bashGraceMs = BASH_GRACE_MS;
+/** Test hook: override the auto-background grace window. */
+export function setBashGraceMs(ms) {
+    bashGraceMs = ms;
+}
+/**
+ * Detect a file write via `echo/printf ... > file` — common model habit that
+ * breaks in cmd.exe: single quotes are not grouping quotes, `>` only applies
+ * to the LAST line of a multi-line command, and double quotes inside the text
+ * split the command. Returns the target filename or null.
+ */
+export function extractEchoFileWrite(command) {
+    if (!/^\s*(?:echo|printf)\b/i.test(command))
+        return null;
+    const m = command.match(/[>»]{1,2}\s*"?([^"'\s&|]+)"?/i);
+    if (!m)
+        return null;
+    return m[1].replace(/["'']$/g, "");
+}
+/**
+ * cmd.exe uses `&` as the command separator, not `;` (bash). The model
+ * regularly chains commands with `;` — without translation cmd passes the
+ * `;` to the first command as an argument (e.g. `node x.ts;` → ENOENT for
+ * "x.ts;"). Replace `;` with `&` only OUTSIDE double-quoted strings so
+ * `echo "a;b"` stays intact. (Single quotes are not special in cmd.)
+ */
+export function translateSemicolonsForCmd(command) {
+    let out = "";
+    let inQuotes = false;
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        if (ch === '"') {
+            inQuotes = !inQuotes;
+            out += ch;
+            continue;
+        }
+        out += ch === ";" && !inQuotes ? "&" : ch;
+    }
+    return out;
+}
 function adaptCommandForWindows(command) {
-    if (platform() !== 'win32')
+    if (platform() !== "win32")
         return command;
+    // The model sometimes appends `|| true` (bash error-suppression idiom)
+    // which PowerShell doesn't understand. Replace with `; exit 0` which
+    // forces a successful exit code regardless of the previous command's result.
+    if (/\|\|\s*true\b/.test(command)) {
+        command = command.replace(/\s*\|\|\s*true\b/g, "; exit 0");
+    }
     // Windows mkdir does not support -p flag, but creates intermediate dirs by default
     const trimmed = command.trim();
-    if (trimmed.startsWith('mkdir -p ')) {
-        return trimmed.replace(/^mkdir -p /, 'mkdir ');
+    if (trimmed.startsWith("mkdir -p ")) {
+        return trimmed.replace(/^mkdir -p /, "mkdir ");
+    }
+    if (trimmed === "mkdir -p" || trimmed.startsWith("mkdir -p ")) {
+        return trimmed.replace(/mkdir -p/g, "mkdir");
     }
-    if (trimmed === 'mkdir -p' || trimmed.startsWith('mkdir -p ')) {
-        return trimmed.replace(/mkdir -p/g, 'mkdir');
+    // Translate simple Unix commands to their cmd.exe equivalents. Only the
+    // leading word is rewritten; flags are passed through (ls -la → dir -la,
+    // which cmd tolerates). Pipe-using forms are left alone — they would break.
+    const firstWord = trimmed.split(/\s+/)[0]?.split(/[\\/]/).pop();
+    const translated = firstWord ? UNIX_TO_WIN_TRANSLATE[firstWord] : undefined;
+    if (translated &&
+        !trimmed.includes("|") &&
+        !trimmed.includes(">") &&
+        !trimmed.includes("&&") &&
+        !trimmed.includes(";")) {
+        return trimmed.replace(firstWord, translated);
     }
-    // No encoding adaptation needed — runner.ts handles UTF-8 decoding
-    return command;
+    // No encoding adaptation needed — registry.ts handles UTF-8/OEM decoding
+    return translateSemicolonsForCmd(command);
 }
 /** Common Unix → Windows command mapping for error hints. */
 const UNIX_TO_WIN_HINTS = {
-    'ls': 'Use "dir" or the list_dir tool instead.',
-    'pwd': 'Use "echo %cd%" or the file_info tool instead.',
-    'cat': 'Use "type" or the read_file tool instead.',
-    'cp': 'Use "copy" or the move_file tool instead.',
-    'mv': 'Use "move" or the move_file tool instead.',
-    'rm': 'Use "del" or the delete_file tool instead.',
-    'grep': 'Use "findstr" or the grep tool instead.',
-    'chmod': 'Use icacls or the chmod tool instead.',
-    'touch': 'Use type nul > file or the write_file tool instead.',
-    'find': 'Use "dir /s" or the glob tool instead.',
-    'head': 'Use the read_file tool with offset/limit instead.',
-    'tail': 'Use the read_file tool instead.',
-    'wc': 'Use the read_file tool instead.',
-    'diff': 'Use the diff tool instead.',
-    'which': 'Use "where" instead.',
-    'echo': 'echo works on Windows, but avoid pipes (|).',
+    ls: "Use the list_dir tool instead.",
+    pwd: "Use the file_info tool instead.",
+    cat: "Use the read_file tool instead.",
+    cp: "Use the move_file tool instead.",
+    mv: "Use the move_file tool instead.",
+    rm: "Use the delete_file tool instead.",
+    grep: "Use the grep tool instead.",
+    chmod: "Use the chmod tool instead.",
+    touch: "Use the write_file tool instead.",
+    find: "Use the glob tool instead.",
+    head: "Use the read_file tool with offset/limit instead.",
+    tail: "Use the read_file tool instead.",
+    wc: "Use the read_file tool instead.",
+    diff: "Use the diff tool instead.",
+    which: 'Use "where" instead.',
+    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.",
+};
+/** Unix commands that can be transparently translated to cmd.exe equivalents. */
+const UNIX_TO_WIN_TRANSLATE = {
+    ls: "dir",
+    pwd: "cd",
+    cat: "type",
 };
+/**
+ * Detect when the model mistakes a tool call for a shell command — e.g.
+ * `bash` with command "create_dir path=C:\...\src" or "read_file file=x".
+ * These are tool invocations, not commands; running them through the shell
+ * fails. The matched tool name and raw args are returned so the caller can
+ * redirect into the real tool.
+ */
+/**
+ * Shell commands that must NEVER be treated as mistaken tool calls. The
+ * model often writes files via `echo '<code with = signs>'` or reads them
+ * via `cat` — those are shell commands, not tool invocations. Without this
+ * guard the redirect heuristic fires on any `<word> <text containing =>`
+ * and fails with "Unknown tool: echo".
+ */
+const NEVER_TOOL_CALLS = new Set([
+    "echo",
+    "cat",
+    "type",
+    "printf",
+    "touch",
+    "mkdir",
+    "cp",
+    "mv",
+    "rm",
+    "ls",
+    "dir",
+    "cd",
+    "pwd",
+    "grep",
+    "find",
+    "head",
+    "tail",
+    "wc",
+    "chmod",
+    "sed",
+    "awk",
+]);
+export function detectToolCallInBash(command) {
+    const match = command.trim().match(/^([\w-]+)\s+(.+)$/s);
+    if (!match)
+        return null;
+    const tool = match[1];
+    // Real shell commands (echo, cat, ...) are never mistaken tool calls.
+    if (NEVER_TOOL_CALLS.has(tool))
+        return null;
+    const rest = match[2].trim();
+    // Only treat as a tool call when the first word looks like a snake_case
+    // tool name and the rest has at least one '=' or a JSON object shape.
+    if (!/^[a-z][a-z0-9_]+$/.test(tool))
+        return null;
+    if (!rest.includes("=") && !rest.startsWith("{"))
+        return null;
+    return { tool, args: rest };
+}
+/**
+ * Parse the raw argument string of a mistaken tool call captured in a bash
+ * command into a Record. Supports JSON objects ("{"path": "..."}") and
+ * key=value pairs ("path=C:\...\src"). Values keep their literal text.
+ */
+export function parseToolArgs(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            /* fall through to key=value parsing */
+        }
+    }
+    const args = {};
+    // Tokenize respecting double/single-quoted values.
+    const tokens = trimmed.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+    for (const token of tokens) {
+        const eq = token.indexOf("=");
+        if (eq > 0) {
+            const key = token.slice(0, eq);
+            const value = token.slice(eq + 1);
+            // Strip surrounding quotes from values.
+            args[key] = value.replace(/^["']|["']$/g, "");
+        }
+    }
+    return args;
+}
 export const bashTool = {
-    name: 'bash',
-    description: 'Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Long-running commands (dev servers, watchers) start in the background and return a process id immediately — manage them with process_list, process_log, process_kill. Set background=true to force background execution.',
-    tags: ['shell', 'code'],
+    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).",
+    tags: ["shell", "code"],
     parameters: {
-        type: 'object',
+        type: "object",
         properties: {
-            command: { type: 'string', description: 'Shell command to execute' },
-            workdir: { type: 'string', description: 'Working directory (default: baseDir)' },
-            background: { type: 'boolean', description: 'Start the command in the background and return immediately with a process id (default: auto-detect long-running commands)' },
+            command: { type: "string", description: "Shell command to execute" },
+            workdir: {
+                type: "string",
+                description: "Working directory (default: baseDir)",
+            },
+            background: {
+                type: "boolean",
+                description: "Return a process id immediately without waiting (default: commands still running after a few seconds are auto-promoted to the background)",
+            },
         },
-        required: ['command'],
+        required: ["command"],
     },
     handler: async (ctx, args) => {
         const originalCommand = String(args.command);
+        // The model sometimes sends a tool invocation (e.g. "create_dir path=...")
+        // as a bash command instead of calling the tool directly. Redirect into
+        // the real tool so the intent succeeds instead of failing in the shell.
+        const toolCall = detectToolCallInBash(originalCommand);
+        if (toolCall &&
+            toolCall.tool !== "bash" &&
+            ctx.toolExecutor &&
+            ctx.toolExecutor.hasTool(toolCall.tool)) {
+            const redirected = await ctx.toolExecutor.executeByName(toolCall.tool, parseToolArgs(toolCall.args), ctx);
+            return {
+                success: redirected.success,
+                output: `[redirected to tool "${toolCall.tool}"]\n${redirected.output}`,
+            };
+        }
         const command = adaptCommandForWindows(originalCommand);
+        // echo/printf redirection to a file is unreliable in cmd.exe (single
+        // quotes don't group, multi-line commands split, embedded double quotes
+        // break the command). Steer the model to write_file instead — it
+        // produces correct files every time.
+        if (platform() === "win32") {
+            const echoWrite = extractEchoFileWrite(originalCommand);
+            if (echoWrite) {
+                return {
+                    success: false,
+                    output: t("bash.echo_write_blocked", { path: echoWrite }),
+                };
+            }
+        }
         const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
         // Get session-specific security config with defaults
         const appConfig = ctx.config || {};
@@ -77,64 +268,70 @@ export const bashTool = {
             logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, // Will be updated after execution
             `Working directory: ${workdir}`);
         }
-        const background = args.background === true || isLongRunningCommand(command);
-        if (background) {
-            const entry = processRegistry.start(command, workdir, ctx.sessionId);
-            if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
-            }
-            const explicit = args.background === true;
-            return {
-                success: true,
-                output: `${t("proc.started", {
-                    id: entry.id,
-                    pid: entry.pid,
-                    command,
-                })}${explicit ? "" : `\n${t("proc.detected_hint")}`}\n${t("proc.manage_hint", {
-                    id: entry.id,
-                })}`,
-            };
+        const entry = processRegistry.start(command, workdir, ctx.sessionId);
+        if (ctx.activeCallId) {
+            // Let the executor abort/kill the child during the grace window.
+            registerKillable(ctx.activeCallId, () => processRegistry.kill(entry.id));
         }
         try {
-            const res = await runCommand(command, {
-                cwd: workdir,
-                callId: ctx.activeCallId,
-                timeoutMs: BASH_TIMEOUT_MS,
-            });
-            const parts = [res.stdout.trimEnd(), res.stderr.trimEnd()].filter(Boolean);
-            let output = parts.join("\n");
-            if (res.timedOut) {
-                output = `${output ? output + "\n" : ""}${t("proc.timed_out", {
-                    ms: BASH_TIMEOUT_MS,
-                })}`;
-            }
-            else if (!output && res.code !== 0) {
-                output = `(exit code ${res.code})`;
-            }
-            // On Windows, hint about Unix commands that don't work
-            if (platform() === 'win32' && res.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}`;
+            const settleMs = args.background === true ? SPAWN_SETTLE_MS : bashGraceMs;
+            const exited = await processRegistry.waitForExit(entry.id, settleMs);
+            if (exited) {
+                // Command finished (or failed to spawn) within the window.
+                if (entry.spawnError) {
+                    return {
+                        success: false,
+                        output: `[process error] ${entry.spawnError}\nHint: check the "workdir" path exists and the command is valid for this OS.`,
+                    };
+                }
+                const code = entry.exitCode;
+                let output = entry.log.join("\n");
+                processRegistry.remove(entry.id);
+                if (!output && code !== 0) {
+                    output = `(exit code ${code})`;
+                }
+                // 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
+                if (securityConfig?.logCommands) {
+                    logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), code === 0, `Working directory: ${workdir}, Output length: ${output.length}`);
+                }
+                const lines = output.split("\n");
+                if (lines.length > MAX_PREVIEW_LINES) {
+                    output =
+                        lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+                            `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
                 }
+                return { success: code === 0, output };
             }
-            // Update audit log with result
+            // Still running — promote to a background process.
+            const explicit = args.background === true;
+            const output = `${t("proc.started", {
+                id: entry.id,
+                pid: entry.pid,
+                command,
+            })}${explicit ? "" : `\n${t("proc.promoted_hint", { ms: settleMs })}`}\n${t("proc.manage_hint", {
+                id: entry.id,
+            })}`;
             if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), res.code === 0, `Working directory: ${workdir}, Output length: ${res.stdout.length}`);
-            }
-            const lines = output.split('\n');
-            if (lines.length > MAX_PREVIEW_LINES) {
-                output = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
             }
-            return { success: res.code === 0, output };
+            return { success: true, output };
         }
-        catch (e) {
-            // Update audit log with failure
-            if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${e.message?.slice(0, 100) || ""}`);
+        finally {
+            if (ctx.activeCallId) {
+                unregisterKillable(ctx.activeCallId);
             }
-            return { success: false, output: e.message || String(e) };
         }
     },
 };

package/dist/tools/create-dir.js

@@ -50,7 +50,6 @@ export const createDirTool = {
         ctx.fileOperationsCount = currentCount + 1;
         // Log directory creation
         logFileWrite(ctx.sessionId, path, true, "Directory created");
-        ctx.trackCreatedPath?.(path);
         return { success: true, output: t("file.created", { path }) };
     },
 };

package/dist/tools/delete-file.js

@@ -57,7 +57,6 @@ export const deleteFileTool = {
         ctx.fileOperationsCount = currentCount + 1;
         // Log successful file deletion
         logFileDelete(ctx.sessionId, path, true);
-        ctx.trackDeletedPath?.(path);
         return { success: true, output: t("file.deleted", { path }), diff };
     },
 };