llmist 1.3.0 → 1.4.0

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-UEEESLOA.js";
 import {
   AgentBuilder,
   BaseGadget,
@@ -13,7 +14,7 @@ import {
   createLogger,
   init_builder,
   init_client,
-  init_constants2 as init_constants,
+  init_constants,
   init_create_gadget,
   init_exceptions,
   init_gadget,
@@ -26,7 +27,7 @@ import {
   resolveModel,
   schemaToJSONSchema,
   validateGadgetSchema
-} from "./chunk-RZTAKIDE.js";
+} from "./chunk-VGZCFUPX.js";
 
 // src/cli/constants.ts
 var CLI_NAME = "llmist";
@@ -79,7 +80,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commande
 // package.json
 var package_default = {
   name: "llmist",
-  version: "1.2.0",
+  version: "1.3.1",
   description: "Universal TypeScript LLM client with streaming-first agent framework. Works with any model - no structured outputs or native tool calling required. Implements its own flexible grammar for function calling.",
   type: "module",
   main: "dist/index.cjs",
@@ -163,6 +164,7 @@ var package_default = {
     "@google/genai": "^1.27.0",
     chalk: "^5.6.2",
     commander: "^12.1.0",
+    diff: "^8.0.2",
     eta: "^4.4.1",
     "js-toml": "^1.0.2",
     "js-yaml": "^4.1.0",
@@ -179,6 +181,7 @@ var package_default = {
     "@commitlint/config-conventional": "^20.0.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
+    "@types/diff": "^8.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.12.7",
@@ -193,10 +196,272 @@ var package_default = {
 
 // src/cli/agent-command.ts
 init_builder();
+import { createInterface as createInterface2 } from "node:readline/promises";
+import chalk5 from "chalk";
+
+// src/core/errors.ts
+function isAbortError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.name === "AbortError") return true;
+  if (error.name === "APIConnectionAbortedError") return true;
+  if (error.name === "APIUserAbortError") return true;
+  const message = error.message.toLowerCase();
+  if (message.includes("abort")) return true;
+  if (message.includes("cancelled")) return true;
+  if (message.includes("canceled")) return true;
+  return false;
+}
+
+// src/cli/agent-command.ts
 init_registry();
 init_constants();
+
+// src/cli/approval/manager.ts
 import { createInterface } from "node:readline/promises";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
+
+// src/cli/approval/context-providers.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createPatch } from "diff";
+
+// src/cli/approval/diff-renderer.ts
+import chalk from "chalk";
+function renderColoredDiff(diff) {
+  return diff.split("\n").map((line) => {
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      return chalk.bold(line);
+    }
+    if (line.startsWith("+")) {
+      return chalk.green(line);
+    }
+    if (line.startsWith("-")) {
+      return chalk.red(line);
+    }
+    if (line.startsWith("@@")) {
+      return chalk.cyan(line);
+    }
+    return chalk.dim(line);
+  }).join("\n");
+}
+function formatNewFileDiff(filePath, content) {
+  const lines = content.split("\n");
+  const header = `+++ ${filePath} (new file)`;
+  const addedLines = lines.map((line) => `+ ${line}`).join("\n");
+  return `${header}
+${addedLines}`;
+}
+
+// src/cli/approval/context-providers.ts
+var WriteFileContextProvider = class {
+  gadgetName = "WriteFile";
+  async getContext(params) {
+    const filePath = String(params.filePath ?? params.path ?? "");
+    const newContent = String(params.content ?? "");
+    const resolvedPath = resolve(process.cwd(), filePath);
+    if (!existsSync(resolvedPath)) {
+      return {
+        summary: `Create new file: ${filePath}`,
+        details: formatNewFileDiff(filePath, newContent)
+      };
+    }
+    const oldContent = readFileSync(resolvedPath, "utf-8");
+    const diff = createPatch(filePath, oldContent, newContent, "original", "modified");
+    return {
+      summary: `Modify: ${filePath}`,
+      details: diff
+    };
+  }
+};
+var EditFileContextProvider = class {
+  gadgetName = "EditFile";
+  async getContext(params) {
+    const filePath = String(params.filePath ?? params.path ?? "");
+    const resolvedPath = resolve(process.cwd(), filePath);
+    if ("content" in params) {
+      const newContent = String(params.content);
+      if (!existsSync(resolvedPath)) {
+        return {
+          summary: `Create new file: ${filePath}`,
+          details: formatNewFileDiff(filePath, newContent)
+        };
+      }
+      const oldContent = readFileSync(resolvedPath, "utf-8");
+      const diff = createPatch(filePath, oldContent, newContent, "original", "modified");
+      return {
+        summary: `Modify: ${filePath}`,
+        details: diff
+      };
+    }
+    if ("commands" in params) {
+      const commands = String(params.commands);
+      return {
+        summary: `Edit: ${filePath}`,
+        details: `Commands:
+${commands}`
+      };
+    }
+    return {
+      summary: `Edit: ${filePath}`
+    };
+  }
+};
+var RunCommandContextProvider = class {
+  gadgetName = "RunCommand";
+  async getContext(params) {
+    const command = String(params.command ?? "");
+    const cwd = params.cwd ? ` (in ${params.cwd})` : "";
+    return {
+      summary: `Execute: ${command}${cwd}`
+    };
+  }
+};
+var DefaultContextProvider = class {
+  constructor(gadgetName) {
+    this.gadgetName = gadgetName;
+  }
+  async getContext(params) {
+    const paramEntries = Object.entries(params);
+    if (paramEntries.length === 0) {
+      return {
+        summary: `${this.gadgetName}()`
+      };
+    }
+    const formatValue = (value) => {
+      const MAX_LEN = 50;
+      const str = JSON.stringify(value);
+      return str.length > MAX_LEN ? `${str.slice(0, MAX_LEN - 3)}...` : str;
+    };
+    const paramStr = paramEntries.map(([k, v]) => `${k}=${formatValue(v)}`).join(", ");
+    return {
+      summary: `${this.gadgetName}(${paramStr})`
+    };
+  }
+};
+var builtinContextProviders = [
+  new WriteFileContextProvider(),
+  new EditFileContextProvider(),
+  new RunCommandContextProvider()
+];
+
+// src/cli/approval/manager.ts
+var ApprovalManager = class {
+  /**
+   * Creates a new ApprovalManager.
+   *
+   * @param config - Approval configuration with per-gadget modes
+   * @param env - CLI environment for I/O operations
+   * @param progress - Optional progress indicator to pause during prompts
+   */
+  constructor(config, env, progress) {
+    this.config = config;
+    this.env = env;
+    this.progress = progress;
+    for (const provider of builtinContextProviders) {
+      this.registerProvider(provider);
+    }
+  }
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Registers a custom context provider for a gadget.
+   *
+   * @param provider - The context provider to register
+   */
+  registerProvider(provider) {
+    this.providers.set(provider.gadgetName.toLowerCase(), provider);
+  }
+  /**
+   * Gets the approval mode for a gadget.
+   *
+   * Resolution order:
+   * 1. Explicit configuration for the gadget name
+   * 2. Wildcard "*" configuration
+   * 3. Default mode from config
+   *
+   * @param gadgetName - Name of the gadget
+   * @returns The approval mode to use
+   */
+  getApprovalMode(gadgetName) {
+    const normalizedName = gadgetName.toLowerCase();
+    for (const [configName, mode] of Object.entries(this.config.gadgetApprovals)) {
+      if (configName.toLowerCase() === normalizedName) {
+        return mode;
+      }
+    }
+    if ("*" in this.config.gadgetApprovals) {
+      return this.config.gadgetApprovals["*"];
+    }
+    return this.config.defaultMode;
+  }
+  /**
+   * Requests approval for a gadget execution.
+   *
+   * Behavior depends on the gadget's approval mode:
+   * - "allowed": Returns approved immediately
+   * - "denied": Returns denied with configuration message
+   * - "approval-required": Prompts user interactively
+   *
+   * @param gadgetName - Name of the gadget
+   * @param params - The gadget's execution parameters
+   * @returns Approval result indicating whether to proceed
+   */
+  async requestApproval(gadgetName, params) {
+    const mode = this.getApprovalMode(gadgetName);
+    if (mode === "allowed") {
+      return { approved: true };
+    }
+    if (mode === "denied") {
+      return {
+        approved: false,
+        reason: `${gadgetName} is denied by configuration`
+      };
+    }
+    return this.promptForApproval(gadgetName, params);
+  }
+  /**
+   * Prompts the user for approval interactively.
+   */
+  async promptForApproval(gadgetName, params) {
+    const provider = this.providers.get(gadgetName.toLowerCase()) ?? new DefaultContextProvider(gadgetName);
+    const context = await provider.getContext(params);
+    this.progress?.pause();
+    this.env.stderr.write(`
+${chalk2.yellow("\u{1F512} Approval required:")} ${context.summary}
+`);
+    if (context.details) {
+      this.env.stderr.write(`
+${renderColoredDiff(context.details)}
+`);
+    }
+    const response = await this.prompt("   \u23CE approve, or type to reject: ");
+    const isApproved = response === "" || response.toLowerCase() === "y";
+    if (isApproved) {
+      this.env.stderr.write(`   ${chalk2.green("\u2713 Approved")}
+
+`);
+      return { approved: true };
+    }
+    this.env.stderr.write(`   ${chalk2.red("\u2717 Denied")}
+
+`);
+    return { approved: false, reason: response || "Rejected by user" };
+  }
+  /**
+   * Prompts for user input.
+   */
+  async prompt(message) {
+    const rl = createInterface({
+      input: this.env.stdin,
+      output: this.env.stderr
+    });
+    try {
+      const answer = await rl.question(message);
+      return answer.trim();
+    } finally {
+      rl.close();
+    }
+  }
+};
 
 // src/cli/builtin-gadgets.ts
 init_create_gadget();
@@ -278,10 +543,422 @@ var builtinGadgets = [askUser, tellUser, finish];
 
 // src/cli/gadgets.ts
 init_gadget();
+import fs5 from "node:fs";
+import path4 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/cli/builtins/filesystem/list-directory.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { z as z2 } from "zod";
+
+// src/cli/builtins/filesystem/utils.ts
 import fs from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
+var PathSandboxException = class extends Error {
+  constructor(inputPath, reason) {
+    super(`Path access denied: ${inputPath}. ${reason}`);
+    this.name = "PathSandboxException";
+  }
+};
+function validatePathIsWithinCwd(inputPath) {
+  const cwd = process.cwd();
+  const resolvedPath = path.resolve(cwd, inputPath);
+  let finalPath;
+  try {
+    finalPath = fs.realpathSync(resolvedPath);
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
+      finalPath = resolvedPath;
+    } else {
+      throw error;
+    }
+  }
+  const cwdWithSep = cwd + path.sep;
+  if (!finalPath.startsWith(cwdWithSep) && finalPath !== cwd) {
+    throw new PathSandboxException(inputPath, "Path is outside the current working directory");
+  }
+  return finalPath;
+}
+
+// src/cli/builtins/filesystem/list-directory.ts
+function listFiles(dirPath, basePath = dirPath, maxDepth = 1, currentDepth = 1) {
+  const entries = [];
+  try {
+    const items = fs2.readdirSync(dirPath);
+    for (const item of items) {
+      const fullPath = path2.join(dirPath, item);
+      const relativePath = path2.relative(basePath, fullPath);
+      try {
+        const stats = fs2.lstatSync(fullPath);
+        let type;
+        let size;
+        if (stats.isSymbolicLink()) {
+          type = "symlink";
+          size = 0;
+        } else if (stats.isDirectory()) {
+          type = "directory";
+          size = 0;
+        } else {
+          type = "file";
+          size = stats.size;
+        }
+        entries.push({
+          name: item,
+          relativePath,
+          type,
+          size,
+          modified: Math.floor(stats.mtime.getTime() / 1e3)
+        });
+        if (type === "directory" && currentDepth < maxDepth) {
+          try {
+            validatePathIsWithinCwd(fullPath);
+            const subEntries = listFiles(fullPath, basePath, maxDepth, currentDepth + 1);
+            entries.push(...subEntries);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return entries;
+}
+function formatAge(epochSeconds) {
+  const now = Math.floor(Date.now() / 1e3);
+  const seconds = now - epochSeconds;
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d`;
+  const weeks = Math.floor(days / 7);
+  if (weeks < 4) return `${weeks}w`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months}mo`;
+  const years = Math.floor(days / 365);
+  return `${years}y`;
+}
+function formatEntriesAsString(entries) {
+  if (entries.length === 0) {
+    return "#empty";
+  }
+  const sortedEntries = [...entries].sort((a, b) => {
+    const typeOrder = { directory: 0, file: 1, symlink: 2 };
+    const typeCompare = typeOrder[a.type] - typeOrder[b.type];
+    if (typeCompare !== 0) return typeCompare;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  const typeCode = {
+    directory: "D",
+    file: "F",
+    symlink: "L"
+  };
+  const encodeName = (name) => name.replace(/\|/g, "%7C").replace(/\n/g, "%0A");
+  const header = "#T|N|S|A";
+  const rows = sortedEntries.map(
+    (e) => `${typeCode[e.type]}|${encodeName(e.relativePath)}|${e.size}|${formatAge(e.modified)}`
+  );
+  return [header, ...rows].join("\n");
+}
+var listDirectory = createGadget({
+  name: "ListDirectory",
+  description: "List files and directories in a directory with full details (names, types, sizes, modification dates). Use maxDepth to explore subdirectories recursively. The directory path must be within the current working directory or its subdirectories.",
+  schema: z2.object({
+    directoryPath: z2.string().default(".").describe("Path to the directory to list"),
+    maxDepth: z2.number().int().min(1).max(10).default(1).describe(
+      "Maximum depth to recurse (1 = immediate children only, 2 = include grandchildren, etc.)"
+    )
+  }),
+  examples: [
+    {
+      params: { directoryPath: ".", maxDepth: 1 },
+      output: "path=. maxDepth=1\n\n#T|N|S|A\nD|src|0|2h\nD|tests|0|1d\nF|package.json|2841|3h",
+      comment: "List current directory"
+    },
+    {
+      params: { directoryPath: "src", maxDepth: 2 },
+      output: "path=src maxDepth=2\n\n#T|N|S|A\nD|components|0|1d\nD|utils|0|2d\nF|index.ts|512|1h\nF|components/Button.tsx|1024|3h",
+      comment: "List src directory recursively"
+    }
+  ],
+  execute: ({ directoryPath, maxDepth }) => {
+    const validatedPath = validatePathIsWithinCwd(directoryPath);
+    const stats = fs2.statSync(validatedPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${directoryPath}`);
+    }
+    const entries = listFiles(validatedPath, validatedPath, maxDepth);
+    const formattedList = formatEntriesAsString(entries);
+    return `path=${directoryPath} maxDepth=${maxDepth}
+
+${formattedList}`;
+  }
+});
+
+// src/cli/builtins/filesystem/read-file.ts
+import fs3 from "node:fs";
+import { z as z3 } from "zod";
+var readFile = createGadget({
+  name: "ReadFile",
+  description: "Read the entire content of a file and return it as text. The file path must be within the current working directory or its subdirectories.",
+  schema: z3.object({
+    filePath: z3.string().describe("Path to the file to read (relative or absolute)")
+  }),
+  examples: [
+    {
+      params: { filePath: "package.json" },
+      output: 'path=package.json\n\n{\n  "name": "my-project",\n  "version": "1.0.0"\n  ...\n}',
+      comment: "Read a JSON config file"
+    },
+    {
+      params: { filePath: "src/index.ts" },
+      output: "path=src/index.ts\n\nexport function main() { ... }",
+      comment: "Read a source file"
+    }
+  ],
+  execute: ({ filePath }) => {
+    const validatedPath = validatePathIsWithinCwd(filePath);
+    const content = fs3.readFileSync(validatedPath, "utf-8");
+    return `path=${filePath}
+
+${content}`;
+  }
+});
+
+// src/cli/builtins/filesystem/write-file.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+import { z as z4 } from "zod";
+var writeFile = createGadget({
+  name: "WriteFile",
+  description: "Write content to a file. Creates parent directories if needed. Overwrites existing files. The file path must be within the current working directory or its subdirectories.",
+  schema: z4.object({
+    filePath: z4.string().describe("Path to the file to write (relative or absolute)"),
+    content: z4.string().describe("Content to write to the file")
+  }),
+  examples: [
+    {
+      params: { filePath: "output.txt", content: "Hello, World!" },
+      output: "path=output.txt\n\nWrote 13 bytes",
+      comment: "Write a simple text file"
+    },
+    {
+      params: {
+        filePath: "src/server.ts",
+        content: `import { serve } from "bun";
+
+const port = 3000;
+
+serve({
+  port,
+  fetch: (req) => new Response(\`Hello from \${req.url}\`),
+});
+
+console.log(\`Server running on http://localhost:\${port}\`);`
+      },
+      output: "path=src/server.ts\n\nWrote 198 bytes (created directory: src)",
+      comment: "Write code with template literals - NO escaping needed inside heredoc (use <<<EOF...EOF)"
+    }
+  ],
+  execute: ({ filePath, content }) => {
+    const validatedPath = validatePathIsWithinCwd(filePath);
+    const parentDir = path3.dirname(validatedPath);
+    let createdDir = false;
+    if (!fs4.existsSync(parentDir)) {
+      validatePathIsWithinCwd(parentDir);
+      fs4.mkdirSync(parentDir, { recursive: true });
+      createdDir = true;
+    }
+    fs4.writeFileSync(validatedPath, content, "utf-8");
+    const bytesWritten = Buffer.byteLength(content, "utf-8");
+    const dirNote = createdDir ? ` (created directory: ${path3.dirname(filePath)})` : "";
+    return `path=${filePath}
+
+Wrote ${bytesWritten} bytes${dirNote}`;
+  }
+});
+
+// src/cli/builtins/filesystem/edit-file.ts
+import { z as z5 } from "zod";
+function filterDangerousCommands(commands) {
+  return commands.split("\n").filter((line) => !line.trimStart().startsWith("!")).join("\n");
+}
+var editFile = createGadget({
+  name: "EditFile",
+  description: "Edit a file using ed commands. Ed is a line-oriented text editor - pipe commands to it for precise file modifications. Commands are executed in sequence. Remember to end with 'w' (write) and 'q' (quit). Shell escape commands (!) are filtered for security.",
+  schema: z5.object({
+    filePath: z5.string().describe("Path to the file to edit (relative or absolute)"),
+    commands: z5.string().describe("Ed commands to execute, one per line")
+  }),
+  examples: [
+    {
+      params: {
+        filePath: "config.txt",
+        commands: `1,$p
+q`
+      },
+      output: "path=config.txt\n\n32\nkey=value\noption=true",
+      comment: "Print entire file contents (ed shows byte count, then content)"
+    },
+    {
+      params: {
+        filePath: "data.txt",
+        commands: `1,$s/foo/bar/g
+w
+q`
+      },
+      output: "path=data.txt\n\n42\n42",
+      comment: "Replace all 'foo' with 'bar' (ed shows bytes read, then bytes written)"
+    },
+    {
+      params: {
+        filePath: "list.txt",
+        commands: `3d
+w
+q`
+      },
+      output: "path=list.txt\n\n45\n28",
+      comment: "Delete line 3, save and quit"
+    },
+    {
+      params: {
+        filePath: "readme.txt",
+        commands: `$a
+New last line
+.
+w
+q`
+      },
+      output: "path=readme.txt\n\n40\n56",
+      comment: "Append text after last line ($ = last line, . = end input mode)"
+    }
+  ],
+  timeoutMs: 3e4,
+  execute: async ({ filePath, commands }) => {
+    const validatedPath = validatePathIsWithinCwd(filePath);
+    const safeCommands = filterDangerousCommands(commands);
+    try {
+      const proc = Bun.spawn(["ed", validatedPath], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      proc.stdin.write(`${safeCommands}
+`);
+      proc.stdin.end();
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          proc.kill();
+          reject(new Error("ed command timed out after 30000ms"));
+        }, 3e4);
+      });
+      const exitCode = await Promise.race([proc.exited, timeoutPromise]);
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+      if (exitCode !== 0) {
+        return `path=${filePath}
+
+${output || "ed exited with non-zero status"}`;
+      }
+      return `path=${filePath}
+
+${output || "(no output)"}`;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `path=${filePath}
+
+error: ${message}`;
+    }
+  }
+});
+
+// src/cli/builtins/run-command.ts
+import { z as z6 } from "zod";
+var runCommand = createGadget({
+  name: "RunCommand",
+  description: "Execute a shell command and return its output. Returns both stdout and stderr combined with the exit status.",
+  schema: z6.object({
+    command: z6.string().describe("The shell command to execute"),
+    cwd: z6.string().optional().describe("Working directory for the command (default: current directory)"),
+    timeout: z6.number().default(3e4).describe("Timeout in milliseconds (default: 30000)")
+  }),
+  examples: [
+    {
+      params: { command: "ls -la", timeout: 3e4 },
+      output: "status=0\n\ntotal 24\ndrwxr-xr-x  5 user  staff   160 Nov 27 10:00 .\ndrwxr-xr-x  3 user  staff    96 Nov 27 09:00 ..\n-rw-r--r--  1 user  staff  1024 Nov 27 10:00 package.json",
+      comment: "List directory contents with details"
+    },
+    {
+      params: { command: "echo 'Hello World'", timeout: 3e4 },
+      output: "status=0\n\nHello World",
+      comment: "Simple echo command"
+    },
+    {
+      params: { command: "cat nonexistent.txt", timeout: 3e4 },
+      output: "status=1\n\ncat: nonexistent.txt: No such file or directory",
+      comment: "Command that fails returns non-zero status"
+    },
+    {
+      params: { command: "pwd", cwd: "/tmp", timeout: 3e4 },
+      output: "status=0\n\n/tmp",
+      comment: "Execute command in a specific directory"
+    }
+  ],
+  execute: async ({ command, cwd, timeout }) => {
+    const workingDir = cwd ?? process.cwd();
+    try {
+      const proc = Bun.spawn(["sh", "-c", command], {
+        cwd: workingDir,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          proc.kill();
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      });
+      const exitCode = await Promise.race([proc.exited, timeoutPromise]);
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+      return `status=${exitCode}
+
+${output || "(no output)"}`;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `status=1
+
+error: ${message}`;
+    }
+  }
+});
+
+// src/cli/builtins/index.ts
+var builtinGadgetRegistry = {
+  ListDirectory: listDirectory,
+  ReadFile: readFile,
+  WriteFile: writeFile,
+  EditFile: editFile,
+  RunCommand: runCommand
+};
+function getBuiltinGadget(name) {
+  return builtinGadgetRegistry[name];
+}
+function isBuiltinGadgetName(name) {
+  return name in builtinGadgetRegistry;
+}
+
+// src/cli/gadgets.ts
 var PATH_PREFIXES = [".", "/", "~"];
+var BUILTIN_PREFIX = "builtin:";
 function isGadgetLike(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -304,18 +981,34 @@ function expandHomePath(input) {
   if (!home) {
     return input;
   }
-  return path.join(home, input.slice(1));
+  return path4.join(home, input.slice(1));
 }
 function isFileLikeSpecifier(specifier) {
-  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(path.sep);
+  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(path4.sep);
+}
+function tryResolveBuiltin(specifier) {
+  if (specifier.startsWith(BUILTIN_PREFIX)) {
+    const name = specifier.slice(BUILTIN_PREFIX.length);
+    const gadget = getBuiltinGadget(name);
+    if (!gadget) {
+      throw new Error(
+        `Unknown builtin gadget: ${name}. Available builtins: ListDirectory, ReadFile, WriteFile, EditFile, RunCommand`
+      );
+    }
+    return gadget;
+  }
+  if (!isFileLikeSpecifier(specifier) && isBuiltinGadgetName(specifier)) {
+    return getBuiltinGadget(specifier);
+  }
+  return null;
 }
 function resolveGadgetSpecifier(specifier, cwd) {
   if (!isFileLikeSpecifier(specifier)) {
     return specifier;
   }
   const expanded = expandHomePath(specifier);
-  const resolvedPath = path.resolve(cwd, expanded);
-  if (!fs.existsSync(resolvedPath)) {
+  const resolvedPath = path4.resolve(cwd, expanded);
+  if (!fs5.existsSync(resolvedPath)) {
     throw new Error(`Gadget module not found at ${resolvedPath}`);
   }
   return pathToFileURL(resolvedPath).href;
@@ -357,6 +1050,11 @@ function extractGadgetsFromModule(moduleExports) {
 async function loadGadgets(specifiers, cwd, importer = (specifier) => import(specifier)) {
   const gadgets = [];
   for (const specifier of specifiers) {
+    const builtin = tryResolveBuiltin(specifier);
+    if (builtin) {
+      gadgets.push(builtin);
+      continue;
+    }
     const resolved = resolveGadgetSpecifier(specifier, cwd);
     let exports;
     try {
@@ -381,7 +1079,7 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
 }
 
 // src/cli/llm-logging.ts
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var DEFAULT_LLM_LOG_DIR = join(homedir(), ".llmist", "logs");
@@ -405,43 +1103,43 @@ function formatLlmRequest(messages) {
 }
 async function writeLogFile(dir, filename, content) {
   await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, filename), content, "utf-8");
+  await writeFile2(join(dir, filename), content, "utf-8");
 }
 
 // src/cli/utils.ts
 init_constants();
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 import { InvalidArgumentError } from "commander";
 
 // src/cli/ui/formatters.ts
-import chalk from "chalk";
+import chalk3 from "chalk";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 var markedConfigured = false;
 function ensureMarkedConfigured() {
   if (!markedConfigured) {
-    chalk.level = process.env.NO_COLOR ? 0 : 3;
+    chalk3.level = process.env.NO_COLOR ? 0 : 3;
     marked.use(
       markedTerminal({
         // Text styling
-        strong: chalk.bold,
-        em: chalk.italic,
-        del: chalk.dim.gray.strikethrough,
+        strong: chalk3.bold,
+        em: chalk3.italic,
+        del: chalk3.dim.gray.strikethrough,
         // Code styling
-        code: chalk.yellow,
-        codespan: chalk.yellow,
+        code: chalk3.yellow,
+        codespan: chalk3.yellow,
         // Headings
-        heading: chalk.green.bold,
-        firstHeading: chalk.magenta.underline.bold,
+        heading: chalk3.green.bold,
+        firstHeading: chalk3.magenta.underline.bold,
         // Links
-        link: chalk.blue,
-        href: chalk.blue.underline,
+        link: chalk3.blue,
+        href: chalk3.blue.underline,
         // Block elements
-        blockquote: chalk.gray.italic,
+        blockquote: chalk3.gray.italic,
         // List formatting - reduce indentation and add bullet styling
         tab: 2,
         // Reduce from default 4 to 2 spaces
-        listitem: chalk.reset
+        listitem: chalk3.reset
         // Keep items readable (no dim)
       })
     );
@@ -451,11 +1149,11 @@ function ensureMarkedConfigured() {
 function renderMarkdown(text) {
   ensureMarkedConfigured();
   let rendered = marked.parse(text);
-  rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content)).replace(/(?<!\*)\*(\S[^*]*)\*(?!\*)/g, (_, content) => chalk.italic(content));
+  rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk3.bold(content)).replace(/(?<!\*)\*(\S[^*]*)\*(?!\*)/g, (_, content) => chalk3.italic(content));
   return rendered.trimEnd();
 }
 function createRainbowSeparator() {
-  const colors = [chalk.red, chalk.yellow, chalk.green, chalk.cyan, chalk.blue, chalk.magenta];
+  const colors = [chalk3.red, chalk3.yellow, chalk3.green, chalk3.cyan, chalk3.blue, chalk3.magenta];
   const char = "\u2500";
   const width = process.stdout.columns || 80;
   let result = "";
@@ -491,58 +1189,58 @@ function formatCost(cost) {
 function renderSummary(metadata) {
   const parts = [];
   if (metadata.iterations !== void 0) {
-    const iterPart = chalk.cyan(`#${metadata.iterations}`);
+    const iterPart = chalk3.cyan(`#${metadata.iterations}`);
     if (metadata.model) {
-      parts.push(`${iterPart} ${chalk.magenta(metadata.model)}`);
+      parts.push(`${iterPart} ${chalk3.magenta(metadata.model)}`);
     } else {
       parts.push(iterPart);
     }
   } else if (metadata.model) {
-    parts.push(chalk.magenta(metadata.model));
+    parts.push(chalk3.magenta(metadata.model));
   }
   if (metadata.usage) {
     const { inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens } = metadata.usage;
-    parts.push(chalk.dim("\u2191") + chalk.yellow(` ${formatTokens(inputTokens)}`));
+    parts.push(chalk3.dim("\u2191") + chalk3.yellow(` ${formatTokens(inputTokens)}`));
     if (cachedInputTokens && cachedInputTokens > 0) {
-      parts.push(chalk.dim("\u27F3") + chalk.blue(` ${formatTokens(cachedInputTokens)}`));
+      parts.push(chalk3.dim("\u27F3") + chalk3.blue(` ${formatTokens(cachedInputTokens)}`));
     }
     if (cacheCreationInputTokens && cacheCreationInputTokens > 0) {
-      parts.push(chalk.dim("\u270E") + chalk.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
+      parts.push(chalk3.dim("\u270E") + chalk3.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
     }
-    parts.push(chalk.dim("\u2193") + chalk.green(` ${formatTokens(outputTokens)}`));
+    parts.push(chalk3.dim("\u2193") + chalk3.green(` ${formatTokens(outputTokens)}`));
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
-    parts.push(chalk.dim(`${metadata.elapsedSeconds}s`));
+    parts.push(chalk3.dim(`${metadata.elapsedSeconds}s`));
   }
   if (metadata.cost !== void 0 && metadata.cost > 0) {
-    parts.push(chalk.cyan(`$${formatCost(metadata.cost)}`));
+    parts.push(chalk3.cyan(`$${formatCost(metadata.cost)}`));
   }
   if (metadata.finishReason) {
-    parts.push(chalk.dim(metadata.finishReason));
+    parts.push(chalk3.dim(metadata.finishReason));
   }
   if (parts.length === 0) {
     return null;
   }
-  return parts.join(chalk.dim(" | "));
+  return parts.join(chalk3.dim(" | "));
 }
 function renderOverallSummary(metadata) {
   const parts = [];
   if (metadata.totalTokens !== void 0 && metadata.totalTokens > 0) {
-    parts.push(chalk.dim("total:") + chalk.magenta(` ${formatTokens(metadata.totalTokens)}`));
+    parts.push(chalk3.dim("total:") + chalk3.magenta(` ${formatTokens(metadata.totalTokens)}`));
   }
   if (metadata.iterations !== void 0 && metadata.iterations > 0) {
-    parts.push(chalk.cyan(`#${metadata.iterations}`));
+    parts.push(chalk3.cyan(`#${metadata.iterations}`));
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
-    parts.push(chalk.dim(`${metadata.elapsedSeconds}s`));
+    parts.push(chalk3.dim(`${metadata.elapsedSeconds}s`));
   }
   if (metadata.cost !== void 0 && metadata.cost > 0) {
-    parts.push(chalk.cyan(`$${formatCost(metadata.cost)}`));
+    parts.push(chalk3.cyan(`$${formatCost(metadata.cost)}`));
   }
   if (parts.length === 0) {
     return null;
   }
-  return parts.join(chalk.dim(" | "));
+  return parts.join(chalk3.dim(" | "));
 }
 function formatParametersInline(params) {
   if (!params || Object.keys(params).length === 0) {
@@ -558,8 +1256,8 @@ function formatParametersInline(params) {
       const json = JSON.stringify(value);
       formatted = json.length > 30 ? `${json.slice(0, 30)}\u2026` : json;
     }
-    return `${chalk.dim(key)}${chalk.dim("=")}${chalk.cyan(formatted)}`;
-  }).join(chalk.dim(", "));
+    return `${chalk3.dim(key)}${chalk3.dim("=")}${chalk3.cyan(formatted)}`;
+  }).join(chalk3.dim(", "));
 }
 function formatBytes(bytes) {
   if (bytes < 1024) {
@@ -571,25 +1269,25 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 function formatGadgetSummary(result) {
-  const gadgetLabel = chalk.magenta.bold(result.gadgetName);
-  const timeLabel = chalk.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const gadgetLabel = chalk3.magenta.bold(result.gadgetName);
+  const timeLabel = chalk3.dim(`${Math.round(result.executionTimeMs)}ms`);
   const paramsStr = formatParametersInline(result.parameters);
-  const paramsLabel = paramsStr ? `${chalk.dim("(")}${paramsStr}${chalk.dim(")")}` : "";
+  const paramsLabel = paramsStr ? `${chalk3.dim("(")}${paramsStr}${chalk3.dim(")")}` : "";
   if (result.error) {
     const errorMsg = result.error.length > 50 ? `${result.error.slice(0, 50)}\u2026` : result.error;
-    return `${chalk.red("\u2717")} ${gadgetLabel}${paramsLabel} ${chalk.red("error:")} ${errorMsg} ${timeLabel}`;
+    return `${chalk3.red("\u2717")} ${gadgetLabel}${paramsLabel} ${chalk3.red("error:")} ${errorMsg} ${timeLabel}`;
   }
   let outputLabel;
   if (result.tokenCount !== void 0 && result.tokenCount > 0) {
-    outputLabel = chalk.green(`${formatTokens(result.tokenCount)} tokens`);
+    outputLabel = chalk3.green(`${formatTokens(result.tokenCount)} tokens`);
   } else if (result.result) {
     const outputBytes = Buffer.byteLength(result.result, "utf-8");
-    outputLabel = outputBytes > 0 ? chalk.green(formatBytes(outputBytes)) : chalk.dim("no output");
+    outputLabel = outputBytes > 0 ? chalk3.green(formatBytes(outputBytes)) : chalk3.dim("no output");
   } else {
-    outputLabel = chalk.dim("no output");
+    outputLabel = chalk3.dim("no output");
   }
-  const icon = result.breaksLoop ? chalk.yellow("\u23F9") : chalk.green("\u2713");
-  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${chalk.dim("\u2192")} ${outputLabel} ${timeLabel}`;
+  const icon = result.breaksLoop ? chalk3.yellow("\u23F9") : chalk3.green("\u2713");
+  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${chalk3.dim("\u2192")} ${outputLabel} ${timeLabel}`;
   if (result.gadgetName === "TellUser" && result.parameters?.message) {
     const message = String(result.parameters.message);
     const rendered = renderMarkdownWithSeparators(message);
@@ -653,6 +1351,66 @@ var StreamPrinter = class {
 function isInteractive(stream) {
   return Boolean(stream.isTTY);
 }
+var ESC_KEY = 27;
+var ESC_TIMEOUT_MS = 50;
+function createEscKeyListener(stdin, onEsc) {
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+    return null;
+  }
+  let escTimeout = null;
+  const handleData = (data) => {
+    if (data[0] === ESC_KEY) {
+      if (data.length === 1) {
+        escTimeout = setTimeout(() => {
+          onEsc();
+        }, ESC_TIMEOUT_MS);
+      } else {
+        if (escTimeout) {
+          clearTimeout(escTimeout);
+          escTimeout = null;
+        }
+      }
+    } else {
+      if (escTimeout) {
+        clearTimeout(escTimeout);
+        escTimeout = null;
+      }
+    }
+  };
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.on("data", handleData);
+  return () => {
+    if (escTimeout) {
+      clearTimeout(escTimeout);
+    }
+    stdin.removeListener("data", handleData);
+    stdin.setRawMode(false);
+    stdin.pause();
+  };
+}
+var SIGINT_DOUBLE_PRESS_MS = 1e3;
+function createSigintListener(onCancel, onQuit, isOperationActive, stderr = process.stderr) {
+  let lastSigintTime = 0;
+  const handler = () => {
+    const now = Date.now();
+    if (isOperationActive()) {
+      onCancel();
+      lastSigintTime = now;
+      return;
+    }
+    if (now - lastSigintTime < SIGINT_DOUBLE_PRESS_MS) {
+      onQuit();
+      return;
+    }
+    lastSigintTime = now;
+    stderr.write(chalk4.dim("\n[Press Ctrl+C again to quit]\n"));
+  };
+  process.on("SIGINT", handler);
+  return () => {
+    process.removeListener("SIGINT", handler);
+  };
+}
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_DELAY_MS = 500;
 var StreamProgress = class {
@@ -824,9 +1582,9 @@ var StreamProgress = class {
     const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
     const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
     const parts = [];
-    const iterPart = chalk2.cyan(`#${this.currentIteration}`);
+    const iterPart = chalk4.cyan(`#${this.currentIteration}`);
     if (this.model) {
-      parts.push(`${iterPart} ${chalk2.magenta(this.model)}`);
+      parts.push(`${iterPart} ${chalk4.magenta(this.model)}`);
     } else {
       parts.push(iterPart);
     }
@@ -834,27 +1592,27 @@ var StreamProgress = class {
     if (usagePercent !== null) {
       const formatted = `${Math.round(usagePercent)}%`;
       if (usagePercent >= 80) {
-        parts.push(chalk2.red(formatted));
+        parts.push(chalk4.red(formatted));
       } else if (usagePercent >= 50) {
-        parts.push(chalk2.yellow(formatted));
+        parts.push(chalk4.yellow(formatted));
       } else {
-        parts.push(chalk2.green(formatted));
+        parts.push(chalk4.green(formatted));
       }
     }
     if (this.callInputTokens > 0) {
       const prefix = this.callInputTokensEstimated ? "~" : "";
-      parts.push(chalk2.dim("\u2191") + chalk2.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
+      parts.push(chalk4.dim("\u2191") + chalk4.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
     }
     if (this.isStreaming || outTokens > 0) {
       const prefix = this.callOutputTokensEstimated ? "~" : "";
-      parts.push(chalk2.dim("\u2193") + chalk2.green(` ${prefix}${formatTokens(outTokens)}`));
+      parts.push(chalk4.dim("\u2193") + chalk4.green(` ${prefix}${formatTokens(outTokens)}`));
     }
-    parts.push(chalk2.dim(`${elapsed}s`));
+    parts.push(chalk4.dim(`${elapsed}s`));
     const callCost = this.calculateCurrentCallCost(outTokens);
     if (callCost > 0) {
-      parts.push(chalk2.cyan(`$${formatCost(callCost)}`));
+      parts.push(chalk4.cyan(`$${formatCost(callCost)}`));
     }
-    this.target.write(`\r${parts.join(chalk2.dim(" | "))} ${chalk2.cyan(spinner)}`);
+    this.target.write(`\r${parts.join(chalk4.dim(" | "))} ${chalk4.cyan(spinner)}`);
   }
   /**
    * Calculates live cost estimate for the current streaming call.
@@ -895,19 +1653,19 @@ var StreamProgress = class {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
     if (this.model) {
-      parts.push(chalk2.cyan(this.model));
+      parts.push(chalk4.cyan(this.model));
     }
     if (this.totalTokens > 0) {
-      parts.push(chalk2.dim("total:") + chalk2.magenta(` ${this.totalTokens}`));
+      parts.push(chalk4.dim("total:") + chalk4.magenta(` ${this.totalTokens}`));
     }
     if (this.iterations > 0) {
-      parts.push(chalk2.dim("iter:") + chalk2.blue(` ${this.iterations}`));
+      parts.push(chalk4.dim("iter:") + chalk4.blue(` ${this.iterations}`));
     }
     if (this.totalCost > 0) {
-      parts.push(chalk2.dim("cost:") + chalk2.cyan(` $${formatCost(this.totalCost)}`));
+      parts.push(chalk4.dim("cost:") + chalk4.cyan(` $${formatCost(this.totalCost)}`));
     }
-    parts.push(chalk2.dim(`${elapsed}s`));
-    this.target.write(`\r${parts.join(chalk2.dim(" | "))} ${chalk2.cyan(spinner)}`);
+    parts.push(chalk4.dim(`${elapsed}s`));
+    this.target.write(`\r${parts.join(chalk4.dim(" | "))} ${chalk4.cyan(spinner)}`);
   }
   /**
    * Pauses the progress indicator and clears the line.
@@ -941,6 +1699,25 @@ var StreamProgress = class {
   getTotalCost() {
     return this.totalCost;
   }
+  /**
+   * Returns a formatted stats string for cancellation messages.
+   * Format: "↑ 1.2k | ↓ 300 | 5.0s"
+   */
+  formatStats() {
+    const parts = [];
+    const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
+    const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
+    if (this.callInputTokens > 0) {
+      const prefix = this.callInputTokensEstimated ? "~" : "";
+      parts.push(`\u2191 ${prefix}${formatTokens(this.callInputTokens)}`);
+    }
+    if (outTokens > 0) {
+      const prefix = this.callOutputTokensEstimated ? "~" : "";
+      parts.push(`\u2193 ${prefix}${formatTokens(outTokens)}`);
+    }
+    parts.push(`${elapsed}s`);
+    return parts.join(" | ");
+  }
   /**
    * Returns a formatted prompt string with stats (like bash PS1).
    * Shows current call stats during streaming, cumulative stats otherwise.
@@ -955,28 +1732,28 @@ var StreamProgress = class {
       if (this.callInputTokens > 0) {
         const prefix = this.callInputTokensEstimated ? "~" : "";
         parts.push(
-          chalk2.dim("\u2191") + chalk2.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`)
+          chalk4.dim("\u2191") + chalk4.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`)
         );
       }
       if (outTokens > 0) {
         const prefix = outEstimated ? "~" : "";
-        parts.push(chalk2.dim("\u2193") + chalk2.green(` ${prefix}${formatTokens(outTokens)}`));
+        parts.push(chalk4.dim("\u2193") + chalk4.green(` ${prefix}${formatTokens(outTokens)}`));
       }
-      parts.push(chalk2.dim(`${elapsed}s`));
+      parts.push(chalk4.dim(`${elapsed}s`));
     } else {
       const elapsed = Math.round((Date.now() - this.totalStartTime) / 1e3);
       if (this.totalTokens > 0) {
-        parts.push(chalk2.magenta(formatTokens(this.totalTokens)));
+        parts.push(chalk4.magenta(formatTokens(this.totalTokens)));
       }
       if (this.iterations > 0) {
-        parts.push(chalk2.blue(`i${this.iterations}`));
+        parts.push(chalk4.blue(`i${this.iterations}`));
       }
       if (this.totalCost > 0) {
-        parts.push(chalk2.cyan(`$${formatCost(this.totalCost)}`));
+        parts.push(chalk4.cyan(`$${formatCost(this.totalCost)}`));
       }
-      parts.push(chalk2.dim(`${elapsed}s`));
+      parts.push(chalk4.dim(`${elapsed}s`));
     }
-    return `${parts.join(chalk2.dim(" | "))} ${chalk2.green(">")} `;
+    return `${parts.join(chalk4.dim(" | "))} ${chalk4.green(">")} `;
   }
 };
 async function readStream(stream) {
@@ -1011,7 +1788,7 @@ async function executeAction(action, env) {
     await action();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    env.stderr.write(`${chalk2.red.bold("Error:")} ${message}
+    env.stderr.write(`${chalk4.red.bold("Error:")} ${message}
 `);
     env.setExitCode(1);
   }
@@ -1036,7 +1813,7 @@ function addAgentOptions(cmd, defaults) {
     ...previous,
     value
   ];
-  const defaultGadgets = defaults?.gadget ?? [];
+  const defaultGadgets = defaults?.gadgets ?? defaults?.gadget ?? [];
   return cmd.option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, defaults?.model ?? DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt, defaults?.system).option(
     OPTION_FLAGS.temperature,
     OPTION_DESCRIPTIONS.temperature,
@@ -1072,7 +1849,8 @@ function configToAgentOptions(config) {
   if (config.system !== void 0) result.system = config.system;
   if (config.temperature !== void 0) result.temperature = config.temperature;
   if (config["max-iterations"] !== void 0) result.maxIterations = config["max-iterations"];
-  if (config.gadget !== void 0) result.gadget = config.gadget;
+  const gadgets = config.gadgets ?? config.gadget;
+  if (gadgets !== void 0) result.gadget = gadgets;
   if (config.builtins !== void 0) result.builtins = config.builtins;
   if (config["builtin-interaction"] !== void 0)
     result.builtinInteraction = config["builtin-interaction"];
@@ -1082,6 +1860,8 @@ function configToAgentOptions(config) {
     result.gadgetEndPrefix = config["gadget-end-prefix"];
   if (config["gadget-arg-prefix"] !== void 0)
     result.gadgetArgPrefix = config["gadget-arg-prefix"];
+  if (config["gadget-approval"] !== void 0)
+    result.gadgetApproval = config["gadget-approval"];
   if (config.quiet !== void 0) result.quiet = config.quiet;
   if (config["log-llm-requests"] !== void 0) result.logLlmRequests = config["log-llm-requests"];
   if (config["log-llm-responses"] !== void 0) result.logLlmResponses = config["log-llm-responses"];
@@ -1089,23 +1869,18 @@ function configToAgentOptions(config) {
 }
 
 // src/cli/agent-command.ts
-async function promptApproval(env, prompt) {
-  const rl = createInterface({ input: env.stdin, output: env.stderr });
-  try {
-    const answer = await rl.question(prompt);
-    return answer.trim();
-  } finally {
-    rl.close();
-  }
-}
-function createHumanInputHandler(env, progress) {
+function createHumanInputHandler(env, progress, keyboard) {
   const stdout = env.stdout;
   if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
     return void 0;
   }
   return async (question) => {
     progress.pause();
-    const rl = createInterface({ input: env.stdin, output: env.stdout });
+    if (keyboard.cleanupEsc) {
+      keyboard.cleanupEsc();
+      keyboard.cleanupEsc = null;
+    }
+    const rl = createInterface2({ input: env.stdin, output: env.stdout });
     try {
       const questionLine = question.trim() ? `
 ${renderMarkdownWithSeparators(question.trim())}` : "";
@@ -1123,6 +1898,7 @@ ${statsPrompt}` : statsPrompt;
       }
     } finally {
       rl.close();
+      keyboard.restore();
     }
   };
 }
@@ -1149,6 +1925,77 @@ async function executeAgent(promptArg, options, env) {
   const printer = new StreamPrinter(env.stdout);
   const stderrTTY = env.stderr.isTTY === true;
   const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
+  const abortController = new AbortController();
+  let wasCancelled = false;
+  let isStreaming = false;
+  const stdinStream = env.stdin;
+  const handleCancel = () => {
+    if (!abortController.signal.aborted) {
+      wasCancelled = true;
+      abortController.abort();
+      progress.pause();
+      env.stderr.write(chalk5.yellow(`
+[Cancelled] ${progress.formatStats()}
+`));
+    }
+  };
+  const keyboard = {
+    cleanupEsc: null,
+    cleanupSigint: null,
+    restore: () => {
+      if (stdinIsInteractive && stdinStream.isTTY && !wasCancelled) {
+        keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
+      }
+    }
+  };
+  const handleQuit = () => {
+    keyboard.cleanupEsc?.();
+    keyboard.cleanupSigint?.();
+    progress.complete();
+    printer.ensureNewline();
+    const summary = renderOverallSummary({
+      totalTokens: usage?.totalTokens,
+      iterations,
+      elapsedSeconds: progress.getTotalElapsedSeconds(),
+      cost: progress.getTotalCost()
+    });
+    if (summary) {
+      env.stderr.write(`${chalk5.dim("\u2500".repeat(40))}
+`);
+      env.stderr.write(`${summary}
+`);
+    }
+    env.stderr.write(chalk5.dim("[Quit]\n"));
+    process.exit(130);
+  };
+  if (stdinIsInteractive && stdinStream.isTTY) {
+    keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
+  }
+  keyboard.cleanupSigint = createSigintListener(
+    handleCancel,
+    handleQuit,
+    () => isStreaming && !abortController.signal.aborted,
+    env.stderr
+  );
+  const DEFAULT_APPROVAL_REQUIRED = ["RunCommand", "WriteFile", "EditFile"];
+  const userApprovals = options.gadgetApproval ?? {};
+  const gadgetApprovals = {
+    ...userApprovals
+  };
+  for (const gadget of DEFAULT_APPROVAL_REQUIRED) {
+    const normalizedGadget = gadget.toLowerCase();
+    const isConfigured = Object.keys(userApprovals).some(
+      (key) => key.toLowerCase() === normalizedGadget
+    );
+    if (!isConfigured) {
+      gadgetApprovals[gadget] = "approval-required";
+    }
+  }
+  const approvalConfig = {
+    gadgetApprovals,
+    defaultMode: "allowed"
+  };
+  const approvalManager = new ApprovalManager(approvalConfig, env, progress);
   let usage;
   let iterations = 0;
   const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
@@ -1176,6 +2023,7 @@ async function executeAgent(promptArg, options, env) {
       // onLLMCallStart: Start progress indicator for each LLM call
       // This showcases how to react to agent lifecycle events
       onLLMCallStart: async (context) => {
+        isStreaming = true;
         llmCallCounter++;
         const inputTokens = await countMessagesTokens(
           context.options.model,
@@ -1209,6 +2057,7 @@ async function executeAgent(promptArg, options, env) {
       // onLLMCallComplete: Finalize metrics after each LLM call
       // This is where you'd typically log metrics or update dashboards
       onLLMCallComplete: async (context) => {
+        isStreaming = false;
         usage = context.usage;
         iterations = Math.max(iterations, context.iteration + 1);
         if (context.usage) {
@@ -1256,47 +2105,53 @@ async function executeAgent(promptArg, options, env) {
         }
       }
     },
-    // SHOWCASE: Controller-based approval gating for dangerous gadgets
+    // SHOWCASE: Controller-based approval gating for gadgets
     //
     // This demonstrates how to add safety layers WITHOUT modifying gadgets.
-    // The RunCommand gadget is simple - it just executes commands. The CLI
-    // adds the approval flow externally via beforeGadgetExecution controller.
+    // The ApprovalManager handles approval flows externally via beforeGadgetExecution.
+    // Approval modes are configurable via cli.toml:
+    //   - "allowed": auto-proceed
+    //   - "denied": auto-reject, return message to LLM
+    //   - "approval-required": prompt user interactively
     //
-    // This pattern is composable: you can apply the same gating logic to
-    // any gadget (DeleteFile, SendEmail, etc.) without changing the gadgets.
+    // Default: RunCommand, WriteFile, EditFile require approval unless overridden.
     controllers: {
       beforeGadgetExecution: async (ctx) => {
-        if (ctx.gadgetName !== "RunCommand") {
+        const mode = approvalManager.getApprovalMode(ctx.gadgetName);
+        if (mode === "allowed") {
           return { action: "proceed" };
         }
         const stdinTTY = isInteractive(env.stdin);
         const stderrTTY2 = env.stderr.isTTY === true;
-        if (!stdinTTY || !stderrTTY2) {
-          return {
-            action: "skip",
-            syntheticResult: "status=denied\n\nRunCommand requires interactive approval. Run in a terminal to approve commands."
-          };
-        }
-        const command = ctx.parameters.command;
-        progress.pause();
-        env.stderr.write(`
-\u{1F512} Execute: ${chalk3.cyan(command)}
-`);
-        const response = await promptApproval(env, "   \u23CE approve, or type to reject: ");
-        const isApproved = response === "" || response.toLowerCase() === "y";
-        if (!isApproved) {
-          env.stderr.write(`   ${chalk3.red("\u2717 Denied")}
+        const canPrompt = stdinTTY && stderrTTY2;
+        if (!canPrompt) {
+          if (mode === "approval-required") {
+            return {
+              action: "skip",
+              syntheticResult: `status=denied
 
-`);
+${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
+            };
+          }
+          if (mode === "denied") {
+            return {
+              action: "skip",
+              syntheticResult: `status=denied
+
+${ctx.gadgetName} is denied by configuration.`
+            };
+          }
+          return { action: "proceed" };
+        }
+        const result = await approvalManager.requestApproval(ctx.gadgetName, ctx.parameters);
+        if (!result.approved) {
           return {
             action: "skip",
             syntheticResult: `status=denied
 
-Command rejected by user with message: "${response}"`
+Denied: ${result.reason ?? "by user"}`
           };
         }
-        env.stderr.write(`   ${chalk3.green("\u2713 Approved")}
-`);
         return { action: "proceed" };
       }
     }
@@ -1310,10 +2165,11 @@ Command rejected by user with message: "${response}"`
   if (options.temperature !== void 0) {
     builder.withTemperature(options.temperature);
   }
-  const humanInputHandler = createHumanInputHandler(env, progress);
+  const humanInputHandler = createHumanInputHandler(env, progress, keyboard);
   if (humanInputHandler) {
     builder.onHumanInput(humanInputHandler);
   }
+  builder.withSignal(abortController.signal);
   const gadgets = registry.getAll();
   if (gadgets.length > 0) {
     builder.withGadgets(...gadgets);
@@ -1351,31 +2207,41 @@ Command rejected by user with message: "${response}"`
       textBuffer = "";
     }
   };
-  for await (const event of agent.run()) {
-    if (event.type === "text") {
-      progress.pause();
-      textBuffer += event.content;
-    } else if (event.type === "gadget_result") {
-      flushTextBuffer();
-      progress.pause();
-      if (options.quiet) {
-        if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
-          const message = String(event.result.parameters.message);
-          env.stdout.write(`${message}
+  try {
+    for await (const event of agent.run()) {
+      if (event.type === "text") {
+        progress.pause();
+        textBuffer += event.content;
+      } else if (event.type === "gadget_result") {
+        flushTextBuffer();
+        progress.pause();
+        if (options.quiet) {
+          if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
+            const message = String(event.result.parameters.message);
+            env.stdout.write(`${message}
 `);
-        }
-      } else {
-        const tokenCount = await countGadgetOutputTokens(event.result.result);
-        env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
+          }
+        } else {
+          const tokenCount = await countGadgetOutputTokens(event.result.result);
+          env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
 `);
+        }
       }
     }
+  } catch (error) {
+    if (!isAbortError(error)) {
+      throw error;
+    }
+  } finally {
+    isStreaming = false;
+    keyboard.cleanupEsc?.();
+    keyboard.cleanupSigint?.();
   }
   flushTextBuffer();
   progress.complete();
   printer.ensureNewline();
   if (!options.quiet && iterations > 1) {
-    env.stderr.write(`${chalk3.dim("\u2500".repeat(40))}
+    env.stderr.write(`${chalk5.dim("\u2500".repeat(40))}
 `);
     const summary = renderOverallSummary({
       totalTokens: usage?.totalTokens,
@@ -1393,7 +2259,13 @@ function registerAgentCommand(program, env, config) {
   const cmd = program.command(COMMANDS.agent).description("Run the llmist agent loop with optional gadgets.").argument("[prompt]", "Prompt for the agent loop. Falls back to stdin when available.");
   addAgentOptions(cmd, config);
   cmd.action(
-    (prompt, options) => executeAction(() => executeAgent(prompt, options, env), env)
+    (prompt, options) => executeAction(() => {
+      const mergedOptions = {
+        ...options,
+        gadgetApproval: config?.["gadget-approval"]
+      };
+      return executeAgent(prompt, mergedOptions, env);
+    }, env)
   );
 }
 
@@ -1477,7 +2349,7 @@ function registerCompleteCommand(program, env, config) {
 }
 
 // src/cli/config.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 import { load as parseToml } from "js-toml";
@@ -1564,6 +2436,7 @@ function hasTemplateSyntax(str) {
 }
 
 // src/cli/config.ts
+var VALID_APPROVAL_MODES = ["allowed", "denied", "approval-required"];
 var GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["log-level", "log-file", "log-reset"]);
 var VALID_LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -1586,12 +2459,20 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "system",
   "temperature",
   "max-iterations",
+  "gadgets",
+  // Full replacement (preferred)
+  "gadget-add",
+  // Add to inherited gadgets
+  "gadget-remove",
+  // Remove from inherited gadgets
   "gadget",
+  // DEPRECATED: alias for gadgets
   "builtins",
   "builtin-interaction",
   "gadget-start-prefix",
   "gadget-end-prefix",
   "gadget-arg-prefix",
+  "gadget-approval",
   "quiet",
   "inherits",
   "log-level",
@@ -1612,9 +2493,9 @@ function getConfigPath() {
   return join2(homedir2(), ".llmist", "cli.toml");
 }
 var ConfigError = class extends Error {
-  constructor(message, path2) {
-    super(path2 ? `${path2}: ${message}` : message);
-    this.path = path2;
+  constructor(message, path5) {
+    super(path5 ? `${path5}: ${message}` : message);
+    this.path = path5;
     this.name = "ConfigError";
   }
 };
@@ -1670,6 +2551,28 @@ function validateInherits(value, section) {
   }
   throw new ConfigError(`[${section}].inherits must be a string or array of strings`);
 }
+function validateGadgetApproval(value, section) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(
+      `[${section}].gadget-approval must be a table (e.g., { WriteFile = "approval-required" })`
+    );
+  }
+  const result = {};
+  for (const [gadgetName, mode] of Object.entries(value)) {
+    if (typeof mode !== "string") {
+      throw new ConfigError(
+        `[${section}].gadget-approval.${gadgetName} must be a string`
+      );
+    }
+    if (!VALID_APPROVAL_MODES.includes(mode)) {
+      throw new ConfigError(
+        `[${section}].gadget-approval.${gadgetName} must be one of: ${VALID_APPROVAL_MODES.join(", ")}`
+      );
+    }
+    result[gadgetName] = mode;
+  }
+  return result;
+}
 function validateLoggingConfig(raw, section) {
   const result = {};
   if ("log-level" in raw) {
@@ -1779,6 +2682,15 @@ function validateAgentConfig(raw, section) {
       min: 1
     });
   }
+  if ("gadgets" in rawObj) {
+    result.gadgets = validateStringArray(rawObj.gadgets, "gadgets", section);
+  }
+  if ("gadget-add" in rawObj) {
+    result["gadget-add"] = validateStringArray(rawObj["gadget-add"], "gadget-add", section);
+  }
+  if ("gadget-remove" in rawObj) {
+    result["gadget-remove"] = validateStringArray(rawObj["gadget-remove"], "gadget-remove", section);
+  }
   if ("gadget" in rawObj) {
     result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
   }
@@ -1813,6 +2725,9 @@ function validateAgentConfig(raw, section) {
       section
     );
   }
+  if ("gadget-approval" in rawObj) {
+    result["gadget-approval"] = validateGadgetApproval(rawObj["gadget-approval"], section);
+  }
   if ("quiet" in rawObj) {
     result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
@@ -1869,6 +2784,15 @@ function validateCustomConfig(raw, section) {
       min: 1
     });
   }
+  if ("gadgets" in rawObj) {
+    result.gadgets = validateStringArray(rawObj.gadgets, "gadgets", section);
+  }
+  if ("gadget-add" in rawObj) {
+    result["gadget-add"] = validateStringArray(rawObj["gadget-add"], "gadget-add", section);
+  }
+  if ("gadget-remove" in rawObj) {
+    result["gadget-remove"] = validateStringArray(rawObj["gadget-remove"], "gadget-remove", section);
+  }
   if ("gadget" in rawObj) {
     result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
   }
@@ -1903,6 +2827,9 @@ function validateCustomConfig(raw, section) {
       section
     );
   }
+  if ("gadget-approval" in rawObj) {
+    result["gadget-approval"] = validateGadgetApproval(rawObj["gadget-approval"], section);
+  }
   if ("max-tokens" in rawObj) {
     result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
       integer: true,
@@ -1958,12 +2885,12 @@ function validateConfig(raw, configPath) {
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return {};
   }
   let content;
   try {
-    content = readFileSync(configPath, "utf-8");
+    content = readFileSync2(configPath, "utf-8");
   } catch (error) {
     throw new ConfigError(
       `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -2058,6 +2985,39 @@ function resolveTemplatesInConfig(config, configPath) {
   }
   return result;
 }
+function resolveGadgets(section, inheritedGadgets, sectionName, configPath) {
+  const hasGadgets = "gadgets" in section;
+  const hasGadgetLegacy = "gadget" in section;
+  const hasGadgetAdd = "gadget-add" in section;
+  const hasGadgetRemove = "gadget-remove" in section;
+  if (hasGadgetLegacy && !hasGadgets) {
+    console.warn(
+      `[config] Warning: [${sectionName}].gadget is deprecated, use 'gadgets' (plural) instead`
+    );
+  }
+  if ((hasGadgets || hasGadgetLegacy) && (hasGadgetAdd || hasGadgetRemove)) {
+    throw new ConfigError(
+      `[${sectionName}] Cannot use 'gadgets' with 'gadget-add'/'gadget-remove'. Use either full replacement (gadgets) OR modification (gadget-add/gadget-remove).`,
+      configPath
+    );
+  }
+  if (hasGadgets) {
+    return section.gadgets;
+  }
+  if (hasGadgetLegacy) {
+    return section.gadget;
+  }
+  let result = [...inheritedGadgets];
+  if (hasGadgetRemove) {
+    const toRemove = new Set(section["gadget-remove"]);
+    result = result.filter((g) => !toRemove.has(g));
+  }
+  if (hasGadgetAdd) {
+    const toAdd = section["gadget-add"];
+    result.push(...toAdd);
+  }
+  return result;
+}
 function resolveInheritance(config, configPath) {
   const resolved = {};
   const resolving = /* @__PURE__ */ new Set();
@@ -2081,8 +3041,23 @@ function resolveInheritance(config, configPath) {
       const parentResolved = resolveSection(parent);
       merged = { ...merged, ...parentResolved };
     }
-    const { inherits: _inherits, ...ownValues } = sectionObj;
+    const inheritedGadgets = merged.gadgets ?? [];
+    const {
+      inherits: _inherits,
+      gadgets: _gadgets,
+      gadget: _gadget,
+      "gadget-add": _gadgetAdd,
+      "gadget-remove": _gadgetRemove,
+      ...ownValues
+    } = sectionObj;
     merged = { ...merged, ...ownValues };
+    const resolvedGadgets = resolveGadgets(sectionObj, inheritedGadgets, name, configPath);
+    if (resolvedGadgets.length > 0) {
+      merged.gadgets = resolvedGadgets;
+    }
+    delete merged["gadget"];
+    delete merged["gadget-add"];
+    delete merged["gadget-remove"];
     resolving.delete(name);
     resolved[name] = merged;
     return merged;
@@ -2096,12 +3071,12 @@ function resolveInheritance(config, configPath) {
 // src/cli/gadget-command.ts
 init_schema_to_json();
 init_schema_validator();
-import chalk5 from "chalk";
+import chalk7 from "chalk";
 
 // src/cli/gadget-prompts.ts
 init_schema_to_json();
-import { createInterface as createInterface2 } from "node:readline/promises";
-import chalk4 from "chalk";
+import { createInterface as createInterface3 } from "node:readline/promises";
+import chalk6 from "chalk";
 async function promptForParameters(schema, ctx) {
   if (!schema) {
     return {};
@@ -2110,7 +3085,7 @@ async function promptForParameters(schema, ctx) {
   if (!jsonSchema.properties || Object.keys(jsonSchema.properties).length === 0) {
     return {};
   }
-  const rl = createInterface2({ input: ctx.stdin, output: ctx.stdout });
+  const rl = createInterface3({ input: ctx.stdin, output: ctx.stdout });
   const params = {};
   try {
     for (const [key, prop] of Object.entries(jsonSchema.properties)) {
@@ -2133,16 +3108,16 @@ ${issues}`);
 async function promptForField(rl, key, prop, required) {
   const isRequired = required.includes(key);
   const typeHint = formatTypeHint(prop);
-  const defaultHint = prop.default !== void 0 ? chalk4.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
-  const requiredMarker = isRequired ? chalk4.red("*") : "";
+  const defaultHint = prop.default !== void 0 ? chalk6.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
+  const requiredMarker = isRequired ? chalk6.red("*") : "";
   let prompt = `
-${chalk4.cyan.bold(key)}${requiredMarker}`;
+${chalk6.cyan.bold(key)}${requiredMarker}`;
   if (prop.description) {
-    prompt += chalk4.dim(` - ${prop.description}`);
+    prompt += chalk6.dim(` - ${prop.description}`);
   }
   prompt += `
   ${typeHint}${defaultHint}
-  ${chalk4.green(">")} `;
+  ${chalk6.green(">")} `;
   const answer = await rl.question(prompt);
   const trimmed = answer.trim();
   if (!trimmed) {
@@ -2158,20 +3133,20 @@ ${chalk4.cyan.bold(key)}${requiredMarker}`;
 }
 function formatTypeHint(prop) {
   if (prop.enum) {
-    return chalk4.yellow(`(${prop.enum.join(" | ")})`);
+    return chalk6.yellow(`(${prop.enum.join(" | ")})`);
   }
   if (prop.type === "array") {
     const items = prop.items;
     if (items?.enum) {
-      return chalk4.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
+      return chalk6.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
     }
     const itemType = items?.type ?? "any";
-    return chalk4.yellow(`(${itemType}[]) comma-separated`);
+    return chalk6.yellow(`(${itemType}[]) comma-separated`);
   }
   if (prop.type === "object" && prop.properties) {
-    return chalk4.yellow("(object) enter as JSON");
+    return chalk6.yellow("(object) enter as JSON");
   }
-  return chalk4.yellow(`(${prop.type ?? "any"})`);
+  return chalk6.yellow(`(${prop.type ?? "any"})`);
 }
 function parseValue(input, prop, key) {
   const type = prop.type;
@@ -2282,7 +3257,7 @@ Available gadgets:
 async function executeGadgetRun(file, options, env) {
   const cwd = process.cwd();
   const { gadget, name } = await selectGadget(file, options.name, cwd);
-  env.stderr.write(chalk5.cyan.bold(`
+  env.stderr.write(chalk7.cyan.bold(`
 \u{1F527} Running gadget: ${name}
 `));
   let params;
@@ -2293,7 +3268,7 @@ async function executeGadgetRun(file, options, env) {
       // Prompts go to stderr to keep stdout clean
     });
   } else {
-    env.stderr.write(chalk5.dim("Reading parameters from stdin...\n"));
+    env.stderr.write(chalk7.dim("Reading parameters from stdin...\n"));
     const stdinParams = await readStdinJson(env.stdin);
     if (gadget.parameterSchema) {
       const result2 = gadget.parameterSchema.safeParse(stdinParams);
@@ -2307,7 +3282,7 @@ ${issues}`);
       params = stdinParams;
     }
   }
-  env.stderr.write(chalk5.dim("\nExecuting...\n"));
+  env.stderr.write(chalk7.dim("\nExecuting...\n"));
   const startTime = Date.now();
   let result;
   try {
@@ -2329,7 +3304,7 @@ ${issues}`);
     throw new Error(`Execution failed: ${message}`);
   }
   const elapsed = Date.now() - startTime;
-  env.stderr.write(chalk5.green(`
+  env.stderr.write(chalk7.green(`
 \u2713 Completed in ${elapsed}ms
 
 `));
@@ -2365,37 +3340,37 @@ async function executeGadgetInfo(file, options, env) {
     return;
   }
   env.stdout.write("\n");
-  env.stdout.write(chalk5.cyan.bold(`${name}
+  env.stdout.write(chalk7.cyan.bold(`${name}
 `));
-  env.stdout.write(chalk5.cyan("\u2550".repeat(name.length)) + "\n\n");
-  env.stdout.write(chalk5.bold("Description:\n"));
+  env.stdout.write(chalk7.cyan("\u2550".repeat(name.length)) + "\n\n");
+  env.stdout.write(chalk7.bold("Description:\n"));
   env.stdout.write(`  ${gadget.description}
 
 `);
   if (gadget.parameterSchema) {
-    env.stdout.write(chalk5.bold("Parameters:\n"));
+    env.stdout.write(chalk7.bold("Parameters:\n"));
     const jsonSchema = schemaToJSONSchema(gadget.parameterSchema, { target: "draft-7" });
     env.stdout.write(formatSchemaAsText(jsonSchema, "  ") + "\n\n");
   } else {
-    env.stdout.write(chalk5.dim("No parameters required.\n\n"));
+    env.stdout.write(chalk7.dim("No parameters required.\n\n"));
   }
   if (gadget.timeoutMs) {
-    env.stdout.write(chalk5.bold("Timeout:\n"));
+    env.stdout.write(chalk7.bold("Timeout:\n"));
     env.stdout.write(`  ${gadget.timeoutMs}ms
 
 `);
   }
   if (gadget.examples && gadget.examples.length > 0) {
-    env.stdout.write(chalk5.bold("Examples:\n"));
+    env.stdout.write(chalk7.bold("Examples:\n"));
     for (const example of gadget.examples) {
       if (example.comment) {
-        env.stdout.write(chalk5.dim(`  # ${example.comment}
+        env.stdout.write(chalk7.dim(`  # ${example.comment}
 `));
       }
-      env.stdout.write(`  Input: ${chalk5.cyan(JSON.stringify(example.params))}
+      env.stdout.write(`  Input: ${chalk7.cyan(JSON.stringify(example.params))}
 `);
       if (example.output !== void 0) {
-        env.stdout.write(`  Output: ${chalk5.green(example.output)}
+        env.stdout.write(`  Output: ${chalk7.green(example.output)}
 `);
       }
       env.stdout.write("\n");
@@ -2428,27 +3403,27 @@ function formatSchemaAsText(schema, indent = "") {
     const isRequired = required.includes(key);
     const enumValues = prop.enum;
     const defaultValue = prop.default;
-    let line = `${indent}${chalk5.cyan(key)}`;
+    let line = `${indent}${chalk7.cyan(key)}`;
     if (isRequired) {
-      line += chalk5.red("*");
+      line += chalk7.red("*");
     }
     if (type === "array") {
       const items = prop.items;
       const itemType = items?.type || "any";
-      line += chalk5.dim(` (${itemType}[])`);
+      line += chalk7.dim(` (${itemType}[])`);
     } else if (type === "object" && prop.properties) {
-      line += chalk5.dim(" (object)");
+      line += chalk7.dim(" (object)");
     } else {
-      line += chalk5.dim(` (${type})`);
+      line += chalk7.dim(` (${type})`);
     }
     if (defaultValue !== void 0) {
-      line += chalk5.dim(` [default: ${JSON.stringify(defaultValue)}]`);
+      line += chalk7.dim(` [default: ${JSON.stringify(defaultValue)}]`);
     }
     if (description) {
       line += `: ${description}`;
     }
     if (enumValues) {
-      line += chalk5.yellow(` - one of: ${enumValues.join(", ")}`);
+      line += chalk7.yellow(` - one of: ${enumValues.join(", ")}`);
     }
     lines.push(line);
     if (type === "object" && prop.properties) {
@@ -2488,20 +3463,20 @@ async function executeGadgetValidate(file, env) {
       throw new Error(`Validation issues:
 ${issues.map((i) => `  - ${i}`).join("\n")}`);
     }
-    env.stdout.write(chalk5.green.bold("\n\u2713 Valid\n\n"));
-    env.stdout.write(chalk5.bold("Gadgets found:\n"));
+    env.stdout.write(chalk7.green.bold("\n\u2713 Valid\n\n"));
+    env.stdout.write(chalk7.bold("Gadgets found:\n"));
     for (const gadget of gadgets) {
       const name = gadget.name ?? gadget.constructor.name;
-      const schemaInfo = gadget.parameterSchema ? chalk5.cyan("(with schema)") : chalk5.dim("(no schema)");
-      env.stdout.write(`  ${chalk5.bold(name)} ${schemaInfo}
+      const schemaInfo = gadget.parameterSchema ? chalk7.cyan("(with schema)") : chalk7.dim("(no schema)");
+      env.stdout.write(`  ${chalk7.bold(name)} ${schemaInfo}
 `);
-      env.stdout.write(chalk5.dim(`    ${gadget.description}
+      env.stdout.write(chalk7.dim(`    ${gadget.description}
 `));
     }
     env.stdout.write("\n");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    env.stdout.write(chalk5.red.bold(`
+    env.stdout.write(chalk7.red.bold(`
 \u2717 Invalid
 
 `));
@@ -2525,7 +3500,7 @@ function registerGadgetCommand(program, env) {
 }
 
 // src/cli/models-command.ts
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 init_model_shortcuts();
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -2545,13 +3520,13 @@ function renderTable(models, verbose, stream) {
     }
     grouped.get(provider).push(model);
   }
-  stream.write(chalk6.bold.cyan("\nAvailable Models\n"));
-  stream.write(chalk6.cyan("=".repeat(80)) + "\n\n");
+  stream.write(chalk8.bold.cyan("\nAvailable Models\n"));
+  stream.write(chalk8.cyan("=".repeat(80)) + "\n\n");
   const providers = Array.from(grouped.keys()).sort();
   for (const provider of providers) {
     const providerModels = grouped.get(provider);
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk6.bold.yellow(`${providerName} Models
+    stream.write(chalk8.bold.yellow(`${providerName} Models
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream);
@@ -2560,11 +3535,11 @@ function renderTable(models, verbose, stream) {
     }
     stream.write("\n");
   }
-  stream.write(chalk6.bold.magenta("Model Shortcuts\n"));
-  stream.write(chalk6.dim("\u2500".repeat(80)) + "\n");
+  stream.write(chalk8.bold.magenta("Model Shortcuts\n"));
+  stream.write(chalk8.dim("\u2500".repeat(80)) + "\n");
   const shortcuts = Object.entries(MODEL_ALIASES).sort((a, b) => a[0].localeCompare(b[0]));
   for (const [shortcut, fullName] of shortcuts) {
-    stream.write(chalk6.cyan(`  ${shortcut.padEnd(15)}`) + chalk6.dim(" \u2192 ") + chalk6.white(fullName) + "\n");
+    stream.write(chalk8.cyan(`  ${shortcut.padEnd(15)}`) + chalk8.dim(" \u2192 ") + chalk8.white(fullName) + "\n");
   }
   stream.write("\n");
 }
@@ -2574,45 +3549,45 @@ function renderCompactTable(models, stream) {
   const contextWidth = 13;
   const inputWidth = 10;
   const outputWidth = 10;
-  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk8.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   stream.write(
-    chalk6.bold(
+    chalk8.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
-  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk8.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   for (const model of models) {
     const contextFormatted = formatTokens2(model.contextWindow);
     const inputPrice = `$${model.pricing.input.toFixed(2)}`;
     const outputPrice = `$${model.pricing.output.toFixed(2)}`;
     stream.write(
-      chalk6.green(model.modelId.padEnd(idWidth)) + "  " + chalk6.white(model.displayName.padEnd(nameWidth)) + "  " + chalk6.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk6.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk6.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      chalk8.green(model.modelId.padEnd(idWidth)) + "  " + chalk8.white(model.displayName.padEnd(nameWidth)) + "  " + chalk8.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk8.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk8.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
-  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
-  stream.write(chalk6.dim(`  * Prices are per 1M tokens
+  stream.write(chalk8.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk8.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream) {
   for (const model of models) {
-    stream.write(chalk6.bold.green(`
+    stream.write(chalk8.bold.green(`
   ${model.modelId}
 `));
-    stream.write(chalk6.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream.write(`  ${chalk6.dim("Name:")}         ${chalk6.white(model.displayName)}
+    stream.write(chalk8.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream.write(`  ${chalk8.dim("Name:")}         ${chalk8.white(model.displayName)}
 `);
-    stream.write(`  ${chalk6.dim("Context:")}      ${chalk6.yellow(formatTokens2(model.contextWindow))}
+    stream.write(`  ${chalk8.dim("Context:")}      ${chalk8.yellow(formatTokens2(model.contextWindow))}
 `);
-    stream.write(`  ${chalk6.dim("Max Output:")}   ${chalk6.yellow(formatTokens2(model.maxOutputTokens))}
+    stream.write(`  ${chalk8.dim("Max Output:")}   ${chalk8.yellow(formatTokens2(model.maxOutputTokens))}
 `);
-    stream.write(`  ${chalk6.dim("Pricing:")}      ${chalk6.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk6.dim("/")} ${chalk6.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk6.dim("(per 1M tokens)")}
+    stream.write(`  ${chalk8.dim("Pricing:")}      ${chalk8.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk8.dim("/")} ${chalk8.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk8.dim("(per 1M tokens)")}
 `);
     if (model.pricing.cachedInput !== void 0) {
-      stream.write(`  ${chalk6.dim("Cached Input:")} ${chalk6.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+      stream.write(`  ${chalk8.dim("Cached Input:")} ${chalk8.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `);
     }
     if (model.knowledgeCutoff) {
-      stream.write(`  ${chalk6.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream.write(`  ${chalk8.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -2623,20 +3598,20 @@ function renderVerboseTable(models, stream) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream.write(`  ${chalk6.dim("Features:")}     ${chalk6.blue(features.join(", "))}
+      stream.write(`  ${chalk8.dim("Features:")}     ${chalk8.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream.write(`  ${chalk6.dim("Family:")}       ${model.metadata.family}
+        stream.write(`  ${chalk8.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream.write(`  ${chalk6.dim("Released:")}     ${model.metadata.releaseDate}
+        stream.write(`  ${chalk8.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream.write(`  ${chalk6.dim("Notes:")}        ${chalk6.italic(model.metadata.notes)}
+        stream.write(`  ${chalk8.dim("Notes:")}        ${chalk8.italic(model.metadata.notes)}
 `);
       }
     }
@@ -2688,7 +3663,7 @@ function registerModelsCommand(program, env) {
 init_client();
 init_logger();
 import readline from "node:readline";
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 var LOG_LEVEL_MAP = {
   silly: 0,
   trace: 1,
@@ -2729,22 +3704,22 @@ function createLoggerFactory(config) {
 }
 function createPromptFunction(stdin, stdout) {
   return (question) => {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const rl = readline.createInterface({
         input: stdin,
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk9.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(chalk7.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(chalk9.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk9.cyan("\u2500".repeat(60))}
 `);
-      rl.question(chalk7.green.bold("You: "), (answer) => {
+      rl.question(chalk9.green.bold("You: "), (answer) => {
         rl.close();
-        resolve(answer);
+        resolve2(answer);
       });
     });
   };