steward-cli 0.13.0 → 0.15.0

package/README.md

@@ -1,6 +1,6 @@
 # Steward
 
-[![Version](https://img.shields.io/badge/version-v0.13.0-D77757.svg)](https://github.com/sapirrior/steward/releases)
+[![Version](https://img.shields.io/badge/version-v0.15.0-D77757.svg)](https://github.com/sapirrior/steward/releases)
 [![npm](https://img.shields.io/npm/v/steward-cli.svg?color=373737)](https://www.npmjs.com/package/steward-cli)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Runtime](https://img.shields.io/badge/runtime-Bun-fbf0df.svg?logo=bun)](https://bun.sh)
@@ -10,19 +10,6 @@ Steward is an interactive AI engineering assistant for the terminal. Built with
 
 ---
 
-```text
- ▄▄▄▄▄   Steward
-▀▙███▟▀  AI engineering assistant for your terminal
- ▘▘ ▝▝
-
-────────────────────────────────────────────────────────────────────────────────
-> Refactor the authentication service to use JWT refresh token rotation
-────────────────────────────────────────────────────────────────────────────────
-? for shortcuts                                            claude-3-7-sonnet
-```
-
----
-
 ## Get Started
 
 ### Installation

package/dist/cli.js

@@ -42842,7 +42842,7 @@ function getTheme() {
   return darkTheme;
 }
 // src/theme/logo.ts
-var LOGO_LINES = [" ▄▄▄▄▄ ", "▀▙███▟▀", " ▘▘ ▝▝ "];
+var LOGO_LINES = [" ▄▄▄▄▄ ", "▀▙███▟▀", " ▝   ▘ "];
 var LOGO_WIDTH = Math.max(...LOGO_LINES.map((line) => stringWidth(line)));
 // node_modules/marked/lib/marked.esm.js
 function A() {
@@ -52973,7 +52973,7 @@ class TerminalEngine {
 }
 
 // src/engine/agent-session.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 // src/session/helpers.ts
 function formatToolOutputSummary(res, isError = false) {
   if (isError || res === undefined || res === null) {
@@ -70955,7 +70955,7 @@ class ToolCatalog {
     for (const [name, def] of this.tools.entries()) {
       aiTools[name] = tool({
         description: def.description,
-        parameters: def.parameters,
+        inputSchema: def.parameters,
         execute: async (args) => {
           return def.execute(args, context);
         }
@@ -70967,13 +70967,52 @@ class ToolCatalog {
 var defaultToolCatalog = new ToolCatalog;
 
 // src/tools/read-file/index.ts
-import { existsSync as existsSync9, lstatSync as lstatSync3, readFileSync as readFileSync8 } from "node:fs";
-import { isAbsolute as isAbsolute2, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync9, lstatSync as lstatSync3, readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve as resolve5, sep as sep3 } from "node:path";
 var readFileInputSchema = object({
   path: string2().describe("The path of the file to read (relative to current working directory or absolute)."),
   offset: number2().int().min(1).optional().describe("The line number to start reading from (1-indexed). Defaults to 1."),
   limit: number2().int().min(1).max(2000).optional().describe("The maximum number of lines to read. Defaults to 200.")
 });
+function isPathInside2(targetPath, basePath) {
+  const normTarget = resolve5(targetPath);
+  const normBase = resolve5(basePath);
+  if (normTarget === normBase) {
+    return true;
+  }
+  const prefix = normBase.endsWith(sep3) ? normBase : `${normBase}${sep3}`;
+  return normTarget.startsWith(prefix);
+}
+function resolveSafeReadPath(cwd, filePath) {
+  if (!filePath || !filePath.trim()) {
+    throw new Error("File path cannot be empty.");
+  }
+  const trimmed = filePath.trim();
+  const resolved = isAbsolute2(trimmed) ? resolve5(trimmed) : resolve5(cwd, trimmed);
+  if (!isPathInside2(resolved, cwd)) {
+    throw new Error(`Access denied: path "${filePath}" resolves outside the trusted workspace root ("${cwd}").`);
+  }
+  if (!existsSync9(resolved)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  let realTarget;
+  try {
+    realTarget = realpathSync3(resolved);
+  } catch {
+    realTarget = resolved;
+  }
+  if (!isPathInside2(realTarget, cwd)) {
+    throw new Error(`Access denied: symlink "${filePath}" points outside the trusted workspace root.`);
+  }
+  const stat = lstatSync3(resolved);
+  if (stat.isDirectory()) {
+    throw new Error(`Cannot read path because it is a directory: ${filePath}`);
+  }
+  if (!stat.isFile() && !stat.isSymbolicLink()) {
+    throw new Error(`Cannot read special or non-regular file: ${filePath}`);
+  }
+  return realTarget;
+}
 function isBinaryBuffer(buffer) {
   const checkLength = Math.min(buffer.length, 1024);
   for (let i = 0;i < checkLength; i++) {
@@ -70986,7 +71025,7 @@ function isBinaryBuffer(buffer) {
 var readFileTool = {
   name: "read_file",
   displayName: "Read",
-  description: "Reads the contents of a file with 1-indexed line numbers. Supports reading specific line ranges via offset and limit. Read is read-only and does not mutate or checkpoint.",
+  description: "Reads the contents of a file. Supports reading specific line ranges via offset and limit. Read is read-only and does not mutate or checkpoint.",
   parameters: readFileInputSchema,
   confirmationPolicy: "never",
   summarize: (_args, result) => {
@@ -70994,10 +71033,7 @@ var readFileTool = {
     return `Read ${lines} line${lines === 1 ? "" : "s"}`;
   },
   execute: async (args, context) => {
-    const targetPath = isAbsolute2(args.path) ? args.path : resolve5(context.cwd, args.path);
-    if (!existsSync9(targetPath)) {
-      throw new Error(`File not found: ${args.path}`);
-    }
+    const targetPath = resolveSafeReadPath(context.cwd, args.path);
     const stat = lstatSync3(targetPath);
     if (stat.isDirectory()) {
       throw new Error(`Cannot read path because it is a directory: ${args.path}`);
@@ -71033,18 +71069,13 @@ var readFileTool = {
     const startIndex = Math.max(0, startLine - 1);
     const endIndex = Math.min(totalLines, startIndex + limit);
     const slice = allLines.slice(startIndex, endIndex);
-    const padWidth = String(endIndex).length;
-    const formattedContent = slice.map((line, idx) => {
-      const lineNum = String(startIndex + idx + 1).padStart(padWidth, " ");
-      return `${lineNum} | ${line}`;
-    }).join(`
-`);
     return {
       path: args.path,
       totalLines,
       startLine,
       endLine: endIndex,
-      content: formattedContent,
+      content: slice.join(`
+`),
       isTruncated: endIndex < totalLines,
       linesRead: slice.length
     };
@@ -71052,6 +71083,9 @@ var readFileTool = {
 };
 
 // src/tools/write-file/index.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync3 } from "node:fs";
+
+// src/utils/atomic-write.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
@@ -71060,13 +71094,46 @@ import {
   fsyncSync as fsyncSync5,
   mkdirSync as mkdirSync7,
   openSync as openSync6,
-  readFileSync as readFileSync9,
   renameSync as renameSync5,
-  statSync as statSync3,
   unlinkSync as unlinkSync5,
   writeSync as writeSync5
 } from "node:fs";
 import { dirname as dirname5, join as join7 } from "node:path";
+function atomicWriteFileSync(targetPath, content, options = {}) {
+  const buffer = typeof content === "string" ? Buffer.from(content, options.encoding ?? "utf-8") : content;
+  const dir = dirname5(targetPath);
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true });
+  }
+  const mode = options.mode ?? 420;
+  const tmpPath = join7(dir, `.tmp-write-${randomUUID5().slice(0, 8)}`);
+  let fd = null;
+  try {
+    fd = openSync6(tmpPath, "w", mode);
+    writeSync5(fd, buffer, 0, buffer.length);
+    fsyncSync5(fd);
+    closeSync6(fd);
+    fd = null;
+    try {
+      chmodSync2(tmpPath, mode);
+    } catch {}
+    renameSync5(tmpPath, targetPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync6(fd);
+      } catch {}
+    }
+    if (existsSync10(tmpPath)) {
+      try {
+        unlinkSync5(tmpPath);
+      } catch {}
+    }
+    throw err;
+  }
+}
+
+// src/tools/write-file/index.ts
 var writeFileInputSchema = object({
   file_path: string2().describe("The path of the file to write (relative to current working directory or absolute inside trusted workspace)."),
   content: string2().describe("The full text content to write to the file.")
@@ -71098,7 +71165,7 @@ ${detail}${overflow}`;
   },
   execute: async (args, context) => {
     const { absolutePath: targetPath, relativePath } = resolveDirectMutationPath(context.cwd, args.file_path);
-    const isNew = !existsSync10(targetPath);
+    const isNew = !existsSync11(targetPath);
     const beforeContent = isNew ? null : readFileSync9(targetPath, "utf-8");
     const afterContent = args.content;
     const linesWritten = afterContent.length === 0 ? 0 : afterContent.split(/\r?\n/).length;
@@ -71134,11 +71201,11 @@ ${detail}${overflow}`;
         throw new Error("File write permission denied by user.");
       }
       if (isNew) {
-        if (existsSync10(targetPath)) {
+        if (existsSync11(targetPath)) {
           throw new Error(`File was created externally during approval review: "${relativePath}". Mutation aborted to prevent data loss.`);
         }
       } else {
-        if (!existsSync10(targetPath)) {
+        if (!existsSync11(targetPath)) {
           throw new Error(`File was deleted externally during approval review: "${relativePath}". Mutation aborted.`);
         }
         const freshContent = readFileSync9(targetPath, "utf-8");
@@ -71146,42 +71213,14 @@ ${detail}${overflow}`;
           throw new Error(`File was modified externally during approval review: "${relativePath}". Mutation aborted to prevent data loss.`);
         }
       }
-      const newBuffer = Buffer.from(afterContent, "utf-8");
-      const dir = dirname5(targetPath);
-      if (!existsSync10(dir)) {
-        mkdirSync7(dir, { recursive: true });
-      }
       let existingMode = 420;
       if (!isNew) {
         try {
           existingMode = statSync3(targetPath).mode;
         } catch {}
       }
-      const tmpPath = join7(dir, `.tmp-write-${randomUUID5().slice(0, 8)}`);
-      let fd = null;
-      try {
-        fd = openSync6(tmpPath, "w", existingMode);
-        writeSync5(fd, newBuffer, 0, newBuffer.length);
-        fsyncSync5(fd);
-        closeSync6(fd);
-        fd = null;
-        try {
-          chmodSync2(tmpPath, existingMode);
-        } catch {}
-        renameSync5(tmpPath, targetPath);
-      } catch (err) {
-        if (fd !== null) {
-          try {
-            closeSync6(fd);
-          } catch {}
-        }
-        if (existsSync10(tmpPath)) {
-          try {
-            unlinkSync5(tmpPath);
-          } catch {}
-        }
-        throw err;
-      }
+      const newBuffer = Buffer.from(afterContent, "utf-8");
+      atomicWriteFileSync(targetPath, newBuffer, { mode: existingMode });
       if (context.checkpointTracker) {
         await context.checkpointTracker.completeMutation(targetPath);
       }
@@ -71201,20 +71240,7 @@ ${detail}${overflow}`;
 };
 
 // src/tools/edit-file/index.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import {
-  chmodSync as chmodSync3,
-  closeSync as closeSync7,
-  existsSync as existsSync11,
-  fsyncSync as fsyncSync6,
-  openSync as openSync7,
-  readFileSync as readFileSync10,
-  renameSync as renameSync6,
-  statSync as statSync4,
-  unlinkSync as unlinkSync6,
-  writeSync as writeSync6
-} from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, statSync as statSync4 } from "node:fs";
 
 // src/utils/diff.ts
 function tokenizeLines(content) {
@@ -71524,7 +71550,7 @@ ${diffLines.join(`
   },
   execute: async (args, context) => {
     const { absolutePath: targetPath, relativePath } = resolveDirectMutationPath(context.cwd, args.file_path);
-    if (!existsSync11(targetPath)) {
+    if (!existsSync12(targetPath)) {
       throw new Error(`Cannot edit file because it does not exist: "${args.file_path}". Use write_file to create new files.`);
     }
     const currentContent = readFileSync10(targetPath, "utf-8");
@@ -71575,65 +71601,30 @@ ${diffLines.join(`
       if (!perm.allowed) {
         throw new Error("File edit permission denied by user.");
       }
-      if (!existsSync11(targetPath)) {
+      if (!existsSync12(targetPath)) {
         throw new Error(`File was deleted externally during approval review: "${relativePath}". Mutation aborted.`);
       }
       const freshContent = readFileSync10(targetPath, "utf-8");
       if (freshContent !== currentContent) {
         throw new Error(`File was modified externally during approval review: "${relativePath}". Mutation aborted to prevent data loss.`);
       }
-      const beforeLines = currentContent.split(/\r?\n/);
-      const afterLines = updatedContent.split(/\r?\n/);
-      const lineDelta = afterLines.length - beforeLines.length;
+      const diff = buildUnifiedDiff(currentContent, updatedContent, 0);
       let addedLines = 0;
       let removedLines = 0;
-      const oldLinesInMatch = args.old_string.split(/\r?\n/).length;
-      const newLinesInMatch = args.new_string.split(/\r?\n/).length;
-      const totalReplacedOccurrences = args.replace_all ? matchCount : 1;
-      if (oldLinesInMatch === newLinesInMatch && !args.old_string.includes(`
-`) && !args.new_string.includes(`
-`)) {
-        addedLines = totalReplacedOccurrences;
-        removedLines = totalReplacedOccurrences;
-      } else {
-        removedLines = (oldLinesInMatch - 1) * totalReplacedOccurrences + (lineDelta < 0 ? Math.abs(lineDelta) : 0);
-        addedLines = (newLinesInMatch - 1) * totalReplacedOccurrences + (lineDelta > 0 ? lineDelta : 0);
-        if (addedLines === 0 && removedLines === 0 && args.old_string !== args.new_string) {
-          addedLines = totalReplacedOccurrences;
-          removedLines = totalReplacedOccurrences;
+      for (const hunk of diff.hunks) {
+        for (const line of hunk.lines) {
+          if (line.kind === "addition")
+            addedLines++;
+          if (line.kind === "deletion")
+            removedLines++;
         }
       }
-      const newBuffer = Buffer.from(updatedContent, "utf-8");
-      const dir = dirname6(targetPath);
       let existingMode = 420;
       try {
         existingMode = statSync4(targetPath).mode;
       } catch {}
-      const tmpPath = join8(dir, `.tmp-edit-${randomUUID6().slice(0, 8)}`);
-      let fd = null;
-      try {
-        fd = openSync7(tmpPath, "w", existingMode);
-        writeSync6(fd, newBuffer, 0, newBuffer.length);
-        fsyncSync6(fd);
-        closeSync7(fd);
-        fd = null;
-        try {
-          chmodSync3(tmpPath, existingMode);
-        } catch {}
-        renameSync6(tmpPath, targetPath);
-      } catch (err) {
-        if (fd !== null) {
-          try {
-            closeSync7(fd);
-          } catch {}
-        }
-        if (existsSync11(tmpPath)) {
-          try {
-            unlinkSync6(tmpPath);
-          } catch {}
-        }
-        throw err;
-      }
+      const newBuffer = Buffer.from(updatedContent, "utf-8");
+      atomicWriteFileSync(targetPath, newBuffer, { mode: existingMode });
       if (context.checkpointTracker) {
         await context.checkpointTracker.completeMutation(targetPath);
       }
@@ -71654,7 +71645,7 @@ ${diffLines.join(`
 
 // src/tools/glob/index.ts
 import { readdirSync as readdirSync2 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join9, relative as relative2, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve6 } from "node:path";
 var globInputSchema = object({
   pattern: string2().describe('Glob pattern to match files against (e.g. "**/*.ts", "src/*.json").'),
   path: string2().optional().describe("Starting directory path. Defaults to workspace root."),
@@ -71683,10 +71674,10 @@ function walkDir(dir, baseDir, matcher, results, limit) {
         break;
       if (entry.isDirectory()) {
         if (!IGNORED_DIRS.has(entry.name)) {
-          walkDir(join9(dir, entry.name), baseDir, matcher, results, limit);
+          walkDir(join8(dir, entry.name), baseDir, matcher, results, limit);
         }
       } else if (entry.isFile()) {
-        const rel = relative2(baseDir, join9(dir, entry.name));
+        const rel = relative2(baseDir, join8(dir, entry.name));
         if (matcher(rel, entry.name)) {
           results.push(rel);
         }
@@ -71706,7 +71697,13 @@ var globTool = {
   },
   execute: async (args, context) => {
     const startTime = Date.now();
-    const searchRoot = args.path ? isAbsolute3(args.path) ? args.path : resolve6(context.cwd, args.path) : context.cwd;
+    const searchRoot = args.path ? isAbsolute3(args.path) ? resolve6(args.path) : resolve6(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve6(context.cwd);
+    const normTarget = resolve6(searchRoot);
+    const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
+    if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
+      throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
+    }
     const limit = args.limit ?? 100;
     const pattern = args.pattern.trim();
     const regex = globToRegex(pattern);
@@ -71729,7 +71726,7 @@ var globTool = {
 
 // src/tools/grep/index.ts
 import { readFileSync as readFileSync11, readdirSync as readdirSync3 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join10, relative as relative3, resolve as resolve7 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join9, relative as relative3, resolve as resolve7 } from "node:path";
 var grepInputSchema = object({
   pattern: string2().describe("The regex or text pattern to search for across files."),
   path: string2().optional().describe("Target directory or file path to search. Defaults to current directory."),
@@ -71758,7 +71755,7 @@ function searchInDir(dir, baseDir, regex, fileFilter, results, filesWithMatches,
     for (const entry of entries) {
       if (results.length >= limit)
         break;
-      const fullPath = join10(dir, entry.name);
+      const fullPath = join9(dir, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORED_DIRS2.has(entry.name)) {
           searchInDir(fullPath, baseDir, regex, fileFilter, results, filesWithMatches, limit);
@@ -71804,7 +71801,13 @@ var grepTool = {
   },
   execute: async (args, context) => {
     const startTime = Date.now();
-    const searchRoot = args.path ? isAbsolute4(args.path) ? args.path : resolve7(context.cwd, args.path) : context.cwd;
+    const searchRoot = args.path ? isAbsolute4(args.path) ? resolve7(args.path) : resolve7(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve7(context.cwd);
+    const normTarget = resolve7(searchRoot);
+    const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
+    if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
+      throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
+    }
     const limit = args.limit ?? 100;
     const isCaseSensitive = args.case_sensitive ?? false;
     const flags = isCaseSensitive ? "" : "i";
@@ -71859,7 +71862,7 @@ var grepTool = {
 
 // src/tools/list-dir/index.ts
 import { readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join11, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join10, resolve as resolve8 } from "node:path";
 var listDirInputSchema = object({
   path: string2().optional().describe("Directory path to list. Defaults to current working directory."),
   recursive: boolean2().optional().describe("If true, lists files recursively (depth 2). Defaults to false.")
@@ -71876,7 +71879,13 @@ var listDirTool = {
     return `Listed ${files} file${files === 1 ? "" : "s"}, ${dirs} director${dirs === 1 ? "y" : "ies"}`;
   },
   execute: async (args, context) => {
-    const targetPath = args.path ? isAbsolute5(args.path) ? args.path : resolve8(context.cwd, args.path) : context.cwd;
+    const targetPath = args.path ? isAbsolute5(args.path) ? resolve8(args.path) : resolve8(context.cwd, args.path) : context.cwd;
+    const normCwd = resolve8(context.cwd);
+    const normTarget = resolve8(targetPath);
+    const prefix = normCwd.endsWith("/") ? normCwd : `${normCwd}/`;
+    if (normTarget !== normCwd && !normTarget.startsWith(prefix)) {
+      throw new Error(`Access denied: path "${args.path}" resolves outside the trusted workspace root ("${context.cwd}").`);
+    }
     const rawEntries = readdirSync4(targetPath, { withFileTypes: true });
     const entries = [];
     let fileCount = 0;
@@ -71893,7 +71902,7 @@ var listDirTool = {
         type = "file";
         fileCount++;
         try {
-          sizeBytes = statSync5(join11(targetPath, entry.name)).size;
+          sizeBytes = statSync5(join10(targetPath, entry.name)).size;
         } catch {}
       } else {
         fileCount++;
@@ -71961,7 +71970,7 @@ import { rmSync as rmSync3 } from "node:fs";
 // src/services/tasks/process.ts
 import { spawn } from "node:child_process";
 import { createWriteStream, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 import { tmpdir, homedir as homedir4 } from "node:os";
 
 // src/services/tasks/shell.ts
@@ -72009,16 +72018,16 @@ class ShellExecution {
     this.command = options.command;
     this.cwd = options.cwd;
     this.startedAt = new Date().toISOString();
-    const taskDir = join12(homedir4(), ".steward", "tasks", options.sessionId || "default");
+    const taskDir = join11(homedir4(), ".steward", "tasks", options.sessionId || "default");
     try {
       mkdirSync8(taskDir, { recursive: true });
     } catch {
-      const fallbackDir = join12(tmpdir(), "steward-tasks");
+      const fallbackDir = join11(tmpdir(), "steward-tasks");
       mkdirSync8(fallbackDir, { recursive: true });
-      this.outputPath = join12(fallbackDir, `${this.taskId}.log`);
+      this.outputPath = join11(fallbackDir, `${this.taskId}.log`);
       return;
     }
-    this.outputPath = join12(taskDir, `${this.taskId}.log`);
+    this.outputPath = join11(taskDir, `${this.taskId}.log`);
   }
   get status() {
     switch (this.state) {
@@ -72556,7 +72565,7 @@ var bashTool = {
     if (result && "status" in result && result.status === "backgrounded") {
       return `Moved to background · task id: ${result.taskId}`;
     }
-    const code = result?.exitCode ?? 0;
+    const code = result && "exitCode" in result ? result.exitCode : 0;
     return `Ran successfully · exit code: ${code}`;
   },
   execute: async (args, context) => {
@@ -72688,10 +72697,34 @@ var taskKillTool = {
     return context.shellTasks.kill(args.task_id);
   }
 };
+
+// src/tools/task-list/index.ts
+var taskListInputSchema = object({});
+var taskListTool = {
+  name: "task_list",
+  displayName: "Task List",
+  description: "Lists all currently tracked background shell tasks along with their IDs, statuses, commands, and exit codes.",
+  parameters: taskListInputSchema,
+  confirmationPolicy: "never",
+  summarize: (_args, result) => {
+    const count = result?.total ?? 0;
+    return `Listed ${count} background task${count === 1 ? "" : "s"}`;
+  },
+  execute: async (_args, context) => {
+    if (!context.shellTasks) {
+      throw new Error("No shell tasks manager available in execution context.");
+    }
+    const tasks = context.shellTasks.list();
+    return {
+      tasks,
+      total: tasks.length
+    };
+  }
+};
 // package.json
 var package_default = {
   name: "steward-cli",
-  version: "0.13.0",
+  version: "0.15.0",
   description: "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
   author: "sapirrior",
   license: "MIT",
@@ -72910,18 +72943,18 @@ var webSearchTool = {
 };
 // src/services/todos/store.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync12,
-  renameSync as renameSync7,
-  unlinkSync as unlinkSync7,
+  renameSync as renameSync6,
+  unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync3,
-  openSync as openSync8,
-  fsyncSync as fsyncSync7,
-  closeSync as closeSync8
+  openSync as openSync7,
+  fsyncSync as fsyncSync6,
+  closeSync as closeSync7
 } from "node:fs";
-import { join as join13 } from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { join as join12 } from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
 
 // src/config/env.ts
 var ALL_PROVIDER_NAMES = [
@@ -73044,10 +73077,10 @@ function sanitizeSessionId(sessionId) {
 }
 function getSessionTodosDir(sessionId) {
   const safeId = sanitizeSessionId(sessionId);
-  return join13(getSettingsDir(), "todos", safeId);
+  return join12(getSettingsDir(), "todos", safeId);
 }
 function getSessionTodosFilePath(sessionId) {
-  return join13(getSessionTodosDir(sessionId), "todos.json");
+  return join12(getSessionTodosDir(sessionId), "todos.json");
 }
 function validateTodoList(todos) {
   if (!Array.isArray(todos)) {
@@ -73095,7 +73128,7 @@ function validateTodoList(todos) {
 }
 async function readTodoList(sessionId) {
   const filePath = getSessionTodosFilePath(sessionId);
-  if (!existsSync12(filePath)) {
+  if (!existsSync13(filePath)) {
     return null;
   }
   const raw = readFileSync12(filePath, "utf-8");
@@ -73128,7 +73161,7 @@ async function writeTodoList(sessionId, todos) {
     const validated = validateTodoList(todos);
     const safeSessionId = sanitizeSessionId(sessionId);
     const dir = getSessionTodosDir(safeSessionId);
-    if (!existsSync12(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync9(dir, { recursive: true, mode: 448 });
     }
     const payload = {
@@ -73138,22 +73171,22 @@ async function writeTodoList(sessionId, todos) {
       todos: validated
     };
     const targetPath = getSessionTodosFilePath(safeSessionId);
-    const tempPath = join13(dir, `.todos.${randomUUID7()}.tmp`);
+    const tempPath = join12(dir, `.todos.${randomUUID6()}.tmp`);
     const jsonStr = JSON.stringify(payload, null, 2) + `
 `;
     try {
       writeFileSync3(tempPath, jsonStr, { encoding: "utf-8", mode: 384 });
-      const fd = openSync8(tempPath, "r");
+      const fd = openSync7(tempPath, "r");
       try {
-        fsyncSync7(fd);
+        fsyncSync6(fd);
       } finally {
-        closeSync8(fd);
+        closeSync7(fd);
       }
-      renameSync7(tempPath, targetPath);
+      renameSync6(tempPath, targetPath);
     } catch (err) {
       try {
-        if (existsSync12(tempPath)) {
-          unlinkSync7(tempPath);
+        if (existsSync13(tempPath)) {
+          unlinkSync6(tempPath);
         }
       } catch {}
       throw err;
@@ -73197,7 +73230,7 @@ async function updateTodoItem(sessionId, todoId, updates) {
     const validated = validateTodoList(updatedTodos);
     const safeSessionId = sanitizeSessionId(sessionId);
     const dir = getSessionTodosDir(safeSessionId);
-    if (!existsSync12(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync9(dir, { recursive: true, mode: 448 });
     }
     const payload = {
@@ -73207,22 +73240,22 @@ async function updateTodoItem(sessionId, todoId, updates) {
       todos: validated
     };
     const targetPath = getSessionTodosFilePath(safeSessionId);
-    const tempPath = join13(dir, `.todos.${randomUUID7()}.tmp`);
+    const tempPath = join12(dir, `.todos.${randomUUID6()}.tmp`);
     const jsonStr = JSON.stringify(payload, null, 2) + `
 `;
     try {
       writeFileSync3(tempPath, jsonStr, { encoding: "utf-8", mode: 384 });
-      const fd = openSync8(tempPath, "r");
+      const fd = openSync7(tempPath, "r");
       try {
-        fsyncSync7(fd);
+        fsyncSync6(fd);
       } finally {
-        closeSync8(fd);
+        closeSync7(fd);
       }
-      renameSync7(tempPath, targetPath);
+      renameSync6(tempPath, targetPath);
     } catch (err) {
       try {
-        if (existsSync12(tempPath)) {
-          unlinkSync7(tempPath);
+        if (existsSync13(tempPath)) {
+          unlinkSync6(tempPath);
         }
       } catch {}
       throw err;
@@ -73265,7 +73298,7 @@ function formatTodoListSummary(todos, maxItems = 10) {
 `);
 }
 var todoWriteTool = {
-  name: "TodoWrite",
+  name: "todo_write",
   displayName: "TodoWrite",
   icon: "\uD83D\uDCDD",
   description: "Initializes or replaces the current session todo list with 2 to 10 items. Use this to establish or replace the multi-step execution plan for the session.",
@@ -73326,7 +73359,7 @@ function formatTodoListSummary2(todos, maxItems = 10) {
 `);
 }
 var todoUpdateTool = {
-  name: "TodoUpdate",
+  name: "todo_update",
   displayName: "TodoUpdate",
   icon: "✓",
   description: "Updates a single todo item status or description in the current session. Cannot create new items or update multiple items at once.",
@@ -73391,7 +73424,7 @@ function formatTodoListSummary3(todos, maxItems = 10) {
 `);
 }
 var todoReadTool = {
-  name: "TodoRead",
+  name: "todo_read",
   displayName: "TodoRead",
   icon: "\uD83D\uDCCB",
   description: "Reads the current session todo list without modifying it. Returns an empty result if no todos have been established yet.",
@@ -73431,9 +73464,9 @@ ${details}`;
   }
 };
 // src/skills/discovery.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync6 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { isAbsolute as isAbsolute6, join as join14, normalize, resolve as resolve9, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join13, normalize, resolve as resolve9, sep as sep4 } from "node:path";
 var MAX_SKILL_FILE_SIZE = 64 * 1024;
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -73486,13 +73519,13 @@ function unquote(str) {
 }
 function discoverSkills(cwd = process.cwd()) {
   const targets = [
-    { dir: join14(cwd, ".agents", "skills"), source: "workspace" },
-    { dir: join14(homedir5(), ".agents", "skills"), source: "user-agents" },
-    { dir: join14(homedir5(), ".steward", "skills"), source: "user-steward" }
+    { dir: join13(cwd, ".agents", "skills"), source: "workspace" },
+    { dir: join13(homedir5(), ".agents", "skills"), source: "user-agents" },
+    { dir: join13(homedir5(), ".steward", "skills"), source: "user-steward" }
   ];
   const skillMap = new Map;
   for (const target of targets) {
-    if (!existsSync13(target.dir)) {
+    if (!existsSync14(target.dir)) {
       continue;
     }
     try {
@@ -73500,10 +73533,10 @@ function discoverSkills(cwd = process.cwd()) {
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const skillDir = join14(target.dir, entry.name);
-        const skillMdPath = join14(skillDir, "SKILL.md");
-        const fallbackMdPath = join14(skillDir, "skill.md");
-        const resolvedFile = existsSync13(skillMdPath) ? skillMdPath : existsSync13(fallbackMdPath) ? fallbackMdPath : null;
+        const skillDir = join13(target.dir, entry.name);
+        const skillMdPath = join13(skillDir, "SKILL.md");
+        const fallbackMdPath = join13(skillDir, "skill.md");
+        const resolvedFile = existsSync14(skillMdPath) ? skillMdPath : existsSync14(fallbackMdPath) ? fallbackMdPath : null;
         if (!resolvedFile)
           continue;
         try {
@@ -73545,16 +73578,16 @@ function readSkillResource(name, relativePath, cwd = process.cwd(), maxBytes = M
       throw new Error(`Invalid skill resource path: absolute paths are not permitted (${trimmedPath})`);
     }
     const normalizedRelative = normalize(trimmedPath);
-    if (normalizedRelative.startsWith("..") || normalizedRelative.includes(`${sep3}..`)) {
+    if (normalizedRelative.startsWith("..") || normalizedRelative.includes(`${sep4}..`)) {
       throw new Error(`Invalid skill resource path: directory traversal ("..") is forbidden (${trimmedPath})`);
     }
     targetFilePath = resolve9(skill.dirPath, normalizedRelative);
     const resolvedDir = resolve9(skill.dirPath);
-    if (!targetFilePath.startsWith(resolvedDir + sep3) && targetFilePath !== resolvedDir) {
+    if (!targetFilePath.startsWith(resolvedDir + sep4) && targetFilePath !== resolvedDir) {
       throw new Error(`Resource "${trimmedPath}" resolves outside skill directory`);
     }
   }
-  if (!existsSync13(targetFilePath)) {
+  if (!existsSync14(targetFilePath)) {
     throw new Error(`Skill resource file "${targetFilePath}" does not exist`);
   }
   const stat = statSync6(targetFilePath);
@@ -73576,7 +73609,7 @@ function readSkillResource(name, relativePath, cwd = process.cwd(), maxBytes = M
 // src/tools/skill-list/index.ts
 var skillListParamsSchema = object({});
 var skillListTool = {
-  name: "SkillList",
+  name: "skill_list",
   displayName: "SkillList",
   icon: "\uD83D\uDCA1",
   description: "Discovers and lists all available specialized skills and their descriptions. Use this when you need specialized domain knowledge or workflows.",
@@ -73608,7 +73641,7 @@ var skillReadParamsSchema = object({
   path: string2().optional()
 });
 var skillReadTool = {
-  name: "SkillRead",
+  name: "skill_read",
   displayName: "SkillRead",
   icon: "\uD83D\uDCD6",
   description: "Loads and reads the instructions (SKILL.md) or a relative resource file of a specialized skill by name. Use this when a task requires specialized guidelines.",
@@ -73640,6 +73673,7 @@ var builtInTools = [
   listDirTool,
   sleepTool,
   bashTool,
+  taskListTool,
   taskReadTool,
   taskSendInputTool,
   taskKillTool,
@@ -73691,6 +73725,7 @@ var MAX_RETAINED_TERMINAL_TASKS = 50;
 class ShellTaskManager {
   tasks = new Map;
   terminalTimestamps = new Map;
+  evictedTaskReasons = new Map;
   isShuttingDown = false;
   generateTaskId() {
     return `task-${randomBytes(4).toString("hex")}`;
@@ -73724,7 +73759,7 @@ class ShellTaskManager {
     this.evictExpiredTasks();
     const exec = this.tasks.get(taskId);
     if (!exec) {
-      throw new Error(`Task "${taskId}" not found or expired.`);
+      throw this.getTaskNotFoundError(taskId);
     }
     const rawOutput = exec.getRecentOutput();
     const { preview, truncated } = boundResultText(rawOutput);
@@ -73745,7 +73780,7 @@ class ShellTaskManager {
     this.evictExpiredTasks();
     const exec = this.tasks.get(taskId);
     if (!exec) {
-      throw new Error(`Task "${taskId}" not found or expired.`);
+      throw this.getTaskNotFoundError(taskId);
     }
     if (!exec.isRunning) {
       throw new Error(`Task "${taskId}" is not running (status: ${exec.status}).`);
@@ -73766,7 +73801,7 @@ class ShellTaskManager {
     this.evictExpiredTasks();
     const exec = this.tasks.get(taskId);
     if (!exec) {
-      throw new Error(`Task "${taskId}" not found or expired.`);
+      throw this.getTaskNotFoundError(taskId);
     }
     if (exec.isRunning) {
       await exec.kill();
@@ -73840,6 +73875,7 @@ class ShellTaskManager {
         }
         this.tasks.delete(id);
         this.terminalTimestamps.delete(id);
+        this.recordEviction(id, "expired due to 10-minute retention TTL");
       }
     }
     const remainingTerminal = Array.from(this.terminalTimestamps.entries()).sort((a, b) => a[1] - b[1]);
@@ -73853,8 +73889,25 @@ class ShellTaskManager {
       }
       this.tasks.delete(oldestId);
       this.terminalTimestamps.delete(oldestId);
+      this.recordEviction(oldestId, "evicted due to task capacity limit (50 tasks max)");
     }
   }
+  recordEviction(taskId, reason) {
+    if (this.evictedTaskReasons.size >= 100) {
+      const oldest = this.evictedTaskReasons.keys().next().value;
+      if (oldest) {
+        this.evictedTaskReasons.delete(oldest);
+      }
+    }
+    this.evictedTaskReasons.set(taskId, reason);
+  }
+  getTaskNotFoundError(taskId) {
+    const reason = this.evictedTaskReasons.get(taskId);
+    if (reason) {
+      return new Error(`Task "${taskId}" was ${reason}.`);
+    }
+    return new Error(`Task "${taskId}" not found (task ID does not exist).`);
+  }
 }
 // src/errors/classifier.ts
 function classifyError(error) {
@@ -74000,15 +74053,15 @@ function classifyError(error) {
   };
 }
 // src/errors/logger.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 var SENSITIVE_KEY_REGEX = /api[_-]?key|token|secret|password|auth|credential|bearer/i;
 function getLogsRootDir() {
   if (process.env.STEWARD_LOGS_DIR) {
     return process.env.STEWARD_LOGS_DIR;
   }
-  return join15(homedir6(), ".steward", "logs");
+  return join14(homedir6(), ".steward", "logs");
 }
 function getLogDateTime(d = new Date) {
   const year = d.getFullYear();
@@ -74092,11 +74145,11 @@ function logError(error, contextInfo) {
   try {
     const rootDir = getLogsRootDir();
     const { date, time } = getLogDateTime();
-    const dateDir = join15(rootDir, date);
-    if (!existsSync14(dateDir)) {
+    const dateDir = join14(rootDir, date);
+    if (!existsSync15(dateDir)) {
       mkdirSync10(dateDir, { recursive: true });
     }
-    const logPath = join15(dateDir, `${time}.log`);
+    const logPath = join14(dateDir, `${time}.log`);
     const structured = classifyError(error);
     const mem = process.memoryUsage ? process.memoryUsage() : undefined;
     const logEntry = {
@@ -74122,7 +74175,7 @@ function logError(error, contextInfo) {
 ` + JSON.stringify(logEntry, null, 2) + `
 
 `;
-    if (existsSync14(logPath)) {
+    if (existsSync15(logPath)) {
       appendFileSync3(logPath, formatted, "utf-8");
     } else {
       writeFileSync4(logPath, formatted, "utf-8");
@@ -117839,24 +117892,24 @@ IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify,
 
 # Tool Usage Policy
 - Investigation: use read_file, grep, list_dir, and glob to explore code before modifying it.
-- Mutations: use write_file and edit_file to apply changes. Respect user permission prompts.
+- Mutations: ALWAYS use write_file and edit_file to create or modify files rather than bash redirection (e.g. cat > file). write_file and edit_file participate in the file checkpoint and rewind system (/rewind), whereas bash commands are not tracked by checkpoints.
 - Commands: when using bash, you MUST always provide a concise, non-empty 'explanation' parameter describing what the command does and why it is needed.
-- Background tasks: use task_read to check status/output, task_send_input to send standard input (with a trailing newline), and task_kill to terminate.
+- Background tasks: use task_list to inspect active and recent tasks, task_read to check status/output, task_send_input to send standard input (with a trailing newline), and task_kill to terminate.
 - Web: use web_fetch and web_search when external documentation or live data is needed. If web_fetch indicates a redirect, follow up with the target URL.
 
 # Task and Plan Management (Todos)
 - For multi-step, complex, or verification-heavy tasks, maintain operational state using session todos:
-  - TodoWrite: initialize or replace the session todo list (must contain 2 to 10 items).
-  - TodoUpdate: update exactly one todo item status or description as progress occurs.
-  - TodoRead: inspect current session todos when recovering or verifying progress.
+  - todo_write (TodoWrite): initialize or replace the session todo list (must contain 2 to 10 items).
+  - todo_update (TodoUpdate): update exactly one todo item status or description as progress occurs.
+  - todo_read (TodoRead): inspect current session todos when recovering or verifying progress.
 - Keep at most one item in 'in_progress' status at any time.
 - Mark todos completed immediately after completing each step; do not batch progress updates.
 - For simple, one-step queries or edits, do not create a todo list.
 
 # Specialized Skills Policy
 - Skills are discoverable on-demand packages of specialized instructions located in workspace or user configuration.
-- Use SkillList to discover available skills and their descriptions.
-- Use SkillRead to load a skill's instructions (SKILL.md) or relative resources only when a task requires specialized domain guidance.
+- Use skill_list (SkillList) to discover available skills and their descriptions.
+- Use skill_read (SkillRead) to load a skill's instructions (SKILL.md) or relative resources only when a task requires specialized domain guidance.
 - Skill instructions are supplemental and must not override core safety rules, tool boundaries, or user permission constraints.
 
 <env>
@@ -118006,7 +118059,7 @@ class AgentSession {
     this.messages.push(userMessage);
     this.isGenerating = true;
     this.activeAbortController = new AbortController;
-    const turnId = randomUUID8();
+    const turnId = randomUUID7();
     const turnStartedAt = new Date().toISOString();
     const turnStartMonotonic = performance.now();
     const turnModel = this.getModel();
@@ -120537,6 +120590,9 @@ class TrustGate extends Component {
 
 // src/tui/components/docks/ModelPicker.tsx
 class ModelPicker extends SelectList {
+  wrap = false;
+  clip = true;
+  ellipsis = false;
   constructor(props) {
     super({
       items: props.models,
@@ -120585,6 +120641,9 @@ class ModelPicker extends SelectList {
 
 // src/tui/components/docks/SessionMenu.tsx
 class SessionMenu extends SelectList {
+  wrap = false;
+  clip = true;
+  ellipsis = false;
   constructor(props) {
     super({
       items: props.sessions,
@@ -120967,6 +121026,9 @@ function buildRewindItems(session, cwd) {
 }
 
 class RewindMenu extends SelectList {
+  wrap = false;
+  clip = true;
+  ellipsis = false;
   constructor(props) {
     const items = buildRewindItems(props.session, props.cwd);
     super({
@@ -121588,6 +121650,15 @@ class FilePermissionDock extends Component {
 }
 
 // src/tui/utils/permission-queue.ts
+function settleItem(item, allowed) {
+  item.settled = true;
+  if (item.kind === "bash") {
+    item.resolve({ allowed });
+  } else {
+    item.resolve({ allowed });
+  }
+}
+
 class PermissionQueue {
   queue = [];
   activeItem = null;
@@ -121658,28 +121729,25 @@ class PermissionQueue {
     if (!current || current.settled) {
       return;
     }
-    current.settled = true;
     this.activeItem = null;
     this.onHide();
-    current.resolve({ allowed });
+    settleItem(current, allowed);
     this.processNext();
   }
   cancelItem(item) {
     if (item.settled)
       return;
     if (this.activeItem === item) {
-      item.settled = true;
       this.activeItem = null;
       this.onHide();
-      item.resolve({ allowed: false });
+      settleItem(item, false);
       this.processNext();
     } else {
       const idx = this.queue.indexOf(item);
       if (idx !== -1) {
         this.queue.splice(idx, 1);
       }
-      item.settled = true;
-      item.resolve({ allowed: false });
+      settleItem(item, false);
     }
   }
   processNext() {
@@ -121687,8 +121755,7 @@ class PermissionQueue {
       const next = this.queue.shift();
       if (next.settled || next.abortSignal?.aborted) {
         if (!next.settled) {
-          next.settled = true;
-          next.resolve({ allowed: false });
+          settleItem(next, false);
         }
         continue;
       }
@@ -121700,16 +121767,15 @@ class PermissionQueue {
   }
   clear() {
     if (this.activeItem && !this.activeItem.settled) {
-      this.activeItem.settled = true;
-      this.activeItem.resolve({ allowed: false });
+      const active = this.activeItem;
       this.activeItem = null;
       this.onHide();
+      settleItem(active, false);
     }
     while (this.queue.length > 0) {
       const item = this.queue.shift();
       if (!item.settled) {
-        item.settled = true;
-        item.resolve({ allowed: false });
+        settleItem(item, false);
       }
     }
   }
@@ -121796,17 +121862,19 @@ function classifyVoiceError(err) {
   };
 }
 // src/voice/prerequisites.ts
+import { spawn as spawn2 } from "node:child_process";
 async function defaultCheckParec() {
-  try {
-    const proc = Bun.spawn(["which", "parec"], {
-      stdout: "ignore",
-      stderr: "ignore"
-    });
-    const exitCode = await proc.exited;
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn2("which", ["parec"], {
+        stdio: "ignore"
+      });
+      proc.on("error", () => resolve(false));
+      proc.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
 }
 async function checkVoicePrerequisites(options = {}) {
   const config = options.config ?? getEnvConfig();
@@ -121874,6 +121942,8 @@ class TranscriptAccumulator {
   }
 }
 // src/voice/recorder.ts
+import { spawn as spawn3 } from "node:child_process";
+import { Readable } from "node:stream";
 var DEFAULT_PAREC_ARGS = ["--raw", "--rate=16000", "--channels=1", "--format=s16le"];
 
 class ParecAudioRecorder {
@@ -121885,12 +121955,40 @@ class ParecAudioRecorder {
   checkAvailableFn;
   constructor(options) {
     this.spawnFn = options?.spawnFn ?? ((cmd, opts) => {
-      const p = Bun.spawn(cmd, opts);
+      const [executable, ...args] = cmd;
+      const child = spawn3(executable, args, {
+        stdio: [
+          "ignore",
+          opts.stdout === "pipe" ? "pipe" : "ignore",
+          opts.stderr === "pipe" ? "pipe" : "ignore"
+        ]
+      });
+      const exited = new Promise((resolve) => {
+        child.on("close", (code) => resolve(code ?? 0));
+        child.on("error", () => resolve(1));
+      });
+      const stdout = child.stdout ? Readable.toWeb(child.stdout) : null;
+      const stderr = child.stderr ? Readable.toWeb(child.stderr) : null;
       return {
-        stdout: p.stdout,
-        stderr: p.stderr,
-        exited: p.exited,
-        kill: (sig) => p.kill(sig)
+        stdout,
+        stderr,
+        exited,
+        kill: (sig) => {
+          try {
+            if (typeof sig === "number") {
+              const signalMap = {
+                2: "SIGINT",
+                9: "SIGKILL",
+                15: "SIGTERM"
+              };
+              child.kill(signalMap[sig] || sig);
+            } else if (sig) {
+              child.kill(sig);
+            } else {
+              child.kill();
+            }
+          } catch {}
+        }
       };
     });
     this.checkAvailableFn = options?.checkAvailableFn ?? defaultCheckParec;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "steward-cli",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
   "author": "sapirrior",
   "license": "MIT",