micro-models-agent 0.28.17 → 0.29.0

package/dist/modules/session/store.js

@@ -5,17 +5,12 @@ 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
      */
@@ -52,7 +47,6 @@ 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);
@@ -64,20 +58,13 @@ 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;
-            const meta = JSON.parse(content);
-            this._metaCache.set(id, meta);
-            return meta;
+            const content = this.encryptor ? this.encryptor.decryptFileContent(raw) : raw;
+            return JSON.parse(content);
         }
         catch {
             return null;
@@ -107,31 +94,11 @@ 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()) {
-                return lines
-                    .map((line) => {
-                    try {
-                        return this.encryptor.decryptFileContent(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((l) => l !== null)
-                    .map(parseLine)
-                    .filter((m) => m !== null);
+                const decryptedLines = lines.map(line => this.encryptor.decryptFileContent(line));
+                return decryptedLines.map((line) => JSON.parse(line));
             }
-            return lines
-                .map(parseLine)
-                .filter((m) => m !== null);
+            return lines.map((line) => JSON.parse(line));
         }
         catch {
             return [];
@@ -155,31 +122,11 @@ 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()) {
-                return lines
-                    .map((line) => {
-                    try {
-                        return this.encryptor.decryptFileContent(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((l) => l !== null)
-                    .map(parseLine)
-                    .filter((e) => e !== null);
+                const decryptedLines = lines.map(line => this.encryptor.decryptFileContent(line));
+                return decryptedLines.map((line) => JSON.parse(line));
             }
-            return lines
-                .map(parseLine)
-                .filter((e) => e !== null);
+            return lines.map((line) => JSON.parse(line));
         }
         catch {
             return [];
@@ -201,7 +148,6 @@ 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,2 +1,3 @@
-export { SkillsLoader } from "./loader";
-export { SkillsModule } from "./module";
+export { SkillsLoader } from './loader';
+export { SkillsMatcher } from './matcher';
+export { SkillsModule } from './module';

package/dist/modules/skills/matcher.js

@@ -0,0 +1,27 @@
+const MIN_WORD_LENGTH = 4;
+export class SkillsMatcher {
+    match(taskDescription, skills, maxResults = 3) {
+        const taskWords = taskDescription.toLowerCase().split(/\W+/).filter(w => w.length >= MIN_WORD_LENGTH);
+        const scored = skills.map(skill => {
+            const allKeywords = [
+                skill.name.toLowerCase(),
+                skill.description.toLowerCase(),
+                ...skill.keywords.map(k => k.toLowerCase()),
+            ];
+            let score = 0;
+            for (const word of taskWords) {
+                for (const kw of allKeywords) {
+                    if (kw === word || (kw.length >= MIN_WORD_LENGTH && kw.includes(word))) {
+                        score++;
+                    }
+                }
+            }
+            return { skill, score };
+        });
+        return scored
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, maxResults)
+            .map(s => s.skill);
+    }
+}

package/dist/modules/skills/module.js

@@ -3,10 +3,12 @@ export class SkillsModule {
     name = "skills";
     availableSkills;
     loadedSkills = new Map();
+    matcher;
     budget;
     currentTokens = 0;
-    constructor(availableSkills, budget) {
+    constructor(availableSkills, matcher, budget) {
         this.availableSkills = availableSkills;
+        this.matcher = matcher;
         this.budget = budget;
     }
     loadByName(name) {
@@ -15,10 +17,24 @@ 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)
@@ -37,9 +53,7 @@ export class SkillsModule {
         return this.availableSkills.find((s) => s.name === name);
     }
     search(query) {
-        const q = query.toLowerCase();
-        return this.availableSkills.filter((s) => s.name.toLowerCase().includes(q) ||
-            s.description.toLowerCase().includes(q));
+        return this.matcher.match(query, this.availableSkills, 10);
     }
     getBudget() {
         return {
@@ -58,17 +72,16 @@ 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, 80);
+                const desc = skill.description.slice(0, 60);
                 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()) {
-                lines.push(`--- ${skill.name} (${this.estimateTokens(skill.content)} tokens) ---`);
-                lines.push(skill.content);
-                lines.push("");
+                const desc = skill.description.slice(0, 80);
+                lines.push(`- ${skill.name}: ${desc}`);
             }
         }
         if (lines.length === 0)
@@ -77,7 +90,7 @@ export class SkillsModule {
         const tokens = this.estimateTokens(content);
         return {
             content,
-            priority: "high",
+            priority: "normal",
             essential: false,
             estimatedTokens: tokens,
         };

package/dist/tools/bash.js

@@ -1,252 +1,61 @@
-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;
-}
+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;
 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 === "mkdir -p" || trimmed.startsWith("mkdir -p ")) {
-        return trimmed.replace(/mkdir -p/g, "mkdir");
+    if (trimmed.startsWith('mkdir -p ')) {
+        return trimmed.replace(/^mkdir -p /, '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);
+    if (trimmed === 'mkdir -p' || trimmed.startsWith('mkdir -p ')) {
+        return trimmed.replace(/mkdir -p/g, 'mkdir');
     }
-    // No encoding adaptation needed — registry.ts handles UTF-8/OEM decoding
-    return translateSemicolonsForCmd(command);
+    // No encoding adaptation needed — runner.ts handles UTF-8 decoding
+    return command;
 }
 /** Common Unix → Windows command mapping for error hints. */
 const UNIX_TO_WIN_HINTS = {
-    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",
+    '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 (|).',
 };
-/**
- * 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. 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"],
+    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'],
     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: "Return a process id immediately without waiting (default: commands still running after a few seconds are auto-promoted to the background)",
-            },
+            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)' },
         },
-        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 || {};
@@ -268,70 +77,64 @@ export const bashTool = {
             logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, // Will be updated after execution
             `Working directory: ${workdir}`);
         }
-        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));
+        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,
+                })}`,
+            };
         }
         try {
-            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)`;
+            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}`;
                 }
-                return { success: code === 0, output };
             }
-            // 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,
-            })}`;
+            // Update audit log with result
             if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
+                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), res.code === 0, `Working directory: ${workdir}, Output length: ${res.stdout.length}`);
             }
-            return { success: true, output };
+            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: res.code === 0, output };
         }
-        finally {
-            if (ctx.activeCallId) {
-                unregisterKillable(ctx.activeCallId);
+        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) || ""}`);
             }
+            return { success: false, output: e.message || String(e) };
         }
     },
 };