llmist 1.5.0 → 1.6.0

package/dist/cli.cjs

@@ -6553,7 +6553,11 @@ var OPTION_FLAGS = {
   logLlmResponses: "--log-llm-responses [dir]",
   noBuiltins: "--no-builtins",
   noBuiltinInteraction: "--no-builtin-interaction",
-  quiet: "-q, --quiet"
+  quiet: "-q, --quiet",
+  docker: "--docker",
+  dockerRo: "--docker-ro",
+  noDocker: "--no-docker",
+  dockerDev: "--docker-dev"
 };
 var OPTION_DESCRIPTIONS = {
   model: "Model identifier, e.g. openai:gpt-5-nano or anthropic:claude-sonnet-4-5.",
@@ -6569,7 +6573,11 @@ var OPTION_DESCRIPTIONS = {
   logLlmResponses: "Save raw LLM responses as plain text. Optional dir, defaults to ~/.llmist/logs/responses/",
   noBuiltins: "Disable built-in gadgets (AskUser, TellUser).",
   noBuiltinInteraction: "Disable interactive gadgets (AskUser) while keeping TellUser.",
-  quiet: "Suppress all output except content (text and TellUser messages)."
+  quiet: "Suppress all output except content (text and TellUser messages).",
+  docker: "Run agent in a Docker sandbox container for security isolation.",
+  dockerRo: "Run in Docker with current directory mounted read-only.",
+  noDocker: "Disable Docker sandboxing (override config).",
+  dockerDev: "Run in Docker dev mode (mount local source instead of npm install)."
 };
 var SUMMARY_PREFIX = "[llmist]";
 
@@ -6579,7 +6587,7 @@ var import_commander2 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "1.4.0",
+  version: "1.5.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",
@@ -8389,7 +8397,7 @@ function addAgentOptions(cmd, defaults) {
     OPTION_FLAGS.noBuiltinInteraction,
     OPTION_DESCRIPTIONS.noBuiltinInteraction,
     defaults?.["builtin-interaction"] !== false
-  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.logLlmResponses, OPTION_DESCRIPTIONS.logLlmResponses, defaults?.["log-llm-responses"]);
+  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.logLlmResponses, OPTION_DESCRIPTIONS.logLlmResponses, defaults?.["log-llm-responses"]).option(OPTION_FLAGS.docker, OPTION_DESCRIPTIONS.docker).option(OPTION_FLAGS.dockerRo, OPTION_DESCRIPTIONS.dockerRo).option(OPTION_FLAGS.noDocker, OPTION_DESCRIPTIONS.noDocker).option(OPTION_FLAGS.dockerDev, OPTION_DESCRIPTIONS.dockerDev);
 }
 function configToCompleteOptions(config) {
   const result = {};
@@ -8424,668 +8432,791 @@ function configToAgentOptions(config) {
   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"];
+  if (config.docker !== void 0) result.docker = config.docker;
+  if (config["docker-cwd-permission"] !== void 0)
+    result.dockerCwdPermission = config["docker-cwd-permission"];
   return result;
 }
 
-// src/cli/agent-command.ts
-function createHumanInputHandler(env, progress, keyboard) {
-  const stdout = env.stdout;
-  if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
-    return void 0;
+// src/cli/docker/types.ts
+var VALID_MOUNT_PERMISSIONS = ["ro", "rw"];
+var DOCKER_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "enabled",
+  "dockerfile",
+  "cwd-permission",
+  "config-permission",
+  "mounts",
+  "env-vars",
+  "image-name",
+  "dev-mode",
+  "dev-source"
+]);
+var DEFAULT_IMAGE_NAME = "llmist-sandbox";
+var DEFAULT_CWD_PERMISSION = "rw";
+var DEFAULT_CONFIG_PERMISSION = "ro";
+var FORWARDED_API_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY"
+];
+var DEV_IMAGE_NAME = "llmist-dev-sandbox";
+var DEV_SOURCE_MOUNT_TARGET = "/llmist-src";
+
+// src/cli/config.ts
+var import_node_fs8 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path8 = require("path");
+var import_js_toml = require("js-toml");
+
+// src/cli/templates.ts
+var import_eta = require("eta");
+var TemplateError = class extends Error {
+  constructor(message, promptName, configPath) {
+    super(promptName ? `[prompts.${promptName}]: ${message}` : message);
+    this.promptName = promptName;
+    this.configPath = configPath;
+    this.name = "TemplateError";
   }
-  return async (question) => {
-    progress.pause();
-    if (keyboard.cleanupEsc) {
-      keyboard.cleanupEsc();
-      keyboard.cleanupEsc = null;
+};
+function createTemplateEngine(prompts, configPath) {
+  const eta = new import_eta.Eta({
+    views: "/",
+    // Required but we use named templates
+    autoEscape: false,
+    // Don't escape - these are prompts, not HTML
+    autoTrim: false
+    // Preserve whitespace in prompts
+  });
+  for (const [name, template] of Object.entries(prompts)) {
+    try {
+      eta.loadTemplate(`@${name}`, template);
+    } catch (error) {
+      throw new TemplateError(
+        error instanceof Error ? error.message : String(error),
+        name,
+        configPath
+      );
     }
-    const rl = (0, import_promises3.createInterface)({ input: env.stdin, output: env.stdout });
+  }
+  return eta;
+}
+function resolveTemplate(eta, template, context = {}, configPath) {
+  try {
+    const fullContext = {
+      ...context,
+      env: process.env,
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      // "2025-12-01"
+    };
+    return eta.renderString(template, fullContext);
+  } catch (error) {
+    throw new TemplateError(
+      error instanceof Error ? error.message : String(error),
+      void 0,
+      configPath
+    );
+  }
+}
+function validatePrompts(prompts, configPath) {
+  const eta = createTemplateEngine(prompts, configPath);
+  for (const [name, template] of Object.entries(prompts)) {
     try {
-      const questionLine = question.trim() ? `
-${renderMarkdownWithSeparators(question.trim())}` : "";
-      let isFirst = true;
-      while (true) {
-        const statsPrompt = progress.formatPrompt();
-        const prompt = isFirst ? `${questionLine}
-${statsPrompt}` : statsPrompt;
-        isFirst = false;
-        const answer = await rl.question(prompt);
-        const trimmed = answer.trim();
-        if (trimmed) {
-          return trimmed;
-        }
-      }
-    } finally {
-      rl.close();
-      keyboard.restore();
+      eta.renderString(template, { env: {} });
+    } catch (error) {
+      throw new TemplateError(
+        error instanceof Error ? error.message : String(error),
+        name,
+        configPath
+      );
     }
-  };
+  }
 }
-async function executeAgent(promptArg, options, env) {
-  const prompt = await resolvePrompt(promptArg, env);
-  const client = env.createClient();
-  const registry = new GadgetRegistry();
-  const stdinIsInteractive = isInteractive(env.stdin);
-  if (options.builtins !== false) {
-    for (const gadget of builtinGadgets) {
-      if (gadget.name === "AskUser" && (options.builtinInteraction === false || !stdinIsInteractive)) {
-        continue;
-      }
-      registry.registerByClass(gadget);
+function validateEnvVars(template, promptName, configPath) {
+  const envVarPattern = /<%=\s*it\.env\.(\w+)\s*%>/g;
+  const matches = template.matchAll(envVarPattern);
+  for (const match of matches) {
+    const varName = match[1];
+    if (process.env[varName] === void 0) {
+      throw new TemplateError(
+        `Environment variable '${varName}' is not set`,
+        promptName,
+        configPath
+      );
     }
   }
-  const gadgetSpecifiers = options.gadget ?? [];
-  if (gadgetSpecifiers.length > 0) {
-    const gadgets2 = await loadGadgets(gadgetSpecifiers, process.cwd());
-    for (const gadget of gadgets2) {
-      registry.registerByClass(gadget);
+}
+function hasTemplateSyntax(str) {
+  return str.includes("<%");
+}
+
+// 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([
+  "model",
+  "system",
+  "temperature",
+  "max-tokens",
+  "quiet",
+  "inherits",
+  "log-level",
+  "log-file",
+  "log-reset",
+  "log-llm-requests",
+  "log-llm-responses",
+  "type",
+  // Allowed for inheritance compatibility, ignored for built-in commands
+  "docker",
+  // Enable Docker sandboxing (only effective for agent type)
+  "docker-cwd-permission"
+  // Override CWD mount permission for this profile
+]);
+var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "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",
+  "log-file",
+  "log-reset",
+  "log-llm-requests",
+  "log-llm-responses",
+  "type",
+  // Allowed for inheritance compatibility, ignored for built-in commands
+  "docker",
+  // Enable Docker sandboxing for this profile
+  "docker-cwd-permission"
+  // Override CWD mount permission for this profile
+]);
+var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  ...COMPLETE_CONFIG_KEYS,
+  ...AGENT_CONFIG_KEYS,
+  "type",
+  "description"
+]);
+function getConfigPath() {
+  return (0, import_node_path8.join)((0, import_node_os2.homedir)(), ".llmist", "cli.toml");
+}
+var ConfigError = class extends Error {
+  constructor(message, path5) {
+    super(path5 ? `${path5}: ${message}` : message);
+    this.path = path5;
+    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`);
     }
   }
-  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()}
-`));
+  return value;
+}
+function validateInherits(value, section) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if (typeof value[i] !== "string") {
+        throw new ConfigError(`[${section}].inherits[${i}] must be a string`);
+      }
     }
-  };
-  const keyboard = {
-    cleanupEsc: null,
-    cleanupSigint: null,
-    restore: () => {
-      if (stdinIsInteractive && stdinStream.isTTY && !wasCancelled) {
-        keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
-      }
+    return value;
+  }
+  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`
+      );
     }
-  };
-  const handleQuit = () => {
-    keyboard.cleanupEsc?.();
-    keyboard.cleanupSigint?.();
-    progress.complete();
-    printer.ensureNewline();
-    const summary = renderOverallSummary({
-      totalTokens: usage?.totalTokens,
-      iterations,
-      elapsedSeconds: progress.getTotalElapsedSeconds(),
-      cost: progress.getTotalCost()
+    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) {
+    const level = validateString(raw["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 raw) {
+    result["log-file"] = validateString(raw["log-file"], "log-file", section);
+  }
+  if ("log-reset" in raw) {
+    result["log-reset"] = validateBoolean(raw["log-reset"], "log-reset", section);
+  }
+  return result;
+}
+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
     });
-    if (summary) {
-      env.stderr.write(`${import_chalk5.default.dim("\u2500".repeat(40))}
-`);
-      env.stderr.write(`${summary}
-`);
+  }
+  if ("inherits" in raw) {
+    result.inherits = validateInherits(raw.inherits, section);
+  }
+  if ("docker" in raw) {
+    result.docker = validateBoolean(raw.docker, "docker", section);
+  }
+  if ("docker-cwd-permission" in raw) {
+    const perm = validateString(raw["docker-cwd-permission"], "docker-cwd-permission", section);
+    if (perm !== "ro" && perm !== "rw") {
+      throw new ConfigError(`[${section}].docker-cwd-permission must be "ro" or "rw"`);
     }
-    env.stderr.write(import_chalk5.default.dim("[Quit]\n"));
-    process.exit(130);
-  };
-  if (stdinIsInteractive && stdinStream.isTTY) {
-    keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
+    result["docker-cwd-permission"] = perm;
   }
-  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";
+  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 approvalConfig = {
-    gadgetApprovals,
-    defaultMode: "allowed"
-  };
-  const approvalManager = new ApprovalManager(approvalConfig, env, progress);
-  let usage;
-  let iterations = 0;
-  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
-  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
-  let llmCallCounter = 0;
-  const countMessagesTokens = async (model, messages) => {
-    try {
-      return await client.countTokens(model, messages);
-    } catch {
-      const totalChars = messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
-      return Math.round(totalChars / FALLBACK_CHARS_PER_TOKEN);
+  return validateLoggingConfig(rawObj, section);
+}
+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),
+    ...validateLoggingConfig(rawObj, section)
   };
-  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;
+  if ("max-tokens" in rawObj) {
+    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  if ("quiet" in rawObj) {
+    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
+  }
+  if ("log-llm-requests" in rawObj) {
+    result["log-llm-requests"] = validateStringOrBoolean(
+      rawObj["log-llm-requests"],
+      "log-llm-requests",
+      section
+    );
+  }
+  if ("log-llm-responses" in rawObj) {
+    result["log-llm-responses"] = validateStringOrBoolean(
+      rawObj["log-llm-responses"],
+      "log-llm-responses",
+      section
+    );
+  }
+  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),
+    ...validateLoggingConfig(rawObj, section)
   };
-  const builder = new AgentBuilder(client).withModel(options.model).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
-    observers: {
-      // 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,
-          context.options.messages
-        );
-        progress.startCall(context.options.model, inputTokens);
-        progress.setInputTokens(inputTokens, false);
-        if (llmRequestsDir) {
-          const filename = `${Date.now()}_call_${llmCallCounter}.request.txt`;
-          const content = formatLlmRequest(context.options.messages);
-          await writeLogFile(llmRequestsDir, filename, content);
-        }
-      },
-      // onStreamChunk: Real-time updates as LLM generates tokens
-      // This enables responsive UIs that show progress during generation
-      onStreamChunk: async (context) => {
-        progress.update(context.accumulatedText.length);
-        if (context.usage) {
-          if (context.usage.inputTokens) {
-            progress.setInputTokens(context.usage.inputTokens, false);
-          }
-          if (context.usage.outputTokens) {
-            progress.setOutputTokens(context.usage.outputTokens, false);
-          }
-          progress.setCachedTokens(
-            context.usage.cachedInputTokens ?? 0,
-            context.usage.cacheCreationInputTokens ?? 0
-          );
-        }
-      },
-      // 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) {
-          if (context.usage.inputTokens) {
-            progress.setInputTokens(context.usage.inputTokens, false);
-          }
-          if (context.usage.outputTokens) {
-            progress.setOutputTokens(context.usage.outputTokens, false);
-          }
-        }
-        let callCost;
-        if (context.usage && client.modelRegistry) {
-          try {
-            const modelName = context.options.model.includes(":") ? context.options.model.split(":")[1] : context.options.model;
-            const costResult = client.modelRegistry.estimateCost(
-              modelName,
-              context.usage.inputTokens,
-              context.usage.outputTokens,
-              context.usage.cachedInputTokens ?? 0,
-              context.usage.cacheCreationInputTokens ?? 0
-            );
-            if (costResult) callCost = costResult.totalCost;
-          } catch {
-          }
-        }
-        const callElapsed = progress.getCallElapsedSeconds();
-        progress.endCall(context.usage);
-        if (!options.quiet) {
-          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}
-`);
-          }
-        }
-        if (llmResponsesDir) {
-          const filename = `${Date.now()}_call_${llmCallCounter}.response.txt`;
-          await writeLogFile(llmResponsesDir, filename, context.rawResponse);
-        }
-      }
-    },
-    // SHOWCASE: Controller-based approval gating for gadgets
-    //
-    // This demonstrates how to add safety layers WITHOUT modifying gadgets.
-    // 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
-    //
-    // Default: RunCommand, WriteFile, EditFile require approval unless overridden.
-    controllers: {
-      beforeGadgetExecution: async (ctx) => {
-        const mode = approvalManager.getApprovalMode(ctx.gadgetName);
-        if (mode === "allowed") {
-          return { action: "proceed" };
-        }
-        const stdinTTY = isInteractive(env.stdin);
-        const stderrTTY2 = env.stderr.isTTY === true;
-        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
-
-Denied: ${result.reason ?? "by user"}`
-          };
-        }
-        return { action: "proceed" };
-      }
-    }
-  });
-  if (options.system) {
-    builder.withSystem(options.system);
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      min: 1
+    });
   }
-  if (options.maxIterations !== void 0) {
-    builder.withMaxIterations(options.maxIterations);
+  if ("gadgets" in rawObj) {
+    result.gadgets = validateStringArray(rawObj.gadgets, "gadgets", section);
   }
-  if (options.temperature !== void 0) {
-    builder.withTemperature(options.temperature);
+  if ("gadget-add" in rawObj) {
+    result["gadget-add"] = validateStringArray(rawObj["gadget-add"], "gadget-add", section);
   }
-  const humanInputHandler = createHumanInputHandler(env, progress, keyboard);
-  if (humanInputHandler) {
-    builder.onHumanInput(humanInputHandler);
+  if ("gadget-remove" in rawObj) {
+    result["gadget-remove"] = validateStringArray(rawObj["gadget-remove"], "gadget-remove", section);
   }
-  builder.withSignal(abortController.signal);
-  const gadgets = registry.getAll();
-  if (gadgets.length > 0) {
-    builder.withGadgets(...gadgets);
+  if ("gadget" in rawObj) {
+    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
   }
-  if (options.gadgetStartPrefix) {
-    builder.withGadgetStartPrefix(options.gadgetStartPrefix);
+  if ("builtins" in rawObj) {
+    result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
   }
-  if (options.gadgetEndPrefix) {
-    builder.withGadgetEndPrefix(options.gadgetEndPrefix);
+  if ("builtin-interaction" in rawObj) {
+    result["builtin-interaction"] = validateBoolean(
+      rawObj["builtin-interaction"],
+      "builtin-interaction",
+      section
+    );
   }
-  if (options.gadgetArgPrefix) {
-    builder.withGadgetArgPrefix(options.gadgetArgPrefix);
+  if ("gadget-start-prefix" in rawObj) {
+    result["gadget-start-prefix"] = validateString(
+      rawObj["gadget-start-prefix"],
+      "gadget-start-prefix",
+      section
+    );
   }
-  builder.withSyntheticGadgetCall(
-    "TellUser",
-    {
-      message: "\u{1F44B} Hello! I'm ready to help.\n\nHere's what I can do:\n- Analyze your codebase\n- Execute commands\n- Answer questions\n\nWhat would you like me to work on?",
-      done: false,
-      type: "info"
-    },
-    "\u2139\uFE0F  \u{1F44B} Hello! I'm ready to help.\n\nHere's what I can do:\n- Analyze your codebase\n- Execute commands\n- Answer questions\n\nWhat would you like me to work on?"
-  );
-  builder.withTextOnlyHandler("acknowledge");
-  builder.withTextWithGadgetsHandler({
-    gadgetName: "TellUser",
-    parameterMapping: (text) => ({ message: text, done: false, type: "info" }),
-    resultMapping: (text) => `\u2139\uFE0F  ${text}`
-  });
-  const agent = builder.ask(prompt);
-  let textBuffer = "";
-  const flushTextBuffer = () => {
-    if (textBuffer) {
-      const output = options.quiet ? textBuffer : renderMarkdownWithSeparators(textBuffer);
-      printer.write(output);
-      textBuffer = "";
-    }
-  };
-  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 })}
-`);
-        }
-      }
-    }
-  } catch (error) {
-    if (!isAbortError(error)) {
-      throw error;
-    }
-  } finally {
-    isStreaming = false;
-    keyboard.cleanupEsc?.();
-    keyboard.cleanupSigint?.();
+  if ("gadget-end-prefix" in rawObj) {
+    result["gadget-end-prefix"] = validateString(
+      rawObj["gadget-end-prefix"],
+      "gadget-end-prefix",
+      section
+    );
   }
-  flushTextBuffer();
-  progress.complete();
-  printer.ensureNewline();
-  if (!options.quiet && iterations > 1) {
-    env.stderr.write(`${import_chalk5.default.dim("\u2500".repeat(40))}
-`);
-    const summary = renderOverallSummary({
-      totalTokens: usage?.totalTokens,
-      iterations,
-      elapsedSeconds: progress.getTotalElapsedSeconds(),
-      cost: progress.getTotalCost()
-    });
-    if (summary) {
-      env.stderr.write(`${summary}
-`);
-    }
+  if ("gadget-arg-prefix" in rawObj) {
+    result["gadget-arg-prefix"] = validateString(
+      rawObj["gadget-arg-prefix"],
+      "gadget-arg-prefix",
+      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);
+  }
+  if ("log-llm-requests" in rawObj) {
+    result["log-llm-requests"] = validateStringOrBoolean(
+      rawObj["log-llm-requests"],
+      "log-llm-requests",
+      section
+    );
+  }
+  if ("log-llm-responses" in rawObj) {
+    result["log-llm-responses"] = validateStringOrBoolean(
+      rawObj["log-llm-responses"],
+      "log-llm-responses",
+      section
+    );
   }
+  return result;
 }
-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(() => {
-      const mergedOptions = {
-        ...options,
-        gadgetApproval: config?.["gadget-approval"]
-      };
-      return executeAgent(prompt, mergedOptions, env);
-    }, env)
-  );
+function validateStringOrBoolean(value, field, section) {
+  if (typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  throw new ConfigError(`[${section}].${field} must be a string or boolean`);
 }
-
-// src/cli/complete-command.ts
-init_messages();
-init_model_shortcuts();
-init_constants2();
-async function executeComplete(promptArg, options, env) {
-  const prompt = await resolvePrompt(promptArg, env);
-  const client = env.createClient();
-  const model = resolveModel(options.model);
-  const builder = new LLMMessageBuilder();
-  if (options.system) {
-    builder.addSystem(options.system);
+function validateCustomConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
   }
-  builder.addUser(prompt);
-  const messages = builder.build();
-  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
-  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
-  const timestamp = Date.now();
-  if (llmRequestsDir) {
-    const filename = `${timestamp}_complete.request.txt`;
-    const content = formatLlmRequest(messages);
-    await writeLogFile(llmRequestsDir, filename, content);
-  }
-  const stream2 = client.stream({
-    model,
-    messages,
-    temperature: options.temperature,
-    maxTokens: options.maxTokens
-  });
-  const printer = new StreamPrinter(env.stdout);
-  const stderrTTY = env.stderr.isTTY === true;
-  const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
-  const estimatedInputTokens = Math.round(prompt.length / FALLBACK_CHARS_PER_TOKEN);
-  progress.startCall(model, estimatedInputTokens);
-  let finishReason;
-  let usage;
-  let accumulatedResponse = "";
-  for await (const chunk of stream2) {
-    if (chunk.usage) {
-      usage = chunk.usage;
-      if (chunk.usage.inputTokens) {
-        progress.setInputTokens(chunk.usage.inputTokens, false);
-      }
-      if (chunk.usage.outputTokens) {
-        progress.setOutputTokens(chunk.usage.outputTokens, false);
-      }
-    }
-    if (chunk.text) {
-      progress.pause();
-      accumulatedResponse += chunk.text;
-      progress.update(accumulatedResponse.length);
-      printer.write(chunk.text);
+  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`);
     }
-    if (chunk.finishReason !== void 0) {
-      finishReason = chunk.finishReason;
+  }
+  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;
   }
-  progress.endCall(usage);
-  progress.complete();
-  printer.ensureNewline();
-  if (llmResponsesDir) {
-    const filename = `${timestamp}_complete.response.txt`;
-    await writeLogFile(llmResponsesDir, filename, accumulatedResponse);
+  const result = {
+    ...validateBaseConfig(rawObj, section),
+    type
+  };
+  if ("description" in rawObj) {
+    result.description = validateString(rawObj.description, "description", section);
   }
-  if (stderrTTY && !options.quiet) {
-    const summary = renderSummary({ finishReason, usage, cost: progress.getTotalCost() });
-    if (summary) {
-      env.stderr.write(`${summary}
-`);
-    }
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      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);
+  }
+  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 ("gadget-start-prefix" in rawObj) {
+    result["gadget-start-prefix"] = validateString(
+      rawObj["gadget-start-prefix"],
+      "gadget-start-prefix",
+      section
+    );
+  }
+  if ("gadget-end-prefix" in rawObj) {
+    result["gadget-end-prefix"] = validateString(
+      rawObj["gadget-end-prefix"],
+      "gadget-end-prefix",
+      section
+    );
+  }
+  if ("gadget-arg-prefix" in rawObj) {
+    result["gadget-arg-prefix"] = validateString(
+      rawObj["gadget-arg-prefix"],
+      "gadget-arg-prefix",
+      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,
+      min: 1
+    });
+  }
+  if ("quiet" in rawObj) {
+    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
+  Object.assign(result, validateLoggingConfig(rawObj, section));
+  return result;
 }
-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)
-  );
+function validatePromptsConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value !== "string") {
+      throw new ConfigError(`[${section}].${key} must be a string`);
+    }
+    result[key] = value;
+  }
+  return result;
 }
-
-// src/cli/config.ts
-var import_node_fs8 = require("fs");
-var import_node_os2 = require("os");
-var import_node_path8 = require("path");
-var import_js_toml = require("js-toml");
-
-// src/cli/templates.ts
-var import_eta = require("eta");
-var TemplateError = class extends Error {
-  constructor(message, promptName, configPath) {
-    super(promptName ? `[prompts.${promptName}]: ${message}` : message);
-    this.promptName = promptName;
-    this.configPath = configPath;
-    this.name = "TemplateError";
+function validateConfig(raw, configPath) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError("Config must be a TOML table", configPath);
   }
-};
-function createTemplateEngine(prompts, configPath) {
-  const eta = new import_eta.Eta({
-    views: "/",
-    // Required but we use named templates
-    autoEscape: false,
-    // Don't escape - these are prompts, not HTML
-    autoTrim: false
-    // Preserve whitespace in prompts
-  });
-  for (const [name, template] of Object.entries(prompts)) {
+  const rawObj = raw;
+  const result = {};
+  for (const [key, value] of Object.entries(rawObj)) {
     try {
-      eta.loadTemplate(`@${name}`, template);
+      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 if (key === "prompts") {
+        result.prompts = validatePromptsConfig(value, key);
+      } else if (key === "docker") {
+        result.docker = validateDockerConfig(value, key);
+      } else {
+        result[key] = validateCustomConfig(value, key);
+      }
     } catch (error) {
-      throw new TemplateError(
-        error instanceof Error ? error.message : String(error),
-        name,
-        configPath
-      );
+      if (error instanceof ConfigError) {
+        throw new ConfigError(error.message, configPath);
+      }
+      throw error;
     }
   }
-  return eta;
+  return result;
 }
-function resolveTemplate(eta, template, context = {}, configPath) {
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!(0, import_node_fs8.existsSync)(configPath)) {
+    return {};
+  }
+  let content;
   try {
-    const fullContext = {
-      ...context,
-      env: process.env,
-      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-      // "2025-12-01"
-    };
-    return eta.renderString(template, fullContext);
+    content = (0, import_node_fs8.readFileSync)(configPath, "utf-8");
   } catch (error) {
-    throw new TemplateError(
-      error instanceof Error ? error.message : String(error),
-      void 0,
+    throw new ConfigError(
+      `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
       configPath
     );
   }
-}
-function validatePrompts(prompts, configPath) {
-  const eta = createTemplateEngine(prompts, configPath);
-  for (const [name, template] of Object.entries(prompts)) {
-    try {
-      eta.renderString(template, { env: {} });
-    } catch (error) {
-      throw new TemplateError(
-        error instanceof Error ? error.message : String(error),
-        name,
-        configPath
-      );
-    }
+  let raw;
+  try {
+    raw = (0, import_js_toml.load)(content);
+  } catch (error) {
+    throw new ConfigError(
+      `Invalid TOML syntax: ${error instanceof Error ? error.message : "Unknown error"}`,
+      configPath
+    );
   }
+  const validated = validateConfig(raw, configPath);
+  const inherited = resolveInheritance(validated, configPath);
+  return resolveTemplatesInConfig(inherited, configPath);
 }
-function validateEnvVars(template, promptName, configPath) {
-  const envVarPattern = /<%=\s*it\.env\.(\w+)\s*%>/g;
-  const matches = template.matchAll(envVarPattern);
-  for (const match of matches) {
-    const varName = match[1];
-    if (process.env[varName] === void 0) {
-      throw new TemplateError(
-        `Environment variable '${varName}' is not set`,
-        promptName,
-        configPath
-      );
-    }
-  }
-}
-function hasTemplateSyntax(str) {
-  return str.includes("<%");
-}
-
-// 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([
-  "model",
-  "system",
-  "temperature",
-  "max-tokens",
-  "quiet",
-  "inherits",
-  "log-level",
-  "log-file",
-  "log-reset",
-  "log-llm-requests",
-  "log-llm-responses",
-  "type"
-  // Allowed for inheritance compatibility, ignored for built-in commands
-]);
-var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "model",
-  "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",
-  "log-file",
-  "log-reset",
-  "log-llm-requests",
-  "log-llm-responses",
-  "type"
-  // Allowed for inheritance compatibility, ignored for built-in commands
-]);
-var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  ...COMPLETE_CONFIG_KEYS,
-  ...AGENT_CONFIG_KEYS,
-  "type",
-  "description"
-]);
-function getConfigPath() {
-  return (0, import_node_path8.join)((0, import_node_os2.homedir)(), ".llmist", "cli.toml");
+function getCustomCommandNames(config) {
+  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent", "prompts", "docker"]);
+  return Object.keys(config).filter((key) => !reserved.has(key));
 }
-var ConfigError = class extends Error {
-  constructor(message, path5) {
-    super(path5 ? `${path5}: ${message}` : message);
-    this.path = path5;
-    this.name = "ConfigError";
+function resolveTemplatesInConfig(config, configPath) {
+  const prompts = config.prompts ?? {};
+  const hasPrompts = Object.keys(prompts).length > 0;
+  let hasTemplates = false;
+  for (const [sectionName, section] of Object.entries(config)) {
+    if (sectionName === "global" || sectionName === "prompts") continue;
+    if (!section || typeof section !== "object") continue;
+    const sectionObj = section;
+    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
+      hasTemplates = true;
+      break;
+    }
   }
-};
-function validateString(value, key, section) {
-  if (typeof value !== "string") {
-    throw new ConfigError(`[${section}].${key} must be a string`);
+  for (const template of Object.values(prompts)) {
+    if (hasTemplateSyntax(template)) {
+      hasTemplates = true;
+      break;
+    }
   }
-  return value;
+  if (!hasPrompts && !hasTemplates) {
+    return config;
+  }
+  try {
+    validatePrompts(prompts, configPath);
+  } catch (error) {
+    if (error instanceof TemplateError) {
+      throw new ConfigError(error.message, configPath);
+    }
+    throw error;
+  }
+  for (const [name, template] of Object.entries(prompts)) {
+    try {
+      validateEnvVars(template, name, configPath);
+    } catch (error) {
+      if (error instanceof TemplateError) {
+        throw new ConfigError(error.message, configPath);
+      }
+      throw error;
+    }
+  }
+  const eta = createTemplateEngine(prompts, configPath);
+  const result = { ...config };
+  for (const [sectionName, section] of Object.entries(config)) {
+    if (sectionName === "global" || sectionName === "prompts") continue;
+    if (!section || typeof section !== "object") continue;
+    const sectionObj = section;
+    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
+      try {
+        validateEnvVars(sectionObj.system, void 0, configPath);
+      } catch (error) {
+        if (error instanceof TemplateError) {
+          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+        }
+        throw error;
+      }
+      try {
+        const resolved = resolveTemplate(eta, sectionObj.system, {}, configPath);
+        result[sectionName] = {
+          ...sectionObj,
+          system: resolved
+        };
+      } catch (error) {
+        if (error instanceof TemplateError) {
+          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+        }
+        throw error;
+      }
+    }
+  }
+  return result;
 }
-function validateNumber(value, key, section, opts) {
-  if (typeof value !== "number") {
-    throw new ConfigError(`[${section}].${key} must be a number`);
+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 (opts?.integer && !Number.isInteger(value)) {
-    throw new ConfigError(`[${section}].${key} must be an integer`);
+  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 (opts?.min !== void 0 && value < opts.min) {
-    throw new ConfigError(`[${section}].${key} must be >= ${opts.min}`);
+  if (hasGadgets) {
+    return section.gadgets;
   }
-  if (opts?.max !== void 0 && value > opts.max) {
-    throw new ConfigError(`[${section}].${key} must be <= ${opts.max}`);
+  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();
+  function resolveSection(name) {
+    if (name in resolved) {
+      return resolved[name];
+    }
+    if (resolving.has(name)) {
+      throw new ConfigError(`Circular inheritance detected: ${name}`, configPath);
+    }
+    const section = config[name];
+    if (section === void 0 || typeof section !== "object") {
+      throw new ConfigError(`Cannot inherit from unknown section: ${name}`, configPath);
+    }
+    resolving.add(name);
+    const sectionObj = section;
+    const inheritsRaw = sectionObj.inherits;
+    const inheritsList = inheritsRaw ? Array.isArray(inheritsRaw) ? inheritsRaw : [inheritsRaw] : [];
+    let merged = {};
+    for (const parent of inheritsList) {
+      const parentResolved = resolveSection(parent);
+      merged = { ...merged, ...parentResolved };
+    }
+    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;
+  }
+  for (const name of Object.keys(config)) {
+    resolveSection(name);
+  }
+  return resolved;
+}
+
+// src/cli/docker/docker-config.ts
+var MOUNT_CONFIG_KEYS = /* @__PURE__ */ new Set(["source", "target", "permission"]);
+function validateString2(value, key, section) {
+  if (typeof value !== "string") {
+    throw new ConfigError(`[${section}].${key} must be a string`);
   }
   return value;
 }
-function validateBoolean(value, key, section) {
+function validateBoolean2(value, key, section) {
   if (typeof value !== "boolean") {
     throw new ConfigError(`[${section}].${key} must be a boolean`);
   }
   return value;
 }
-function validateStringArray(value, key, section) {
+function validateStringArray2(value, key, section) {
   if (!Array.isArray(value)) {
     throw new ConfigError(`[${section}].${key} must be an array`);
   }
@@ -9096,535 +9227,949 @@ function validateStringArray(value, key, section) {
   }
   return value;
 }
-function validateInherits(value, section) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      if (typeof value[i] !== "string") {
-        throw new ConfigError(`[${section}].inherits[${i}] must be a string`);
-      }
-    }
-    return value;
+function validateMountPermission(value, key, section) {
+  const str = validateString2(value, key, section);
+  if (!VALID_MOUNT_PERMISSIONS.includes(str)) {
+    throw new ConfigError(
+      `[${section}].${key} must be one of: ${VALID_MOUNT_PERMISSIONS.join(", ")}`
+    );
   }
-  throw new ConfigError(`[${section}].inherits must be a string or array of strings`);
+  return str;
 }
-function validateGadgetApproval(value, section) {
+function validateMountConfig(value, index, 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" })`
-    );
+    throw new ConfigError(`[${section}].mounts[${index}] must be a table`);
   }
-  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(", ")}`
-      );
+  const rawObj = value;
+  const mountSection = `${section}.mounts[${index}]`;
+  for (const key of Object.keys(rawObj)) {
+    if (!MOUNT_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${mountSection}].${key} is not a valid mount option`);
     }
-    result[gadgetName] = mode;
   }
-  return result;
-}
-function validateLoggingConfig(raw, section) {
-  const result = {};
-  if ("log-level" in raw) {
-    const level = validateString(raw["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 (!("source" in rawObj)) {
+    throw new ConfigError(`[${mountSection}] missing required field 'source'`);
   }
-  if ("log-file" in raw) {
-    result["log-file"] = validateString(raw["log-file"], "log-file", section);
+  if (!("target" in rawObj)) {
+    throw new ConfigError(`[${mountSection}] missing required field 'target'`);
   }
-  if ("log-reset" in raw) {
-    result["log-reset"] = validateBoolean(raw["log-reset"], "log-reset", section);
+  if (!("permission" in rawObj)) {
+    throw new ConfigError(`[${mountSection}] missing required field 'permission'`);
   }
-  return result;
+  return {
+    source: validateString2(rawObj.source, "source", mountSection),
+    target: validateString2(rawObj.target, "target", mountSection),
+    permission: validateMountPermission(rawObj.permission, "permission", mountSection)
+  };
 }
-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
-    });
+function validateMountsArray(value, section) {
+  if (!Array.isArray(value)) {
+    throw new ConfigError(`[${section}].mounts must be an array of tables`);
   }
-  if ("inherits" in raw) {
-    result.inherits = validateInherits(raw.inherits, section);
+  const result = [];
+  for (let i = 0; i < value.length; i++) {
+    result.push(validateMountConfig(value[i], i, section));
   }
   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`);
-    }
-  }
-  return validateLoggingConfig(rawObj, section);
-}
-function validateCompleteConfig(raw, section) {
+function validateDockerConfig(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)) {
+    if (!DOCKER_CONFIG_KEYS.has(key)) {
       throw new ConfigError(`[${section}].${key} is not a valid option`);
     }
   }
-  const result = {
-    ...validateBaseConfig(rawObj, section),
-    ...validateLoggingConfig(rawObj, section)
-  };
-  if ("max-tokens" in rawObj) {
-    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
-      integer: true,
-      min: 1
-    });
+  const result = {};
+  if ("enabled" in rawObj) {
+    result.enabled = validateBoolean2(rawObj.enabled, "enabled", section);
   }
-  if ("quiet" in rawObj) {
-    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
+  if ("dockerfile" in rawObj) {
+    result.dockerfile = validateString2(rawObj.dockerfile, "dockerfile", section);
   }
-  if ("log-llm-requests" in rawObj) {
-    result["log-llm-requests"] = validateStringOrBoolean(
-      rawObj["log-llm-requests"],
-      "log-llm-requests",
+  if ("cwd-permission" in rawObj) {
+    result["cwd-permission"] = validateMountPermission(
+      rawObj["cwd-permission"],
+      "cwd-permission",
       section
     );
   }
-  if ("log-llm-responses" in rawObj) {
-    result["log-llm-responses"] = validateStringOrBoolean(
-      rawObj["log-llm-responses"],
-      "log-llm-responses",
+  if ("config-permission" in rawObj) {
+    result["config-permission"] = validateMountPermission(
+      rawObj["config-permission"],
+      "config-permission",
       section
     );
   }
+  if ("mounts" in rawObj) {
+    result.mounts = validateMountsArray(rawObj.mounts, section);
+  }
+  if ("env-vars" in rawObj) {
+    result["env-vars"] = validateStringArray2(rawObj["env-vars"], "env-vars", section);
+  }
+  if ("image-name" in rawObj) {
+    result["image-name"] = validateString2(rawObj["image-name"], "image-name", section);
+  }
+  if ("dev-mode" in rawObj) {
+    result["dev-mode"] = validateBoolean2(rawObj["dev-mode"], "dev-mode", section);
+  }
+  if ("dev-source" in rawObj) {
+    result["dev-source"] = validateString2(rawObj["dev-source"], "dev-source", section);
+  }
   return result;
 }
-function validateAgentConfig(raw, section) {
-  if (typeof raw !== "object" || raw === null) {
-    throw new ConfigError(`[${section}] must be a table`);
+
+// src/cli/docker/dockerfile.ts
+var DEFAULT_DOCKERFILE = `# llmist sandbox image
+# Auto-generated - customize via [docker].dockerfile in cli.toml
+
+FROM oven/bun:1-debian
+
+# Install essential tools
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    # ripgrep for fast file searching
+    ripgrep \\
+    # git for version control operations
+    git \\
+    # curl for downloads and API calls
+    curl \\
+    # ca-certificates for HTTPS
+    ca-certificates \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install ast-grep for code search/refactoring
+# Using the official install script
+RUN curl -fsSL https://raw.githubusercontent.com/ast-grep/ast-grep/main/install.sh | bash \\
+    && mv /root/.local/bin/ast-grep /usr/local/bin/ 2>/dev/null || true \\
+    && mv /root/.local/bin/sg /usr/local/bin/ 2>/dev/null || true
+
+# Install llmist globally via bun
+RUN bun add -g llmist
+
+# Working directory (host CWD will be mounted here)
+WORKDIR /workspace
+
+# Entry point - llmist with all arguments forwarded
+ENTRYPOINT ["llmist"]
+`;
+var DEV_DOCKERFILE = `# llmist DEV sandbox image
+# For development/testing with local source code
+
+FROM oven/bun:1-debian
+
+# Install essential tools (same as production)
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    ripgrep \\
+    git \\
+    curl \\
+    ca-certificates \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install ast-grep for code search/refactoring
+RUN curl -fsSL https://raw.githubusercontent.com/ast-grep/ast-grep/main/install.sh | bash \\
+    && mv /root/.local/bin/ast-grep /usr/local/bin/ 2>/dev/null || true \\
+    && mv /root/.local/bin/sg /usr/local/bin/ 2>/dev/null || true
+
+# Working directory (host CWD will be mounted here)
+WORKDIR /workspace
+
+# Entry point - run llmist from mounted source
+# Source is mounted at ${DEV_SOURCE_MOUNT_TARGET}
+ENTRYPOINT ["bun", "run", "${DEV_SOURCE_MOUNT_TARGET}/src/cli.ts"]
+`;
+function resolveDockerfile(config, devMode = false) {
+  if (config.dockerfile) {
+    return config.dockerfile;
   }
-  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`);
-    }
+  return devMode ? DEV_DOCKERFILE : DEFAULT_DOCKERFILE;
+}
+function computeDockerfileHash(dockerfile) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(dockerfile);
+  return Bun.hash(data).toString(16);
+}
+
+// src/cli/docker/image-manager.ts
+var import_node_fs9 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path9 = require("path");
+var CACHE_DIR = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".llmist", "docker-cache");
+var HASH_FILE = "image-hash.json";
+function ensureCacheDir() {
+  if (!(0, import_node_fs9.existsSync)(CACHE_DIR)) {
+    (0, import_node_fs9.mkdirSync)(CACHE_DIR, { recursive: true });
   }
-  const result = {
-    ...validateBaseConfig(rawObj, section),
-    ...validateLoggingConfig(rawObj, section)
-  };
-  if ("max-iterations" in rawObj) {
-    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
-      integer: true,
-      min: 1
-    });
+}
+function getCachedHash(imageName) {
+  const hashPath = (0, import_node_path9.join)(CACHE_DIR, HASH_FILE);
+  if (!(0, import_node_fs9.existsSync)(hashPath)) {
+    return void 0;
   }
-  if ("gadgets" in rawObj) {
-    result.gadgets = validateStringArray(rawObj.gadgets, "gadgets", section);
+  try {
+    const content = (0, import_node_fs9.readFileSync)(hashPath, "utf-8");
+    const cache = JSON.parse(content);
+    return cache[imageName]?.dockerfileHash;
+  } catch {
+    return void 0;
   }
-  if ("gadget-add" in rawObj) {
-    result["gadget-add"] = validateStringArray(rawObj["gadget-add"], "gadget-add", section);
+}
+function setCachedHash(imageName, hash) {
+  ensureCacheDir();
+  const hashPath = (0, import_node_path9.join)(CACHE_DIR, HASH_FILE);
+  let cache = {};
+  if ((0, import_node_fs9.existsSync)(hashPath)) {
+    try {
+      const content = (0, import_node_fs9.readFileSync)(hashPath, "utf-8");
+      cache = JSON.parse(content);
+    } catch {
+      cache = {};
+    }
   }
-  if ("gadget-remove" in rawObj) {
-    result["gadget-remove"] = validateStringArray(rawObj["gadget-remove"], "gadget-remove", section);
+  cache[imageName] = {
+    imageName,
+    dockerfileHash: hash,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_node_fs9.writeFileSync)(hashPath, JSON.stringify(cache, null, 2));
+}
+var DockerBuildError = class extends Error {
+  constructor(message, output) {
+    super(message);
+    this.output = output;
+    this.name = "DockerBuildError";
   }
-  if ("gadget" in rawObj) {
-    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
+};
+async function buildImage(imageName, dockerfile) {
+  ensureCacheDir();
+  const dockerfilePath = (0, import_node_path9.join)(CACHE_DIR, "Dockerfile");
+  (0, import_node_fs9.writeFileSync)(dockerfilePath, dockerfile);
+  const proc = Bun.spawn(
+    ["docker", "build", "-t", imageName, "-f", dockerfilePath, CACHE_DIR],
+    {
+      stdout: "pipe",
+      stderr: "pipe"
+    }
+  );
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  if (exitCode !== 0) {
+    const output = [stdout, stderr].filter(Boolean).join("\n");
+    throw new DockerBuildError(
+      `Docker build failed with exit code ${exitCode}`,
+      output
+    );
   }
-  if ("builtins" in rawObj) {
-    result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
+}
+async function ensureImage(imageName = DEFAULT_IMAGE_NAME, dockerfile) {
+  const hash = computeDockerfileHash(dockerfile);
+  const cachedHash = getCachedHash(imageName);
+  if (cachedHash === hash) {
+    return imageName;
   }
-  if ("builtin-interaction" in rawObj) {
-    result["builtin-interaction"] = validateBoolean(
-      rawObj["builtin-interaction"],
-      "builtin-interaction",
-      section
+  console.error(`Building Docker image '${imageName}'...`);
+  await buildImage(imageName, dockerfile);
+  setCachedHash(imageName, hash);
+  console.error(`Docker image '${imageName}' built successfully.`);
+  return imageName;
+}
+
+// src/cli/docker/docker-wrapper.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
+var import_node_os4 = require("os");
+var DockerUnavailableError = class extends Error {
+  constructor() {
+    super(
+      "Docker is required but not available. Install Docker or disable Docker sandboxing in your configuration."
     );
+    this.name = "DockerUnavailableError";
   }
-  if ("gadget-start-prefix" in rawObj) {
-    result["gadget-start-prefix"] = validateString(
-      rawObj["gadget-start-prefix"],
-      "gadget-start-prefix",
-      section
-    );
+};
+var DockerSkipError = class extends Error {
+  constructor() {
+    super("Docker execution skipped - already inside container");
+    this.name = "DockerSkipError";
   }
-  if ("gadget-end-prefix" in rawObj) {
-    result["gadget-end-prefix"] = validateString(
-      rawObj["gadget-end-prefix"],
-      "gadget-end-prefix",
-      section
-    );
+};
+async function checkDockerAvailable() {
+  try {
+    const proc = Bun.spawn(["docker", "info"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
   }
-  if ("gadget-arg-prefix" in rawObj) {
-    result["gadget-arg-prefix"] = validateString(
-      rawObj["gadget-arg-prefix"],
-      "gadget-arg-prefix",
-      section
-    );
+}
+function isInsideContainer() {
+  if ((0, import_node_fs10.existsSync)("/.dockerenv")) {
+    return true;
   }
-  if ("gadget-approval" in rawObj) {
-    result["gadget-approval"] = validateGadgetApproval(rawObj["gadget-approval"], section);
+  try {
+    const cgroup = (0, import_node_fs10.readFileSync)("/proc/1/cgroup", "utf-8");
+    if (cgroup.includes("docker") || cgroup.includes("containerd")) {
+      return true;
+    }
+  } catch {
   }
-  if ("quiet" in rawObj) {
-    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
+  return false;
+}
+function autoDetectDevSource() {
+  const scriptPath = process.argv[1];
+  if (!scriptPath || !scriptPath.endsWith("src/cli.ts")) {
+    return void 0;
   }
-  if ("log-llm-requests" in rawObj) {
-    result["log-llm-requests"] = validateStringOrBoolean(
-      rawObj["log-llm-requests"],
-      "log-llm-requests",
-      section
-    );
+  const srcDir = (0, import_node_path10.dirname)(scriptPath);
+  const projectDir = (0, import_node_path10.dirname)(srcDir);
+  const packageJsonPath = (0, import_node_path10.join)(projectDir, "package.json");
+  if (!(0, import_node_fs10.existsSync)(packageJsonPath)) {
+    return void 0;
   }
-  if ("log-llm-responses" in rawObj) {
-    result["log-llm-responses"] = validateStringOrBoolean(
-      rawObj["log-llm-responses"],
-      "log-llm-responses",
-      section
+  try {
+    const pkg = JSON.parse((0, import_node_fs10.readFileSync)(packageJsonPath, "utf-8"));
+    if (pkg.name === "llmist") {
+      return projectDir;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function resolveDevMode(config, cliDevMode) {
+  const enabled = cliDevMode || config?.["dev-mode"] || process.env.LLMIST_DEV_MODE === "1";
+  if (!enabled) {
+    return { enabled: false, sourcePath: void 0 };
+  }
+  const sourcePath = config?.["dev-source"] || process.env.LLMIST_DEV_SOURCE || autoDetectDevSource();
+  if (!sourcePath) {
+    throw new Error(
+      "Docker dev mode enabled but llmist source path not found. Set [docker].dev-source in config, LLMIST_DEV_SOURCE env var, or run from the llmist source directory (bun src/cli.ts)."
     );
   }
-  return result;
+  return { enabled: true, sourcePath };
 }
-function validateStringOrBoolean(value, field, section) {
-  if (typeof value === "string" || typeof value === "boolean") {
-    return value;
+function expandHome(path5) {
+  if (path5.startsWith("~")) {
+    return path5.replace(/^~/, (0, import_node_os4.homedir)());
   }
-  throw new ConfigError(`[${section}].${field} must be a string or boolean`);
+  return path5;
 }
-function validateCustomConfig(raw, section) {
-  if (typeof raw !== "object" || raw === null) {
-    throw new ConfigError(`[${section}] must be a table`);
+function buildDockerRunArgs(ctx, imageName, devMode) {
+  const args = ["run", "--rm"];
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).slice(2, 8);
+  const containerName = `llmist-${timestamp}-${random}`;
+  args.push("--name", containerName);
+  if (process.stdin.isTTY) {
+    args.push("-it");
   }
-  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`);
+  const cwdPermission = ctx.options.dockerRo ? "ro" : ctx.profileCwdPermission ?? ctx.config["cwd-permission"] ?? DEFAULT_CWD_PERMISSION;
+  args.push("-v", `${ctx.cwd}:/workspace:${cwdPermission}`);
+  args.push("-w", "/workspace");
+  const configPermission = ctx.config["config-permission"] ?? DEFAULT_CONFIG_PERMISSION;
+  const llmistDir = expandHome("~/.llmist");
+  args.push("-v", `${llmistDir}:/root/.llmist:${configPermission}`);
+  if (devMode.enabled && devMode.sourcePath) {
+    const expandedSource = expandHome(devMode.sourcePath);
+    args.push("-v", `${expandedSource}:${DEV_SOURCE_MOUNT_TARGET}:ro`);
+  }
+  if (ctx.config.mounts) {
+    for (const mount of ctx.config.mounts) {
+      const source = expandHome(mount.source);
+      args.push("-v", `${source}:${mount.target}:${mount.permission}`);
     }
   }
-  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"`);
+  for (const key of FORWARDED_API_KEYS) {
+    if (process.env[key]) {
+      args.push("-e", key);
     }
-    type = typeValue;
   }
-  const result = {
-    ...validateBaseConfig(rawObj, section),
-    type
-  };
-  if ("description" in rawObj) {
-    result.description = validateString(rawObj.description, "description", section);
+  if (ctx.config["env-vars"]) {
+    for (const key of ctx.config["env-vars"]) {
+      if (process.env[key]) {
+        args.push("-e", key);
+      }
+    }
   }
-  if ("max-iterations" in rawObj) {
-    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
-      integer: true,
-      min: 1
-    });
+  args.push(imageName);
+  args.push(...ctx.forwardArgs);
+  return args;
+}
+function filterDockerArgs(argv) {
+  const dockerFlags = /* @__PURE__ */ new Set(["--docker", "--docker-ro", "--no-docker", "--docker-dev"]);
+  return argv.filter((arg) => !dockerFlags.has(arg));
+}
+function resolveDockerEnabled(config, options, profileDocker) {
+  if (options.noDocker) {
+    return false;
   }
-  if ("gadgets" in rawObj) {
-    result.gadgets = validateStringArray(rawObj.gadgets, "gadgets", section);
+  if (options.docker || options.dockerRo) {
+    return true;
   }
-  if ("gadget-add" in rawObj) {
-    result["gadget-add"] = validateStringArray(rawObj["gadget-add"], "gadget-add", section);
+  if (profileDocker !== void 0) {
+    return profileDocker;
   }
-  if ("gadget-remove" in rawObj) {
-    result["gadget-remove"] = validateStringArray(rawObj["gadget-remove"], "gadget-remove", section);
+  return config?.enabled ?? false;
+}
+async function executeInDocker(ctx, devMode) {
+  if (isInsideContainer()) {
+    console.error(
+      "Warning: Docker mode requested but already inside a container. Proceeding without re-containerization."
+    );
+    throw new DockerSkipError();
   }
-  if ("gadget" in rawObj) {
-    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
+  const available = await checkDockerAvailable();
+  if (!available) {
+    throw new DockerUnavailableError();
   }
-  if ("builtins" in rawObj) {
-    result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
+  const dockerfile = resolveDockerfile(ctx.config, devMode.enabled);
+  const imageName = devMode.enabled ? DEV_IMAGE_NAME : ctx.config["image-name"] ?? DEFAULT_IMAGE_NAME;
+  if (devMode.enabled) {
+    console.error(`[dev mode] Mounting source from ${devMode.sourcePath}`);
   }
-  if ("builtin-interaction" in rawObj) {
-    result["builtin-interaction"] = validateBoolean(
-      rawObj["builtin-interaction"],
-      "builtin-interaction",
-      section
-    );
-  }
-  if ("gadget-start-prefix" in rawObj) {
-    result["gadget-start-prefix"] = validateString(
-      rawObj["gadget-start-prefix"],
-      "gadget-start-prefix",
-      section
-    );
-  }
-  if ("gadget-end-prefix" in rawObj) {
-    result["gadget-end-prefix"] = validateString(
-      rawObj["gadget-end-prefix"],
-      "gadget-end-prefix",
-      section
-    );
-  }
-  if ("gadget-arg-prefix" in rawObj) {
-    result["gadget-arg-prefix"] = validateString(
-      rawObj["gadget-arg-prefix"],
-      "gadget-arg-prefix",
-      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,
-      min: 1
-    });
-  }
-  if ("quiet" in rawObj) {
-    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
-  }
-  Object.assign(result, validateLoggingConfig(rawObj, section));
-  return result;
-}
-function validatePromptsConfig(raw, section) {
-  if (typeof raw !== "object" || raw === null) {
-    throw new ConfigError(`[${section}] must be a table`);
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (typeof value !== "string") {
-      throw new ConfigError(`[${section}].${key} must be a string`);
+  try {
+    await ensureImage(imageName, dockerfile);
+  } catch (error) {
+    if (error instanceof DockerBuildError) {
+      console.error("Docker build failed:");
+      console.error(error.output);
+      throw error;
     }
-    result[key] = value;
+    throw error;
   }
-  return result;
+  const dockerArgs = buildDockerRunArgs(ctx, imageName, devMode);
+  const proc = Bun.spawn(["docker", ...dockerArgs], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
 }
-function validateConfig(raw, configPath) {
-  if (typeof raw !== "object" || raw === null) {
-    throw new ConfigError("Config must be a TOML table", configPath);
+function createDockerContext(config, options, argv, cwd, profileCwdPermission) {
+  return {
+    config: config ?? {},
+    options,
+    forwardArgs: filterDockerArgs(argv),
+    cwd,
+    profileCwdPermission
+  };
+}
+
+// src/cli/agent-command.ts
+function createHumanInputHandler(env, progress, keyboard) {
+  const stdout = env.stdout;
+  if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
+    return void 0;
   }
-  const rawObj = raw;
-  const result = {};
-  for (const [key, value] of Object.entries(rawObj)) {
+  return async (question) => {
+    progress.pause();
+    if (keyboard.cleanupEsc) {
+      keyboard.cleanupEsc();
+      keyboard.cleanupEsc = null;
+    }
+    const rl = (0, import_promises3.createInterface)({ input: env.stdin, output: env.stdout });
     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 if (key === "prompts") {
-        result.prompts = validatePromptsConfig(value, key);
-      } else {
-        result[key] = validateCustomConfig(value, key);
-      }
-    } catch (error) {
-      if (error instanceof ConfigError) {
-        throw new ConfigError(error.message, configPath);
+      const questionLine = question.trim() ? `
+${renderMarkdownWithSeparators(question.trim())}` : "";
+      let isFirst = true;
+      while (true) {
+        const statsPrompt = progress.formatPrompt();
+        const prompt = isFirst ? `${questionLine}
+${statsPrompt}` : statsPrompt;
+        isFirst = false;
+        const answer = await rl.question(prompt);
+        const trimmed = answer.trim();
+        if (trimmed) {
+          return trimmed;
+        }
       }
-      throw error;
+    } finally {
+      rl.close();
+      keyboard.restore();
     }
-  }
-  return result;
+  };
 }
-function loadConfig() {
-  const configPath = getConfigPath();
-  if (!(0, import_node_fs8.existsSync)(configPath)) {
-    return {};
-  }
-  let content;
-  try {
-    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"}`,
-      configPath
-    );
-  }
-  let raw;
-  try {
-    raw = (0, import_js_toml.load)(content);
-  } catch (error) {
-    throw new ConfigError(
-      `Invalid TOML syntax: ${error instanceof Error ? error.message : "Unknown error"}`,
-      configPath
+async function executeAgent(promptArg, options, env) {
+  const dockerOptions = {
+    docker: options.docker ?? false,
+    dockerRo: options.dockerRo ?? false,
+    noDocker: options.noDocker ?? false,
+    dockerDev: options.dockerDev ?? false
+  };
+  const dockerEnabled = resolveDockerEnabled(
+    env.dockerConfig,
+    dockerOptions,
+    options.docker
+    // Profile-level docker: true/false
+  );
+  if (dockerEnabled) {
+    const devMode = resolveDevMode(env.dockerConfig, dockerOptions.dockerDev);
+    const ctx = createDockerContext(
+      env.dockerConfig,
+      dockerOptions,
+      env.argv.slice(2),
+      // Remove 'node' and script path
+      process.cwd(),
+      options.dockerCwdPermission
+      // Profile-level CWD permission override
     );
+    try {
+      await executeInDocker(ctx, devMode);
+    } catch (error) {
+      if (error instanceof Error && error.message === "SKIP_DOCKER") {
+      } else {
+        throw error;
+      }
+    }
   }
-  const validated = validateConfig(raw, configPath);
-  const inherited = resolveInheritance(validated, configPath);
-  return resolveTemplatesInConfig(inherited, configPath);
-}
-function getCustomCommandNames(config) {
-  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent", "prompts"]);
-  return Object.keys(config).filter((key) => !reserved.has(key));
-}
-function resolveTemplatesInConfig(config, configPath) {
-  const prompts = config.prompts ?? {};
-  const hasPrompts = Object.keys(prompts).length > 0;
-  let hasTemplates = false;
-  for (const [sectionName, section] of Object.entries(config)) {
-    if (sectionName === "global" || sectionName === "prompts") continue;
-    if (!section || typeof section !== "object") continue;
-    const sectionObj = section;
-    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
-      hasTemplates = true;
-      break;
+  const prompt = await resolvePrompt(promptArg, env);
+  const client = env.createClient();
+  const registry = new GadgetRegistry();
+  const stdinIsInteractive = isInteractive(env.stdin);
+  if (options.builtins !== false) {
+    for (const gadget of builtinGadgets) {
+      if (gadget.name === "AskUser" && (options.builtinInteraction === false || !stdinIsInteractive)) {
+        continue;
+      }
+      registry.registerByClass(gadget);
     }
   }
-  for (const template of Object.values(prompts)) {
-    if (hasTemplateSyntax(template)) {
-      hasTemplates = true;
-      break;
+  const gadgetSpecifiers = options.gadget ?? [];
+  if (gadgetSpecifiers.length > 0) {
+    const gadgets2 = await loadGadgets(gadgetSpecifiers, process.cwd());
+    for (const gadget of gadgets2) {
+      registry.registerByClass(gadget);
     }
   }
-  if (!hasPrompts && !hasTemplates) {
-    return config;
+  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);
   }
-  try {
-    validatePrompts(prompts, configPath);
-  } catch (error) {
-    if (error instanceof TemplateError) {
-      throw new ConfigError(error.message, configPath);
+  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";
     }
-    throw error;
   }
-  for (const [name, template] of Object.entries(prompts)) {
+  const approvalConfig = {
+    gadgetApprovals,
+    defaultMode: "allowed"
+  };
+  const approvalManager = new ApprovalManager(approvalConfig, env, progress);
+  let usage;
+  let iterations = 0;
+  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
+  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
+  let llmCallCounter = 0;
+  const countMessagesTokens = async (model, messages) => {
     try {
-      validateEnvVars(template, name, configPath);
-    } catch (error) {
-      if (error instanceof TemplateError) {
-        throw new ConfigError(error.message, configPath);
-      }
-      throw error;
+      return await client.countTokens(model, messages);
+    } catch {
+      const totalChars = messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
+      return Math.round(totalChars / FALLBACK_CHARS_PER_TOKEN);
     }
-  }
-  const eta = createTemplateEngine(prompts, configPath);
-  const result = { ...config };
-  for (const [sectionName, section] of Object.entries(config)) {
-    if (sectionName === "global" || sectionName === "prompts") continue;
-    if (!section || typeof section !== "object") continue;
-    const sectionObj = section;
-    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
-      try {
-        validateEnvVars(sectionObj.system, void 0, configPath);
-      } catch (error) {
-        if (error instanceof TemplateError) {
-          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+  };
+  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
+      // This showcases how to react to agent lifecycle events
+      onLLMCallStart: async (context) => {
+        isStreaming = true;
+        llmCallCounter++;
+        const inputTokens = await countMessagesTokens(
+          context.options.model,
+          context.options.messages
+        );
+        progress.startCall(context.options.model, inputTokens);
+        progress.setInputTokens(inputTokens, false);
+        if (llmRequestsDir) {
+          const filename = `${Date.now()}_call_${llmCallCounter}.request.txt`;
+          const content = formatLlmRequest(context.options.messages);
+          await writeLogFile(llmRequestsDir, filename, content);
+        }
+      },
+      // onStreamChunk: Real-time updates as LLM generates tokens
+      // This enables responsive UIs that show progress during generation
+      onStreamChunk: async (context) => {
+        progress.update(context.accumulatedText.length);
+        if (context.usage) {
+          if (context.usage.inputTokens) {
+            progress.setInputTokens(context.usage.inputTokens, false);
+          }
+          if (context.usage.outputTokens) {
+            progress.setOutputTokens(context.usage.outputTokens, false);
+          }
+          progress.setCachedTokens(
+            context.usage.cachedInputTokens ?? 0,
+            context.usage.cacheCreationInputTokens ?? 0
+          );
+        }
+      },
+      // 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) {
+          if (context.usage.inputTokens) {
+            progress.setInputTokens(context.usage.inputTokens, false);
+          }
+          if (context.usage.outputTokens) {
+            progress.setOutputTokens(context.usage.outputTokens, false);
+          }
+        }
+        let callCost;
+        if (context.usage && client.modelRegistry) {
+          try {
+            const modelName = context.options.model.includes(":") ? context.options.model.split(":")[1] : context.options.model;
+            const costResult = client.modelRegistry.estimateCost(
+              modelName,
+              context.usage.inputTokens,
+              context.usage.outputTokens,
+              context.usage.cachedInputTokens ?? 0,
+              context.usage.cacheCreationInputTokens ?? 0
+            );
+            if (costResult) callCost = costResult.totalCost;
+          } catch {
+          }
+        }
+        const callElapsed = progress.getCallElapsedSeconds();
+        progress.endCall(context.usage);
+        if (!options.quiet) {
+          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}
+`);
+          }
+        }
+        if (llmResponsesDir) {
+          const filename = `${Date.now()}_call_${llmCallCounter}.response.txt`;
+          await writeLogFile(llmResponsesDir, filename, context.rawResponse);
         }
-        throw error;
       }
-      try {
-        const resolved = resolveTemplate(eta, sectionObj.system, {}, configPath);
-        result[sectionName] = {
-          ...sectionObj,
-          system: resolved
-        };
-      } catch (error) {
-        if (error instanceof TemplateError) {
-          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+    },
+    // SHOWCASE: Controller-based approval gating for gadgets
+    //
+    // This demonstrates how to add safety layers WITHOUT modifying gadgets.
+    // 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
+    //
+    // Default: RunCommand, WriteFile, EditFile require approval unless overridden.
+    controllers: {
+      beforeGadgetExecution: async (ctx) => {
+        const mode = approvalManager.getApprovalMode(ctx.gadgetName);
+        if (mode === "allowed") {
+          return { action: "proceed" };
+        }
+        const stdinTTY = isInteractive(env.stdin);
+        const stderrTTY2 = env.stderr.isTTY === true;
+        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
+
+Denied: ${result.reason ?? "by user"}`
+          };
         }
-        throw error;
+        return { action: "proceed" };
       }
     }
+  });
+  if (options.system) {
+    builder.withSystem(options.system);
   }
-  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 (options.maxIterations !== void 0) {
+    builder.withMaxIterations(options.maxIterations);
   }
-  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 (options.temperature !== void 0) {
+    builder.withTemperature(options.temperature);
   }
-  if (hasGadgets) {
-    return section.gadgets;
+  const humanInputHandler = createHumanInputHandler(env, progress, keyboard);
+  if (humanInputHandler) {
+    builder.onHumanInput(humanInputHandler);
   }
-  if (hasGadgetLegacy) {
-    return section.gadget;
+  builder.withSignal(abortController.signal);
+  const gadgets = registry.getAll();
+  if (gadgets.length > 0) {
+    builder.withGadgets(...gadgets);
   }
-  let result = [...inheritedGadgets];
-  if (hasGadgetRemove) {
-    const toRemove = new Set(section["gadget-remove"]);
-    result = result.filter((g) => !toRemove.has(g));
+  if (options.gadgetStartPrefix) {
+    builder.withGadgetStartPrefix(options.gadgetStartPrefix);
   }
-  if (hasGadgetAdd) {
-    const toAdd = section["gadget-add"];
-    result.push(...toAdd);
+  if (options.gadgetEndPrefix) {
+    builder.withGadgetEndPrefix(options.gadgetEndPrefix);
   }
-  return result;
-}
-function resolveInheritance(config, configPath) {
-  const resolved = {};
-  const resolving = /* @__PURE__ */ new Set();
-  function resolveSection(name) {
-    if (name in resolved) {
-      return resolved[name];
+  if (options.gadgetArgPrefix) {
+    builder.withGadgetArgPrefix(options.gadgetArgPrefix);
+  }
+  builder.withSyntheticGadgetCall(
+    "TellUser",
+    {
+      message: "\u{1F44B} Hello! I'm ready to help.\n\nHere's what I can do:\n- Analyze your codebase\n- Execute commands\n- Answer questions\n\nWhat would you like me to work on?",
+      done: false,
+      type: "info"
+    },
+    "\u2139\uFE0F  \u{1F44B} Hello! I'm ready to help.\n\nHere's what I can do:\n- Analyze your codebase\n- Execute commands\n- Answer questions\n\nWhat would you like me to work on?"
+  );
+  builder.withTextOnlyHandler("acknowledge");
+  builder.withTextWithGadgetsHandler({
+    gadgetName: "TellUser",
+    parameterMapping: (text) => ({ message: text, done: false, type: "info" }),
+    resultMapping: (text) => `\u2139\uFE0F  ${text}`
+  });
+  const agent = builder.ask(prompt);
+  let textBuffer = "";
+  const flushTextBuffer = () => {
+    if (textBuffer) {
+      const output = options.quiet ? textBuffer : renderMarkdownWithSeparators(textBuffer);
+      printer.write(output);
+      textBuffer = "";
     }
-    if (resolving.has(name)) {
-      throw new ConfigError(`Circular inheritance detected: ${name}`, configPath);
+  };
+  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 })}
+`);
+        }
+      }
     }
-    const section = config[name];
-    if (section === void 0 || typeof section !== "object") {
-      throw new ConfigError(`Cannot inherit from unknown section: ${name}`, configPath);
+  } catch (error) {
+    if (!isAbortError(error)) {
+      throw error;
     }
-    resolving.add(name);
-    const sectionObj = section;
-    const inheritsRaw = sectionObj.inherits;
-    const inheritsList = inheritsRaw ? Array.isArray(inheritsRaw) ? inheritsRaw : [inheritsRaw] : [];
-    let merged = {};
-    for (const parent of inheritsList) {
-      const parentResolved = resolveSection(parent);
-      merged = { ...merged, ...parentResolved };
+  } finally {
+    isStreaming = false;
+    keyboard.cleanupEsc?.();
+    keyboard.cleanupSigint?.();
+  }
+  flushTextBuffer();
+  progress.complete();
+  printer.ensureNewline();
+  if (!options.quiet && iterations > 1) {
+    env.stderr.write(`${import_chalk5.default.dim("\u2500".repeat(40))}
+`);
+    const summary = renderOverallSummary({
+      totalTokens: usage?.totalTokens,
+      iterations,
+      elapsedSeconds: progress.getTotalElapsedSeconds(),
+      cost: progress.getTotalCost()
+    });
+    if (summary) {
+      env.stderr.write(`${summary}
+`);
     }
-    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;
+  }
+}
+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(() => {
+      const mergedOptions = {
+        ...options,
+        gadgetApproval: config?.["gadget-approval"]
+      };
+      return executeAgent(prompt, mergedOptions, env);
+    }, env)
+  );
+}
+
+// src/cli/complete-command.ts
+init_messages();
+init_model_shortcuts();
+init_constants2();
+async function executeComplete(promptArg, options, env) {
+  const prompt = await resolvePrompt(promptArg, env);
+  const client = env.createClient();
+  const model = resolveModel(options.model);
+  const builder = new LLMMessageBuilder();
+  if (options.system) {
+    builder.addSystem(options.system);
+  }
+  builder.addUser(prompt);
+  const messages = builder.build();
+  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
+  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
+  const timestamp = Date.now();
+  if (llmRequestsDir) {
+    const filename = `${timestamp}_complete.request.txt`;
+    const content = formatLlmRequest(messages);
+    await writeLogFile(llmRequestsDir, filename, content);
+  }
+  const stream2 = client.stream({
+    model,
+    messages,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens
+  });
+  const printer = new StreamPrinter(env.stdout);
+  const stderrTTY = env.stderr.isTTY === true;
+  const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
+  const estimatedInputTokens = Math.round(prompt.length / FALLBACK_CHARS_PER_TOKEN);
+  progress.startCall(model, estimatedInputTokens);
+  let finishReason;
+  let usage;
+  let accumulatedResponse = "";
+  for await (const chunk of stream2) {
+    if (chunk.usage) {
+      usage = chunk.usage;
+      if (chunk.usage.inputTokens) {
+        progress.setInputTokens(chunk.usage.inputTokens, false);
+      }
+      if (chunk.usage.outputTokens) {
+        progress.setOutputTokens(chunk.usage.outputTokens, false);
+      }
+    }
+    if (chunk.text) {
+      progress.pause();
+      accumulatedResponse += chunk.text;
+      progress.update(accumulatedResponse.length);
+      printer.write(chunk.text);
+    }
+    if (chunk.finishReason !== void 0) {
+      finishReason = chunk.finishReason;
     }
-    delete merged["gadget"];
-    delete merged["gadget-add"];
-    delete merged["gadget-remove"];
-    resolving.delete(name);
-    resolved[name] = merged;
-    return merged;
   }
-  for (const name of Object.keys(config)) {
-    resolveSection(name);
+  progress.endCall(usage);
+  progress.complete();
+  printer.ensureNewline();
+  if (llmResponsesDir) {
+    const filename = `${timestamp}_complete.response.txt`;
+    await writeLogFile(llmResponsesDir, filename, accumulatedResponse);
   }
-  return resolved;
+  if (stderrTTY && !options.quiet) {
+    const summary = renderSummary({ finishReason, usage, cost: progress.getTotalCost() });
+    if (summary) {
+      env.stderr.write(`${summary}
+`);
+    }
+  }
+}
+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/gadget-command.ts
@@ -10314,7 +10859,11 @@ function createCommandEnvironment(baseEnv, config) {
     logFile: config["log-file"] ?? baseEnv.loggerConfig?.logFile,
     logReset: config["log-reset"] ?? baseEnv.loggerConfig?.logReset
   };
-  return createDefaultEnvironment(loggerConfig);
+  return {
+    ...baseEnv,
+    loggerConfig,
+    createLogger: createLoggerFactory(loggerConfig)
+  };
 }
 function registerCustomCommand(program, name, config, env) {
   const type = config.type ?? "agent";
@@ -10390,7 +10939,12 @@ async function runCLI(overrides = {}) {
     logReset: globalOpts.logReset ?? config.global?.["log-reset"]
   };
   const defaultEnv = createDefaultEnvironment(loggerConfig);
-  const env = { ...defaultEnv, ...envOverrides };
+  const env = {
+    ...defaultEnv,
+    ...envOverrides,
+    // Pass Docker config from [docker] section
+    dockerConfig: config.docker
+  };
   const program = createProgram(env, config);
   await program.parseAsync(env.argv);
 }