llmist 1.3.1 → 1.5.0

package/dist/cli.cjs

@@ -172,7 +172,7 @@ Example fixes:
     );
   }
 }
-function findUnknownTypes(schema, path2 = []) {
+function findUnknownTypes(schema, path5 = []) {
   const issues = [];
   if (!schema || typeof schema !== "object") {
     return issues;
@@ -184,7 +184,7 @@ function findUnknownTypes(schema, path2 = []) {
   }
   if (schema.properties) {
     for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      const propPath = [...path2, propName];
+      const propPath = [...path5, propName];
       if (hasNoType(propSchema)) {
         issues.push(propPath.join(".") || propName);
       }
@@ -192,7 +192,7 @@ function findUnknownTypes(schema, path2 = []) {
     }
   }
   if (schema.items) {
-    const itemPath = [...path2, "[]"];
+    const itemPath = [...path5, "[]"];
     if (hasNoType(schema.items)) {
       issues.push(itemPath.join("."));
     }
@@ -200,17 +200,17 @@ function findUnknownTypes(schema, path2 = []) {
   }
   if (schema.anyOf) {
     schema.anyOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path2, `anyOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path5, `anyOf[${index}]`]));
     });
   }
   if (schema.oneOf) {
     schema.oneOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path2, `oneOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path5, `oneOf[${index}]`]));
     });
   }
   if (schema.allOf) {
     schema.allOf.forEach((subSchema, index) => {
-      issues.push(...findUnknownTypes(subSchema, [...path2, `allOf[${index}]`]));
+      issues.push(...findUnknownTypes(subSchema, [...path5, `allOf[${index}]`]));
     });
   }
   return issues;
@@ -737,29 +737,29 @@ function schemaToJSONSchema(schema, options) {
 }
 function detectDescriptionMismatch(schema, jsonSchema) {
   const mismatches = [];
-  function checkSchema(zodSchema, json, path2) {
+  function checkSchema(zodSchema, json, path5) {
     if (!zodSchema || typeof zodSchema !== "object") return;
     const def = zodSchema._def;
     const jsonObj = json;
     if (def?.description && !jsonObj?.description) {
-      mismatches.push(path2 || "root");
+      mismatches.push(path5 || "root");
     }
     if (def?.typeName === "ZodObject" && def?.shape) {
       const shape = typeof def.shape === "function" ? def.shape() : def.shape;
       for (const [key, fieldSchema] of Object.entries(shape)) {
         const properties = jsonObj?.properties;
         const jsonProp = properties?.[key];
-        checkSchema(fieldSchema, jsonProp, path2 ? `${path2}.${key}` : key);
+        checkSchema(fieldSchema, jsonProp, path5 ? `${path5}.${key}` : key);
       }
     }
     if (def?.typeName === "ZodArray" && def?.type) {
-      checkSchema(def.type, jsonObj?.items, path2 ? `${path2}[]` : "[]");
+      checkSchema(def.type, jsonObj?.items, path5 ? `${path5}[]` : "[]");
     }
     if ((def?.typeName === "ZodOptional" || def?.typeName === "ZodNullable") && def?.innerType) {
-      checkSchema(def.innerType, json, path2);
+      checkSchema(def.innerType, json, path5);
     }
     if (def?.typeName === "ZodDefault" && def?.innerType) {
-      checkSchema(def.innerType, json, path2);
+      checkSchema(def.innerType, json, path5);
     }
   }
   checkSchema(schema, jsonSchema, "");
@@ -830,38 +830,83 @@ function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX)
   }
   return lines.join("\n");
 }
-function formatSchemaAsPlainText(schema, indent = "") {
+function formatParamLine(key, propObj, isRequired, indent = "") {
+  const type = propObj.type;
+  const description = propObj.description;
+  const enumValues = propObj.enum;
+  let line = `${indent}- ${key}`;
+  if (type === "array") {
+    const items = propObj.items;
+    const itemType = items?.type || "any";
+    line += ` (array of ${itemType})`;
+  } else if (type === "object" && propObj.properties) {
+    line += " (object)";
+  } else {
+    line += ` (${type})`;
+  }
+  if (isRequired && indent !== "") {
+    line += " [required]";
+  }
+  if (description) {
+    line += `: ${description}`;
+  }
+  if (enumValues) {
+    line += ` - one of: ${enumValues.map((v) => `"${v}"`).join(", ")}`;
+  }
+  return line;
+}
+function formatSchemaAsPlainText(schema, indent = "", atRoot = true) {
   const lines = [];
   const properties = schema.properties || {};
   const required = schema.required || [];
-  for (const [key, prop] of Object.entries(properties)) {
-    const propObj = prop;
-    const type = propObj.type;
-    const description = propObj.description;
-    const isRequired = required.includes(key);
-    const enumValues = propObj.enum;
-    let line = `${indent}- ${key}`;
-    if (type === "array") {
-      const items = propObj.items;
-      const itemType = items?.type || "any";
-      line += ` (array of ${itemType})`;
-    } else if (type === "object" && propObj.properties) {
-      line += " (object)";
-    } else {
-      line += ` (${type})`;
+  if (atRoot && indent === "") {
+    const requiredProps = [];
+    const optionalProps = [];
+    for (const [key, prop] of Object.entries(properties)) {
+      if (required.includes(key)) {
+        requiredProps.push([key, prop]);
+      } else {
+        optionalProps.push([key, prop]);
+      }
     }
-    if (isRequired) {
-      line += " [required]";
+    const reqCount = requiredProps.length;
+    const optCount = optionalProps.length;
+    if (reqCount > 0 || optCount > 0) {
+      const parts = [];
+      if (reqCount > 0) parts.push(`${reqCount} required`);
+      if (optCount > 0) parts.push(`${optCount} optional`);
+      lines.push(parts.join(", "));
+      lines.push("");
     }
-    if (description) {
-      line += `: ${description}`;
+    if (reqCount > 0) {
+      lines.push("REQUIRED Parameters:");
+      for (const [key, prop] of requiredProps) {
+        lines.push(formatParamLine(key, prop, true, ""));
+        const propObj = prop;
+        if (propObj.type === "object" && propObj.properties) {
+          lines.push(formatSchemaAsPlainText(propObj, "  ", false));
+        }
+      }
     }
-    if (enumValues) {
-      line += ` - one of: ${enumValues.map((v) => `"${v}"`).join(", ")}`;
+    if (optCount > 0) {
+      if (reqCount > 0) lines.push("");
+      lines.push("OPTIONAL Parameters:");
+      for (const [key, prop] of optionalProps) {
+        lines.push(formatParamLine(key, prop, false, ""));
+        const propObj = prop;
+        if (propObj.type === "object" && propObj.properties) {
+          lines.push(formatSchemaAsPlainText(propObj, "  ", false));
+        }
+      }
     }
-    lines.push(line);
-    if (type === "object" && propObj.properties) {
-      lines.push(formatSchemaAsPlainText(propObj, indent + "  "));
+    return lines.join("\n");
+  }
+  for (const [key, prop] of Object.entries(properties)) {
+    const isRequired = required.includes(key);
+    lines.push(formatParamLine(key, prop, isRequired, indent));
+    const propObj = prop;
+    if (propObj.type === "object" && propObj.properties) {
+      lines.push(formatSchemaAsPlainText(propObj, indent + "  ", false));
     }
   }
   return lines.join("\n");
@@ -912,10 +957,11 @@ var init_gadget = __esm({
        * Generate instruction text for the LLM.
        * Combines name, description, and parameter schema into a formatted instruction.
        *
-       * @param argPrefix - Optional custom argument prefix for block format examples
+       * @param optionsOrArgPrefix - Optional custom prefixes for examples, or just argPrefix string for backwards compatibility
        * @returns Formatted instruction string
        */
-      getInstruction(argPrefix) {
+      getInstruction(optionsOrArgPrefix) {
+        const options = typeof optionsOrArgPrefix === "string" ? { argPrefix: optionsOrArgPrefix } : optionsOrArgPrefix;
         const parts = [];
         parts.push(this.description);
         if (this.parameterSchema) {
@@ -929,18 +975,25 @@ var init_gadget = __esm({
         }
         if (this.examples && this.examples.length > 0) {
           parts.push("\n\nExamples:");
-          const effectiveArgPrefix = argPrefix ?? GADGET_ARG_PREFIX;
+          const effectiveArgPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
+          const effectiveStartPrefix = options?.startPrefix ?? GADGET_START_PREFIX;
+          const effectiveEndPrefix = options?.endPrefix ?? GADGET_END_PREFIX;
+          const gadgetName = this.name || this.constructor.name;
           this.examples.forEach((example, index) => {
             if (index > 0) {
               parts.push("");
+              parts.push("---");
+              parts.push("");
             }
             if (example.comment) {
               parts.push(`# ${example.comment}`);
             }
-            parts.push("Input:");
+            parts.push(`${effectiveStartPrefix}${gadgetName}`);
             parts.push(formatParamsAsBlock(example.params, "", effectiveArgPrefix));
+            parts.push(effectiveEndPrefix);
             if (example.output !== void 0) {
-              parts.push("Output:");
+              parts.push("");
+              parts.push("Expected Output:");
               parts.push(example.output);
             }
           });
@@ -2268,8 +2321,8 @@ var init_error_formatter = __esm({
         const parts = [];
         parts.push(`Error: Invalid parameters for '${gadgetName}':`);
         for (const issue of zodError.issues) {
-          const path2 = issue.path.join(".") || "root";
-          parts.push(`  - ${path2}: ${issue.message}`);
+          const path5 = issue.path.join(".") || "root";
+          parts.push(`  - ${path5}: ${issue.message}`);
         }
         parts.push("");
         parts.push("Gadget Usage:");
@@ -3250,6 +3303,8 @@ var init_agent = __esm({
       outputLimitCharLimit;
       // Context compaction
       compactionManager;
+      // Cancellation
+      signal;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -3317,6 +3372,7 @@ var init_agent = __esm({
             options.compactionConfig
           );
         }
+        this.signal = options.signal;
       }
       /**
        * Get the gadget registry for this agent.
@@ -3434,7 +3490,8 @@ var init_agent = __esm({
               model: this.model,
               messages: this.conversation.getMessages(),
               temperature: this.temperature,
-              maxTokens: this.defaultMaxTokens
+              maxTokens: this.defaultMaxTokens,
+              signal: this.signal
             };
             await this.safeObserve(async () => {
               if (this.hooks.observers?.onLLMCallStart) {
@@ -4052,7 +4109,7 @@ var init_base_provider = __esm({
       async *stream(options, descriptor, spec) {
         const preparedMessages = this.prepareMessages(options.messages);
         const payload = this.buildRequestPayload(options, descriptor, spec, preparedMessages);
-        const rawStream = await this.executeStreamRequest(payload);
+        const rawStream = await this.executeStreamRequest(payload, options.signal);
         yield* this.wrapStream(rawStream);
       }
       /**
@@ -4170,9 +4227,9 @@ var init_anthropic = __esm({
         };
         return payload;
       }
-      async executeStreamRequest(payload) {
+      async executeStreamRequest(payload, signal) {
         const client = this.client;
-        const stream2 = await client.messages.create(payload);
+        const stream2 = await client.messages.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
       async *wrapStream(iterable) {
@@ -4504,9 +4561,15 @@ var init_gemini = __esm({
           config
         };
       }
-      async executeStreamRequest(payload) {
+      async executeStreamRequest(payload, signal) {
         const client = this.client;
-        const streamResponse = await client.models.generateContentStream(payload);
+        const streamResponse = await client.models.generateContentStream({
+          ...payload,
+          config: {
+            ...payload.config,
+            ...signal ? { abortSignal: signal } : {}
+          }
+        });
         return streamResponse;
       }
       /**
@@ -5095,9 +5158,9 @@ var init_openai = __esm({
           ...shouldIncludeTemperature ? { temperature } : {}
         };
       }
-      async executeStreamRequest(payload) {
+      async executeStreamRequest(payload, signal) {
         const client = this.client;
-        const stream2 = await client.chat.completions.create(payload);
+        const stream2 = await client.chat.completions.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
       async *wrapStream(iterable) {
@@ -5760,6 +5823,7 @@ var init_builder = __esm({
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
       compactionConfig;
+      signal;
       constructor(client) {
         this.client = client;
       }
@@ -6206,6 +6270,35 @@ var init_builder = __esm({
         this.compactionConfig = { enabled: false };
         return this;
       }
+      /**
+       * Set an abort signal for cancelling requests mid-flight.
+       *
+       * When the signal is aborted, the current LLM request will be cancelled
+       * and the agent loop will exit gracefully.
+       *
+       * @param signal - AbortSignal from an AbortController
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * const controller = new AbortController();
+       *
+       * // Cancel after 30 seconds
+       * setTimeout(() => controller.abort(), 30000);
+       *
+       * const agent = LLMist.createAgent()
+       *   .withModel("sonnet")
+       *   .withSignal(controller.signal)
+       *   .ask("Write a long story");
+       *
+       * // Or cancel on user action
+       * document.getElementById("cancel").onclick = () => controller.abort();
+       * ```
+       */
+      withSignal(signal) {
+        this.signal = signal;
+        return this;
+      }
       /**
        * Add a synthetic gadget call to the conversation history.
        *
@@ -6322,7 +6415,8 @@ ${endPrefix}`
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
-          compactionConfig: this.compactionConfig
+          compactionConfig: this.compactionConfig,
+          signal: this.signal
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -6425,7 +6519,8 @@ ${endPrefix}`
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
-          compactionConfig: this.compactionConfig
+          compactionConfig: this.compactionConfig,
+          signal: this.signal
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -6484,7 +6579,7 @@ var import_commander2 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "1.3.0",
+  version: "1.4.0",
   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",
@@ -6568,6 +6663,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",
@@ -6584,6 +6680,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",
@@ -6597,12 +6694,274 @@ var package_default = {
 };
 
 // src/cli/agent-command.ts
-var import_promises2 = require("readline/promises");
-var import_chalk3 = __toESM(require("chalk"), 1);
+var import_promises3 = require("readline/promises");
+var import_chalk5 = __toESM(require("chalk"), 1);
 init_builder();
+
+// 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_constants2();
 
+// src/cli/approval/manager.ts
+var import_promises = require("readline/promises");
+var import_chalk2 = __toESM(require("chalk"), 1);
+
+// src/cli/approval/context-providers.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_diff = require("diff");
+
+// src/cli/approval/diff-renderer.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function renderColoredDiff(diff) {
+  return diff.split("\n").map((line) => {
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      return import_chalk.default.bold(line);
+    }
+    if (line.startsWith("+")) {
+      return import_chalk.default.green(line);
+    }
+    if (line.startsWith("-")) {
+      return import_chalk.default.red(line);
+    }
+    if (line.startsWith("@@")) {
+      return import_chalk.default.cyan(line);
+    }
+    return import_chalk.default.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 = (0, import_node_path2.resolve)(process.cwd(), filePath);
+    if (!(0, import_node_fs2.existsSync)(resolvedPath)) {
+      return {
+        summary: `Create new file: ${filePath}`,
+        details: formatNewFileDiff(filePath, newContent)
+      };
+    }
+    const oldContent = (0, import_node_fs2.readFileSync)(resolvedPath, "utf-8");
+    const diff = (0, import_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 = (0, import_node_path2.resolve)(process.cwd(), filePath);
+    if ("content" in params) {
+      const newContent = String(params.content);
+      if (!(0, import_node_fs2.existsSync)(resolvedPath)) {
+        return {
+          summary: `Create new file: ${filePath}`,
+          details: formatNewFileDiff(filePath, newContent)
+        };
+      }
+      const oldContent = (0, import_node_fs2.readFileSync)(resolvedPath, "utf-8");
+      const diff = (0, import_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(`
+${import_chalk2.default.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(`   ${import_chalk2.default.green("\u2713 Approved")}
+
+`);
+      return { approved: true };
+    }
+    this.env.stderr.write(`   ${import_chalk2.default.red("\u2717 Denied")}
+
+`);
+    return { approved: false, reason: response || "Rejected by user" };
+  }
+  /**
+   * Prompts for user input.
+   */
+  async prompt(message) {
+    const rl = (0, import_promises.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
 var import_zod2 = require("zod");
 init_create_gadget();
@@ -6682,11 +7041,483 @@ var finish = createGadget({
 var builtinGadgets = [askUser, tellUser, finish];
 
 // src/cli/gadgets.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 init_gadget();
+
+// src/cli/builtins/filesystem/list-directory.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_zod4 = require("zod");
+
+// src/index.ts
+var import_zod3 = require("zod");
+init_builder();
+init_event_handlers();
+
+// src/agent/index.ts
+init_conversation_manager();
+init_stream_processor();
+init_gadget_output_store();
+
+// src/agent/compaction/index.ts
+init_config();
+init_strategy();
+init_strategies();
+init_manager();
+
+// src/agent/hints.ts
+init_prompt_config();
+
+// src/index.ts
+init_client();
+init_messages();
+init_model_registry();
+init_model_shortcuts();
+init_options();
+init_prompt_config();
+init_quick_methods();
+init_create_gadget();
+init_output_viewer();
+init_exceptions();
+init_executor();
+init_gadget();
+init_parser();
+init_registry();
+
+// src/gadgets/typed-gadget.ts
+init_gadget();
+
+// src/index.ts
+init_logger();
+init_anthropic();
+init_discovery();
+init_gemini();
+init_openai();
+
+// src/testing/mock-manager.ts
+init_logger();
+
+// src/testing/mock-stream.ts
+init_constants();
+
+// src/testing/mock-client.ts
+init_client();
+
+// src/testing/mock-gadget.ts
+init_gadget();
+
+// src/testing/cli-helpers.ts
+var import_node_stream = require("stream");
+
+// src/cli/builtins/filesystem/utils.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+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 = import_node_path3.default.resolve(cwd, inputPath);
+  let finalPath;
+  try {
+    finalPath = import_node_fs3.default.realpathSync(resolvedPath);
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
+      finalPath = resolvedPath;
+    } else {
+      throw error;
+    }
+  }
+  const cwdWithSep = cwd + import_node_path3.default.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 = import_node_fs4.default.readdirSync(dirPath);
+    for (const item of items) {
+      const fullPath = import_node_path4.default.join(dirPath, item);
+      const relativePath = import_node_path4.default.relative(basePath, fullPath);
+      try {
+        const stats = import_node_fs4.default.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: import_zod4.z.object({
+    directoryPath: import_zod4.z.string().default(".").describe("Path to the directory to list"),
+    maxDepth: import_zod4.z.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 = import_node_fs4.default.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
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_zod5 = require("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: import_zod5.z.object({
+    filePath: import_zod5.z.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 = import_node_fs5.default.readFileSync(validatedPath, "utf-8");
+    return `path=${filePath}
+
+${content}`;
+  }
+});
+
+// src/cli/builtins/filesystem/write-file.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_zod6 = require("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: import_zod6.z.object({
+    filePath: import_zod6.z.string().describe("Path to the file to write (relative or absolute)"),
+    content: import_zod6.z.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 = import_node_path5.default.dirname(validatedPath);
+    let createdDir = false;
+    if (!import_node_fs6.default.existsSync(parentDir)) {
+      validatePathIsWithinCwd(parentDir);
+      import_node_fs6.default.mkdirSync(parentDir, { recursive: true });
+      createdDir = true;
+    }
+    import_node_fs6.default.writeFileSync(validatedPath, content, "utf-8");
+    const bytesWritten = Buffer.byteLength(content, "utf-8");
+    const dirNote = createdDir ? ` (created directory: ${import_node_path5.default.dirname(filePath)})` : "";
+    return `path=${filePath}
+
+Wrote ${bytesWritten} bytes${dirNote}`;
+  }
+});
+
+// src/cli/builtins/filesystem/edit-file.ts
+var import_zod7 = require("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: import_zod7.z.object({
+    filePath: import_zod7.z.string().describe("Path to the file to edit (relative or absolute)"),
+    commands: import_zod7.z.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
+var import_zod8 = require("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: import_zod8.z.object({
+    command: import_zod8.z.string().describe("The shell command to execute"),
+    cwd: import_zod8.z.string().optional().describe("Working directory for the command (default: current directory)"),
+    timeout: import_zod8.z.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;
@@ -6709,18 +7540,34 @@ function expandHomePath(input) {
   if (!home) {
     return input;
   }
-  return import_node_path2.default.join(home, input.slice(1));
+  return import_node_path6.default.join(home, input.slice(1));
 }
 function isFileLikeSpecifier(specifier) {
-  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(import_node_path2.default.sep);
+  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(import_node_path6.default.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 = import_node_path2.default.resolve(cwd, expanded);
-  if (!import_node_fs2.default.existsSync(resolvedPath)) {
+  const resolvedPath = import_node_path6.default.resolve(cwd, expanded);
+  if (!import_node_fs7.default.existsSync(resolvedPath)) {
     throw new Error(`Gadget module not found at ${resolvedPath}`);
   }
   return (0, import_node_url.pathToFileURL)(resolvedPath).href;
@@ -6762,6 +7609,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 exports2;
     try {
@@ -6786,13 +7638,13 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
 }
 
 // src/cli/llm-logging.ts
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_os = require("os");
-var import_node_path3 = require("path");
-var DEFAULT_LLM_LOG_DIR = (0, import_node_path3.join)((0, import_node_os.homedir)(), ".llmist", "logs");
+var import_node_path7 = require("path");
+var DEFAULT_LLM_LOG_DIR = (0, import_node_path7.join)((0, import_node_os.homedir)(), ".llmist", "logs");
 function resolveLogDir(option, subdir) {
   if (option === true) {
-    return (0, import_node_path3.join)(DEFAULT_LLM_LOG_DIR, subdir);
+    return (0, import_node_path7.join)(DEFAULT_LLM_LOG_DIR, subdir);
   }
   if (typeof option === "string") {
     return option;
@@ -6809,44 +7661,44 @@ function formatLlmRequest(messages) {
   return lines.join("\n");
 }
 async function writeLogFile(dir, filename, content) {
-  await (0, import_promises.mkdir)(dir, { recursive: true });
-  await (0, import_promises.writeFile)((0, import_node_path3.join)(dir, filename), content, "utf-8");
+  await (0, import_promises2.mkdir)(dir, { recursive: true });
+  await (0, import_promises2.writeFile)((0, import_node_path7.join)(dir, filename), content, "utf-8");
 }
 
 // src/cli/utils.ts
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 init_constants2();
 
 // src/cli/ui/formatters.ts
-var import_chalk = __toESM(require("chalk"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 var import_marked = require("marked");
 var import_marked_terminal = require("marked-terminal");
 var markedConfigured = false;
 function ensureMarkedConfigured() {
   if (!markedConfigured) {
-    import_chalk.default.level = process.env.NO_COLOR ? 0 : 3;
+    import_chalk3.default.level = process.env.NO_COLOR ? 0 : 3;
     import_marked.marked.use(
       (0, import_marked_terminal.markedTerminal)({
         // Text styling
-        strong: import_chalk.default.bold,
-        em: import_chalk.default.italic,
-        del: import_chalk.default.dim.gray.strikethrough,
+        strong: import_chalk3.default.bold,
+        em: import_chalk3.default.italic,
+        del: import_chalk3.default.dim.gray.strikethrough,
         // Code styling
-        code: import_chalk.default.yellow,
-        codespan: import_chalk.default.yellow,
+        code: import_chalk3.default.yellow,
+        codespan: import_chalk3.default.yellow,
         // Headings
-        heading: import_chalk.default.green.bold,
-        firstHeading: import_chalk.default.magenta.underline.bold,
+        heading: import_chalk3.default.green.bold,
+        firstHeading: import_chalk3.default.magenta.underline.bold,
         // Links
-        link: import_chalk.default.blue,
-        href: import_chalk.default.blue.underline,
+        link: import_chalk3.default.blue,
+        href: import_chalk3.default.blue.underline,
         // Block elements
-        blockquote: import_chalk.default.gray.italic,
+        blockquote: import_chalk3.default.gray.italic,
         // List formatting - reduce indentation and add bullet styling
         tab: 2,
         // Reduce from default 4 to 2 spaces
-        listitem: import_chalk.default.reset
+        listitem: import_chalk3.default.reset
         // Keep items readable (no dim)
       })
     );
@@ -6856,11 +7708,11 @@ function ensureMarkedConfigured() {
 function renderMarkdown(text) {
   ensureMarkedConfigured();
   let rendered = import_marked.marked.parse(text);
-  rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_, content) => import_chalk.default.bold(content)).replace(/(?<!\*)\*(\S[^*]*)\*(?!\*)/g, (_, content) => import_chalk.default.italic(content));
+  rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_, content) => import_chalk3.default.bold(content)).replace(/(?<!\*)\*(\S[^*]*)\*(?!\*)/g, (_, content) => import_chalk3.default.italic(content));
   return rendered.trimEnd();
 }
 function createRainbowSeparator() {
-  const colors = [import_chalk.default.red, import_chalk.default.yellow, import_chalk.default.green, import_chalk.default.cyan, import_chalk.default.blue, import_chalk.default.magenta];
+  const colors = [import_chalk3.default.red, import_chalk3.default.yellow, import_chalk3.default.green, import_chalk3.default.cyan, import_chalk3.default.blue, import_chalk3.default.magenta];
   const char = "\u2500";
   const width = process.stdout.columns || 80;
   let result = "";
@@ -6896,58 +7748,58 @@ function formatCost(cost) {
 function renderSummary(metadata) {
   const parts = [];
   if (metadata.iterations !== void 0) {
-    const iterPart = import_chalk.default.cyan(`#${metadata.iterations}`);
+    const iterPart = import_chalk3.default.cyan(`#${metadata.iterations}`);
     if (metadata.model) {
-      parts.push(`${iterPart} ${import_chalk.default.magenta(metadata.model)}`);
+      parts.push(`${iterPart} ${import_chalk3.default.magenta(metadata.model)}`);
     } else {
       parts.push(iterPart);
     }
   } else if (metadata.model) {
-    parts.push(import_chalk.default.magenta(metadata.model));
+    parts.push(import_chalk3.default.magenta(metadata.model));
   }
   if (metadata.usage) {
     const { inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens } = metadata.usage;
-    parts.push(import_chalk.default.dim("\u2191") + import_chalk.default.yellow(` ${formatTokens(inputTokens)}`));
+    parts.push(import_chalk3.default.dim("\u2191") + import_chalk3.default.yellow(` ${formatTokens(inputTokens)}`));
     if (cachedInputTokens && cachedInputTokens > 0) {
-      parts.push(import_chalk.default.dim("\u27F3") + import_chalk.default.blue(` ${formatTokens(cachedInputTokens)}`));
+      parts.push(import_chalk3.default.dim("\u27F3") + import_chalk3.default.blue(` ${formatTokens(cachedInputTokens)}`));
     }
     if (cacheCreationInputTokens && cacheCreationInputTokens > 0) {
-      parts.push(import_chalk.default.dim("\u270E") + import_chalk.default.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
+      parts.push(import_chalk3.default.dim("\u270E") + import_chalk3.default.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
     }
-    parts.push(import_chalk.default.dim("\u2193") + import_chalk.default.green(` ${formatTokens(outputTokens)}`));
+    parts.push(import_chalk3.default.dim("\u2193") + import_chalk3.default.green(` ${formatTokens(outputTokens)}`));
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
-    parts.push(import_chalk.default.dim(`${metadata.elapsedSeconds}s`));
+    parts.push(import_chalk3.default.dim(`${metadata.elapsedSeconds}s`));
   }
   if (metadata.cost !== void 0 && metadata.cost > 0) {
-    parts.push(import_chalk.default.cyan(`$${formatCost(metadata.cost)}`));
+    parts.push(import_chalk3.default.cyan(`$${formatCost(metadata.cost)}`));
   }
   if (metadata.finishReason) {
-    parts.push(import_chalk.default.dim(metadata.finishReason));
+    parts.push(import_chalk3.default.dim(metadata.finishReason));
   }
   if (parts.length === 0) {
     return null;
   }
-  return parts.join(import_chalk.default.dim(" | "));
+  return parts.join(import_chalk3.default.dim(" | "));
 }
 function renderOverallSummary(metadata) {
   const parts = [];
   if (metadata.totalTokens !== void 0 && metadata.totalTokens > 0) {
-    parts.push(import_chalk.default.dim("total:") + import_chalk.default.magenta(` ${formatTokens(metadata.totalTokens)}`));
+    parts.push(import_chalk3.default.dim("total:") + import_chalk3.default.magenta(` ${formatTokens(metadata.totalTokens)}`));
   }
   if (metadata.iterations !== void 0 && metadata.iterations > 0) {
-    parts.push(import_chalk.default.cyan(`#${metadata.iterations}`));
+    parts.push(import_chalk3.default.cyan(`#${metadata.iterations}`));
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
-    parts.push(import_chalk.default.dim(`${metadata.elapsedSeconds}s`));
+    parts.push(import_chalk3.default.dim(`${metadata.elapsedSeconds}s`));
   }
   if (metadata.cost !== void 0 && metadata.cost > 0) {
-    parts.push(import_chalk.default.cyan(`$${formatCost(metadata.cost)}`));
+    parts.push(import_chalk3.default.cyan(`$${formatCost(metadata.cost)}`));
   }
   if (parts.length === 0) {
     return null;
   }
-  return parts.join(import_chalk.default.dim(" | "));
+  return parts.join(import_chalk3.default.dim(" | "));
 }
 function formatParametersInline(params) {
   if (!params || Object.keys(params).length === 0) {
@@ -6963,8 +7815,8 @@ function formatParametersInline(params) {
       const json = JSON.stringify(value);
       formatted = json.length > 30 ? `${json.slice(0, 30)}\u2026` : json;
     }
-    return `${import_chalk.default.dim(key)}${import_chalk.default.dim("=")}${import_chalk.default.cyan(formatted)}`;
-  }).join(import_chalk.default.dim(", "));
+    return `${import_chalk3.default.dim(key)}${import_chalk3.default.dim("=")}${import_chalk3.default.cyan(formatted)}`;
+  }).join(import_chalk3.default.dim(", "));
 }
 function formatBytes(bytes) {
   if (bytes < 1024) {
@@ -6976,25 +7828,25 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 function formatGadgetSummary(result) {
-  const gadgetLabel = import_chalk.default.magenta.bold(result.gadgetName);
-  const timeLabel = import_chalk.default.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const gadgetLabel = import_chalk3.default.magenta.bold(result.gadgetName);
+  const timeLabel = import_chalk3.default.dim(`${Math.round(result.executionTimeMs)}ms`);
   const paramsStr = formatParametersInline(result.parameters);
-  const paramsLabel = paramsStr ? `${import_chalk.default.dim("(")}${paramsStr}${import_chalk.default.dim(")")}` : "";
+  const paramsLabel = paramsStr ? `${import_chalk3.default.dim("(")}${paramsStr}${import_chalk3.default.dim(")")}` : "";
   if (result.error) {
     const errorMsg = result.error.length > 50 ? `${result.error.slice(0, 50)}\u2026` : result.error;
-    return `${import_chalk.default.red("\u2717")} ${gadgetLabel}${paramsLabel} ${import_chalk.default.red("error:")} ${errorMsg} ${timeLabel}`;
+    return `${import_chalk3.default.red("\u2717")} ${gadgetLabel}${paramsLabel} ${import_chalk3.default.red("error:")} ${errorMsg} ${timeLabel}`;
   }
   let outputLabel;
   if (result.tokenCount !== void 0 && result.tokenCount > 0) {
-    outputLabel = import_chalk.default.green(`${formatTokens(result.tokenCount)} tokens`);
+    outputLabel = import_chalk3.default.green(`${formatTokens(result.tokenCount)} tokens`);
   } else if (result.result) {
     const outputBytes = Buffer.byteLength(result.result, "utf-8");
-    outputLabel = outputBytes > 0 ? import_chalk.default.green(formatBytes(outputBytes)) : import_chalk.default.dim("no output");
+    outputLabel = outputBytes > 0 ? import_chalk3.default.green(formatBytes(outputBytes)) : import_chalk3.default.dim("no output");
   } else {
-    outputLabel = import_chalk.default.dim("no output");
+    outputLabel = import_chalk3.default.dim("no output");
   }
-  const icon = result.breaksLoop ? import_chalk.default.yellow("\u23F9") : import_chalk.default.green("\u2713");
-  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${import_chalk.default.dim("\u2192")} ${outputLabel} ${timeLabel}`;
+  const icon = result.breaksLoop ? import_chalk3.default.yellow("\u23F9") : import_chalk3.default.green("\u2713");
+  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${import_chalk3.default.dim("\u2192")} ${outputLabel} ${timeLabel}`;
   if (result.gadgetName === "TellUser" && result.parameters?.message) {
     const message = String(result.parameters.message);
     const rendered = renderMarkdownWithSeparators(message);
@@ -7058,6 +7910,66 @@ var StreamPrinter = class {
 function isInteractive(stream2) {
   return Boolean(stream2.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(import_chalk4.default.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 {
@@ -7229,9 +8141,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 = import_chalk2.default.cyan(`#${this.currentIteration}`);
+    const iterPart = import_chalk4.default.cyan(`#${this.currentIteration}`);
     if (this.model) {
-      parts.push(`${iterPart} ${import_chalk2.default.magenta(this.model)}`);
+      parts.push(`${iterPart} ${import_chalk4.default.magenta(this.model)}`);
     } else {
       parts.push(iterPart);
     }
@@ -7239,27 +8151,27 @@ var StreamProgress = class {
     if (usagePercent !== null) {
       const formatted = `${Math.round(usagePercent)}%`;
       if (usagePercent >= 80) {
-        parts.push(import_chalk2.default.red(formatted));
+        parts.push(import_chalk4.default.red(formatted));
       } else if (usagePercent >= 50) {
-        parts.push(import_chalk2.default.yellow(formatted));
+        parts.push(import_chalk4.default.yellow(formatted));
       } else {
-        parts.push(import_chalk2.default.green(formatted));
+        parts.push(import_chalk4.default.green(formatted));
       }
     }
     if (this.callInputTokens > 0) {
       const prefix = this.callInputTokensEstimated ? "~" : "";
-      parts.push(import_chalk2.default.dim("\u2191") + import_chalk2.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
+      parts.push(import_chalk4.default.dim("\u2191") + import_chalk4.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
     }
     if (this.isStreaming || outTokens > 0) {
       const prefix = this.callOutputTokensEstimated ? "~" : "";
-      parts.push(import_chalk2.default.dim("\u2193") + import_chalk2.default.green(` ${prefix}${formatTokens(outTokens)}`));
+      parts.push(import_chalk4.default.dim("\u2193") + import_chalk4.default.green(` ${prefix}${formatTokens(outTokens)}`));
     }
-    parts.push(import_chalk2.default.dim(`${elapsed}s`));
+    parts.push(import_chalk4.default.dim(`${elapsed}s`));
     const callCost = this.calculateCurrentCallCost(outTokens);
     if (callCost > 0) {
-      parts.push(import_chalk2.default.cyan(`$${formatCost(callCost)}`));
+      parts.push(import_chalk4.default.cyan(`$${formatCost(callCost)}`));
     }
-    this.target.write(`\r${parts.join(import_chalk2.default.dim(" | "))} ${import_chalk2.default.cyan(spinner)}`);
+    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
   }
   /**
    * Calculates live cost estimate for the current streaming call.
@@ -7300,19 +8212,19 @@ var StreamProgress = class {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
     if (this.model) {
-      parts.push(import_chalk2.default.cyan(this.model));
+      parts.push(import_chalk4.default.cyan(this.model));
     }
     if (this.totalTokens > 0) {
-      parts.push(import_chalk2.default.dim("total:") + import_chalk2.default.magenta(` ${this.totalTokens}`));
+      parts.push(import_chalk4.default.dim("total:") + import_chalk4.default.magenta(` ${this.totalTokens}`));
     }
     if (this.iterations > 0) {
-      parts.push(import_chalk2.default.dim("iter:") + import_chalk2.default.blue(` ${this.iterations}`));
+      parts.push(import_chalk4.default.dim("iter:") + import_chalk4.default.blue(` ${this.iterations}`));
     }
     if (this.totalCost > 0) {
-      parts.push(import_chalk2.default.dim("cost:") + import_chalk2.default.cyan(` $${formatCost(this.totalCost)}`));
+      parts.push(import_chalk4.default.dim("cost:") + import_chalk4.default.cyan(` $${formatCost(this.totalCost)}`));
     }
-    parts.push(import_chalk2.default.dim(`${elapsed}s`));
-    this.target.write(`\r${parts.join(import_chalk2.default.dim(" | "))} ${import_chalk2.default.cyan(spinner)}`);
+    parts.push(import_chalk4.default.dim(`${elapsed}s`));
+    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
   }
   /**
    * Pauses the progress indicator and clears the line.
@@ -7346,6 +8258,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.
@@ -7360,28 +8291,28 @@ var StreamProgress = class {
       if (this.callInputTokens > 0) {
         const prefix = this.callInputTokensEstimated ? "~" : "";
         parts.push(
-          import_chalk2.default.dim("\u2191") + import_chalk2.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`)
+          import_chalk4.default.dim("\u2191") + import_chalk4.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`)
         );
       }
       if (outTokens > 0) {
         const prefix = outEstimated ? "~" : "";
-        parts.push(import_chalk2.default.dim("\u2193") + import_chalk2.default.green(` ${prefix}${formatTokens(outTokens)}`));
+        parts.push(import_chalk4.default.dim("\u2193") + import_chalk4.default.green(` ${prefix}${formatTokens(outTokens)}`));
       }
-      parts.push(import_chalk2.default.dim(`${elapsed}s`));
+      parts.push(import_chalk4.default.dim(`${elapsed}s`));
     } else {
       const elapsed = Math.round((Date.now() - this.totalStartTime) / 1e3);
       if (this.totalTokens > 0) {
-        parts.push(import_chalk2.default.magenta(formatTokens(this.totalTokens)));
+        parts.push(import_chalk4.default.magenta(formatTokens(this.totalTokens)));
       }
       if (this.iterations > 0) {
-        parts.push(import_chalk2.default.blue(`i${this.iterations}`));
+        parts.push(import_chalk4.default.blue(`i${this.iterations}`));
       }
       if (this.totalCost > 0) {
-        parts.push(import_chalk2.default.cyan(`$${formatCost(this.totalCost)}`));
+        parts.push(import_chalk4.default.cyan(`$${formatCost(this.totalCost)}`));
       }
-      parts.push(import_chalk2.default.dim(`${elapsed}s`));
+      parts.push(import_chalk4.default.dim(`${elapsed}s`));
     }
-    return `${parts.join(import_chalk2.default.dim(" | "))} ${import_chalk2.default.green(">")} `;
+    return `${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.green(">")} `;
   }
 };
 async function readStream(stream2) {
@@ -7416,7 +8347,7 @@ async function executeAction(action, env) {
     await action();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    env.stderr.write(`${import_chalk2.default.red.bold("Error:")} ${message}
+    env.stderr.write(`${import_chalk4.default.red.bold("Error:")} ${message}
 `);
     env.setExitCode(1);
   }
@@ -7441,7 +8372,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,
@@ -7477,7 +8408,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"];
@@ -7487,6 +8419,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"];
@@ -7494,23 +8428,18 @@ function configToAgentOptions(config) {
 }
 
 // src/cli/agent-command.ts
-async function promptApproval(env, prompt) {
-  const rl = (0, import_promises2.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 = (0, import_promises2.createInterface)({ input: env.stdin, output: env.stdout });
+    if (keyboard.cleanupEsc) {
+      keyboard.cleanupEsc();
+      keyboard.cleanupEsc = null;
+    }
+    const rl = (0, import_promises3.createInterface)({ input: env.stdin, output: env.stdout });
     try {
       const questionLine = question.trim() ? `
 ${renderMarkdownWithSeparators(question.trim())}` : "";
@@ -7528,6 +8457,7 @@ ${statsPrompt}` : statsPrompt;
       }
     } finally {
       rl.close();
+      keyboard.restore();
     }
   };
 }
@@ -7554,6 +8484,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(import_chalk5.default.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(`${import_chalk5.default.dim("\u2500".repeat(40))}
+`);
+      env.stderr.write(`${summary}
+`);
+    }
+    env.stderr.write(import_chalk5.default.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");
@@ -7581,6 +8582,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,
@@ -7614,6 +8616,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) {
@@ -7661,47 +8664,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: ${import_chalk3.default.cyan(command)}
-`);
-        const response = await promptApproval(env, "   \u23CE approve, or type to reject: ");
-        const isApproved = response === "" || response.toLowerCase() === "y";
-        if (!isApproved) {
-          env.stderr.write(`   ${import_chalk3.default.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(`   ${import_chalk3.default.green("\u2713 Approved")}
-`);
         return { action: "proceed" };
       }
     }
@@ -7715,10 +8724,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);
@@ -7756,31 +8766,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(`${import_chalk3.default.dim("\u2500".repeat(40))}
+    env.stderr.write(`${import_chalk5.default.dim("\u2500".repeat(40))}
 `);
     const summary = renderOverallSummary({
       totalTokens: usage?.totalTokens,
@@ -7798,7 +8818,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)
   );
 }
 
@@ -7882,9 +8908,9 @@ function registerCompleteCommand(program, env, config) {
 }
 
 // src/cli/config.ts
-var import_node_fs3 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path4 = require("path");
+var import_node_path8 = require("path");
 var import_js_toml = require("js-toml");
 
 // src/cli/templates.ts
@@ -7969,6 +8995,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([
@@ -7991,12 +9018,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",
@@ -8014,12 +9049,12 @@ var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "description"
 ]);
 function getConfigPath() {
-  return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".llmist", "cli.toml");
+  return (0, import_node_path8.join)((0, import_node_os2.homedir)(), ".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";
   }
 };
@@ -8075,6 +9110,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) {
@@ -8184,6 +9241,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);
   }
@@ -8218,6 +9284,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);
   }
@@ -8274,6 +9343,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);
   }
@@ -8308,6 +9386,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,
@@ -8363,12 +9444,12 @@ function validateConfig(raw, configPath) {
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_node_fs3.existsSync)(configPath)) {
+  if (!(0, import_node_fs8.existsSync)(configPath)) {
     return {};
   }
   let content;
   try {
-    content = (0, import_node_fs3.readFileSync)(configPath, "utf-8");
+    content = (0, import_node_fs8.readFileSync)(configPath, "utf-8");
   } catch (error) {
     throw new ConfigError(
       `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -8463,6 +9544,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();
@@ -8486,8 +9600,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;
@@ -8499,13 +9628,13 @@ function resolveInheritance(config, configPath) {
 }
 
 // src/cli/gadget-command.ts
-var import_chalk5 = __toESM(require("chalk"), 1);
+var import_chalk7 = __toESM(require("chalk"), 1);
 init_schema_to_json();
 init_schema_validator();
 
 // src/cli/gadget-prompts.ts
-var import_promises3 = require("readline/promises");
-var import_chalk4 = __toESM(require("chalk"), 1);
+var import_promises4 = require("readline/promises");
+var import_chalk6 = __toESM(require("chalk"), 1);
 init_schema_to_json();
 async function promptForParameters(schema, ctx) {
   if (!schema) {
@@ -8515,7 +9644,7 @@ async function promptForParameters(schema, ctx) {
   if (!jsonSchema.properties || Object.keys(jsonSchema.properties).length === 0) {
     return {};
   }
-  const rl = (0, import_promises3.createInterface)({ input: ctx.stdin, output: ctx.stdout });
+  const rl = (0, import_promises4.createInterface)({ input: ctx.stdin, output: ctx.stdout });
   const params = {};
   try {
     for (const [key, prop] of Object.entries(jsonSchema.properties)) {
@@ -8538,16 +9667,16 @@ ${issues}`);
 async function promptForField(rl, key, prop, required) {
   const isRequired = required.includes(key);
   const typeHint = formatTypeHint(prop);
-  const defaultHint = prop.default !== void 0 ? import_chalk4.default.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
-  const requiredMarker = isRequired ? import_chalk4.default.red("*") : "";
+  const defaultHint = prop.default !== void 0 ? import_chalk6.default.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
+  const requiredMarker = isRequired ? import_chalk6.default.red("*") : "";
   let prompt = `
-${import_chalk4.default.cyan.bold(key)}${requiredMarker}`;
+${import_chalk6.default.cyan.bold(key)}${requiredMarker}`;
   if (prop.description) {
-    prompt += import_chalk4.default.dim(` - ${prop.description}`);
+    prompt += import_chalk6.default.dim(` - ${prop.description}`);
   }
   prompt += `
   ${typeHint}${defaultHint}
-  ${import_chalk4.default.green(">")} `;
+  ${import_chalk6.default.green(">")} `;
   const answer = await rl.question(prompt);
   const trimmed = answer.trim();
   if (!trimmed) {
@@ -8563,20 +9692,20 @@ ${import_chalk4.default.cyan.bold(key)}${requiredMarker}`;
 }
 function formatTypeHint(prop) {
   if (prop.enum) {
-    return import_chalk4.default.yellow(`(${prop.enum.join(" | ")})`);
+    return import_chalk6.default.yellow(`(${prop.enum.join(" | ")})`);
   }
   if (prop.type === "array") {
     const items = prop.items;
     if (items?.enum) {
-      return import_chalk4.default.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
+      return import_chalk6.default.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
     }
     const itemType = items?.type ?? "any";
-    return import_chalk4.default.yellow(`(${itemType}[]) comma-separated`);
+    return import_chalk6.default.yellow(`(${itemType}[]) comma-separated`);
   }
   if (prop.type === "object" && prop.properties) {
-    return import_chalk4.default.yellow("(object) enter as JSON");
+    return import_chalk6.default.yellow("(object) enter as JSON");
   }
-  return import_chalk4.default.yellow(`(${prop.type ?? "any"})`);
+  return import_chalk6.default.yellow(`(${prop.type ?? "any"})`);
 }
 function parseValue(input, prop, key) {
   const type = prop.type;
@@ -8687,7 +9816,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(import_chalk5.default.cyan.bold(`
+  env.stderr.write(import_chalk7.default.cyan.bold(`
 \u{1F527} Running gadget: ${name}
 `));
   let params;
@@ -8698,7 +9827,7 @@ async function executeGadgetRun(file, options, env) {
       // Prompts go to stderr to keep stdout clean
     });
   } else {
-    env.stderr.write(import_chalk5.default.dim("Reading parameters from stdin...\n"));
+    env.stderr.write(import_chalk7.default.dim("Reading parameters from stdin...\n"));
     const stdinParams = await readStdinJson(env.stdin);
     if (gadget.parameterSchema) {
       const result2 = gadget.parameterSchema.safeParse(stdinParams);
@@ -8712,7 +9841,7 @@ ${issues}`);
       params = stdinParams;
     }
   }
-  env.stderr.write(import_chalk5.default.dim("\nExecuting...\n"));
+  env.stderr.write(import_chalk7.default.dim("\nExecuting...\n"));
   const startTime = Date.now();
   let result;
   try {
@@ -8734,7 +9863,7 @@ ${issues}`);
     throw new Error(`Execution failed: ${message}`);
   }
   const elapsed = Date.now() - startTime;
-  env.stderr.write(import_chalk5.default.green(`
+  env.stderr.write(import_chalk7.default.green(`
 \u2713 Completed in ${elapsed}ms
 
 `));
@@ -8770,37 +9899,37 @@ async function executeGadgetInfo(file, options, env) {
     return;
   }
   env.stdout.write("\n");
-  env.stdout.write(import_chalk5.default.cyan.bold(`${name}
+  env.stdout.write(import_chalk7.default.cyan.bold(`${name}
 `));
-  env.stdout.write(import_chalk5.default.cyan("\u2550".repeat(name.length)) + "\n\n");
-  env.stdout.write(import_chalk5.default.bold("Description:\n"));
+  env.stdout.write(import_chalk7.default.cyan("\u2550".repeat(name.length)) + "\n\n");
+  env.stdout.write(import_chalk7.default.bold("Description:\n"));
   env.stdout.write(`  ${gadget.description}
 
 `);
   if (gadget.parameterSchema) {
-    env.stdout.write(import_chalk5.default.bold("Parameters:\n"));
+    env.stdout.write(import_chalk7.default.bold("Parameters:\n"));
     const jsonSchema = schemaToJSONSchema(gadget.parameterSchema, { target: "draft-7" });
     env.stdout.write(formatSchemaAsText(jsonSchema, "  ") + "\n\n");
   } else {
-    env.stdout.write(import_chalk5.default.dim("No parameters required.\n\n"));
+    env.stdout.write(import_chalk7.default.dim("No parameters required.\n\n"));
   }
   if (gadget.timeoutMs) {
-    env.stdout.write(import_chalk5.default.bold("Timeout:\n"));
+    env.stdout.write(import_chalk7.default.bold("Timeout:\n"));
     env.stdout.write(`  ${gadget.timeoutMs}ms
 
 `);
   }
   if (gadget.examples && gadget.examples.length > 0) {
-    env.stdout.write(import_chalk5.default.bold("Examples:\n"));
+    env.stdout.write(import_chalk7.default.bold("Examples:\n"));
     for (const example of gadget.examples) {
       if (example.comment) {
-        env.stdout.write(import_chalk5.default.dim(`  # ${example.comment}
+        env.stdout.write(import_chalk7.default.dim(`  # ${example.comment}
 `));
       }
-      env.stdout.write(`  Input: ${import_chalk5.default.cyan(JSON.stringify(example.params))}
+      env.stdout.write(`  Input: ${import_chalk7.default.cyan(JSON.stringify(example.params))}
 `);
       if (example.output !== void 0) {
-        env.stdout.write(`  Output: ${import_chalk5.default.green(example.output)}
+        env.stdout.write(`  Output: ${import_chalk7.default.green(example.output)}
 `);
       }
       env.stdout.write("\n");
@@ -8833,27 +9962,27 @@ function formatSchemaAsText(schema, indent = "") {
     const isRequired = required.includes(key);
     const enumValues = prop.enum;
     const defaultValue = prop.default;
-    let line = `${indent}${import_chalk5.default.cyan(key)}`;
+    let line = `${indent}${import_chalk7.default.cyan(key)}`;
     if (isRequired) {
-      line += import_chalk5.default.red("*");
+      line += import_chalk7.default.red("*");
     }
     if (type === "array") {
       const items = prop.items;
       const itemType = items?.type || "any";
-      line += import_chalk5.default.dim(` (${itemType}[])`);
+      line += import_chalk7.default.dim(` (${itemType}[])`);
     } else if (type === "object" && prop.properties) {
-      line += import_chalk5.default.dim(" (object)");
+      line += import_chalk7.default.dim(" (object)");
     } else {
-      line += import_chalk5.default.dim(` (${type})`);
+      line += import_chalk7.default.dim(` (${type})`);
     }
     if (defaultValue !== void 0) {
-      line += import_chalk5.default.dim(` [default: ${JSON.stringify(defaultValue)}]`);
+      line += import_chalk7.default.dim(` [default: ${JSON.stringify(defaultValue)}]`);
     }
     if (description) {
       line += `: ${description}`;
     }
     if (enumValues) {
-      line += import_chalk5.default.yellow(` - one of: ${enumValues.join(", ")}`);
+      line += import_chalk7.default.yellow(` - one of: ${enumValues.join(", ")}`);
     }
     lines.push(line);
     if (type === "object" && prop.properties) {
@@ -8893,20 +10022,20 @@ async function executeGadgetValidate(file, env) {
       throw new Error(`Validation issues:
 ${issues.map((i) => `  - ${i}`).join("\n")}`);
     }
-    env.stdout.write(import_chalk5.default.green.bold("\n\u2713 Valid\n\n"));
-    env.stdout.write(import_chalk5.default.bold("Gadgets found:\n"));
+    env.stdout.write(import_chalk7.default.green.bold("\n\u2713 Valid\n\n"));
+    env.stdout.write(import_chalk7.default.bold("Gadgets found:\n"));
     for (const gadget of gadgets) {
       const name = gadget.name ?? gadget.constructor.name;
-      const schemaInfo = gadget.parameterSchema ? import_chalk5.default.cyan("(with schema)") : import_chalk5.default.dim("(no schema)");
-      env.stdout.write(`  ${import_chalk5.default.bold(name)} ${schemaInfo}
+      const schemaInfo = gadget.parameterSchema ? import_chalk7.default.cyan("(with schema)") : import_chalk7.default.dim("(no schema)");
+      env.stdout.write(`  ${import_chalk7.default.bold(name)} ${schemaInfo}
 `);
-      env.stdout.write(import_chalk5.default.dim(`    ${gadget.description}
+      env.stdout.write(import_chalk7.default.dim(`    ${gadget.description}
 `));
     }
     env.stdout.write("\n");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    env.stdout.write(import_chalk5.default.red.bold(`
+    env.stdout.write(import_chalk7.default.red.bold(`
 \u2717 Invalid
 
 `));
@@ -8930,7 +10059,7 @@ function registerGadgetCommand(program, env) {
 }
 
 // src/cli/models-command.ts
-var import_chalk6 = __toESM(require("chalk"), 1);
+var import_chalk8 = __toESM(require("chalk"), 1);
 init_model_shortcuts();
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -8950,13 +10079,13 @@ function renderTable(models, verbose, stream2) {
     }
     grouped.get(provider).push(model);
   }
-  stream2.write(import_chalk6.default.bold.cyan("\nAvailable Models\n"));
-  stream2.write(import_chalk6.default.cyan("=".repeat(80)) + "\n\n");
+  stream2.write(import_chalk8.default.bold.cyan("\nAvailable Models\n"));
+  stream2.write(import_chalk8.default.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);
-    stream2.write(import_chalk6.default.bold.yellow(`${providerName} Models
+    stream2.write(import_chalk8.default.bold.yellow(`${providerName} Models
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream2);
@@ -8965,11 +10094,11 @@ function renderTable(models, verbose, stream2) {
     }
     stream2.write("\n");
   }
-  stream2.write(import_chalk6.default.bold.magenta("Model Shortcuts\n"));
-  stream2.write(import_chalk6.default.dim("\u2500".repeat(80)) + "\n");
+  stream2.write(import_chalk8.default.bold.magenta("Model Shortcuts\n"));
+  stream2.write(import_chalk8.default.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) {
-    stream2.write(import_chalk6.default.cyan(`  ${shortcut.padEnd(15)}`) + import_chalk6.default.dim(" \u2192 ") + import_chalk6.default.white(fullName) + "\n");
+    stream2.write(import_chalk8.default.cyan(`  ${shortcut.padEnd(15)}`) + import_chalk8.default.dim(" \u2192 ") + import_chalk8.default.white(fullName) + "\n");
   }
   stream2.write("\n");
 }
@@ -8979,45 +10108,45 @@ function renderCompactTable(models, stream2) {
   const contextWidth = 13;
   const inputWidth = 10;
   const outputWidth = 10;
-  stream2.write(import_chalk6.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk8.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   stream2.write(
-    import_chalk6.default.bold(
+    import_chalk8.default.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
-  stream2.write(import_chalk6.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk8.default.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)}`;
     stream2.write(
-      import_chalk6.default.green(model.modelId.padEnd(idWidth)) + "  " + import_chalk6.default.white(model.displayName.padEnd(nameWidth)) + "  " + import_chalk6.default.yellow(contextFormatted.padEnd(contextWidth)) + "  " + import_chalk6.default.cyan(inputPrice.padEnd(inputWidth)) + "  " + import_chalk6.default.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      import_chalk8.default.green(model.modelId.padEnd(idWidth)) + "  " + import_chalk8.default.white(model.displayName.padEnd(nameWidth)) + "  " + import_chalk8.default.yellow(contextFormatted.padEnd(contextWidth)) + "  " + import_chalk8.default.cyan(inputPrice.padEnd(inputWidth)) + "  " + import_chalk8.default.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
-  stream2.write(import_chalk6.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
-  stream2.write(import_chalk6.default.dim(`  * Prices are per 1M tokens
+  stream2.write(import_chalk8.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk8.default.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream2) {
   for (const model of models) {
-    stream2.write(import_chalk6.default.bold.green(`
+    stream2.write(import_chalk8.default.bold.green(`
   ${model.modelId}
 `));
-    stream2.write(import_chalk6.default.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream2.write(`  ${import_chalk6.default.dim("Name:")}         ${import_chalk6.default.white(model.displayName)}
+    stream2.write(import_chalk8.default.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream2.write(`  ${import_chalk8.default.dim("Name:")}         ${import_chalk8.default.white(model.displayName)}
 `);
-    stream2.write(`  ${import_chalk6.default.dim("Context:")}      ${import_chalk6.default.yellow(formatTokens2(model.contextWindow))}
+    stream2.write(`  ${import_chalk8.default.dim("Context:")}      ${import_chalk8.default.yellow(formatTokens2(model.contextWindow))}
 `);
-    stream2.write(`  ${import_chalk6.default.dim("Max Output:")}   ${import_chalk6.default.yellow(formatTokens2(model.maxOutputTokens))}
+    stream2.write(`  ${import_chalk8.default.dim("Max Output:")}   ${import_chalk8.default.yellow(formatTokens2(model.maxOutputTokens))}
 `);
-    stream2.write(`  ${import_chalk6.default.dim("Pricing:")}      ${import_chalk6.default.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${import_chalk6.default.dim("/")} ${import_chalk6.default.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${import_chalk6.default.dim("(per 1M tokens)")}
+    stream2.write(`  ${import_chalk8.default.dim("Pricing:")}      ${import_chalk8.default.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${import_chalk8.default.dim("/")} ${import_chalk8.default.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${import_chalk8.default.dim("(per 1M tokens)")}
 `);
     if (model.pricing.cachedInput !== void 0) {
-      stream2.write(`  ${import_chalk6.default.dim("Cached Input:")} ${import_chalk6.default.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+      stream2.write(`  ${import_chalk8.default.dim("Cached Input:")} ${import_chalk8.default.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `);
     }
     if (model.knowledgeCutoff) {
-      stream2.write(`  ${import_chalk6.default.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream2.write(`  ${import_chalk8.default.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -9028,20 +10157,20 @@ function renderVerboseTable(models, stream2) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream2.write(`  ${import_chalk6.default.dim("Features:")}     ${import_chalk6.default.blue(features.join(", "))}
+      stream2.write(`  ${import_chalk8.default.dim("Features:")}     ${import_chalk8.default.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream2.write(`  ${import_chalk6.default.dim("Family:")}       ${model.metadata.family}
+        stream2.write(`  ${import_chalk8.default.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream2.write(`  ${import_chalk6.default.dim("Released:")}     ${model.metadata.releaseDate}
+        stream2.write(`  ${import_chalk8.default.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream2.write(`  ${import_chalk6.default.dim("Notes:")}        ${import_chalk6.default.italic(model.metadata.notes)}
+        stream2.write(`  ${import_chalk8.default.dim("Notes:")}        ${import_chalk8.default.italic(model.metadata.notes)}
 `);
       }
     }
@@ -9091,7 +10220,7 @@ function registerModelsCommand(program, env) {
 
 // src/cli/environment.ts
 var import_node_readline = __toESM(require("readline"), 1);
-var import_chalk7 = __toESM(require("chalk"), 1);
+var import_chalk9 = __toESM(require("chalk"), 1);
 init_client();
 init_logger();
 var LOG_LEVEL_MAP = {
@@ -9134,22 +10263,22 @@ function createLoggerFactory(config) {
 }
 function createPromptFunction(stdin, stdout) {
   return (question) => {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const rl = import_node_readline.default.createInterface({
         input: stdin,
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${import_chalk7.default.cyan("\u2500".repeat(60))}
+      stdout.write(`${import_chalk9.default.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(import_chalk7.default.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(import_chalk9.default.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${import_chalk7.default.cyan("\u2500".repeat(60))}
+      stdout.write(`${import_chalk9.default.cyan("\u2500".repeat(60))}
 `);
-      rl.question(import_chalk7.default.green.bold("You: "), (answer) => {
+      rl.question(import_chalk9.default.green.bold("You: "), (answer) => {
         rl.close();
-        resolve(answer);
+        resolve2(answer);
       });
     });
   };