llmist 0.4.1 → 0.5.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   createGadget
-} from "./chunk-QVDGTUQN.js";
+} from "./chunk-LKIBXQ5I.js";
 import {
   AgentBuilder,
   BaseGadget,
@@ -22,7 +22,7 @@ import {
   init_model_shortcuts,
   init_registry,
   resolveModel
-} from "./chunk-LQE7TKKW.js";
+} from "./chunk-MH4TQ5AD.js";
 
 // src/cli/constants.ts
 var CLI_NAME = "llmist";
@@ -34,7 +34,7 @@ var COMMANDS = {
 };
 var LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var DEFAULT_MODEL = "openai:gpt-5-nano";
-var DEFAULT_PARAMETER_FORMAT = "json";
+var DEFAULT_PARAMETER_FORMAT = "toml";
 var OPTION_FLAGS = {
   model: "-m, --model <identifier>",
   systemPrompt: "-s, --system <prompt>",
@@ -55,7 +55,7 @@ var OPTION_DESCRIPTIONS = {
   maxTokens: "Maximum number of output tokens requested from the model.",
   maxIterations: "Maximum number of agent loop iterations before exiting.",
   gadgetModule: "Path or module specifier for a gadget export. Repeat to register multiple gadgets.",
-  parameterFormat: "Format for gadget parameter schemas: 'json', 'yaml', or 'auto'.",
+  parameterFormat: "Format for gadget parameter schemas: 'json', 'yaml', 'toml', or 'auto'.",
   logLevel: "Log level: silly, trace, debug, info, warn, error, fatal.",
   logFile: "Path to log file. When set, logs are written to file instead of stderr.",
   noBuiltins: "Disable built-in gadgets (AskUser, TellUser).",
@@ -69,7 +69,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError3 } from "commande
 // package.json
 var package_default = {
   name: "llmist",
-  version: "0.4.0",
+  version: "0.4.1",
   description: "Universal TypeScript LLM client with streaming-first agent framework. Works with any model - no structured outputs or native tool calling required. Implements its own flexible grammar for function calling.",
   type: "module",
   main: "dist/index.cjs",
@@ -153,7 +153,10 @@ var package_default = {
     "@google/genai": "^1.27.0",
     chalk: "^5.6.2",
     commander: "^12.1.0",
+    "js-toml": "^1.0.2",
     "js-yaml": "^4.1.0",
+    marked: "^17.0.1",
+    "marked-terminal": "^7.3.0",
     openai: "^6.0.0",
     tiktoken: "^1.0.22",
     tslog: "^4.10.2",
@@ -166,6 +169,7 @@ var package_default = {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/js-yaml": "^4.0.9",
+    "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.12.7",
     "bun-types": "^1.3.2",
     dotenv: "^17.2.3",
@@ -181,7 +185,7 @@ init_builder();
 init_registry();
 init_constants();
 import { createInterface } from "node:readline/promises";
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import chalk3 from "chalk";
 
 // src/cli/builtin-gadgets.ts
 import { z } from "zod";
@@ -190,8 +194,20 @@ var askUser = createGadget({
   name: "AskUser",
   description: "Ask the user a question when you need more information or clarification. The user's response will be provided back to you.",
   schema: z.object({
-    question: z.string().describe("The question to ask the user")
+    question: z.string().describe("The question to ask the user in plain-text or Markdown")
   }),
+  examples: [
+    {
+      comment: "Ask for clarification about the task",
+      params: { question: "Which file would you like me to modify?" }
+    },
+    {
+      comment: "Ask user to choose between options",
+      params: {
+        question: "I found multiple matches. Which one should I use?\n- src/utils/helper.ts\n- src/lib/helper.ts"
+      }
+    }
+  ],
   execute: ({ question }) => {
     throw new HumanInputException(question);
   }
@@ -200,10 +216,28 @@ var tellUser = createGadget({
   name: "TellUser",
   description: "Tell the user something important. Set done=true when your work is complete and you want to end the conversation.",
   schema: z.object({
-    message: z.string().describe("The message to display to the user"),
-    done: z.boolean().describe("Set to true to end the conversation, false to continue"),
+    message: z.string().describe("The message to display to the user in Markdown"),
+    done: z.boolean().default(false).describe("Set to true to end the conversation, false to continue"),
     type: z.enum(["info", "success", "warning", "error"]).default("info").describe("Message type: info, success, warning, or error")
   }),
+  examples: [
+    {
+      comment: "Report successful completion and end the conversation",
+      params: {
+        message: "I've completed the refactoring. All tests pass.",
+        done: true,
+        type: "success"
+      }
+    },
+    {
+      comment: "Warn the user about something without ending",
+      params: {
+        message: "Found 3 files with potential issues. Continuing analysis...",
+        done: false,
+        type: "warning"
+      }
+    }
+  ],
   execute: ({ message, done, type }) => {
     const prefixes = {
       info: "\u2139\uFE0F  ",
@@ -316,6 +350,9 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
   return gadgets;
 }
 
+// src/cli/option-helpers.ts
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+
 // src/cli/utils.ts
 init_constants();
 import chalk2 from "chalk";
@@ -323,6 +360,44 @@ import { InvalidArgumentError } from "commander";
 
 // src/cli/ui/formatters.ts
 import chalk from "chalk";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+var markedConfigured = false;
+function ensureMarkedConfigured() {
+  if (!markedConfigured) {
+    chalk.level = process.env.NO_COLOR ? 0 : 3;
+    marked.use(
+      markedTerminal({
+        // Text styling
+        strong: chalk.bold,
+        em: chalk.italic,
+        del: chalk.dim.gray.strikethrough,
+        // Code styling
+        code: chalk.yellow,
+        codespan: chalk.yellow,
+        // Headings
+        heading: chalk.green.bold,
+        firstHeading: chalk.magenta.underline.bold,
+        // Links
+        link: chalk.blue,
+        href: chalk.blue.underline,
+        // Block elements
+        blockquote: chalk.gray.italic,
+        // List formatting - reduce indentation and add bullet styling
+        tab: 2,
+        // Reduce from default 4 to 2 spaces
+        listitem: chalk.reset
+        // Keep items readable (no dim)
+      })
+    );
+    markedConfigured = true;
+  }
+}
+function renderMarkdown(text) {
+  ensureMarkedConfigured();
+  const rendered = marked.parse(text);
+  return rendered.trimEnd();
+}
 function formatTokens(tokens) {
   return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : `${tokens}`;
 }
@@ -341,7 +416,14 @@ function formatCost(cost) {
 function renderSummary(metadata) {
   const parts = [];
   if (metadata.iterations !== void 0) {
-    parts.push(chalk.cyan(`#${metadata.iterations}`));
+    const iterPart = chalk.cyan(`#${metadata.iterations}`);
+    if (metadata.model) {
+      parts.push(`${iterPart} ${chalk.magenta(metadata.model)}`);
+    } else {
+      parts.push(iterPart);
+    }
+  } else if (metadata.model) {
+    parts.push(chalk.magenta(metadata.model));
   }
   if (metadata.usage) {
     const { inputTokens, outputTokens } = metadata.usage;
@@ -362,22 +444,128 @@ function renderSummary(metadata) {
   }
   return parts.join(chalk.dim(" | "));
 }
+function renderOverallSummary(metadata) {
+  const parts = [];
+  if (metadata.totalTokens !== void 0 && metadata.totalTokens > 0) {
+    parts.push(chalk.dim("total:") + chalk.magenta(` ${formatTokens(metadata.totalTokens)}`));
+  }
+  if (metadata.iterations !== void 0 && metadata.iterations > 0) {
+    parts.push(chalk.cyan(`#${metadata.iterations}`));
+  }
+  if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
+    parts.push(chalk.dim(`${metadata.elapsedSeconds}s`));
+  }
+  if (metadata.cost !== void 0 && metadata.cost > 0) {
+    parts.push(chalk.cyan(`$${formatCost(metadata.cost)}`));
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts.join(chalk.dim(" | "));
+}
+function formatParametersInline(params) {
+  if (!params || Object.keys(params).length === 0) {
+    return "";
+  }
+  return Object.entries(params).map(([key, value]) => {
+    let formatted;
+    if (typeof value === "string") {
+      formatted = value.length > 30 ? `${value.slice(0, 30)}\u2026` : value;
+    } else if (typeof value === "boolean" || typeof value === "number") {
+      formatted = String(value);
+    } else {
+      const json = JSON.stringify(value);
+      formatted = json.length > 30 ? `${json.slice(0, 30)}\u2026` : json;
+    }
+    return `${chalk.dim(key)}${chalk.dim("=")}${chalk.cyan(formatted)}`;
+  }).join(chalk.dim(", "));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} bytes`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 function formatGadgetSummary(result) {
   const gadgetLabel = chalk.magenta.bold(result.gadgetName);
   const timeLabel = chalk.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const paramsStr = formatParametersInline(result.parameters);
+  const paramsLabel = paramsStr ? `${chalk.dim("(")}${paramsStr}${chalk.dim(")")}` : "";
   if (result.error) {
-    return `${chalk.red("\u2717")} ${gadgetLabel} ${chalk.red("error:")} ${result.error} ${timeLabel}`;
+    const errorMsg = result.error.length > 50 ? `${result.error.slice(0, 50)}\u2026` : result.error;
+    return `${chalk.red("\u2717")} ${gadgetLabel}${paramsLabel} ${chalk.red("error:")} ${errorMsg} ${timeLabel}`;
+  }
+  let outputLabel;
+  if (result.tokenCount !== void 0 && result.tokenCount > 0) {
+    outputLabel = chalk.green(`${formatTokens(result.tokenCount)} tokens`);
+  } else if (result.result) {
+    const outputBytes = Buffer.byteLength(result.result, "utf-8");
+    outputLabel = outputBytes > 0 ? chalk.green(formatBytes(outputBytes)) : chalk.dim("no output");
+  } else {
+    outputLabel = chalk.dim("no output");
   }
-  if (result.breaksLoop) {
-    return `${chalk.yellow("\u23F9")} ${gadgetLabel} ${chalk.yellow("finished:")} ${result.result} ${timeLabel}`;
+  const icon = result.breaksLoop ? chalk.yellow("\u23F9") : chalk.green("\u2713");
+  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${chalk.dim("\u2192")} ${outputLabel} ${timeLabel}`;
+  if (result.gadgetName === "TellUser" && result.parameters?.message) {
+    const message = String(result.parameters.message);
+    const rendered = renderMarkdown(message);
+    return `${summaryLine}
+${rendered}`;
   }
-  const maxLen = 80;
-  const shouldTruncate = result.gadgetName !== "TellUser";
-  const resultText = result.result ? shouldTruncate && result.result.length > maxLen ? `${result.result.slice(0, maxLen)}...` : result.result : "";
-  return `${chalk.green("\u2713")} ${gadgetLabel} ${chalk.dim("\u2192")} ${resultText} ${timeLabel}`;
+  return summaryLine;
 }
 
 // src/cli/utils.ts
+var RARE_EMOJI = [
+  "\u{1F531}",
+  "\u2697\uFE0F",
+  "\u{1F9FF}",
+  "\u{1F530}",
+  "\u269B\uFE0F",
+  "\u{1F3FA}",
+  "\u{1F9EB}",
+  "\u{1F52C}",
+  "\u2695\uFE0F",
+  "\u{1F5DD}\uFE0F",
+  "\u2696\uFE0F",
+  "\u{1F52E}",
+  "\u{1FAAC}",
+  "\u{1F9EC}",
+  "\u2699\uFE0F",
+  "\u{1F529}",
+  "\u{1FA9B}",
+  "\u26CF\uFE0F",
+  "\u{1FA83}",
+  "\u{1F3F9}",
+  "\u{1F6E1}\uFE0F",
+  "\u2694\uFE0F",
+  "\u{1F5E1}\uFE0F",
+  "\u{1FA93}",
+  "\u{1F5C3}\uFE0F",
+  "\u{1F4DC}",
+  "\u{1F4EF}",
+  "\u{1F3B4}",
+  "\u{1F004}",
+  "\u{1F3B2}"
+];
+function generateMarkers() {
+  const pick = (count) => {
+    const result = [];
+    const pool = [...RARE_EMOJI];
+    for (let i = 0; i < count && pool.length > 0; i++) {
+      const idx = Math.floor(Math.random() * pool.length);
+      result.push(pool.splice(idx, 1)[0]);
+    }
+    return result.join("");
+  };
+  return {
+    startPrefix: pick(5),
+    endPrefix: pick(5)
+  };
+}
 function createNumericParser({
   label,
   integer = false,
@@ -544,6 +732,13 @@ var StreamProgress = class {
     if (this.totalStartTime === 0) return 0;
     return Number(((Date.now() - this.totalStartTime) / 1e3).toFixed(1));
   }
+  /**
+   * Get elapsed time in seconds for the current call.
+   * @returns Elapsed time in seconds with 1 decimal place
+   */
+  getCallElapsedSeconds() {
+    return Number(((Date.now() - this.callStartTime) / 1e3).toFixed(1));
+  }
   /**
    * Starts the progress indicator animation after a brief delay.
    */
@@ -578,7 +773,12 @@ 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 = [];
-    parts.push(chalk2.cyan(`#${this.currentIteration}`));
+    const iterPart = chalk2.cyan(`#${this.currentIteration}`);
+    if (this.model) {
+      parts.push(`${iterPart} ${chalk2.magenta(this.model)}`);
+    } else {
+      parts.push(iterPart);
+    }
     if (this.callInputTokens > 0) {
       const prefix = this.callInputTokensEstimated ? "~" : "";
       parts.push(chalk2.dim("\u2191") + chalk2.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
@@ -591,7 +791,7 @@ var StreamProgress = class {
     if (this.totalCost > 0) {
       parts.push(chalk2.cyan(`$${formatCost(this.totalCost)}`));
     }
-    this.target.write(`\r${chalk2.cyan(spinner)} ${parts.join(chalk2.dim(" | "))}`);
+    this.target.write(`\r${parts.join(chalk2.dim(" | "))} ${chalk2.cyan(spinner)}`);
   }
   renderCumulativeMode(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
@@ -609,7 +809,7 @@ var StreamProgress = class {
       parts.push(chalk2.dim("cost:") + chalk2.cyan(` $${formatCost(this.totalCost)}`));
     }
     parts.push(chalk2.dim(`${elapsed}s`));
-    this.target.write(`\r${chalk2.cyan(spinner)} ${parts.join(chalk2.dim(" | "))}`);
+    this.target.write(`\r${parts.join(chalk2.dim(" | "))} ${chalk2.cyan(spinner)}`);
   }
   /**
    * Pauses the progress indicator and clears the line.
@@ -719,15 +919,91 @@ async function executeAction(action, env) {
   }
 }
 
-// src/cli/agent-command.ts
-var PARAMETER_FORMAT_VALUES = ["json", "yaml", "auto"];
+// src/cli/option-helpers.ts
+var PARAMETER_FORMAT_VALUES = ["json", "yaml", "toml", "auto"];
 function parseParameterFormat(value) {
   const normalized = value.toLowerCase();
   if (!PARAMETER_FORMAT_VALUES.includes(normalized)) {
-    throw new InvalidArgumentError2("Parameter format must be one of 'json', 'yaml', or 'auto'.");
+    throw new InvalidArgumentError2(
+      `Parameter format must be one of: ${PARAMETER_FORMAT_VALUES.join(", ")}`
+    );
   }
   return normalized;
 }
+function addCompleteOptions(cmd, defaults) {
+  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,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 }),
+    defaults?.temperature
+  ).option(
+    OPTION_FLAGS.maxTokens,
+    OPTION_DESCRIPTIONS.maxTokens,
+    createNumericParser({ label: "Max tokens", integer: true, min: 1 }),
+    defaults?.["max-tokens"]
+  );
+}
+function addAgentOptions(cmd, defaults) {
+  const gadgetAccumulator = (value, previous = []) => [
+    ...previous,
+    value
+  ];
+  const defaultGadgets = 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,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 }),
+    defaults?.temperature
+  ).option(
+    OPTION_FLAGS.maxIterations,
+    OPTION_DESCRIPTIONS.maxIterations,
+    createNumericParser({ label: "Max iterations", integer: true, min: 1 }),
+    defaults?.["max-iterations"]
+  ).option(OPTION_FLAGS.gadgetModule, OPTION_DESCRIPTIONS.gadgetModule, gadgetAccumulator, [
+    ...defaultGadgets
+  ]).option(
+    OPTION_FLAGS.parameterFormat,
+    OPTION_DESCRIPTIONS.parameterFormat,
+    parseParameterFormat,
+    defaults?.["parameter-format"] ?? DEFAULT_PARAMETER_FORMAT
+  ).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins, defaults?.builtins !== false).option(
+    OPTION_FLAGS.noBuiltinInteraction,
+    OPTION_DESCRIPTIONS.noBuiltinInteraction,
+    defaults?.["builtin-interaction"] !== false
+  );
+}
+function configToCompleteOptions(config) {
+  const result = {};
+  if (config.model !== void 0) result.model = config.model;
+  if (config.system !== void 0) result.system = config.system;
+  if (config.temperature !== void 0) result.temperature = config.temperature;
+  if (config["max-tokens"] !== void 0) result.maxTokens = config["max-tokens"];
+  return result;
+}
+function configToAgentOptions(config) {
+  const result = {};
+  if (config.model !== void 0) result.model = config.model;
+  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;
+  if (config["parameter-format"] !== void 0) result.parameterFormat = config["parameter-format"];
+  if (config.builtins !== void 0) result.builtins = config.builtins;
+  if (config["builtin-interaction"] !== void 0)
+    result.builtinInteraction = config["builtin-interaction"];
+  return result;
+}
+
+// src/cli/agent-command.ts
+async function promptApproval(env, prompt) {
+  const rl = createInterface({ input: env.stdin, output: env.stderr });
+  try {
+    const answer = await rl.question(prompt);
+    return answer.toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
 function createHumanInputHandler(env, progress) {
   const stdout = env.stdout;
   if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
@@ -738,7 +1014,7 @@ function createHumanInputHandler(env, progress) {
     const rl = createInterface({ input: env.stdin, output: env.stdout });
     try {
       const questionLine = question.trim() ? `
-${question.trim()}` : "";
+${renderMarkdown(question.trim())}` : "";
       let isFirst = true;
       while (true) {
         const statsPrompt = progress.formatPrompt();
@@ -756,7 +1032,7 @@ ${statsPrompt}` : statsPrompt;
     }
   };
 }
-async function handleAgentCommand(promptArg, options, env) {
+async function executeAgent(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
   const registry = new GadgetRegistry();
@@ -778,7 +1054,6 @@ async function handleAgentCommand(promptArg, options, env) {
   const printer = new StreamPrinter(env.stdout);
   const stderrTTY = env.stderr.isTTY === true;
   const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
-  let finishReason;
   let usage;
   let iterations = 0;
   const countMessagesTokens = async (model, messages) => {
@@ -789,6 +1064,15 @@ async function handleAgentCommand(promptArg, options, env) {
       return Math.round(totalChars / FALLBACK_CHARS_PER_TOKEN);
     }
   };
+  const countGadgetOutputTokens = async (output) => {
+    if (!output) return void 0;
+    try {
+      const messages = [{ role: "assistant", content: output }];
+      return await client.countTokens(options.model, messages);
+    } catch {
+      return void 0;
+    }
+  };
   const builder = new AgentBuilder(client).withModel(options.model).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
     observers: {
       // onLLMCallStart: Start progress indicator for each LLM call
@@ -817,7 +1101,6 @@ async function handleAgentCommand(promptArg, options, env) {
       // onLLMCallComplete: Finalize metrics after each LLM call
       // This is where you'd typically log metrics or update dashboards
       onLLMCallComplete: async (context) => {
-        finishReason = context.finishReason;
         usage = context.usage;
         iterations = Math.max(iterations, context.iteration + 1);
         if (context.usage) {
@@ -828,7 +1111,76 @@ async function handleAgentCommand(promptArg, options, env) {
             progress.setOutputTokens(context.usage.outputTokens, false);
           }
         }
+        let callCost;
+        if (context.usage && client.modelRegistry) {
+          try {
+            const modelName = options.model.includes(":") ? options.model.split(":")[1] : options.model;
+            const costResult = client.modelRegistry.estimateCost(
+              modelName,
+              context.usage.inputTokens,
+              context.usage.outputTokens
+            );
+            if (costResult) callCost = costResult.totalCost;
+          } catch {
+          }
+        }
+        const callElapsed = progress.getCallElapsedSeconds();
         progress.endCall(context.usage);
+        if (stderrTTY) {
+          const summary = renderSummary({
+            iterations: context.iteration + 1,
+            model: options.model,
+            usage: context.usage,
+            elapsedSeconds: callElapsed,
+            cost: callCost,
+            finishReason: context.finishReason
+          });
+          if (summary) {
+            env.stderr.write(`${summary}
+`);
+          }
+        }
+      }
+    },
+    // SHOWCASE: Controller-based approval gating for dangerous 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.
+    //
+    // This pattern is composable: you can apply the same gating logic to
+    // any gadget (DeleteFile, SendEmail, etc.) without changing the gadgets.
+    controllers: {
+      beforeGadgetExecution: async (ctx) => {
+        if (ctx.gadgetName !== "RunCommand") {
+          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(`
+${chalk3.yellow("\u{1F512} Execute:")} ${command}
+`);
+        const approved = await promptApproval(env, "   Approve? [y/n] ");
+        if (!approved) {
+          env.stderr.write(`   ${chalk3.red("\u2717 Denied")}
+
+`);
+          return {
+            action: "skip",
+            syntheticResult: "status=denied\n\nCommand denied by user. Ask what they'd like to do instead."
+          };
+        }
+        env.stderr.write(`   ${chalk3.green("\u2713 Approved")}
+`);
+        return { action: "proceed" };
       }
     }
   });
@@ -849,6 +1201,10 @@ async function handleAgentCommand(promptArg, options, env) {
   if (gadgets.length > 0) {
     builder.withGadgets(...gadgets);
   }
+  builder.withParameterFormat(options.parameterFormat);
+  const markers = generateMarkers();
+  builder.withGadgetStartPrefix(markers.startPrefix);
+  builder.withGadgetEndPrefix(markers.endPrefix);
   const agent = builder.ask(prompt);
   for await (const event of agent.run()) {
     if (event.type === "text") {
@@ -857,20 +1213,22 @@ async function handleAgentCommand(promptArg, options, env) {
     } else if (event.type === "gadget_result") {
       progress.pause();
       if (stderrTTY) {
-        env.stderr.write(`${formatGadgetSummary(event.result)}
+        const tokenCount = await countGadgetOutputTokens(event.result.result);
+        env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
 `);
       }
     }
   }
   progress.complete();
   printer.ensureNewline();
-  if (stderrTTY) {
-    const summary = renderSummary({
-      finishReason,
-      usage,
+  if (stderrTTY && iterations > 1) {
+    env.stderr.write(`${chalk3.dim("\u2500".repeat(40))}
+`);
+    const summary = renderOverallSummary({
+      totalTokens: usage?.totalTokens,
       iterations,
-      cost: progress.getTotalCost(),
-      elapsedSeconds: progress.getTotalElapsedSeconds()
+      elapsedSeconds: progress.getTotalElapsedSeconds(),
+      cost: progress.getTotalCost()
     });
     if (summary) {
       env.stderr.write(`${summary}
@@ -878,27 +1236,11 @@ async function handleAgentCommand(promptArg, options, env) {
     }
   }
 }
-function registerAgentCommand(program, env) {
-  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.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
-    OPTION_FLAGS.temperature,
-    OPTION_DESCRIPTIONS.temperature,
-    createNumericParser({ label: "Temperature", min: 0, max: 2 })
-  ).option(
-    OPTION_FLAGS.maxIterations,
-    OPTION_DESCRIPTIONS.maxIterations,
-    createNumericParser({ label: "Max iterations", integer: true, min: 1 })
-  ).option(
-    OPTION_FLAGS.gadgetModule,
-    OPTION_DESCRIPTIONS.gadgetModule,
-    (value, previous = []) => [...previous, value],
-    []
-  ).option(
-    OPTION_FLAGS.parameterFormat,
-    OPTION_DESCRIPTIONS.parameterFormat,
-    parseParameterFormat,
-    DEFAULT_PARAMETER_FORMAT
-  ).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins).option(OPTION_FLAGS.noBuiltinInteraction, OPTION_DESCRIPTIONS.noBuiltinInteraction).action(
-    (prompt, options) => executeAction(() => handleAgentCommand(prompt, options, env), env)
+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)
   );
 }
 
@@ -906,7 +1248,7 @@ function registerAgentCommand(program, env) {
 init_messages();
 init_model_shortcuts();
 init_constants();
-async function handleCompleteCommand(promptArg, options, env) {
+async function executeComplete(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
   const model = resolveModel(options.model);
@@ -960,25 +1302,307 @@ async function handleCompleteCommand(promptArg, options, env) {
     }
   }
 }
-function registerCompleteCommand(program, env) {
-  program.command(COMMANDS.complete).description("Stream a single completion from a specified model.").argument("[prompt]", "Prompt to send to the LLM. If omitted, stdin is used when available.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
-    OPTION_FLAGS.temperature,
-    OPTION_DESCRIPTIONS.temperature,
-    createNumericParser({ label: "Temperature", min: 0, max: 2 })
-  ).option(
-    OPTION_FLAGS.maxTokens,
-    OPTION_DESCRIPTIONS.maxTokens,
-    createNumericParser({ label: "Max tokens", integer: true, min: 1 })
-  ).action(
-    (prompt, options) => executeAction(
-      () => handleCompleteCommand(prompt, options, env),
-      env
-    )
+function registerCompleteCommand(program, env, config) {
+  const cmd = program.command(COMMANDS.complete).description("Stream a single completion from a specified model.").argument("[prompt]", "Prompt to send to the LLM. If omitted, stdin is used when available.");
+  addCompleteOptions(cmd, config);
+  cmd.action(
+    (prompt, options) => executeAction(() => executeComplete(prompt, options, env), env)
   );
 }
 
+// src/cli/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { load as parseToml } from "js-toml";
+var GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["log-level", "log-file"]);
+var VALID_LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
+var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set(["model", "system", "temperature", "max-tokens"]);
+var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "system",
+  "temperature",
+  "max-iterations",
+  "gadget",
+  "parameter-format",
+  "builtins",
+  "builtin-interaction"
+]);
+var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  ...COMPLETE_CONFIG_KEYS,
+  ...AGENT_CONFIG_KEYS,
+  "type",
+  "description"
+]);
+var VALID_PARAMETER_FORMATS = ["json", "yaml", "toml", "auto"];
+function getConfigPath() {
+  return join(homedir(), ".llmist", "cli.toml");
+}
+var ConfigError = class extends Error {
+  constructor(message, path2) {
+    super(path2 ? `${path2}: ${message}` : message);
+    this.path = path2;
+    this.name = "ConfigError";
+  }
+};
+function validateString(value, key, section) {
+  if (typeof value !== "string") {
+    throw new ConfigError(`[${section}].${key} must be a string`);
+  }
+  return value;
+}
+function validateNumber(value, key, section, opts) {
+  if (typeof value !== "number") {
+    throw new ConfigError(`[${section}].${key} must be a number`);
+  }
+  if (opts?.integer && !Number.isInteger(value)) {
+    throw new ConfigError(`[${section}].${key} must be an integer`);
+  }
+  if (opts?.min !== void 0 && value < opts.min) {
+    throw new ConfigError(`[${section}].${key} must be >= ${opts.min}`);
+  }
+  if (opts?.max !== void 0 && value > opts.max) {
+    throw new ConfigError(`[${section}].${key} must be <= ${opts.max}`);
+  }
+  return value;
+}
+function validateBoolean(value, key, section) {
+  if (typeof value !== "boolean") {
+    throw new ConfigError(`[${section}].${key} must be a boolean`);
+  }
+  return value;
+}
+function validateStringArray(value, key, section) {
+  if (!Array.isArray(value)) {
+    throw new ConfigError(`[${section}].${key} must be an array`);
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] !== "string") {
+      throw new ConfigError(`[${section}].${key}[${i}] must be a string`);
+    }
+  }
+  return value;
+}
+function validateBaseConfig(raw, section) {
+  const result = {};
+  if ("model" in raw) {
+    result.model = validateString(raw.model, "model", section);
+  }
+  if ("system" in raw) {
+    result.system = validateString(raw.system, "system", section);
+  }
+  if ("temperature" in raw) {
+    result.temperature = validateNumber(raw.temperature, "temperature", section, {
+      min: 0,
+      max: 2
+    });
+  }
+  return result;
+}
+function validateGlobalConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!GLOBAL_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = {};
+  if ("log-level" in rawObj) {
+    const level = validateString(rawObj["log-level"], "log-level", section);
+    if (!VALID_LOG_LEVELS.includes(level)) {
+      throw new ConfigError(
+        `[${section}].log-level must be one of: ${VALID_LOG_LEVELS.join(", ")}`
+      );
+    }
+    result["log-level"] = level;
+  }
+  if ("log-file" in rawObj) {
+    result["log-file"] = validateString(rawObj["log-file"], "log-file", section);
+  }
+  return result;
+}
+function validateCompleteConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!COMPLETE_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = { ...validateBaseConfig(rawObj, section) };
+  if ("max-tokens" in rawObj) {
+    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  return result;
+}
+function validateAgentConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!AGENT_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = { ...validateBaseConfig(rawObj, section) };
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  if ("gadget" in rawObj) {
+    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
+  }
+  if ("parameter-format" in rawObj) {
+    const format = validateString(rawObj["parameter-format"], "parameter-format", section);
+    if (!VALID_PARAMETER_FORMATS.includes(format)) {
+      throw new ConfigError(
+        `[${section}].parameter-format must be one of: ${VALID_PARAMETER_FORMATS.join(", ")}`
+      );
+    }
+    result["parameter-format"] = format;
+  }
+  if ("builtins" in rawObj) {
+    result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
+  }
+  if ("builtin-interaction" in rawObj) {
+    result["builtin-interaction"] = validateBoolean(
+      rawObj["builtin-interaction"],
+      "builtin-interaction",
+      section
+    );
+  }
+  return result;
+}
+function validateCustomConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!CUSTOM_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  let type = "agent";
+  if ("type" in rawObj) {
+    const typeValue = validateString(rawObj.type, "type", section);
+    if (typeValue !== "agent" && typeValue !== "complete") {
+      throw new ConfigError(`[${section}].type must be "agent" or "complete"`);
+    }
+    type = typeValue;
+  }
+  const result = {
+    ...validateBaseConfig(rawObj, section),
+    type
+  };
+  if ("description" in rawObj) {
+    result.description = validateString(rawObj.description, "description", section);
+  }
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  if ("gadget" in rawObj) {
+    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
+  }
+  if ("parameter-format" in rawObj) {
+    const format = validateString(rawObj["parameter-format"], "parameter-format", section);
+    if (!VALID_PARAMETER_FORMATS.includes(format)) {
+      throw new ConfigError(
+        `[${section}].parameter-format must be one of: ${VALID_PARAMETER_FORMATS.join(", ")}`
+      );
+    }
+    result["parameter-format"] = format;
+  }
+  if ("builtins" in rawObj) {
+    result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
+  }
+  if ("builtin-interaction" in rawObj) {
+    result["builtin-interaction"] = validateBoolean(
+      rawObj["builtin-interaction"],
+      "builtin-interaction",
+      section
+    );
+  }
+  if ("max-tokens" in rawObj) {
+    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  return result;
+}
+function validateConfig(raw, configPath) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError("Config must be a TOML table", configPath);
+  }
+  const rawObj = raw;
+  const result = {};
+  for (const [key, value] of Object.entries(rawObj)) {
+    try {
+      if (key === "global") {
+        result.global = validateGlobalConfig(value, key);
+      } else if (key === "complete") {
+        result.complete = validateCompleteConfig(value, key);
+      } else if (key === "agent") {
+        result.agent = validateAgentConfig(value, key);
+      } else {
+        result[key] = validateCustomConfig(value, key);
+      }
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        throw new ConfigError(error.message, configPath);
+      }
+      throw error;
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  let content;
+  try {
+    content = readFileSync(configPath, "utf-8");
+  } catch (error) {
+    throw new ConfigError(
+      `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      configPath
+    );
+  }
+  let raw;
+  try {
+    raw = parseToml(content);
+  } catch (error) {
+    throw new ConfigError(
+      `Invalid TOML syntax: ${error instanceof Error ? error.message : "Unknown error"}`,
+      configPath
+    );
+  }
+  return validateConfig(raw, configPath);
+}
+function getCustomCommandNames(config) {
+  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent"]);
+  return Object.keys(config).filter((key) => !reserved.has(key));
+}
+
 // src/cli/models-command.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 init_model_shortcuts();
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -998,13 +1622,13 @@ function renderTable(models, verbose, stream) {
     }
     grouped.get(provider).push(model);
   }
-  stream.write(chalk3.bold.cyan("\nAvailable Models\n"));
-  stream.write(chalk3.cyan("=".repeat(80)) + "\n\n");
+  stream.write(chalk4.bold.cyan("\nAvailable Models\n"));
+  stream.write(chalk4.cyan("=".repeat(80)) + "\n\n");
   const providers = Array.from(grouped.keys()).sort();
   for (const provider of providers) {
     const providerModels = grouped.get(provider);
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk3.bold.yellow(`${providerName} Models
+    stream.write(chalk4.bold.yellow(`${providerName} Models
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream);
@@ -1013,11 +1637,11 @@ function renderTable(models, verbose, stream) {
     }
     stream.write("\n");
   }
-  stream.write(chalk3.bold.magenta("Model Shortcuts\n"));
-  stream.write(chalk3.dim("\u2500".repeat(80)) + "\n");
+  stream.write(chalk4.bold.magenta("Model Shortcuts\n"));
+  stream.write(chalk4.dim("\u2500".repeat(80)) + "\n");
   const shortcuts = Object.entries(MODEL_ALIASES).sort((a, b) => a[0].localeCompare(b[0]));
   for (const [shortcut, fullName] of shortcuts) {
-    stream.write(chalk3.cyan(`  ${shortcut.padEnd(15)}`) + chalk3.dim(" \u2192 ") + chalk3.white(fullName) + "\n");
+    stream.write(chalk4.cyan(`  ${shortcut.padEnd(15)}`) + chalk4.dim(" \u2192 ") + chalk4.white(fullName) + "\n");
   }
   stream.write("\n");
 }
@@ -1027,45 +1651,45 @@ function renderCompactTable(models, stream) {
   const contextWidth = 13;
   const inputWidth = 10;
   const outputWidth = 10;
-  stream.write(chalk3.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   stream.write(
-    chalk3.bold(
+    chalk4.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
-  stream.write(chalk3.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   for (const model of models) {
     const contextFormatted = formatTokens2(model.contextWindow);
     const inputPrice = `$${model.pricing.input.toFixed(2)}`;
     const outputPrice = `$${model.pricing.output.toFixed(2)}`;
     stream.write(
-      chalk3.green(model.modelId.padEnd(idWidth)) + "  " + chalk3.white(model.displayName.padEnd(nameWidth)) + "  " + chalk3.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk3.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk3.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      chalk4.green(model.modelId.padEnd(idWidth)) + "  " + chalk4.white(model.displayName.padEnd(nameWidth)) + "  " + chalk4.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk4.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk4.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
-  stream.write(chalk3.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
-  stream.write(chalk3.dim(`  * Prices are per 1M tokens
+  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk4.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream) {
   for (const model of models) {
-    stream.write(chalk3.bold.green(`
+    stream.write(chalk4.bold.green(`
   ${model.modelId}
 `));
-    stream.write(chalk3.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream.write(`  ${chalk3.dim("Name:")}         ${chalk3.white(model.displayName)}
+    stream.write(chalk4.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream.write(`  ${chalk4.dim("Name:")}         ${chalk4.white(model.displayName)}
 `);
-    stream.write(`  ${chalk3.dim("Context:")}      ${chalk3.yellow(formatTokens2(model.contextWindow))}
+    stream.write(`  ${chalk4.dim("Context:")}      ${chalk4.yellow(formatTokens2(model.contextWindow))}
 `);
-    stream.write(`  ${chalk3.dim("Max Output:")}   ${chalk3.yellow(formatTokens2(model.maxOutputTokens))}
+    stream.write(`  ${chalk4.dim("Max Output:")}   ${chalk4.yellow(formatTokens2(model.maxOutputTokens))}
 `);
-    stream.write(`  ${chalk3.dim("Pricing:")}      ${chalk3.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk3.dim("/")} ${chalk3.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk3.dim("(per 1M tokens)")}
+    stream.write(`  ${chalk4.dim("Pricing:")}      ${chalk4.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk4.dim("/")} ${chalk4.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk4.dim("(per 1M tokens)")}
 `);
     if (model.pricing.cachedInput !== void 0) {
-      stream.write(`  ${chalk3.dim("Cached Input:")} ${chalk3.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+      stream.write(`  ${chalk4.dim("Cached Input:")} ${chalk4.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `);
     }
     if (model.knowledgeCutoff) {
-      stream.write(`  ${chalk3.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream.write(`  ${chalk4.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -1076,20 +1700,20 @@ function renderVerboseTable(models, stream) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream.write(`  ${chalk3.dim("Features:")}     ${chalk3.blue(features.join(", "))}
+      stream.write(`  ${chalk4.dim("Features:")}     ${chalk4.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream.write(`  ${chalk3.dim("Family:")}       ${model.metadata.family}
+        stream.write(`  ${chalk4.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream.write(`  ${chalk3.dim("Released:")}     ${model.metadata.releaseDate}
+        stream.write(`  ${chalk4.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream.write(`  ${chalk3.dim("Notes:")}        ${chalk3.italic(model.metadata.notes)}
+        stream.write(`  ${chalk4.dim("Notes:")}        ${chalk4.italic(model.metadata.notes)}
 `);
       }
     }
@@ -1137,11 +1761,43 @@ function registerModelsCommand(program, env) {
   );
 }
 
+// src/cli/custom-command.ts
+function registerCustomCommand(program, name, config, env) {
+  const type = config.type ?? "agent";
+  const description = config.description ?? `Custom ${type} command`;
+  const cmd = program.command(name).description(description).argument("[prompt]", "Prompt for the command. Falls back to stdin when available.");
+  if (type === "complete") {
+    addCompleteOptions(cmd, config);
+    cmd.action(
+      (prompt, cliOptions) => executeAction(async () => {
+        const configDefaults = configToCompleteOptions(config);
+        const options = {
+          ...configDefaults,
+          ...cliOptions
+        };
+        await executeComplete(prompt, options, env);
+      }, env)
+    );
+  } else {
+    addAgentOptions(cmd, config);
+    cmd.action(
+      (prompt, cliOptions) => executeAction(async () => {
+        const configDefaults = configToAgentOptions(config);
+        const options = {
+          ...configDefaults,
+          ...cliOptions
+        };
+        await executeAgent(prompt, options, env);
+      }, env)
+    );
+  }
+}
+
 // src/cli/environment.ts
 init_client();
 init_logger();
 import readline from "node:readline";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var LOG_LEVEL_MAP = {
   silly: 0,
   trace: 1,
@@ -1185,14 +1841,14 @@ function createPromptFunction(stdin, stdout) {
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${chalk4.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk5.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(chalk4.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(chalk5.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${chalk4.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk5.cyan("\u2500".repeat(60))}
 `);
-      rl.question(chalk4.green.bold("You: "), (answer) => {
+      rl.question(chalk5.green.bold("You: "), (answer) => {
         rl.close();
         resolve(answer);
       });
@@ -1227,29 +1883,39 @@ function parseLogLevel(value) {
   }
   return normalized;
 }
-function createProgram(env) {
+function createProgram(env, config) {
   const program = new Command();
   program.name(CLI_NAME).description(CLI_DESCRIPTION).version(package_default.version).option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).configureOutput({
     writeOut: (str) => env.stdout.write(str),
     writeErr: (str) => env.stderr.write(str)
   });
-  registerCompleteCommand(program, env);
-  registerAgentCommand(program, env);
+  registerCompleteCommand(program, env, config?.complete);
+  registerAgentCommand(program, env, config?.agent);
   registerModelsCommand(program, env);
+  if (config) {
+    const customNames = getCustomCommandNames(config);
+    for (const name of customNames) {
+      const cmdConfig = config[name];
+      registerCustomCommand(program, name, cmdConfig, env);
+    }
+  }
   return program;
 }
 async function runCLI(overrides = {}) {
+  const opts = "env" in overrides || "config" in overrides ? overrides : { env: overrides };
+  const config = opts.config !== void 0 ? opts.config : loadConfig();
+  const envOverrides = opts.env ?? {};
   const preParser = new Command();
   preParser.option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).allowUnknownOption().allowExcessArguments().helpOption(false);
   preParser.parse(process.argv);
   const globalOpts = preParser.opts();
   const loggerConfig = {
-    logLevel: globalOpts.logLevel,
-    logFile: globalOpts.logFile
+    logLevel: globalOpts.logLevel ?? config.global?.["log-level"],
+    logFile: globalOpts.logFile ?? config.global?.["log-file"]
   };
   const defaultEnv = createDefaultEnvironment(loggerConfig);
-  const env = { ...defaultEnv, ...overrides };
-  const program = createProgram(env);
+  const env = { ...defaultEnv, ...envOverrides };
+  const program = createProgram(env, config);
   await program.parseAsync(env.argv);
 }