@llmist/cli 16.0.4 → 16.2.0

package/dist/cli.js

@@ -110,7 +110,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commande
 // package.json
 var package_default = {
   name: "@llmist/cli",
-  version: "16.0.4",
+  version: "16.2.0",
   description: "CLI for llmist - run LLM agents from the command line",
   type: "module",
   main: "dist/cli.js",
@@ -167,7 +167,7 @@ var package_default = {
     node: ">=22.0.0"
   },
   dependencies: {
-    llmist: "^16.0.4",
+    llmist: "^16.2.0",
     "@unblessed/node": "^1.0.0-alpha.23",
     "diff-match-patch": "^1.0.5",
     chalk: "^5.6.2",
@@ -182,7 +182,7 @@ var package_default = {
     zod: "^4.1.12"
   },
   devDependencies: {
-    "@llmist/testing": "^16.0.4",
+    "@llmist/testing": "^16.2.0",
     "@types/diff": "^8.0.0",
     "@types/diff-match-patch": "^1.0.36",
     "@types/js-yaml": "^4.0.9",
@@ -211,15 +211,15 @@ var CONVERSION_TIMEOUT_MS = 3e4;
 var ffmpegCheckPromise = null;
 async function isFFmpegAvailable() {
   if (ffmpegCheckPromise !== null) return ffmpegCheckPromise;
-  ffmpegCheckPromise = new Promise((resolve3) => {
+  ffmpegCheckPromise = new Promise((resolve4) => {
     const proc = spawn("ffmpeg", ["-version"], { stdio: "ignore" });
-    proc.on("error", () => resolve3(false));
-    proc.on("close", (code) => resolve3(code === 0));
+    proc.on("error", () => resolve4(false));
+    proc.on("close", (code) => resolve4(code === 0));
   });
   return ffmpegCheckPromise;
 }
 async function convertToMp3(input, inputFormat, timeout = CONVERSION_TIMEOUT_MS) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let timeoutId;
     const inputArgs = inputFormat === "pcm16" ? ["-f", "s16le", "-ar", "24000", "-ac", "1"] : ["-f", inputFormat];
     const proc = spawn(
@@ -244,15 +244,15 @@ async function convertToMp3(input, inputFormat, timeout = CONVERSION_TIMEOUT_MS)
     proc.stdout.on("data", (chunk) => chunks.push(chunk));
     proc.on("error", () => {
       clearTimeout(timeoutId);
-      resolve3(null);
+      resolve4(null);
     });
     proc.on("close", (code) => {
       clearTimeout(timeoutId);
-      resolve3(code === 0 ? Buffer.concat(chunks) : null);
+      resolve4(code === 0 ? Buffer.concat(chunks) : null);
     });
     timeoutId = setTimeout(() => {
       proc.kill();
-      resolve3(null);
+      resolve4(null);
     }, timeout);
     proc.stdin.on("error", () => {
     });
@@ -453,7 +453,6 @@ var finish = createGadget2({
     throw new TaskCompletionSignal("Task completed");
   }
 });
-var builtinGadgets = [askUser, tellUser, finish, createTextToSpeech()];
 function getBuiltinGadgets(speechConfig) {
   return [askUser, tellUser, finish, createTextToSpeech(speechConfig)];
 }
@@ -507,8 +506,6 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   // Add to inherited gadgets
   "gadget-remove",
   // Remove from inherited gadgets
-  "gadget",
-  // DEPRECATED: alias for gadgets
   "builtins",
   "builtin-interaction",
   "gadget-start-prefix",
@@ -559,18 +556,18 @@ var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["none", "low", "medium",
 
 // src/paths.ts
 import { homedir } from "os";
-function expandTildePath(path6) {
-  if (!path6.startsWith("~")) {
-    return path6;
+function expandTildePath(path7) {
+  if (!path7.startsWith("~")) {
+    return path7;
   }
-  return path6.replace(/^~/, homedir());
+  return path7.replace(/^~/, homedir());
 }
 
 // src/config-validators.ts
 var ConfigError = class extends Error {
-  constructor(message, path6) {
-    super(path6 ? `${path6}: ${message}` : message);
-    this.path = path6;
+  constructor(message, path7) {
+    super(path7 ? `${path7}: ${message}` : message);
+    this.path = path7;
     this.name = "ConfigError";
   }
 };
@@ -935,9 +932,6 @@ function validateAgentFields(rawObj, section, result) {
       section
     );
   }
-  if ("gadget" in rawObj) {
-    result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
-  }
   if ("builtins" in rawObj) {
     result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
   }
@@ -1189,13 +1183,13 @@ function createTemplateEngine(prompts, configPath) {
     functionHeader: "const includeFile = (path) => it.__includeFile(path);"
   });
   const includeStack = [];
-  eta.__includeFileImpl = (path6) => {
-    if (includeStack.includes(path6)) {
-      throw new Error(`Circular include detected: ${[...includeStack, path6].join(" -> ")}`);
+  eta.__includeFileImpl = (path7) => {
+    if (includeStack.includes(path7)) {
+      throw new Error(`Circular include detected: ${[...includeStack, path7].join(" -> ")}`);
     }
-    includeStack.push(path6);
+    includeStack.push(path7);
     try {
-      const content = loadFileContents(path6, configDir);
+      const content = loadFileContents(path7, configDir);
       if (hasTemplateSyntax(content)) {
         const context = {
           env: process.env,
@@ -1278,15 +1272,9 @@ function hasTemplateSyntax(str) {
 // src/config-resolution.ts
 function resolveGadgets(section, inheritedGadgets, sectionName, configPath) {
   const hasGadgets = "gadgets" in section;
-  const hasGadgetLegacy = "gadget" in section;
   const hasGadgetAdd = "gadget-add" in section;
   const hasGadgetRemove = "gadget-remove" in section;
-  if (hasGadgetLegacy && !hasGadgets) {
-    console.warn(
-      `[config] Warning: [${sectionName}].gadget is deprecated, use 'gadgets' (plural) instead`
-    );
-  }
-  if ((hasGadgets || hasGadgetLegacy) && (hasGadgetAdd || hasGadgetRemove)) {
+  if (hasGadgets && (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
@@ -1295,9 +1283,6 @@ function resolveGadgets(section, inheritedGadgets, sectionName, configPath) {
   if (hasGadgets) {
     return section.gadgets;
   }
-  if (hasGadgetLegacy) {
-    return section.gadget;
-  }
   let result = [...inheritedGadgets];
   if (hasGadgetRemove) {
     const toRemove = new Set(section["gadget-remove"]);
@@ -1336,7 +1321,6 @@ function resolveInheritance(config, configPath) {
     const {
       inherits: _inherits,
       gadgets: _gadgets,
-      gadget: _gadget,
       "gadget-add": _gadgetAdd,
       "gadget-remove": _gadgetRemove,
       ...ownValues
@@ -1346,7 +1330,6 @@ function resolveInheritance(config, configPath) {
     if (resolvedGadgets.length > 0) {
       merged.gadgets = resolvedGadgets;
     }
-    delete merged.gadget;
     delete merged["gadget-add"];
     delete merged["gadget-remove"];
     resolving.delete(name);
@@ -1430,6 +1413,48 @@ function resolveTemplatesInConfig(config, configPath) {
   return result;
 }
 
+// src/skills/config-types.ts
+var SKILLS_CONFIG_KEYS = /* @__PURE__ */ new Set(["sources", "overrides"]);
+var SKILL_OVERRIDE_KEYS = /* @__PURE__ */ new Set(["model", "enabled"]);
+function validateSkillsConfig(value, sectionName) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`[${sectionName}] must be a table`);
+  }
+  const raw = value;
+  const result = {};
+  for (const [key, val] of Object.entries(raw)) {
+    if (key === "sources") {
+      if (!Array.isArray(val)) {
+        throw new Error(`[${sectionName}].sources must be an array`);
+      }
+      result.sources = val.map(String);
+    } else if (key === "overrides") {
+      if (typeof val !== "object" || val === null) {
+        throw new Error(`[${sectionName}].overrides must be a table`);
+      }
+      result.overrides = {};
+      for (const [skillName, override] of Object.entries(val)) {
+        if (typeof override !== "object" || override === null) {
+          throw new Error(`[${sectionName}].overrides.${skillName} must be a table`);
+        }
+        const overrideObj = override;
+        const skillOverride = {};
+        for (const [oKey, oVal] of Object.entries(overrideObj)) {
+          if (!SKILL_OVERRIDE_KEYS.has(oKey)) {
+            throw new Error(`[${sectionName}].overrides.${skillName}: unknown key "${oKey}"`);
+          }
+          if (oKey === "model") skillOverride.model = String(oVal);
+          if (oKey === "enabled") skillOverride.enabled = Boolean(oVal);
+        }
+        result.overrides[skillName] = skillOverride;
+      }
+    } else if (!SKILLS_CONFIG_KEYS.has(key)) {
+      throw new Error(`[${sectionName}]: unknown key "${key}"`);
+    }
+  }
+  return result;
+}
+
 // src/config.ts
 function getConfigPath() {
   return join(homedir2(), ".llmist", "cli.toml");
@@ -1460,6 +1485,8 @@ function validateConfig(raw, configPath) {
         result["rate-limits"] = validateRateLimitsConfig(value, key);
       } else if (key === "retry") {
         result.retry = validateRetryConfig(value, key);
+      } else if (key === "skills") {
+        result.skills = validateSkillsConfig(value, key);
       } else {
         result[key] = validateCustomConfig(value, key);
       }
@@ -1600,18 +1627,99 @@ async function readFileBuffer(filePath, options = {}) {
 }
 
 // src/gadgets.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import { createRequire } from "module";
-import path5 from "path";
+import path6 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { createJiti } from "jiti";
 import { AbstractGadget } from "llmist";
 
-// src/builtins/filesystem/edit-file.ts
-import { readFileSync as readFileSync3, writeFileSync } from "fs";
+// src/builtins/filesystem/delete-file.ts
+import fs2 from "fs";
 import { createGadget as createGadget3 } from "llmist";
 import { z as z3 } from "zod";
 
+// src/builtins/filesystem/utils.ts
+import fs from "fs";
+import path from "path";
+var PathSandboxException = class extends Error {
+  constructor(inputPath, reason) {
+    super(`Path access denied: ${inputPath}. ${reason}`);
+    this.name = "PathSandboxException";
+  }
+};
+function validatePathIsWithinCwd(inputPath) {
+  const cwd = process.cwd();
+  const resolvedPath = path.resolve(cwd, inputPath);
+  let realCwd;
+  try {
+    realCwd = fs.realpathSync(cwd);
+  } catch {
+    realCwd = cwd;
+  }
+  let finalPath;
+  try {
+    finalPath = fs.realpathSync(resolvedPath);
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
+      finalPath = resolvedPath;
+    } else {
+      throw error;
+    }
+  }
+  const cwdWithSep = realCwd + path.sep;
+  if (!finalPath.startsWith(cwdWithSep) && finalPath !== realCwd) {
+    throw new PathSandboxException(inputPath, "Path is outside the current working directory");
+  }
+  return finalPath;
+}
+
+// src/builtins/filesystem/delete-file.ts
+var deleteFile = createGadget3({
+  name: "DeleteFile",
+  description: "Delete a file or directory from the local filesystem. The path must be within the current working directory or its subdirectories.",
+  maxConcurrent: 1,
+  // Sequential execution to prevent race conditions
+  schema: z3.object({
+    filePath: z3.string().describe("Path to the file or directory to delete (relative or absolute)"),
+    recursive: z3.boolean().optional().default(false).describe("If true, perform a recursive deletion (required for directories)")
+  }),
+  examples: [
+    {
+      params: { filePath: "temp.txt", recursive: false },
+      output: "path=temp.txt\n\nDeleted file successfully",
+      comment: "Delete a single file"
+    },
+    {
+      params: { filePath: "tmp-dir", recursive: true },
+      output: "path=tmp-dir\n\nDeleted directory successfully",
+      comment: "Delete a directory and its contents"
+    }
+  ],
+  execute: ({ filePath, recursive }) => {
+    const validatedPath = validatePathIsWithinCwd(filePath);
+    if (!fs2.existsSync(validatedPath)) {
+      return `Error: Path does not exist: ${filePath}`;
+    }
+    const stats = fs2.statSync(validatedPath);
+    const isDirectory = stats.isDirectory();
+    if (isDirectory && !recursive) {
+      return `Error: ${filePath} is a directory. Set recursive=true to delete it.`;
+    }
+    fs2.rmSync(validatedPath, { recursive, force: true });
+    const type = isDirectory ? "directory" : "file";
+    return `path=${filePath}
+
+Deleted ${type} successfully`;
+  }
+});
+
+// src/builtins/filesystem/edit-file.ts
+import { readFileSync as readFileSync3, writeFileSync } from "fs";
+import { createGadget as createGadget4 } from "llmist";
+import { z as z4 } from "zod";
+
 // src/builtins/filesystem/editfile/matcher.ts
 import DiffMatchPatch from "diff-match-patch";
 var dmp = new DiffMatchPatch();
@@ -2029,36 +2137,6 @@ function formatMultipleMatches(content, matches, maxMatches = 5) {
   return output.join("\n");
 }
 
-// src/builtins/filesystem/utils.ts
-import fs from "fs";
-import path from "path";
-var PathSandboxException = class extends Error {
-  constructor(inputPath, reason) {
-    super(`Path access denied: ${inputPath}. ${reason}`);
-    this.name = "PathSandboxException";
-  }
-};
-function validatePathIsWithinCwd(inputPath) {
-  const cwd = process.cwd();
-  const resolvedPath = path.resolve(cwd, inputPath);
-  let finalPath;
-  try {
-    finalPath = fs.realpathSync(resolvedPath);
-  } catch (error) {
-    const nodeError = error;
-    if (nodeError.code === "ENOENT") {
-      finalPath = resolvedPath;
-    } else {
-      throw error;
-    }
-  }
-  const cwdWithSep = cwd + path.sep;
-  if (!finalPath.startsWith(cwdWithSep) && finalPath !== cwd) {
-    throw new PathSandboxException(inputPath, "Path is outside the current working directory");
-  }
-  return finalPath;
-}
-
 // src/builtins/filesystem/edit-file.ts
 function formatFailure(filePath, search, failure, fileContent) {
   const lines = [
@@ -2090,7 +2168,7 @@ function formatFailure(filePath, search, failure, fileContent) {
   lines.push("", "CURRENT FILE CONTENT:", "```", fileContent, "```");
   return lines.join("\n");
 }
-var editFile = createGadget3({
+var editFile = createGadget4({
   name: "EditFile",
   description: `Edit a file by searching for content and replacing it.
 
@@ -2109,12 +2187,12 @@ Options:
 - expectedCount: Validate exact number of matches before applying`,
   maxConcurrent: 1,
   // Sequential execution to prevent race conditions
-  schema: z3.object({
-    filePath: z3.string().describe("Path to the file to edit (relative or absolute)"),
-    search: z3.string().describe("The content to search for in the file"),
-    replace: z3.string().describe("The content to replace it with (empty string to delete)"),
-    replaceAll: z3.boolean().optional().default(false).describe("Replace all occurrences instead of just the first match"),
-    expectedCount: z3.number().int().positive().optional().describe("Expected number of matches. Edit fails if actual count differs")
+  schema: z4.object({
+    filePath: z4.string().describe("Path to the file to edit (relative or absolute)"),
+    search: z4.string().describe("The content to search for in the file"),
+    replace: z4.string().describe("The content to replace it with (empty string to delete)"),
+    replaceAll: z4.boolean().optional().default(false).describe("Replace all occurrences instead of just the first match"),
+    expectedCount: z4.number().int().positive().optional().describe("Expected number of matches. Edit fails if actual count differs")
   }),
   examples: [
     {
@@ -2266,19 +2344,19 @@ function executeReplaceAll(content, matches, replace) {
 }
 
 // src/builtins/filesystem/list-directory.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path2 from "path";
-import { createGadget as createGadget4 } from "llmist";
-import { z as z4 } from "zod";
+import { createGadget as createGadget5 } from "llmist";
+import { z as z5 } from "zod";
 function listFiles(dirPath, basePath = dirPath, maxDepth = 1, currentDepth = 1) {
   const entries = [];
   try {
-    const items = fs2.readdirSync(dirPath);
+    const items = fs3.readdirSync(dirPath);
     for (const item of items) {
       const fullPath = path2.join(dirPath, item);
       const relativePath = path2.relative(basePath, fullPath);
       try {
-        const stats = fs2.lstatSync(fullPath);
+        const stats = fs3.lstatSync(fullPath);
         let type;
         let size;
         if (stats.isSymbolicLink()) {
@@ -2353,12 +2431,12 @@ function formatEntriesAsString(entries) {
   );
   return [header, ...rows].join("\n");
 }
-var listDirectory = createGadget4({
+var listDirectory = createGadget5({
   name: "ListDirectory",
   description: "List files and directories in a directory with full details (names, types, sizes, modification dates). Use maxDepth to explore subdirectories recursively. The directory path must be within the current working directory or its subdirectories.",
-  schema: z4.object({
-    directoryPath: z4.string().default(".").describe("Path to the directory to list"),
-    maxDepth: z4.number().int().min(1).max(10).default(3).describe(
+  schema: z5.object({
+    directoryPath: z5.string().default(".").describe("Path to the directory to list"),
+    maxDepth: z5.number().int().min(1).max(10).default(3).describe(
       "Maximum depth to recurse (1 = immediate children only, 2 = include grandchildren, etc.)"
     )
   }),
@@ -2376,7 +2454,7 @@ var listDirectory = createGadget4({
   ],
   execute: ({ directoryPath, maxDepth }) => {
     const validatedPath = validatePathIsWithinCwd(directoryPath);
-    const stats = fs2.statSync(validatedPath);
+    const stats = fs3.statSync(validatedPath);
     if (!stats.isDirectory()) {
       throw new Error(`Path is not a directory: ${directoryPath}`);
     }
@@ -2389,14 +2467,14 @@ ${formattedList}`;
 });
 
 // src/builtins/filesystem/read-file.ts
-import fs3 from "fs";
-import { createGadget as createGadget5 } from "llmist";
-import { z as z5 } from "zod";
-var readFile2 = createGadget5({
+import fs4 from "fs";
+import { createGadget as createGadget6 } from "llmist";
+import { z as z6 } from "zod";
+var readFile2 = createGadget6({
   name: "ReadFile",
   description: "Read the entire content of a file and return it as text. The file path must be within the current working directory or its subdirectories.",
-  schema: z5.object({
-    filePath: z5.string().describe("Path to the file to read (relative or absolute)")
+  schema: z6.object({
+    filePath: z6.string().describe("Path to the file to read (relative or absolute)")
   }),
   examples: [
     {
@@ -2412,7 +2490,7 @@ var readFile2 = createGadget5({
   ],
   execute: ({ filePath }) => {
     const validatedPath = validatePathIsWithinCwd(filePath);
-    const content = fs3.readFileSync(validatedPath, "utf-8");
+    const content = fs4.readFileSync(validatedPath, "utf-8");
     return `path=${filePath}
 
 ${content}`;
@@ -2420,18 +2498,18 @@ ${content}`;
 });
 
 // src/builtins/filesystem/write-file.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path3 from "path";
-import { createGadget as createGadget6 } from "llmist";
-import { z as z6 } from "zod";
-var writeFile = createGadget6({
+import { createGadget as createGadget7 } from "llmist";
+import { z as z7 } from "zod";
+var writeFile = createGadget7({
   name: "WriteFile",
   description: "Write content to a file. Creates parent directories if needed. Overwrites existing files. The file path must be within the current working directory or its subdirectories.",
   maxConcurrent: 1,
   // Sequential execution to prevent race conditions
-  schema: z6.object({
-    filePath: z6.string().describe("Path to the file to write (relative or absolute)"),
-    content: z6.string().describe("Content to write to the file")
+  schema: z7.object({
+    filePath: z7.string().describe("Path to the file to write (relative or absolute)"),
+    content: z7.string().describe("Content to write to the file")
   }),
   examples: [
     {
@@ -2461,12 +2539,12 @@ console.log(\`Server running on http://localhost:\${port}\`);`
     const validatedPath = validatePathIsWithinCwd(filePath);
     const parentDir = path3.dirname(validatedPath);
     let createdDir = false;
-    if (!fs4.existsSync(parentDir)) {
+    if (!fs5.existsSync(parentDir)) {
       validatePathIsWithinCwd(parentDir);
-      fs4.mkdirSync(parentDir, { recursive: true });
+      fs5.mkdirSync(parentDir, { recursive: true });
       createdDir = true;
     }
-    fs4.writeFileSync(validatedPath, content, "utf-8");
+    fs5.writeFileSync(validatedPath, content, "utf-8");
     const bytesWritten = Buffer.byteLength(content, "utf-8");
     const dirNote = createdDir ? ` (created directory: ${path3.dirname(filePath)})` : "";
     return `path=${filePath}
@@ -2475,9 +2553,141 @@ Wrote ${bytesWritten} bytes${dirNote}`;
   }
 });
 
+// src/builtins/read-image.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import path4 from "path";
+import { createGadget as createGadget8, getErrorMessage as getErrorMessage2, resultWithImage } from "llmist";
+import { z as z8 } from "zod";
+var MAX_IMAGE_SIZE = 50 * 1024 * 1024;
+var URL_FETCH_TIMEOUT_MS = 3e4;
+var SUPPORTED_FORMATS = "JPEG, PNG, GIF, WebP";
+var USER_AGENT = "llmist-cli";
+var MIME_TO_EXT = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp"
+};
+function isUrl(source) {
+  return source.startsWith("http://") || source.startsWith("https://");
+}
+function fileNameFromUrl(source) {
+  try {
+    const urlPath = new URL(source).pathname;
+    const base = path4.basename(urlPath);
+    if (base && base.includes(".")) {
+      return base;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function readImageFromFile(source) {
+  const resolvedPath = path4.resolve(source);
+  let stats;
+  try {
+    stats = await stat2(resolvedPath);
+  } catch (error) {
+    return `error: Cannot read image file "${source}": ${getErrorMessage2(error)}`;
+  }
+  if (stats.size > MAX_IMAGE_SIZE) {
+    return `error: Image file "${source}" is too large (${formatFileSize(stats.size)}). Maximum: ${formatFileSize(MAX_IMAGE_SIZE)}.`;
+  }
+  let buffer;
+  try {
+    buffer = await readFile3(resolvedPath);
+  } catch (error) {
+    return `error: Cannot read image file "${source}": ${getErrorMessage2(error)}`;
+  }
+  const fileName = path4.basename(resolvedPath);
+  try {
+    return resultWithImage(`source=${source}
+size=${formatFileSize(buffer.length)}`, buffer, {
+      description: `Image: ${fileName}`,
+      fileName
+    });
+  } catch (error) {
+    if (getErrorMessage2(error).includes("MIME type")) {
+      return `error: File "${source}" is not a supported image format. Supported formats: ${SUPPORTED_FORMATS}.`;
+    }
+    throw error;
+  }
+}
+async function fetchImageFromUrl(source) {
+  const response = await fetch(source, {
+    signal: AbortSignal.timeout(URL_FETCH_TIMEOUT_MS),
+    headers: { "User-Agent": USER_AGENT }
+  });
+  if (!response.ok) {
+    return `error: Failed to fetch image: HTTP ${response.status} ${response.statusText}`;
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number.parseInt(contentLength, 10) > MAX_IMAGE_SIZE) {
+    return `error: Image at URL is too large (${formatFileSize(Number.parseInt(contentLength, 10))}). Maximum: ${formatFileSize(MAX_IMAGE_SIZE)}.`;
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  if (buffer.length > MAX_IMAGE_SIZE) {
+    return `error: Downloaded image is too large (${formatFileSize(buffer.length)}). Maximum: ${formatFileSize(MAX_IMAGE_SIZE)}.`;
+  }
+  try {
+    const result = resultWithImage(
+      `source=${source}
+size=${formatFileSize(buffer.length)}`,
+      buffer,
+      { description: `Image from ${source}` }
+    );
+    const detectedMime = result.media?.[0]?.mimeType;
+    const fileName = fileNameFromUrl(source) ?? `image${detectedMime && MIME_TO_EXT[detectedMime] || ".bin"}`;
+    if (result.media?.[0]) {
+      result.media[0].fileName = fileName;
+    }
+    return result;
+  } catch (error) {
+    if (getErrorMessage2(error).includes("MIME type")) {
+      return `error: Content at "${source}" is not a supported image format. Supported formats: ${SUPPORTED_FORMATS}.`;
+    }
+    throw error;
+  }
+}
+var readImage = createGadget8({
+  name: "ReadImage",
+  description: "Read an image from a local file path or HTTP/HTTPS URL and return it for visual analysis. Supports JPEG, PNG, GIF, and WebP formats.",
+  schema: z8.object({
+    source: z8.string().min(1).describe("Path to a local image file or an HTTP/HTTPS URL")
+  }),
+  examples: [
+    {
+      params: { source: "./screenshot.png" },
+      output: "source=./screenshot.png\nsize=1.2 MB",
+      comment: "Read a local PNG image"
+    },
+    {
+      params: { source: "https://example.com/photo.jpg" },
+      output: "source=https://example.com/photo.jpg\nsize=245.3 KB",
+      comment: "Fetch an image from a URL"
+    },
+    {
+      params: { source: "/home/user/photos/cat.webp" },
+      output: "source=/home/user/photos/cat.webp\nsize=89.4 KB",
+      comment: "Read an image with absolute path (no CWD restriction)"
+    }
+  ],
+  execute: async ({ source }) => {
+    try {
+      if (isUrl(source)) {
+        return await fetchImageFromUrl(source);
+      }
+      return await readImageFromFile(source);
+    } catch (error) {
+      return `error: ${getErrorMessage2(error)}`;
+    }
+  }
+});
+
 // src/builtins/run-command.ts
-import { createGadget as createGadget7 } from "llmist";
-import { z as z7 } from "zod";
+import { createGadget as createGadget9 } from "llmist";
+import { z as z9 } from "zod";
 
 // src/spawn.ts
 import { spawn as nodeSpawn } from "child_process";
@@ -2510,9 +2720,9 @@ function spawn2(argv, options = {}) {
       options.stderr === "pipe" ? "pipe" : options.stderr ?? "ignore"
     ]
   });
-  const exited = new Promise((resolve3, reject) => {
+  const exited = new Promise((resolve4, reject) => {
     proc.on("exit", (code) => {
-      resolve3(code ?? 1);
+      resolve4(code ?? 1);
     });
     proc.on("error", (err) => {
       reject(err);
@@ -2538,13 +2748,13 @@ function spawn2(argv, options = {}) {
 }
 
 // src/builtins/run-command.ts
-var runCommand = createGadget7({
+var runCommand = createGadget9({
   name: "RunCommand",
   description: "Execute a command with arguments and return its output. Uses argv array to bypass shell - arguments are passed directly without interpretation. Returns stdout/stderr combined with exit status.",
-  schema: z7.object({
-    argv: z7.array(z7.string()).describe("Command and arguments as array (e.g., ['git', 'commit', '-m', 'message'])"),
-    cwd: z7.string().optional().describe("Working directory for the command (default: current directory)"),
-    timeout: z7.number().default(3e4).describe("Timeout in milliseconds (default: 30000)")
+  schema: z9.object({
+    argv: z9.array(z9.string()).describe("Command and arguments as array (e.g., ['git', 'commit', '-m', 'message'])"),
+    cwd: z9.string().optional().describe("Working directory for the command (default: current directory)"),
+    timeout: z9.number().default(3e4).describe("Timeout in milliseconds (default: 30000)")
   }),
   examples: [
     {
@@ -2649,8 +2859,10 @@ error: ${message}`;
 var builtinGadgetRegistry = {
   ListDirectory: listDirectory,
   ReadFile: readFile2,
+  ReadImage: readImage,
   WriteFile: writeFile,
   EditFile: editFile,
+  DeleteFile: deleteFile,
   RunCommand: runCommand,
   TextToSpeech: textToSpeech
 };
@@ -2660,12 +2872,15 @@ function getBuiltinGadget(name) {
 function isBuiltinGadgetName(name) {
   return name in builtinGadgetRegistry;
 }
+function getBuiltinGadgetNames() {
+  return Object.keys(builtinGadgetRegistry);
+}
 
 // src/external-gadgets.ts
 import { execSync } from "child_process";
-import fs5 from "fs";
+import fs6 from "fs";
 import os from "os";
-import path4 from "path";
+import path5 from "path";
 import { pathToFileURL } from "url";
 function isCommandAvailable(cmd) {
   try {
@@ -2676,7 +2891,7 @@ function isCommandAvailable(cmd) {
     return false;
   }
 }
-var CACHE_DIR = path4.join(os.homedir(), ".llmist", "gadget-cache");
+var CACHE_DIR = path5.join(os.homedir(), ".llmist", "gadget-cache");
 function isExternalPackageSpecifier(specifier) {
   if (/^(?:@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(?:@[\w.-]+)?(?::[a-z]+)?(?:\/[A-Z]\w*)?$/i.test(
     specifier
@@ -2766,21 +2981,21 @@ function parseGadgetSpecifier(specifier) {
 function getCacheDir(spec) {
   const versionSuffix = spec.version ? `@${spec.version}` : "@latest";
   if (spec.type === "npm") {
-    return path4.join(CACHE_DIR, "npm", `${spec.package}${versionSuffix}`);
+    return path5.join(CACHE_DIR, "npm", `${spec.package}${versionSuffix}`);
   }
   const sanitizedUrl = spec.package.replace(/[/:]/g, "-").replace(/^-+|-+$/g, "");
-  return path4.join(CACHE_DIR, "git", `${sanitizedUrl}${versionSuffix}`);
+  return path5.join(CACHE_DIR, "git", `${sanitizedUrl}${versionSuffix}`);
 }
 function isCached(cacheDir) {
-  const packageJsonPath = path4.join(cacheDir, "package.json");
-  if (!fs5.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(cacheDir, "package.json");
+  if (!fs6.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
     const entryPoint = packageJson.llmist?.gadgets || "./dist/index.js";
-    const entryPointPath = path4.join(cacheDir, entryPoint);
-    if (!fs5.existsSync(entryPointPath)) {
+    const entryPointPath = path5.join(cacheDir, entryPoint);
+    if (!fs6.existsSync(entryPointPath)) {
       return false;
     }
   } catch {
@@ -2789,13 +3004,13 @@ function isCached(cacheDir) {
   return true;
 }
 async function installNpmPackage(spec, cacheDir) {
-  fs5.mkdirSync(cacheDir, { recursive: true });
+  fs6.mkdirSync(cacheDir, { recursive: true });
   const packageJson = {
     name: "llmist-gadget-cache",
     private: true,
     type: "module"
   };
-  fs5.writeFileSync(path4.join(cacheDir, "package.json"), JSON.stringify(packageJson, null, 2));
+  fs6.writeFileSync(path5.join(cacheDir, "package.json"), JSON.stringify(packageJson, null, 2));
   const packageSpec = spec.version ? `${spec.package}@${spec.version}` : spec.package;
   const quietEnv = { ...process.env, DISABLE_OPENCOLLECTIVE: "1", ADBLOCK: "1" };
   if (!isCommandAvailable("npm")) {
@@ -2813,18 +3028,18 @@ Please install Node.js: https://nodejs.org/`
   }
 }
 async function installGitPackage(spec, cacheDir) {
-  fs5.mkdirSync(path4.dirname(cacheDir), { recursive: true });
-  if (fs5.existsSync(cacheDir)) {
+  fs6.mkdirSync(path5.dirname(cacheDir), { recursive: true });
+  if (fs6.existsSync(cacheDir)) {
     try {
       execSync("git fetch", { cwd: cacheDir, stdio: "pipe" });
       if (spec.version) {
         execSync(`git checkout ${spec.version}`, { cwd: cacheDir, stdio: "pipe" });
       }
     } catch (error) {
-      fs5.rmSync(cacheDir, { recursive: true, force: true });
+      fs6.rmSync(cacheDir, { recursive: true, force: true });
     }
   }
-  if (!fs5.existsSync(cacheDir)) {
+  if (!fs6.existsSync(cacheDir)) {
     try {
       const cloneCmd = spec.version ? `git clone --branch ${spec.version} "${spec.package}" "${cacheDir}"` : `git clone "${spec.package}" "${cacheDir}"`;
       execSync(cloneCmd, { stdio: "pipe" });
@@ -2832,7 +3047,7 @@ async function installGitPackage(spec, cacheDir) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to clone git repository '${spec.package}': ${message}`);
     }
-    if (fs5.existsSync(path4.join(cacheDir, "package.json"))) {
+    if (fs6.existsSync(path5.join(cacheDir, "package.json"))) {
       const hasNpm = isCommandAvailable("npm");
       if (!hasNpm) {
         throw new Error(
@@ -2851,14 +3066,14 @@ Please install Node.js: https://nodejs.org/`
           `Failed to install dependencies for '${spec.package}' using npm: ${message}`
         );
       }
-      const packageJson = JSON.parse(fs5.readFileSync(path4.join(cacheDir, "package.json"), "utf-8"));
+      const packageJson = JSON.parse(fs6.readFileSync(path5.join(cacheDir, "package.json"), "utf-8"));
       if (packageJson.scripts?.build) {
         try {
           execSync(`${runCmd} build`, { cwd: cacheDir, stdio: "inherit", env: quietEnv });
         } catch (error) {
           const entryPoint = packageJson.llmist?.gadgets || "./dist/index.js";
-          const entryPointPath = path4.join(cacheDir, entryPoint);
-          if (!fs5.existsSync(entryPointPath)) {
+          const entryPointPath = path5.join(cacheDir, entryPoint);
+          if (!fs6.existsSync(entryPointPath)) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to build package '${spec.package}': ${message}`);
           }
@@ -2868,20 +3083,20 @@ Please install Node.js: https://nodejs.org/`
   }
 }
 function readManifest(packageDir) {
-  const packageJsonPath = path4.join(packageDir, "package.json");
-  if (!fs5.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  if (!fs6.existsSync(packageJsonPath)) {
     return null;
   }
   try {
-    const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
     return packageJson.llmist || null;
   } catch {
     return null;
   }
 }
 function getPackagePath(cacheDir, packageName) {
-  const nodeModulesPath = path4.join(cacheDir, "node_modules", packageName);
-  if (fs5.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path5.join(cacheDir, "node_modules", packageName);
+  if (fs6.existsSync(nodeModulesPath)) {
     return nodeModulesPath;
   }
   return cacheDir;
@@ -2927,8 +3142,8 @@ async function loadExternalGadgets(specifier, forceInstall = false) {
   } else {
     entryPoint = manifest?.gadgets || "./dist/index.js";
   }
-  const resolvedEntryPoint = path4.resolve(packagePath, entryPoint);
-  if (!fs5.existsSync(resolvedEntryPoint)) {
+  const resolvedEntryPoint = path5.resolve(packagePath, entryPoint);
+  if (!fs6.existsSync(resolvedEntryPoint)) {
     throw new Error(
       `Entry point not found: ${resolvedEntryPoint}. Make sure the package is built (run 'npm run build' in the package directory).`
     );
@@ -3071,7 +3286,7 @@ function parseLocalSpecifier(specifier) {
   return { path: specifier };
 }
 function isFileLikeSpecifier(specifier) {
-  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(path5.sep);
+  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(path6.sep);
 }
 function tryResolveBuiltin(specifier) {
   if (specifier.startsWith(BUILTIN_PREFIX)) {
@@ -3079,7 +3294,7 @@ function tryResolveBuiltin(specifier) {
     const gadget = getBuiltinGadget(name);
     if (!gadget) {
       throw new Error(
-        `Unknown builtin gadget: ${name}. Available builtins: ListDirectory, ReadFile, WriteFile, EditFile, RunCommand`
+        `Unknown builtin gadget: ${name}. Available builtins: ${getBuiltinGadgetNames().join(", ")}`
       );
     }
     return gadget;
@@ -3094,8 +3309,8 @@ function resolveGadgetSpecifier(specifier, cwd) {
     return specifier;
   }
   const expanded = expandTildePath(specifier);
-  const resolvedPath = path5.resolve(cwd, expanded);
-  if (!fs6.existsSync(resolvedPath)) {
+  const resolvedPath = path6.resolve(cwd, expanded);
+  if (!fs7.existsSync(resolvedPath)) {
     throw new Error(`Gadget module not found at ${resolvedPath}`);
   }
   return pathToFileURL2(resolvedPath).href;
@@ -3262,7 +3477,7 @@ async function resolvePrompt(promptArg, env) {
 }
 
 // src/ui/formatters.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { format } from "llmist";
 
 // src/ui/call-number.ts
@@ -3376,6 +3591,62 @@ function stripProviderPrefix(model) {
   return model.includes(":") ? model.split(":")[1] : model;
 }
 
+// src/ui/metric-parts.ts
+import chalk3 from "chalk";
+function tokenPart(direction, tokens, opts) {
+  const prefix = opts?.estimated ? "~" : "";
+  const formatted = `${prefix}${formatTokens(tokens)}`;
+  switch (direction) {
+    case "input":
+      return chalk3.dim("\u2191") + chalk3.yellow(` ${formatted}`);
+    case "cached":
+      return chalk3.dim("\u27F3") + chalk3.blue(` ${formatted}`);
+    case "output":
+      return chalk3.dim("\u2193") + chalk3.green(` ${formatted}`);
+    case "reasoning":
+      return chalk3.dim("\u{1F4AD}") + chalk3.magenta(` ${formatted}`);
+    case "cacheCreation":
+      return chalk3.dim("\u270E") + chalk3.magenta(` ${formatted}`);
+  }
+}
+function costPart(cost) {
+  return chalk3.cyan(`$${formatCost(cost)}`);
+}
+function timePart(seconds) {
+  return chalk3.dim(`${seconds.toFixed(1)}s`);
+}
+function finishReasonPart(reason) {
+  const upper = reason.toUpperCase();
+  if (upper === "STOP" || upper === "END_TURN") {
+    return chalk3.green(upper);
+  }
+  return chalk3.yellow(upper);
+}
+function buildTokenMetrics(opts) {
+  const parts = [];
+  if (opts.input && opts.input > 0) {
+    parts.push(tokenPart("input", opts.input, { estimated: opts.estimated?.input }));
+  }
+  if (opts.cached && opts.cached > 0) {
+    parts.push(tokenPart("cached", opts.cached));
+  }
+  if (opts.output && opts.output > 0) {
+    parts.push(tokenPart("output", opts.output, { estimated: opts.estimated?.output }));
+  }
+  if (opts.reasoning && opts.reasoning > 0) {
+    parts.push(tokenPart("reasoning", opts.reasoning));
+  }
+  if (opts.cacheCreation && opts.cacheCreation > 0) {
+    parts.push(tokenPart("cacheCreation", opts.cacheCreation));
+  }
+  return parts;
+}
+function joinParts(parts) {
+  const filtered = parts.filter((p) => p.length > 0);
+  if (filtered.length === 0) return "";
+  return filtered.join(chalk3.dim(" | "));
+}
+
 // src/ui/formatters.ts
 function formatLLMCallLine(info) {
   const parts = [];
@@ -3384,85 +3655,81 @@ function formatLLMCallLine(info) {
     info.parentCallNumber,
     info.gadgetInvocationId
   );
-  parts.push(`${chalk3.cyan(callNumber)} ${chalk3.magenta(info.model)}`);
+  parts.push(`${chalk4.cyan(callNumber)} ${chalk4.magenta(info.model)}`);
   if (info.contextPercent !== void 0 && info.contextPercent !== null) {
     const formatted = `${Math.round(info.contextPercent)}%`;
     if (info.contextPercent >= 80) {
-      parts.push(chalk3.red(formatted));
+      parts.push(chalk4.red(formatted));
     } else if (info.contextPercent >= 50) {
-      parts.push(chalk3.yellow(formatted));
+      parts.push(chalk4.yellow(formatted));
     } else {
-      parts.push(chalk3.green(formatted));
+      parts.push(chalk4.green(formatted));
     }
   }
-  if (info.inputTokens && info.inputTokens > 0) {
-    const prefix = info.estimated?.input ? "~" : "";
-    parts.push(chalk3.dim("\u2191") + chalk3.yellow(` ${prefix}${formatTokens(info.inputTokens)}`));
-  }
-  if (info.cachedInputTokens && info.cachedInputTokens > 0) {
-    parts.push(chalk3.dim("\u27F3") + chalk3.blue(` ${formatTokens(info.cachedInputTokens)}`));
-  }
+  parts.push(
+    ...buildTokenMetrics({
+      input: info.inputTokens,
+      cached: info.cachedInputTokens,
+      estimated: info.estimated
+    })
+  );
   if (info.outputTokens !== void 0 && info.outputTokens > 0 || info.isStreaming) {
     const prefix = info.estimated?.output ? "~" : "";
-    parts.push(chalk3.dim("\u2193") + chalk3.green(` ${prefix}${formatTokens(info.outputTokens ?? 0)}`));
+    parts.push(chalk4.dim("\u2193") + chalk4.green(` ${prefix}${formatTokens(info.outputTokens ?? 0)}`));
   }
-  parts.push(chalk3.dim(`${info.elapsedSeconds.toFixed(1)}s`));
+  parts.push(timePart(info.elapsedSeconds));
   if (info.cost !== void 0 && info.cost > 0) {
-    parts.push(chalk3.cyan(`$${formatCost(info.cost)}`));
+    parts.push(costPart(info.cost));
   }
   if (!info.isStreaming && info.finishReason !== void 0) {
     const reason = info.finishReason || "stop";
-    if (reason === "stop" || reason === "end_turn") {
-      parts.push(chalk3.green(reason.toUpperCase()));
-    } else {
-      parts.push(chalk3.yellow(reason.toUpperCase()));
-    }
+    parts.push(finishReasonPart(reason));
   }
-  const line = parts.join(chalk3.dim(" | "));
+  const line = joinParts(parts);
   if (info.isStreaming && info.spinner) {
-    return `${chalk3.cyan(info.spinner)} ${line}`;
+    return `${chalk4.cyan(info.spinner)} ${line}`;
   }
   if (!info.isStreaming) {
-    return `${chalk3.green("\u2713")} ${line}`;
+    return `${chalk4.green("\u2713")} ${line}`;
   }
   return line;
 }
 function renderSummary(metadata) {
   const parts = [];
   if (metadata.iterations !== void 0) {
-    const iterPart = chalk3.cyan(`#${metadata.iterations}`);
+    const iterPart = chalk4.cyan(`#${metadata.iterations}`);
     if (metadata.model) {
-      parts.push(`${iterPart} ${chalk3.magenta(metadata.model)}`);
+      parts.push(`${iterPart} ${chalk4.magenta(metadata.model)}`);
     } else {
       parts.push(iterPart);
     }
   } else if (metadata.model) {
-    parts.push(chalk3.magenta(metadata.model));
+    parts.push(chalk4.magenta(metadata.model));
   }
   if (metadata.usage) {
     const { inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens } = metadata.usage;
-    parts.push(chalk3.dim("\u2191") + chalk3.yellow(` ${formatTokens(inputTokens)}`));
-    if (cachedInputTokens && cachedInputTokens > 0) {
-      parts.push(chalk3.dim("\u27F3") + chalk3.blue(` ${formatTokens(cachedInputTokens)}`));
-    }
-    if (cacheCreationInputTokens && cacheCreationInputTokens > 0) {
-      parts.push(chalk3.dim("\u270E") + chalk3.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
-    }
-    parts.push(chalk3.dim("\u2193") + chalk3.green(` ${formatTokens(outputTokens)}`));
+    parts.push(
+      ...buildTokenMetrics({
+        input: inputTokens,
+        cached: cachedInputTokens,
+        cacheCreation: cacheCreationInputTokens,
+        output: outputTokens
+      })
+    );
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
-    parts.push(chalk3.dim(`${metadata.elapsedSeconds}s`));
+    parts.push(timePart(metadata.elapsedSeconds));
   }
   if (metadata.cost !== void 0 && metadata.cost > 0) {
-    parts.push(chalk3.cyan(`$${formatCost(metadata.cost)}`));
+    parts.push(costPart(metadata.cost));
   }
   if (metadata.finishReason) {
-    parts.push(chalk3.dim(metadata.finishReason));
+    parts.push(chalk4.dim(metadata.finishReason));
   }
   if (parts.length === 0) {
     return null;
   }
-  return parts.join(chalk3.dim(" | "));
+  return joinParts(parts);
 }
 function getRawValue(value) {
   if (typeof value === "string") {
@@ -3516,48 +3783,48 @@ function formatParametersInline(params, maxWidth) {
   }
   return entries.map(([key, _], i) => {
     const formatted = truncateValue(rawValues[i], limits[i]);
-    return `${chalk3.dim(key)}${chalk3.dim("=")}${chalk3.cyan(formatted)}`;
-  }).join(chalk3.dim(", "));
+    return `${chalk4.dim(key)}${chalk4.dim("=")}${chalk4.cyan(formatted)}`;
+  }).join(chalk4.dim(", "));
 }
 function formatGadgetLine(info, maxWidth) {
   const terminalWidth = maxWidth ?? process.stdout.columns ?? 80;
-  const gadgetLabel = chalk3.magenta.bold(info.name);
+  const gadgetLabel = chalk4.magenta.bold(info.name);
   const timeStr = `${info.elapsedSeconds.toFixed(1)}s`;
-  const timeLabel = chalk3.dim(timeStr);
+  const timeLabel = chalk4.dim(timeStr);
   const fixedLength = 3 + info.name.length + 2 + 1 + timeStr.length;
   const availableForParams = Math.max(40, terminalWidth - fixedLength - 3);
   const paramsStr = formatParametersInline(info.parameters, availableForParams);
-  const paramsLabel = paramsStr ? `${chalk3.dim("(")}${paramsStr}${chalk3.dim(")")}` : "";
+  const paramsLabel = paramsStr ? `${chalk4.dim("(")}${paramsStr}${chalk4.dim(")")}` : "";
   if (info.error) {
     const errorMsg = info.error.length > 50 ? `${info.error.slice(0, 50)}\u2026` : info.error;
-    return `${chalk3.red("\u2717")} ${gadgetLabel}${paramsLabel} ${chalk3.red("error:")} ${errorMsg} ${timeLabel}`;
+    return `${chalk4.red("\u2717")} ${gadgetLabel}${paramsLabel} ${chalk4.red("error:")} ${errorMsg} ${timeLabel}`;
   }
   if (!info.isComplete) {
     const parts = [];
-    if (info.subagentInputTokens && info.subagentInputTokens > 0) {
-      parts.push(chalk3.dim("\u2191") + chalk3.yellow(` ${formatTokens(info.subagentInputTokens)}`));
-    }
-    if (info.subagentOutputTokens && info.subagentOutputTokens > 0) {
-      parts.push(chalk3.dim("\u2193") + chalk3.green(` ${formatTokens(info.subagentOutputTokens)}`));
-    }
+    parts.push(
+      ...buildTokenMetrics({
+        input: info.subagentInputTokens,
+        output: info.subagentOutputTokens
+      })
+    );
     if (info.subagentCost && info.subagentCost > 0) {
-      parts.push(chalk3.cyan(`$${formatCost(info.subagentCost)}`));
+      parts.push(costPart(info.subagentCost));
     }
-    parts.push(chalk3.dim(`${info.elapsedSeconds.toFixed(1)}s`));
-    const metricsStr = parts.length > 0 ? ` ${parts.join(chalk3.dim(" | "))}` : "";
-    return `${chalk3.blue("\u23F5")} ${gadgetLabel}${metricsStr}`;
+    parts.push(timePart(info.elapsedSeconds));
+    const metricsStr = parts.length > 0 ? ` ${joinParts(parts)}` : "";
+    return `${chalk4.blue("\u23F5")} ${gadgetLabel}${metricsStr}`;
   }
   let outputLabel;
   if (info.tokenCount !== void 0 && info.tokenCount > 0) {
-    outputLabel = chalk3.dim("\u2193") + chalk3.green(` ${formatTokens(info.tokenCount)} `);
+    outputLabel = chalk4.dim("\u2193") + chalk4.green(` ${formatTokens(info.tokenCount)} `);
   } else if (info.outputBytes !== void 0 && info.outputBytes > 0) {
-    outputLabel = `${chalk3.green(format.bytes(info.outputBytes))} `;
+    outputLabel = `${chalk4.green(format.bytes(info.outputBytes))} `;
   } else {
     outputLabel = "";
   }
-  const resultIcon = info.breaksLoop ? chalk3.yellow("\u23F9") : chalk3.green("\u2713");
-  const nameRef = chalk3.magenta(info.name);
-  const line1 = `${chalk3.dim("\u2192")} ${gadgetLabel}${paramsLabel}`;
+  const resultIcon = info.breaksLoop ? chalk4.yellow("\u23F9") : chalk4.green("\u2713");
+  const nameRef = chalk4.magenta(info.name);
+  const line1 = `${chalk4.dim("\u2192")} ${gadgetLabel}${paramsLabel}`;
   const line2Prefix = `  ${resultIcon} ${nameRef} ${outputLabel}`;
   const line2 = `${line2Prefix}${timeLabel}`;
   return `${line1}
@@ -3979,7 +4246,7 @@ var NestedOperationTracker = class {
 };
 
 // src/progress/progress-renderer.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import { FALLBACK_CHARS_PER_TOKEN } from "llmist";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_DELAY_MS = 500;
@@ -4163,7 +4430,7 @@ var ProgressRenderer = class {
           const elapsedSeconds2 = (Date.now() - op.startTime) / 1e3;
           const nestedMetrics = op.id ? this.nestedOperationTracker.getAggregatedSubagentMetrics(op.id) : { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cost: 0, callCount: 0 };
           const termWidth2 = process.stdout.columns ?? 80;
-          const parentPrefix = `${chalk4.dim(`${gadget.name}:`)} `;
+          const parentPrefix = `${chalk5.dim(`${gadget.name}:`)} `;
           const line2 = formatGadgetLine(
             {
               name: op.name ?? "",
@@ -4186,7 +4453,7 @@ var ProgressRenderer = class {
     }
     for (const stream of activeNestedStreams) {
       const indent = "  ".repeat(stream.depth + 2);
-      const parentPrefix = `${chalk4.dim(`${stream.parentGadgetName}:`)} `;
+      const parentPrefix = `${chalk5.dim(`${stream.parentGadgetName}:`)} `;
       const elapsedSeconds = (Date.now() - stream.startTime) / 1e3;
       const line = formatLLMCallLine({
         iteration: stream.iteration,
@@ -4244,21 +4511,19 @@ var ProgressRenderer = class {
     const elapsed = ((Date.now() - this.callStatsTracker.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
     if (this.callStatsTracker.model) {
-      parts.push(chalk4.cyan(this.callStatsTracker.model));
+      parts.push(chalk5.cyan(this.callStatsTracker.model));
     }
     if (this.callStatsTracker.totalTokens > 0) {
-      parts.push(chalk4.dim("total:") + chalk4.magenta(` ${this.callStatsTracker.totalTokens}`));
+      parts.push(chalk5.dim("total:") + chalk5.magenta(` ${this.callStatsTracker.totalTokens}`));
     }
     if (this.callStatsTracker.iterations > 0) {
-      parts.push(chalk4.dim("iter:") + chalk4.blue(` ${this.callStatsTracker.iterations}`));
+      parts.push(chalk5.dim("iter:") + chalk5.blue(` ${this.callStatsTracker.iterations}`));
     }
     if (this.callStatsTracker.totalCost > 0) {
-      parts.push(
-        chalk4.dim("cost:") + chalk4.cyan(` $${formatCost(this.callStatsTracker.totalCost)}`)
-      );
+      parts.push(`${chalk5.dim("cost:")} ${costPart(this.callStatsTracker.totalCost)}`);
     }
-    parts.push(chalk4.dim(`${elapsed}s`));
-    return `${parts.join(chalk4.dim(" | "))} ${chalk4.cyan(spinner)}`;
+    parts.push(chalk5.dim(`${elapsed}s`));
+    return `${parts.join(chalk5.dim(" | "))} ${chalk5.cyan(spinner)}`;
   }
   /**
    * Returns a formatted stats string for cancellation messages.
@@ -4269,15 +4534,21 @@ var ProgressRenderer = class {
     const elapsed = ((Date.now() - this.callStatsTracker.callStartTime) / 1e3).toFixed(1);
     const outTokens = this.callStatsTracker.callOutputTokensEstimated ? Math.round(this.callStatsTracker.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callStatsTracker.callOutputTokens;
     if (this.callStatsTracker.callInputTokens > 0) {
-      const prefix = this.callStatsTracker.callInputTokensEstimated ? "~" : "";
-      parts.push(`\u2191 ${prefix}${formatTokens(this.callStatsTracker.callInputTokens)}`);
+      parts.push(
+        tokenPart("input", this.callStatsTracker.callInputTokens, {
+          estimated: this.callStatsTracker.callInputTokensEstimated
+        })
+      );
     }
     if (outTokens > 0) {
-      const prefix = this.callStatsTracker.callOutputTokensEstimated ? "~" : "";
-      parts.push(`\u2193 ${prefix}${formatTokens(outTokens)}`);
+      parts.push(
+        tokenPart("output", outTokens, {
+          estimated: this.callStatsTracker.callOutputTokensEstimated
+        })
+      );
     }
     parts.push(`${elapsed}s`);
-    return parts.join(" | ");
+    return joinParts(parts);
   }
   /**
    * Returns a formatted prompt string with stats (like bash PS1).
@@ -4291,30 +4562,30 @@ var ProgressRenderer = class {
       const outTokens = this.callStatsTracker.callOutputTokensEstimated ? Math.round(this.callStatsTracker.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callStatsTracker.callOutputTokens;
       const outEstimated = this.callStatsTracker.callOutputTokensEstimated;
       if (this.callStatsTracker.callInputTokens > 0) {
-        const prefix = this.callStatsTracker.callInputTokensEstimated ? "~" : "";
         parts.push(
-          chalk4.dim("\u2191") + chalk4.yellow(` ${prefix}${formatTokens(this.callStatsTracker.callInputTokens)}`)
+          tokenPart("input", this.callStatsTracker.callInputTokens, {
+            estimated: this.callStatsTracker.callInputTokensEstimated
+          })
         );
       }
       if (outTokens > 0) {
-        const prefix = outEstimated ? "~" : "";
-        parts.push(chalk4.dim("\u2193") + chalk4.green(` ${prefix}${formatTokens(outTokens)}`));
+        parts.push(tokenPart("output", outTokens, { estimated: outEstimated }));
       }
-      parts.push(chalk4.dim(`${elapsed}s`));
+      parts.push(chalk5.dim(`${elapsed}s`));
     } else {
       const elapsed = Math.round((Date.now() - this.callStatsTracker.totalStartTime) / 1e3);
       if (this.callStatsTracker.totalTokens > 0) {
-        parts.push(chalk4.magenta(formatTokens(this.callStatsTracker.totalTokens)));
+        parts.push(chalk5.magenta(formatTokens(this.callStatsTracker.totalTokens)));
       }
       if (this.callStatsTracker.iterations > 0) {
-        parts.push(chalk4.blue(`i${this.callStatsTracker.iterations}`));
+        parts.push(chalk5.blue(`i${this.callStatsTracker.iterations}`));
       }
       if (this.callStatsTracker.totalCost > 0) {
-        parts.push(chalk4.cyan(`$${formatCost(this.callStatsTracker.totalCost)}`));
+        parts.push(costPart(this.callStatsTracker.totalCost));
       }
-      parts.push(chalk4.dim(`${elapsed}s`));
+      parts.push(chalk5.dim(`${elapsed}s`));
     }
-    return `${parts.join(chalk4.dim(" | "))} ${chalk4.green(">")} `;
+    return `${parts.join(chalk5.dim(" | "))} ${chalk5.green(">")} `;
   }
 };
 
@@ -4556,7 +4827,7 @@ function addAgentOptions(cmd, defaults) {
     ...previous,
     value
   ];
-  const defaultGadgets = defaults?.gadgets ?? defaults?.gadget ?? [];
+  const defaultGadgets = defaults?.gadgets ?? [];
   return cmd.option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, defaults?.model ?? DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt, defaults?.system).option(OPTION_FLAGS.systemPromptFile, OPTION_DESCRIPTIONS.systemPromptFile).option(
     OPTION_FLAGS.temperature,
     OPTION_DESCRIPTIONS.temperature,
@@ -4637,14 +4908,14 @@ function configToCompleteOptions(config) {
     if (rl["tokens-per-minute"] !== void 0) result.rateLimitTpm = rl["tokens-per-minute"];
     if (rl["tokens-per-day"] !== void 0) result.rateLimitDaily = rl["tokens-per-day"];
     if (rl["safety-margin"] !== void 0) result.rateLimitSafetyMargin = rl["safety-margin"];
-    if (rl.enabled === false) result.noRateLimit = true;
+    if (rl.enabled === false) result.rateLimit = false;
   }
   if (config.retry) {
     const r = config.retry;
     if (r.retries !== void 0) result.maxRetries = r.retries;
     if (r["min-timeout"] !== void 0) result.retryMinTimeout = r["min-timeout"];
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
-    if (r.enabled === false) result.noRetry = true;
+    if (r.enabled === false) result.retry = false;
   }
   if (config.reasoning) {
     result.profileReasoning = config.reasoning;
@@ -4658,8 +4929,7 @@ function configToAgentOptions(config) {
   if (config.temperature !== void 0) result.temperature = config.temperature;
   if (config["max-iterations"] !== void 0) result.maxIterations = config["max-iterations"];
   if (config.budget !== void 0) result.budget = config.budget;
-  const gadgets = config.gadgets ?? config.gadget;
-  if (gadgets !== void 0) result.gadget = gadgets;
+  if (config.gadgets !== void 0) result.gadget = config.gadgets;
   if (config.builtins !== void 0) result.builtins = config.builtins;
   if (config["builtin-interaction"] !== void 0)
     result.builtinInteraction = config["builtin-interaction"];
@@ -4680,14 +4950,14 @@ function configToAgentOptions(config) {
     if (rl["tokens-per-minute"] !== void 0) result.rateLimitTpm = rl["tokens-per-minute"];
     if (rl["tokens-per-day"] !== void 0) result.rateLimitDaily = rl["tokens-per-day"];
     if (rl["safety-margin"] !== void 0) result.rateLimitSafetyMargin = rl["safety-margin"];
-    if (rl.enabled === false) result.noRateLimit = true;
+    if (rl.enabled === false) result.rateLimit = false;
   }
   if (config.retry) {
     const r = config.retry;
     if (r.retries !== void 0) result.maxRetries = r.retries;
     if (r["min-timeout"] !== void 0) result.retryMinTimeout = r["min-timeout"];
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
-    if (r.enabled === false) result.noRetry = true;
+    if (r.enabled === false) result.retry = false;
   }
   if (config.reasoning) {
     result.profileReasoning = config.reasoning;
@@ -4731,7 +5001,7 @@ function detectProvider(model) {
   }
 }
 function resolveRateLimitConfig(options, globalConfig, profileConfig, model) {
-  if (options.noRateLimit === true) {
+  if (options.rateLimit === false) {
     return { enabled: false, safetyMargin: 0.8 };
   }
   let resolved;
@@ -4856,12 +5126,82 @@ function resolveRetryConfig(options, globalConfig, profileConfig) {
   if (options.retryMaxTimeout !== void 0) {
     resolved.maxTimeout = options.retryMaxTimeout;
   }
-  if (options.noRetry === true) {
+  if (options.retry === false) {
     resolved.enabled = false;
   }
   return resolved;
 }
 
+// src/skills/skill-manager.ts
+import { homedir as homedir3 } from "os";
+import { join as join2, resolve as resolve3 } from "path";
+import { discoverSkills, loadSkillsFromDirectory } from "llmist";
+var CLISkillManager = class {
+  /**
+   * Load all skills from standard locations and configured sources.
+   *
+   * @param config - Skills configuration from cli.toml [skills] section
+   * @param projectDir - Project directory (cwd)
+   */
+  async loadAll(config, projectDir) {
+    const registry = discoverSkills({
+      projectDir: projectDir ?? process.cwd()
+    });
+    if (config?.sources) {
+      for (const source of config.sources) {
+        const resolvedSource = this.resolveSource(source);
+        const skills = loadSkillsFromDirectory(resolvedSource, {
+          type: "directory",
+          path: resolvedSource
+        });
+        registry.registerMany(skills);
+      }
+    }
+    if (config?.overrides) {
+      for (const [skillName, override] of Object.entries(config.overrides)) {
+        if (override.enabled === false) {
+          registry.remove(skillName);
+        }
+      }
+    }
+    return registry;
+  }
+  /**
+   * Resolve a source string to an absolute directory path.
+   */
+  resolveSource(source) {
+    if (source.startsWith("~")) {
+      return join2(homedir3(), source.slice(1));
+    }
+    return resolve3(source);
+  }
+};
+
+// src/skills/slash-handler.ts
+function parseSlashCommand(input, registry) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { isSkillInvocation: false };
+  }
+  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+  if (!match) {
+    return { isSkillInvocation: false };
+  }
+  const [, commandName, args] = match;
+  if (commandName === "skills") {
+    return { isSkillInvocation: true, isListCommand: true };
+  }
+  const skill = registry.get(commandName);
+  if (!skill || !skill.isUserInvocable) {
+    return { isSkillInvocation: false };
+  }
+  return {
+    isSkillInvocation: true,
+    skillName: commandName,
+    arguments: args?.trim()
+  };
+}
+
 // src/subagent-config.ts
 var INHERIT_MODEL = "inherit";
 function resolveSubagentConfig(subagentName, parentModel, profileConfig, globalConfig) {
@@ -4910,11 +5250,34 @@ function extractSubagentConfig(globalConfig, subagentName) {
   return {};
 }
 
-// src/tui/block-renderer.ts
-import { Box } from "@unblessed/node";
-
-// src/ui/block-formatters.ts
-import chalk5 from "chalk";
+// src/tui/raw-viewer-data.ts
+function isRawViewerNode(node) {
+  return node.type === "llm_call" || node.type === "gadget";
+}
+function createRawViewerData(node, mode) {
+  if (node.type === "llm_call") {
+    return {
+      mode,
+      request: node.rawRequest,
+      response: node.rawResponse,
+      iteration: node.iteration,
+      model: node.model
+    };
+  }
+  return {
+    mode,
+    gadgetName: node.name,
+    parameters: node.parameters,
+    result: node.result,
+    error: node.error
+  };
+}
+
+// src/tui/block-renderer.ts
+import { Box } from "@unblessed/node";
+
+// src/ui/block-formatters.ts
+import chalk6 from "chalk";
 var BOX = {
   topLeft: "\u250C",
   topRight: "\u2510",
@@ -4930,44 +5293,35 @@ var COMPLETE_INDICATOR = "\u2713";
 var ERROR_INDICATOR = "\u2717";
 function formatLLMCallCollapsed(node, selected) {
   const indicator = node.isComplete ? COMPLETE_INDICATOR : PROGRESS_INDICATOR;
-  const indicatorColor = node.isComplete ? chalk5.green : chalk5.blue;
+  const indicatorColor = node.isComplete ? chalk6.green : chalk6.blue;
   const parts = [];
-  const callNumber = chalk5.cyan(`#${node.iteration}`);
-  const model = chalk5.magenta(node.model);
+  const callNumber = chalk6.cyan(`#${node.iteration}`);
+  const model = chalk6.magenta(node.model);
   parts.push(`${callNumber} ${model}`);
   if (node.details) {
     const d = node.details;
-    if (d.inputTokens && d.inputTokens > 0) {
-      parts.push(chalk5.dim("\u2191") + chalk5.yellow(` ${formatTokens(d.inputTokens)}`));
-    }
-    if (d.cachedInputTokens && d.cachedInputTokens > 0) {
-      parts.push(chalk5.dim("\u27F3") + chalk5.blue(` ${formatTokens(d.cachedInputTokens)}`));
-    }
-    if (d.outputTokens && d.outputTokens > 0) {
-      parts.push(chalk5.dim("\u2193") + chalk5.green(` ${formatTokens(d.outputTokens)}`));
-    }
-    if (d.reasoningTokens && d.reasoningTokens > 0) {
-      parts.push(chalk5.dim("\u{1F4AD}") + chalk5.magenta(` ${formatTokens(d.reasoningTokens)}`));
-    }
+    parts.push(
+      ...buildTokenMetrics({
+        input: d.inputTokens,
+        cached: d.cachedInputTokens,
+        output: d.outputTokens,
+        reasoning: d.reasoningTokens
+      })
+    );
     if (d.elapsedSeconds !== void 0) {
-      parts.push(chalk5.dim(`${d.elapsedSeconds.toFixed(1)}s`));
+      parts.push(timePart(d.elapsedSeconds));
     }
     if (d.cost !== void 0 && d.cost > 0) {
-      parts.push(chalk5.cyan(`$${formatCost(d.cost)}`));
+      parts.push(costPart(d.cost));
     }
     if (node.isComplete && d.finishReason) {
-      const reason = d.finishReason.toUpperCase();
-      if (reason === "STOP" || reason === "END_TURN") {
-        parts.push(chalk5.green(reason));
-      } else {
-        parts.push(chalk5.yellow(reason));
-      }
+      parts.push(finishReasonPart(d.finishReason));
     }
   }
-  const line = parts.join(chalk5.dim(" | "));
+  const line = joinParts(parts);
   const prefix = indicatorColor(indicator);
   if (selected) {
-    return chalk5.bgBlue.white(`${prefix} ${line}`);
+    return chalk6.bgBlue.white(`${prefix} ${line}`);
   }
   return `${prefix} ${line}`;
 }
@@ -4976,58 +5330,58 @@ function formatLLMCallExpanded(node) {
   const indent = "  ";
   const d = node.details;
   if (!d) {
-    lines.push(`${indent}${chalk5.dim("No details available")}`);
+    lines.push(`${indent}${chalk6.dim("No details available")}`);
     return lines;
   }
   const width = Math.min(60, (process.stdout.columns || 80) - 4);
   const headerLine = `${BOX.topLeft}${BOX.horizontal} Details ${BOX.horizontal.repeat(width - 11)}`;
-  lines.push(`${indent}${chalk5.dim(headerLine)}`);
-  lines.push(`${indent}${chalk5.dim(BOX.vertical)} Model:   ${chalk5.magenta(node.model)}`);
+  lines.push(`${indent}${chalk6.dim(headerLine)}`);
+  lines.push(`${indent}${chalk6.dim(BOX.vertical)} Model:   ${chalk6.magenta(node.model)}`);
   if (d.inputTokens !== void 0) {
-    let inputLine = `${indent}${chalk5.dim(BOX.vertical)} Input:   ${chalk5.yellow(formatTokens(d.inputTokens))} tokens`;
+    let inputLine = `${indent}${chalk6.dim(BOX.vertical)} Input:   ${chalk6.yellow(formatTokens(d.inputTokens))} tokens`;
     if (d.cachedInputTokens && d.cachedInputTokens > 0) {
       const cachePercent = (d.cachedInputTokens / d.inputTokens * 100).toFixed(1);
-      inputLine += chalk5.blue(` (${formatTokens(d.cachedInputTokens)} cached, ${cachePercent}%)`);
+      inputLine += chalk6.blue(` (${formatTokens(d.cachedInputTokens)} cached, ${cachePercent}%)`);
     }
     lines.push(inputLine);
   }
   if (d.outputTokens !== void 0) {
     lines.push(
-      `${indent}${chalk5.dim(BOX.vertical)} Output:  ${chalk5.green(formatTokens(d.outputTokens))} tokens`
+      `${indent}${chalk6.dim(BOX.vertical)} Output:  ${chalk6.green(formatTokens(d.outputTokens))} tokens`
     );
   }
   if (d.reasoningTokens !== void 0 && d.reasoningTokens > 0) {
     lines.push(
-      `${indent}${chalk5.dim(BOX.vertical)} Reason:  ${chalk5.magenta(formatTokens(d.reasoningTokens))} tokens`
+      `${indent}${chalk6.dim(BOX.vertical)} Reason:  ${chalk6.magenta(formatTokens(d.reasoningTokens))} tokens`
     );
   }
   if (d.contextPercent !== void 0) {
-    let contextColor = chalk5.green;
-    if (d.contextPercent >= 80) contextColor = chalk5.red;
-    else if (d.contextPercent >= 50) contextColor = chalk5.yellow;
+    let contextColor = chalk6.green;
+    if (d.contextPercent >= 80) contextColor = chalk6.red;
+    else if (d.contextPercent >= 50) contextColor = chalk6.yellow;
     lines.push(
-      `${indent}${chalk5.dim(BOX.vertical)} Context: ${contextColor(`${Math.round(d.contextPercent)}%`)}`
+      `${indent}${chalk6.dim(BOX.vertical)} Context: ${contextColor(`${Math.round(d.contextPercent)}%`)}`
     );
   }
   if (d.elapsedSeconds !== void 0) {
-    let timeLine = `${indent}${chalk5.dim(BOX.vertical)} Time:    ${chalk5.dim(`${d.elapsedSeconds.toFixed(1)}s`)}`;
+    let timeLine = `${indent}${chalk6.dim(BOX.vertical)} Time:    ${chalk6.dim(`${d.elapsedSeconds.toFixed(1)}s`)}`;
     if (d.outputTokens && d.elapsedSeconds > 0) {
       const tokensPerSec = Math.round(d.outputTokens / d.elapsedSeconds);
-      timeLine += chalk5.dim(` (${tokensPerSec} tok/s)`);
+      timeLine += chalk6.dim(` (${tokensPerSec} tok/s)`);
     }
     lines.push(timeLine);
   }
   if (d.cost !== void 0 && d.cost > 0) {
     lines.push(
-      `${indent}${chalk5.dim(BOX.vertical)} Cost:    ${chalk5.cyan(`$${formatCost(d.cost)}`)}`
+      `${indent}${chalk6.dim(BOX.vertical)} Cost:    ${chalk6.cyan(`$${formatCost(d.cost)}`)}`
     );
   }
   if (d.finishReason) {
     const reason = d.finishReason.toUpperCase();
-    const reasonColor = reason === "STOP" || reason === "END_TURN" ? chalk5.green : chalk5.yellow;
-    lines.push(`${indent}${chalk5.dim(BOX.vertical)} Finish:  ${reasonColor(reason)}`);
+    const reasonColor = reason === "STOP" || reason === "END_TURN" ? chalk6.green : chalk6.yellow;
+    lines.push(`${indent}${chalk6.dim(BOX.vertical)} Finish:  ${reasonColor(reason)}`);
   }
-  lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+  lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   return lines;
 }
 function formatGadgetCollapsed(node, selected) {
@@ -5035,15 +5389,15 @@ function formatGadgetCollapsed(node, selected) {
   let indicatorColor;
   if (node.error) {
     indicator = ERROR_INDICATOR;
-    indicatorColor = chalk5.red;
+    indicatorColor = chalk6.red;
   } else if (node.isComplete) {
     indicator = COMPLETE_INDICATOR;
-    indicatorColor = chalk5.green;
+    indicatorColor = chalk6.green;
   } else {
     indicator = PROGRESS_INDICATOR;
-    indicatorColor = chalk5.blue;
+    indicatorColor = chalk6.blue;
   }
-  const gadgetLabel = chalk5.magenta.bold(node.name);
+  const gadgetLabel = chalk6.magenta.bold(node.name);
   let paramsStr = "";
   if (node.parameters && Object.keys(node.parameters).length > 0) {
     if (node.name === "TellUser") {
@@ -5065,15 +5419,15 @@ function formatGadgetCollapsed(node, selected) {
       const formatted = entries.map(([key, value]) => {
         const strValue = typeof value === "string" ? value : JSON.stringify(value);
         const truncated = strValue.length > maxParamLen ? `${strValue.slice(0, maxParamLen - 3)}...` : strValue;
-        return `${chalk5.dim(key)}=${chalk5.cyan(truncated)}`;
+        return `${chalk6.dim(key)}=${chalk6.cyan(truncated)}`;
       });
-      paramsStr = `${chalk5.dim("(")}${formatted.join(chalk5.dim(", "))}${chalk5.dim(")")}`;
+      paramsStr = `${chalk6.dim("(")}${formatted.join(chalk6.dim(", "))}${chalk6.dim(")")}`;
     }
   }
   let errorStr = "";
   if (node.error) {
     const truncated = node.error.length > 40 ? `${node.error.slice(0, 37)}...` : node.error;
-    errorStr = ` ${chalk5.red("error:")} ${truncated}`;
+    errorStr = ` ${chalk6.red("error:")} ${truncated}`;
   }
   const metrics = [];
   if (node.executionTimeMs !== void 0) {
@@ -5081,24 +5435,23 @@ function formatGadgetCollapsed(node, selected) {
   }
   if (node.subagentStats && node.subagentStats.llmCallCount > 0) {
     const { inputTokens, cachedTokens, outputTokens } = node.subagentStats;
-    const tokenParts = [];
-    tokenParts.push(chalk5.dim("\u2191") + chalk5.yellow(` ${formatTokens(inputTokens)}`));
-    if (cachedTokens > 0) {
-      tokenParts.push(chalk5.dim("\u293F") + chalk5.blue(` ${formatTokens(cachedTokens)}`));
-    }
-    tokenParts.push(chalk5.dim("\u2193") + chalk5.green(` ${formatTokens(outputTokens)}`));
-    metrics.push(tokenParts.join(" "));
+    const tokenMetrics = buildTokenMetrics({
+      input: inputTokens,
+      cached: cachedTokens,
+      output: outputTokens
+    });
+    metrics.push(tokenMetrics.join(" "));
   } else if (node.resultTokens && node.resultTokens > 0) {
-    metrics.push(chalk5.dim("\u2193") + chalk5.green(` ${formatTokens(node.resultTokens)}`));
+    metrics.push(chalk6.dim("\u2193") + chalk6.green(` ${formatTokens(node.resultTokens)}`));
   }
   if (node.cost && node.cost > 0) {
-    metrics.push(chalk5.cyan(`$${formatCost(node.cost)}`));
+    metrics.push(costPart(node.cost));
   }
-  const metricsStr = metrics.length > 0 ? ` ${chalk5.dim(metrics.join(" | "))}` : "";
+  const metricsStr = metrics.length > 0 ? ` ${chalk6.dim(metrics.join(" | "))}` : "";
   const line = `${indicatorColor(indicator)} ${gadgetLabel}${paramsStr}${errorStr}${metricsStr}`;
   let result;
   if (selected) {
-    result = chalk5.bgBlue.white(line);
+    result = chalk6.bgBlue.white(line);
   } else {
     result = line;
   }
@@ -5120,7 +5473,7 @@ function formatGadgetExpanded(node) {
   const paramsToShow = node.parameters ? Object.entries(node.parameters).filter(([key]) => !(isTellUser && key === "message")) : [];
   if (paramsToShow.length > 0) {
     const headerLine = `${BOX.topLeft}${BOX.horizontal} Parameters ${BOX.horizontal.repeat(width - 14)}`;
-    lines.push(`${indent}${chalk5.dim(headerLine)}`);
+    lines.push(`${indent}${chalk6.dim(headerLine)}`);
     for (const [key, value] of paramsToShow) {
       const strValue = typeof value === "string" ? value : JSON.stringify(value, null, 2);
       const valueLines = strValue.split("\n");
@@ -5128,30 +5481,30 @@ function formatGadgetExpanded(node) {
       if (valueLines.length === 1) {
         const truncated = strValue.length > maxValueLen ? `${strValue.slice(0, maxValueLen - 3)}...` : strValue;
         lines.push(
-          `${indent}${chalk5.dim(BOX.vertical)} ${chalk5.dim(key)}: ${chalk5.cyan(truncated)}`
+          `${indent}${chalk6.dim(BOX.vertical)} ${chalk6.dim(key)}: ${chalk6.cyan(truncated)}`
         );
       } else {
-        lines.push(`${indent}${chalk5.dim(BOX.vertical)} ${chalk5.dim(key)}:`);
+        lines.push(`${indent}${chalk6.dim(BOX.vertical)} ${chalk6.dim(key)}:`);
         for (const line of valueLines.slice(0, 5)) {
-          lines.push(`${indent}${chalk5.dim(BOX.vertical)}   ${chalk5.cyan(line)}`);
+          lines.push(`${indent}${chalk6.dim(BOX.vertical)}   ${chalk6.cyan(line)}`);
         }
         if (valueLines.length > 5) {
           lines.push(
-            `${indent}${chalk5.dim(BOX.vertical)}   ${chalk5.dim(`... (${valueLines.length - 5} more lines)`)}`
+            `${indent}${chalk6.dim(BOX.vertical)}   ${chalk6.dim(`... (${valueLines.length - 5} more lines)`)}`
           );
         }
       }
     }
-    lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+    lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   }
   if (node.name === "TellUser" && node.parameters?.message) {
     const message = String(node.parameters.message);
     const messageType = node.parameters.type || "info";
     const typeIndicators = {
-      info: { emoji: "\u2139\uFE0F", color: chalk5.blue },
-      success: { emoji: "\u2705", color: chalk5.green },
-      warning: { emoji: "\u26A0\uFE0F", color: chalk5.yellow },
-      error: { emoji: "\u274C", color: chalk5.red }
+      info: { emoji: "\u2139\uFE0F", color: chalk6.blue },
+      success: { emoji: "\u2705", color: chalk6.green },
+      warning: { emoji: "\u26A0\uFE0F", color: chalk6.yellow },
+      error: { emoji: "\u274C", color: chalk6.red }
     };
     const typeInfo = typeIndicators[messageType] || typeIndicators.info;
     const headerLine = `${BOX.topLeft}${BOX.horizontal} ${typeInfo.emoji} Message ${BOX.horizontal.repeat(width - 13)}`;
@@ -5159,86 +5512,84 @@ function formatGadgetExpanded(node) {
     const rendered = renderMarkdown(message);
     const renderedLines = rendered.split("\n");
     for (const line of renderedLines) {
-      lines.push(`${indent}${chalk5.dim(BOX.vertical)} ${line}`);
+      lines.push(`${indent}${chalk6.dim(BOX.vertical)} ${line}`);
     }
     lines.push(`${indent}${typeInfo.color(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   } else if (node.result || node.error) {
     const headerText = node.error ? " Error " : " Result ";
     const headerLine = `${BOX.topLeft}${BOX.horizontal}${headerText}${BOX.horizontal.repeat(width - headerText.length - 2)}`;
-    lines.push(`${indent}${chalk5.dim(headerLine)}`);
+    lines.push(`${indent}${chalk6.dim(headerLine)}`);
     const content = node.error || node.result || "";
     const contentLines = content.split("\n");
     const maxLines = 10;
     const displayLines = contentLines.slice(0, maxLines);
     for (const line of displayLines) {
       const truncated = line.length > width - 4 ? `${line.slice(0, width - 7)}...` : line;
-      const color = node.error ? chalk5.red : chalk5.white;
-      lines.push(`${indent}${chalk5.dim(BOX.vertical)} ${color(truncated)}`);
+      const color = node.error ? chalk6.red : chalk6.white;
+      lines.push(`${indent}${chalk6.dim(BOX.vertical)} ${color(truncated)}`);
     }
     if (contentLines.length > maxLines) {
       lines.push(
-        `${indent}${chalk5.dim(BOX.vertical)} ${chalk5.dim(`... (${contentLines.length - maxLines} more lines)`)}`
+        `${indent}${chalk6.dim(BOX.vertical)} ${chalk6.dim(`... (${contentLines.length - maxLines} more lines)`)}`
       );
     }
     if (node.executionTimeMs !== void 0) {
       lines.push(
-        `${indent}${chalk5.dim(BOX.vertical)} Time: ${chalk5.dim(formatExecutionTime(node.executionTimeMs))}`
+        `${indent}${chalk6.dim(BOX.vertical)} Time: ${chalk6.dim(formatExecutionTime(node.executionTimeMs))}`
       );
     }
-    lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+    lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   }
   if (node.mediaOutputs && node.mediaOutputs.length > 0) {
     const headerLine = `${BOX.topLeft}${BOX.horizontal} Media ${BOX.horizontal.repeat(width - 9)}`;
-    lines.push(`${indent}${chalk5.dim(headerLine)}`);
+    lines.push(`${indent}${chalk6.dim(headerLine)}`);
     for (const media of node.mediaOutputs) {
       const kindEmoji = media.kind === "audio" ? "\u{1F50A}" : media.kind === "image" ? "\u{1F5BC}\uFE0F" : media.kind === "video" ? "\u{1F3AC}" : "\u{1F4C4}";
       const maxPathLen = width - 8;
       const displayPath = media.path.length > maxPathLen ? `...${media.path.slice(-(maxPathLen - 3))}` : media.path;
-      lines.push(`${indent}${chalk5.dim(BOX.vertical)} ${kindEmoji} ${chalk5.cyan(displayPath)}`);
+      lines.push(`${indent}${chalk6.dim(BOX.vertical)} ${kindEmoji} ${chalk6.cyan(displayPath)}`);
     }
-    lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+    lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   }
   if (node.children.length > 0) {
     const headerLine = `${BOX.topLeft}${BOX.horizontal} Subagent Activity ${BOX.horizontal.repeat(width - 21)}`;
-    lines.push(`${indent}${chalk5.dim(headerLine)}`);
+    lines.push(`${indent}${chalk6.dim(headerLine)}`);
     lines.push(
-      `${indent}${chalk5.dim(BOX.vertical)} ${chalk5.dim(`${node.children.length} nested calls (expand children to see details)`)}`
+      `${indent}${chalk6.dim(BOX.vertical)} ${chalk6.dim(`${node.children.length} nested calls (expand children to see details)`)}`
     );
-    lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+    lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   }
   if (node.executionTimeMs !== void 0 || node.cost || node.resultTokens || node.subagentStats) {
     const metricsHeaderLine = `${BOX.topLeft}${BOX.horizontal} Metrics ${BOX.horizontal.repeat(width - 11)}`;
-    lines.push(`${indent}${chalk5.dim(metricsHeaderLine)}`);
+    lines.push(`${indent}${chalk6.dim(metricsHeaderLine)}`);
     if (node.executionTimeMs !== void 0) {
       lines.push(
-        `${indent}${chalk5.dim(BOX.vertical)} Duration: ${chalk5.dim(formatExecutionTime(node.executionTimeMs))}`
+        `${indent}${chalk6.dim(BOX.vertical)} Duration: ${chalk6.dim(formatExecutionTime(node.executionTimeMs))}`
       );
     }
     if (node.resultTokens && node.resultTokens > 0) {
       lines.push(
-        `${indent}${chalk5.dim(BOX.vertical)} Output:   ${chalk5.green(`~${formatTokens(node.resultTokens)}`)} tokens`
+        `${indent}${chalk6.dim(BOX.vertical)} Output:   ${chalk6.green(`~${formatTokens(node.resultTokens)}`)} tokens`
       );
     }
     if (node.cost && node.cost > 0) {
       lines.push(
-        `${indent}${chalk5.dim(BOX.vertical)} Cost:     ${chalk5.cyan(`$${formatCost(node.cost)}`)}`
+        `${indent}${chalk6.dim(BOX.vertical)} Cost:     ${chalk6.cyan(`$${formatCost(node.cost)}`)}`
       );
     }
     if (node.subagentStats && node.subagentStats.llmCallCount > 0) {
       const s = node.subagentStats;
-      const tokenParts = [];
-      tokenParts.push(chalk5.dim("\u2191") + chalk5.yellow(` ${formatTokens(s.inputTokens)}`));
-      if (s.cachedTokens > 0) {
-        tokenParts.push(chalk5.dim("\u293F") + chalk5.blue(` ${formatTokens(s.cachedTokens)}`));
-      }
-      tokenParts.push(chalk5.dim("\u2193") + chalk5.green(` ${formatTokens(s.outputTokens)}`));
-      const tokenStr = tokenParts.join(" ");
-      lines.push(`${indent}${chalk5.dim(BOX.vertical)} LLM calls: ${s.llmCallCount} (${tokenStr})`);
+      const tokenStr = buildTokenMetrics({
+        input: s.inputTokens,
+        cached: s.cachedTokens,
+        output: s.outputTokens
+      }).join(" ");
+      lines.push(`${indent}${chalk6.dim(BOX.vertical)} LLM calls: ${s.llmCallCount} (${tokenStr})`);
     }
-    lines.push(`${indent}${chalk5.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
+    lines.push(`${indent}${chalk6.dim(BOX.bottomLeft + BOX.horizontal.repeat(width - 1))}`);
   }
   if (lines.length === 0) {
-    lines.push(`${indent}${chalk5.dim("No details available")}`);
+    lines.push(`${indent}${chalk6.dim("No details available")}`);
   }
   return lines;
 }
@@ -5253,6 +5604,163 @@ function getContinuationIndent(depth) {
   return `${"  ".repeat(depth)}  `;
 }
 
+// src/tui/block-content-formatter.ts
+function formatBlockContent(node, selected, expanded) {
+  const indent = getIndent(node.depth);
+  switch (node.type) {
+    case "llm_call": {
+      const collapsed = formatLLMCallCollapsed(node, selected);
+      if (!expanded) {
+        return indent + collapsed;
+      }
+      const expandedLines = formatLLMCallExpanded(node);
+      const contIndent = getContinuationIndent(node.depth);
+      return [indent + collapsed, ...expandedLines.map((line) => contIndent + line)].join("\n");
+    }
+    case "gadget": {
+      const collapsed = formatGadgetCollapsed(node, selected);
+      if (!expanded) {
+        return indent + collapsed;
+      }
+      const expandedLines = formatGadgetExpanded(node);
+      const contIndent = getContinuationIndent(node.depth);
+      return [indent + collapsed, ...expandedLines.map((line) => contIndent + line)].join("\n");
+    }
+    case "text": {
+      if (node.id.startsWith("user_")) {
+        return formatUserMessage(node.content);
+      }
+      const fullContent = renderMarkdown(node.content);
+      if (expanded) {
+        return `
+${fullContent}
+`;
+      }
+      return abbreviateToLines(fullContent, 2, selected);
+    }
+    case "thinking": {
+      return formatThinkingContent(node, indent, expanded);
+    }
+    case "system_message": {
+      const icon = getSystemMessageIcon(node.category);
+      const color = getSystemMessageColor(node.category);
+      const RESET3 = "\x1B[0m";
+      return `${indent}${color}${icon} ${node.message}${RESET3}`;
+    }
+  }
+}
+function formatThinkingContent(node, indent, expanded) {
+  const DIM2 = "\x1B[2m";
+  const RED_DIM = "\x1B[2;31m";
+  const RESET3 = "\x1B[0m";
+  const contIndent = getContinuationIndent(node.depth);
+  if (node.thinkingType === "redacted") {
+    return `${indent}${RED_DIM}\u{1F512} [Redacted thinking block]${RESET3}`;
+  }
+  if (!expanded) {
+    const firstLine = node.content.split("\n")[0]?.slice(0, 60) ?? "";
+    const suffix = node.isComplete ? "" : "...";
+    return `${indent}${DIM2}\u{1F4AD} Thinking${suffix} ${firstLine}${RESET3}`;
+  }
+  const tokenInfo = node.isComplete ? ` (${Math.ceil(node.content.length / 4)} tokens est.)` : "";
+  const header = `${indent}${DIM2}\u25BC \u{1F4AD} Thinking${tokenInfo}${RESET3}`;
+  const contentLines = node.content.split("\n").map((line) => `${contIndent}${DIM2}${line}${RESET3}`);
+  return [header, ...contentLines].join("\n");
+}
+function getSystemMessageIcon(category) {
+  switch (category) {
+    case "throttle":
+      return "\u23F8";
+    case "retry":
+      return "\u{1F504}";
+    case "info":
+      return "\u2139\uFE0F";
+    case "warning":
+      return "\u26A0\uFE0F";
+    case "error":
+      return "\u274C";
+  }
+}
+function getSystemMessageColor(category) {
+  const YELLOW2 = "\x1B[33m";
+  const BLUE = "\x1B[34m";
+  const GRAY2 = "\x1B[90m";
+  const RED2 = "\x1B[31m";
+  switch (category) {
+    case "throttle":
+      return YELLOW2;
+    case "retry":
+      return BLUE;
+    case "info":
+      return GRAY2;
+    case "warning":
+      return YELLOW2;
+    case "error":
+      return RED2;
+  }
+}
+function abbreviateToLines(text3, maxLines, selected) {
+  const lines = text3.split("\n");
+  let startIndex = 0;
+  while (startIndex < lines.length && lines[startIndex].trim() === "") {
+    startIndex++;
+  }
+  const contentLines = lines.slice(startIndex);
+  if (contentLines.length <= maxLines) {
+    return `
+${contentLines.join("\n")}`;
+  }
+  const truncatedLines = contentLines.slice(0, maxLines);
+  const indicator = selected ? "\u25B6 ..." : "  ...";
+  return `
+${truncatedLines.join("\n")}
+${indicator}`;
+}
+function isNodeVisibleInFilterMode(node, contentFilterMode) {
+  if (contentFilterMode === "full") {
+    return true;
+  }
+  switch (node.type) {
+    case "text":
+      return true;
+    case "gadget":
+      return shouldRenderAsText(node, contentFilterMode);
+    default:
+      return false;
+  }
+}
+function shouldRenderAsText(node, contentFilterMode) {
+  if (contentFilterMode !== "focused") return false;
+  if (node.type !== "gadget") return false;
+  const name = node.name;
+  return name === "TellUser" || name === "AskUser" || name === "Finish";
+}
+function formatGadgetAsText(node) {
+  if (node.name === "TellUser") {
+    const message = node.parameters?.message;
+    if (typeof message === "string") {
+      return `
+${renderMarkdown(message)}
+`;
+    }
+  } else if (node.name === "AskUser") {
+    const question = node.parameters?.question;
+    if (typeof question === "string") {
+      return `
+? ${question}
+`;
+    }
+  } else if (node.name === "Finish") {
+    const message = node.parameters?.message;
+    if (typeof message === "string" && message.trim()) {
+      return `
+\x1B[32m\u2713\x1B[0m ${renderMarkdown(message)}
+`;
+    }
+  }
+  return "";
+}
+
 // src/tui/node-store.ts
 var NodeStore = class {
   /** All nodes in the tree (flat for easy lookup) */
@@ -5675,6 +6183,28 @@ var NodeStore = class {
   }
 };
 
+// src/tui/tree-layout.ts
+function traverseNodeTree(nodeId, getNode, visit, top) {
+  const node = getNode(nodeId);
+  if (!node) {
+    return top;
+  }
+  let nextTop = visit(nodeId, node, top);
+  if ("children" in node) {
+    for (const childId of node.children) {
+      nextTop = traverseNodeTree(childId, getNode, visit, nextTop);
+    }
+  }
+  return nextTop;
+}
+function traverseRootTrees(rootIds, getNode, visit) {
+  let top = 0;
+  for (const rootId of rootIds) {
+    top = traverseNodeTree(rootId, getNode, visit, top);
+  }
+  return top;
+}
+
 // src/tui/scroll-manager.ts
 var ScrollManager = class _ScrollManager {
   container;
@@ -5803,25 +6333,14 @@ var ScrollManager = class _ScrollManager {
    * Calculate total height of all rendered blocks.
    */
   getTotalContentHeight() {
-    let totalHeight = 0;
-    for (const rootId of this.accessors.getRootIds()) {
-      totalHeight = this.sumNodeTreeHeight(rootId, totalHeight);
-    }
-    return totalHeight;
-  }
-  sumNodeTreeHeight(nodeId, currentHeight) {
-    const node = this.accessors.getNode(nodeId);
-    if (!node) return currentHeight;
-    const block = this.accessors.getBlock(nodeId);
-    if (block) {
-      currentHeight += getBlockHeight(block);
-    }
-    if ("children" in node) {
-      for (const childId of node.children) {
-        currentHeight = this.sumNodeTreeHeight(childId, currentHeight);
+    return traverseRootTrees(
+      this.accessors.getRootIds(),
+      (id) => this.accessors.getNode(id),
+      (nodeId, _node, currentHeight) => {
+        const block = this.accessors.getBlock(nodeId);
+        return currentHeight + (block ? getBlockHeight(block) : 0);
       }
-    }
-    return currentHeight;
+    );
   }
   /**
    * Calculate vertical offset to push content to bottom when content < viewport.
@@ -5838,17 +6357,18 @@ var ScrollManager = class _ScrollManager {
    * Apply vertical offset to a node tree (for bottom alignment).
    */
   applyOffsetToNodeTree(nodeId, offset) {
-    const node = this.accessors.getNode(nodeId);
-    if (!node) return;
-    const block = this.accessors.getBlock(nodeId);
-    if (block) {
-      block.box.top = block.box.top + offset;
-    }
-    if ("children" in node) {
-      for (const childId of node.children) {
-        this.applyOffsetToNodeTree(childId, offset);
-      }
-    }
+    traverseNodeTree(
+      nodeId,
+      (id) => this.accessors.getNode(id),
+      (currentNodeId, _node, top) => {
+        const block = this.accessors.getBlock(currentNodeId);
+        if (block) {
+          block.box.top = block.box.top + offset;
+        }
+        return top;
+      },
+      0
+    );
   }
 };
 function getBlockHeight(block) {
@@ -5856,6 +6376,167 @@ function getBlockHeight(block) {
   return content.split("\n").length;
 }
 
+// src/tui/tree-bridge.ts
+var TreeBridge = class {
+  /** Unsubscribe function for tree events */
+  treeUnsubscribe = null;
+  /** Map tree node IDs to block node IDs */
+  treeNodeToBlockId = /* @__PURE__ */ new Map();
+  callbacks;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Public API
+  // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * Check if tree subscription is active.
+   */
+  isSubscribed() {
+    return this.treeUnsubscribe !== null;
+  }
+  /**
+   * Subscribe to an ExecutionTree for automatic block updates.
+   *
+   * When subscribed, the TreeBridge will automatically create and update
+   * blocks based on tree events, calling the provided callbacks.
+   *
+   * @param tree - The ExecutionTree to subscribe to
+   * @returns Unsubscribe function to stop listening
+   *
+   * @example
+   * ```typescript
+   * const agent = builder.ask("Hello");
+   * const unsubscribe = treeBridge.subscribeToTree(agent.getTree());
+   *
+   * for await (const event of agent.run()) {
+   *   // Blocks are automatically updated via tree subscription
+   * }
+   *
+   * unsubscribe();
+   * ```
+   */
+  subscribeToTree(tree) {
+    if (this.treeUnsubscribe) {
+      this.treeUnsubscribe();
+    }
+    this.treeNodeToBlockId.clear();
+    this.callbacks.onClearIdempotencyMaps();
+    this.treeUnsubscribe = tree.onAll((event) => {
+      this.handleTreeEvent(event, tree);
+    });
+    return () => {
+      if (this.treeUnsubscribe) {
+        this.treeUnsubscribe();
+        this.treeUnsubscribe = null;
+      }
+    };
+  }
+  /**
+   * Get block ID for a tree node ID.
+   * Useful for external code that needs to correlate tree nodes with blocks.
+   */
+  getBlockIdForTreeNode(treeNodeId) {
+    return this.treeNodeToBlockId.get(treeNodeId);
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Event Handling
+  // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * Handle an ExecutionTree event.
+   */
+  handleTreeEvent(event, tree) {
+    switch (event.type) {
+      case "llm_call_start": {
+        this.callbacks.onResetThinking();
+        let parentBlockId;
+        if (event.parentId) {
+          parentBlockId = this.treeNodeToBlockId.get(event.parentId);
+        }
+        const blockId = this.callbacks.onAddLLMCall(
+          event.iteration + 1,
+          event.model,
+          parentBlockId,
+          event.depth > 0
+        );
+        this.treeNodeToBlockId.set(event.nodeId, blockId);
+        const startNode = tree.getNode(event.nodeId);
+        if (startNode?.type === "llm_call" && startNode.request) {
+          this.callbacks.onSetLLMCallRequest(blockId, startNode.request);
+        }
+        break;
+      }
+      case "llm_call_complete": {
+        this.callbacks.onCompleteThinking();
+        const blockId = this.treeNodeToBlockId.get(event.nodeId);
+        if (blockId) {
+          this.callbacks.onCompleteLLMCall(blockId, {
+            inputTokens: event.usage?.inputTokens,
+            cachedInputTokens: event.usage?.cachedInputTokens,
+            outputTokens: event.usage?.outputTokens,
+            reasoningTokens: event.usage?.reasoningTokens,
+            cost: event.cost,
+            finishReason: event.finishReason ?? void 0
+          });
+          const completeNode = tree.getNode(event.nodeId);
+          if (completeNode?.type === "llm_call" && completeNode.response) {
+            this.callbacks.onSetLLMCallResponse(blockId, completeNode.response);
+          }
+        }
+        break;
+      }
+      case "thinking": {
+        this.callbacks.onAddThinking(event.content, event.thinkingType);
+        break;
+      }
+      case "gadget_call": {
+        let parentBlockId;
+        if (event.parentId) {
+          parentBlockId = this.treeNodeToBlockId.get(event.parentId);
+        }
+        const previousLLMCallId = this.callbacks.onGetCurrentLLMCallId();
+        if (parentBlockId) {
+          this.callbacks.onSetCurrentLLMCall(parentBlockId);
+        }
+        const blockId = this.callbacks.onAddGadget(
+          event.invocationId,
+          event.name,
+          event.parameters
+        );
+        this.treeNodeToBlockId.set(event.nodeId, blockId);
+        this.callbacks.onSetCurrentLLMCall(previousLLMCallId);
+        break;
+      }
+      case "gadget_complete": {
+        const mediaOutputs = event.storedMedia?.map((m) => ({
+          kind: m.kind,
+          path: m.path,
+          mimeType: m.mimeType,
+          description: m.description
+        }));
+        this.callbacks.onCompleteGadget(event.invocationId, {
+          result: event.result,
+          executionTimeMs: event.executionTimeMs,
+          cost: event.cost,
+          mediaOutputs
+        });
+        break;
+      }
+      case "gadget_error": {
+        this.callbacks.onCompleteGadget(event.invocationId, {
+          error: event.error,
+          executionTimeMs: event.executionTimeMs
+        });
+        break;
+      }
+      case "gadget_skipped": {
+        this.callbacks.onSkipGadget(event.invocationId, `Skipped: ${event.failedDependencyError}`);
+        break;
+      }
+    }
+  }
+};
+
 // src/tui/block-renderer.ts
 var BlockRenderer = class {
   container;
@@ -5865,6 +6546,8 @@ var BlockRenderer = class {
   nodeStore;
   /** Scroll manager — manages scroll position, follow mode, and bottom alignment */
   scrollManager;
+  /** Tree bridge — manages ExecutionTree subscriptions and tree→block mapping */
+  treeBridge;
   /** Rendered blocks with UI state */
   blocks = /* @__PURE__ */ new Map();
   /** IDs of selectable blocks in display order */
@@ -5894,6 +6577,21 @@ var BlockRenderer = class {
       getBlock: (id) => this.blocks.get(id),
       getSelectedBlock: () => this.getSelectedBlock()
     });
+    this.treeBridge = new TreeBridge({
+      onResetThinking: () => this.nodeStore.resetCurrentThinking(),
+      onSetCurrentLLMCall: (llmCallId) => this.setCurrentLLMCall(llmCallId),
+      onClearIdempotencyMaps: () => this.nodeStore.clearIdempotencyMaps(),
+      onAddLLMCall: (iteration, model, parentGadgetId, isNested) => this.addLLMCall(iteration, model, parentGadgetId, isNested),
+      onCompleteLLMCall: (id, details, rawResponse) => this.completeLLMCall(id, details, rawResponse),
+      onSetLLMCallRequest: (id, messages) => this.setLLMCallRequest(id, messages),
+      onSetLLMCallResponse: (id, rawResponse) => this.setLLMCallResponse(id, rawResponse),
+      onCompleteThinking: () => this.completeThinking(),
+      onAddThinking: (content, thinkingType) => this.addThinking(content, thinkingType),
+      onAddGadget: (invocationId, name, parameters) => this.addGadget(invocationId, name, parameters),
+      onCompleteGadget: (invocationId, options) => this.completeGadget(invocationId, options),
+      onSkipGadget: (invocationId, reason) => this.skipGadget(invocationId, reason),
+      onGetCurrentLLMCallId: () => this.getCurrentLLMCallId()
+    });
   }
   // ───────────────────────────────────────────────────────────────────────────
   // Public API - Node Management
@@ -5939,6 +6637,12 @@ var BlockRenderer = class {
   completeGadget(invocationId, options = {}) {
     this.nodeStore.completeGadget(invocationId, options);
   }
+  /**
+   * Mark a gadget as skipped with a rendered reason.
+   */
+  skipGadget(invocationId, reason) {
+    this.nodeStore.completeGadget(invocationId, { error: reason });
+  }
   /**
    * Add a text node (flows between LLM calls).
    */
@@ -6006,9 +6710,8 @@ var BlockRenderer = class {
   /**
    * Get the current LLM call ID.
    *
-   * In tree mode, this is only used for attaching raw request/response data
-   * to the block for the raw viewer feature. Parent-child relationships are
-   * determined by event.parentId in handleTreeEvent(), not by this method.
+   * In tree mode, TreeBridge uses this to restore the current parent context
+   * while translating gadget events into renderer updates.
    */
   getCurrentLLMCallId() {
     return this.nodeStore.currentLLMCallId;
@@ -6018,7 +6721,7 @@ var BlockRenderer = class {
    * When active, external code should skip block creation (tree handles it).
    */
   isTreeSubscribed() {
-    return this.treeUnsubscribe !== null;
+    return this.treeBridge.isSubscribed();
   }
   /**
    * Store raw response for an LLM call (enrichment only).
@@ -6189,22 +6892,7 @@ var BlockRenderer = class {
    * Called when nodes are added/removed.
    */
   rebuildBlocks() {
-    for (const child of [...this.container.children]) {
-      child.detach();
-    }
-    this.container.setContent("");
-    this.blocks.clear();
-    this.selectableIds = [];
-    let top = 0;
-    for (const rootId of this.nodeStore.rootIds) {
-      top = this.renderNodeTree(rootId, top);
-    }
-    if (this.selectedIndex >= this.selectableIds.length) {
-      this.selectedIndex = this.selectableIds.length - 1;
-    }
-    this.applyBottomAlignmentAndScroll();
-    this.renderCallback();
-    this.notifyHasContentChange();
+    this.rebuildBlocksCore(false);
   }
   /**
    * Render a node and its children recursively.
@@ -6218,64 +6906,29 @@ var BlockRenderer = class {
    * (no headers, just content) for a clean chat-like experience.
    */
   renderNodeTree(nodeId, top) {
-    const node = this.getNode(nodeId);
-    if (!node) return top;
-    const visible = this.isNodeVisible(node);
-    if (visible) {
-      const renderAsText = this.shouldRenderAsText(node);
-      const block = renderAsText ? this.createTextLikeBlock(node, top) : this.createBlock(node, top);
-      this.blocks.set(nodeId, block);
-      if (block.selectable) {
-        this.selectableIds.push(nodeId);
-      }
-      const height = getBlockHeight(block);
-      top += height;
-    }
-    if ("children" in node && node.children.length > 0) {
-      for (const childId of node.children) {
-        top = this.renderNodeTree(childId, top);
-      }
-    }
-    return top;
-  }
-  /**
-   * Check if a gadget should render as plain text in focused mode.
-   * TellUser, AskUser, and Finish render as text for a chat-like experience.
-   */
-  shouldRenderAsText(node) {
-    if (this.contentFilterMode !== "focused") return false;
-    if (node.type !== "gadget") return false;
-    const name = node.name;
-    return name === "TellUser" || name === "AskUser" || name === "Finish";
+    return traverseNodeTree(
+      nodeId,
+      (id) => this.getNode(id),
+      (currentNodeId, node, currentTop) => {
+        if (!this.isNodeVisible(node)) {
+          return currentTop;
+        }
+        const block = shouldRenderAsText(node, this.contentFilterMode) ? this.createTextLikeBlock(node, currentTop) : this.createBlock(node, currentTop);
+        this.blocks.set(currentNodeId, block);
+        if (block.selectable) {
+          this.selectableIds.push(currentNodeId);
+        }
+        return currentTop + getBlockHeight(block);
+      },
+      top
+    );
   }
   /**
    * Create a text-like block for TellUser/AskUser/Finish gadgets in focused mode.
    * Renders just the content without the gadget header.
    */
   createTextLikeBlock(node, top) {
-    let content = "";
-    if (node.name === "TellUser") {
-      const message = node.parameters?.message;
-      if (typeof message === "string") {
-        content = `
-${renderMarkdown(message)}
-`;
-      }
-    } else if (node.name === "AskUser") {
-      const question = node.parameters?.question;
-      if (typeof question === "string") {
-        content = `
-? ${question}
-`;
-      }
-    } else if (node.name === "Finish") {
-      const message = node.parameters?.message;
-      if (typeof message === "string" && message.trim()) {
-        content = `
-\x1B[32m\u2713\x1B[0m ${renderMarkdown(message)}
-`;
-      }
-    }
+    const content = formatGadgetAsText(node);
     const box = new Box({
       parent: this.container,
       top,
@@ -6300,7 +6953,7 @@ ${renderMarkdown(message)}
     const isSelected = this.selectableIds.length === this.selectedIndex;
     const selectable = node.type !== "text" || !node.id.startsWith("user_");
     const expanded = this.expandedStates.get(node.id) ?? false;
-    const content = this.formatBlockContent(node, isSelected, expanded);
+    const content = formatBlockContent(node, isSelected, expanded);
     const box = new Box({
       parent: this.container,
       top,
@@ -6318,133 +6971,6 @@ ${renderMarkdown(message)}
       selectable
     };
   }
-  /**
-   * Format block content based on type and state.
-   */
-  formatBlockContent(node, selected, expanded) {
-    const indent = getIndent(node.depth);
-    switch (node.type) {
-      case "llm_call": {
-        const collapsed = formatLLMCallCollapsed(node, selected);
-        if (!expanded) {
-          return indent + collapsed;
-        }
-        const expandedLines = formatLLMCallExpanded(node);
-        const contIndent = getContinuationIndent(node.depth);
-        return [indent + collapsed, ...expandedLines.map((line) => contIndent + line)].join("\n");
-      }
-      case "gadget": {
-        const collapsed = formatGadgetCollapsed(node, selected);
-        if (!expanded) {
-          return indent + collapsed;
-        }
-        const expandedLines = formatGadgetExpanded(node);
-        const contIndent = getContinuationIndent(node.depth);
-        return [indent + collapsed, ...expandedLines.map((line) => contIndent + line)].join("\n");
-      }
-      case "text": {
-        if (node.id.startsWith("user_")) {
-          return formatUserMessage(node.content);
-        }
-        const fullContent = renderMarkdown(node.content);
-        if (expanded) {
-          return `
-${fullContent}
-`;
-        }
-        return this.abbreviateToLines(fullContent, 2, selected);
-      }
-      case "thinking": {
-        const DIM2 = "\x1B[2m";
-        const RED_DIM = "\x1B[2;31m";
-        const RESET3 = "\x1B[0m";
-        const contIndent = getContinuationIndent(node.depth);
-        if (node.thinkingType === "redacted") {
-          const header2 = `${indent}${RED_DIM}\u{1F512} [Redacted thinking block]${RESET3}`;
-          return header2;
-        }
-        if (!expanded) {
-          const firstLine = node.content.split("\n")[0]?.slice(0, 60) ?? "";
-          const suffix = node.isComplete ? "" : "...";
-          return `${indent}${DIM2}\u{1F4AD} Thinking${suffix} ${firstLine}${RESET3}`;
-        }
-        const tokenInfo = node.isComplete ? ` (${Math.ceil(node.content.length / 4)} tokens est.)` : "";
-        const header = `${indent}${DIM2}\u25BC \u{1F4AD} Thinking${tokenInfo}${RESET3}`;
-        const contentLines = node.content.split("\n").map((line) => `${contIndent}${DIM2}${line}${RESET3}`);
-        return [header, ...contentLines].join("\n");
-      }
-      case "system_message": {
-        const icon = this.getSystemMessageIcon(node.category);
-        const color = this.getSystemMessageColor(node.category);
-        const RESET3 = "\x1B[0m";
-        return `${indent}${color}${icon} ${node.message}${RESET3}`;
-      }
-    }
-  }
-  /**
-   * Get icon for system message category.
-   */
-  getSystemMessageIcon(category) {
-    switch (category) {
-      case "throttle":
-        return "\u23F8";
-      case "retry":
-        return "\u{1F504}";
-      case "info":
-        return "\u2139\uFE0F";
-      case "warning":
-        return "\u26A0\uFE0F";
-      case "error":
-        return "\u274C";
-    }
-  }
-  /**
-   * Get ANSI color code for system message category.
-   */
-  getSystemMessageColor(category) {
-    const YELLOW2 = "\x1B[33m";
-    const BLUE = "\x1B[34m";
-    const GRAY2 = "\x1B[90m";
-    const RED2 = "\x1B[31m";
-    switch (category) {
-      case "throttle":
-        return YELLOW2;
-      case "retry":
-        return BLUE;
-      case "info":
-        return GRAY2;
-      case "warning":
-        return YELLOW2;
-      case "error":
-        return RED2;
-    }
-  }
-  /**
-   * Abbreviate text content to a maximum number of lines.
-   * Shows truncation indicator if content exceeds limit.
-   *
-   * @param text - The text to abbreviate
-   * @param maxLines - Maximum number of lines to show
-   * @param selected - Whether this block is selected (for indicator styling)
-   * @returns Abbreviated text with truncation indicator if needed
-   */
-  abbreviateToLines(text3, maxLines, selected) {
-    const lines = text3.split("\n");
-    let startIndex = 0;
-    while (startIndex < lines.length && lines[startIndex].trim() === "") {
-      startIndex++;
-    }
-    const contentLines = lines.slice(startIndex);
-    if (contentLines.length <= maxLines) {
-      return `
-${contentLines.join("\n")}`;
-    }
-    const truncatedLines = contentLines.slice(0, maxLines);
-    const indicator = selected ? "\u25B6 ..." : "  ...";
-    return `
-${truncatedLines.join("\n")}
-${indicator}`;
-  }
   /**
    * Update a single block (after state change).
    */
@@ -6453,7 +6979,7 @@ ${indicator}`;
     const node = this.getNode(nodeId);
     if (!block || !node) return;
     const isSelected = this.selectableIds[this.selectedIndex] === nodeId;
-    const content = this.formatBlockContent(node, isSelected, block.expanded);
+    const content = formatBlockContent(node, isSelected, block.expanded);
     const oldHeight = getBlockHeight(block);
     block.box.setContent(content);
     const newHeight = content.split("\n").length;
@@ -6471,7 +6997,7 @@ ${indicator}`;
       const block = this.blocks.get(id);
       if (block) {
         const isSelected = this.selectableIds[this.selectedIndex] === id;
-        const content = this.formatBlockContent(block.node, isSelected, block.expanded);
+        const content = formatBlockContent(block.node, isSelected, block.expanded);
         block.box.setContent(content);
       }
     }
@@ -6486,20 +7012,19 @@ ${indicator}`;
     this.scrollManager.repositionBlocks((rootId, top) => this.repositionNodeTree(rootId, top));
   }
   repositionNodeTree(nodeId, top) {
-    const node = this.getNode(nodeId);
-    if (!node) return top;
-    const block = this.blocks.get(nodeId);
-    if (block) {
-      block.box.top = top;
-      const height = getBlockHeight(block);
-      top += height;
-    }
-    if ("children" in node) {
-      for (const childId of node.children) {
-        top = this.repositionNodeTree(childId, top);
-      }
-    }
-    return top;
+    return traverseNodeTree(
+      nodeId,
+      (id) => this.getNode(id),
+      (currentNodeId, _node, currentTop) => {
+        const block = this.blocks.get(currentNodeId);
+        if (!block) {
+          return currentTop;
+        }
+        block.box.top = currentTop;
+        return currentTop + getBlockHeight(block);
+      },
+      top
+    );
   }
   /**
    * Scroll container to keep selected block visible.
@@ -6566,13 +7091,25 @@ ${indicator}`;
    * Used for mode switches where we need to ensure the screen is fully cleared.
    */
   rebuildBlocksImmediate() {
+    this.rebuildBlocksCore(true);
+  }
+  /**
+   * Shared implementation for rebuildBlocks and rebuildBlocksImmediate.
+   *
+   * @param immediate - When true, forces a synchronous render pass before
+   *   and after building blocks to clear visual artifacts (used on mode switch).
+   *   When false, defers a single render to the end via renderCallback.
+   */
+  rebuildBlocksCore(immediate) {
     for (const child of [...this.container.children]) {
       child.detach();
     }
     this.container.setContent("");
     this.blocks.clear();
     this.selectableIds = [];
-    this.renderNowCallback();
+    if (immediate) {
+      this.renderNowCallback();
+    }
     let top = 0;
     for (const rootId of this.nodeStore.rootIds) {
       top = this.renderNodeTree(rootId, top);
@@ -6581,7 +7118,11 @@ ${indicator}`;
       this.selectedIndex = this.selectableIds.length - 1;
     }
     this.applyBottomAlignmentAndScroll();
-    this.renderNowCallback();
+    if (immediate) {
+      this.renderNowCallback();
+    } else {
+      this.renderCallback();
+    }
     this.notifyHasContentChange();
   }
   /**
@@ -6593,38 +7134,15 @@ ${indicator}`;
   /**
    * Check if a node should be visible in the current content filter mode.
    *
-   * In focused mode:
-   * - Text nodes are always visible
-   * - LLM call blocks are hidden
-   * - Gadget blocks are hidden EXCEPT TellUser and AskUser
-   *   (Finish is hidden - status bar indicates completion)
+   * In focused mode, only text and user-facing gadgets remain visible.
+   * TellUser, AskUser, and Finish render as plain text for a chat-like view.
    */
   isNodeVisible(node) {
-    if (this.contentFilterMode === "full") {
-      return true;
-    }
-    switch (node.type) {
-      case "text":
-        return true;
-      case "llm_call":
-        return false;
-      case "thinking":
-        return false;
-      case "gadget": {
-        const name = node.name;
-        return name === "TellUser" || name === "AskUser" || name === "Finish";
-      }
-      default:
-        return false;
-    }
+    return isNodeVisibleInFilterMode(node, this.contentFilterMode);
   }
   // ───────────────────────────────────────────────────────────────────────────
   // ExecutionTree Integration
   // ───────────────────────────────────────────────────────────────────────────
-  /** Unsubscribe function for tree events */
-  treeUnsubscribe = null;
-  /** Map tree node IDs to block node IDs */
-  treeNodeToBlockId = /* @__PURE__ */ new Map();
   /**
    * Subscribe to an ExecutionTree for automatic block updates.
    *
@@ -6648,121 +7166,14 @@ ${indicator}`;
    * ```
    */
   subscribeToTree(tree) {
-    if (this.treeUnsubscribe) {
-      this.treeUnsubscribe();
-    }
-    this.treeNodeToBlockId.clear();
-    this.nodeStore.clearIdempotencyMaps();
-    this.treeUnsubscribe = tree.onAll((event) => {
-      this.handleTreeEvent(event, tree);
-    });
-    return () => {
-      if (this.treeUnsubscribe) {
-        this.treeUnsubscribe();
-        this.treeUnsubscribe = null;
-      }
-    };
-  }
-  /**
-   * Handle an ExecutionTree event.
-   */
-  handleTreeEvent(event, tree) {
-    switch (event.type) {
-      case "llm_call_start": {
-        this.nodeStore.resetCurrentThinking();
-        let parentBlockId;
-        if (event.parentId) {
-          parentBlockId = this.treeNodeToBlockId.get(event.parentId);
-        }
-        const blockId = this.addLLMCall(
-          event.iteration + 1,
-          event.model,
-          parentBlockId,
-          event.depth > 0
-        );
-        this.treeNodeToBlockId.set(event.nodeId, blockId);
-        const startNode = tree.getNode(event.nodeId);
-        if (startNode?.type === "llm_call" && startNode.request) {
-          this.setLLMCallRequest(blockId, startNode.request);
-        }
-        break;
-      }
-      case "llm_call_complete": {
-        this.completeThinking();
-        const blockId = this.treeNodeToBlockId.get(event.nodeId);
-        if (blockId) {
-          this.completeLLMCall(blockId, {
-            inputTokens: event.usage?.inputTokens,
-            cachedInputTokens: event.usage?.cachedInputTokens,
-            outputTokens: event.usage?.outputTokens,
-            reasoningTokens: event.usage?.reasoningTokens,
-            cost: event.cost,
-            finishReason: event.finishReason ?? void 0
-          });
-          const completeNode = tree.getNode(event.nodeId);
-          if (completeNode?.type === "llm_call" && completeNode.response) {
-            this.setLLMCallResponse(blockId, completeNode.response);
-          }
-        }
-        break;
-      }
-      case "thinking": {
-        this.addThinking(event.content, event.thinkingType);
-        break;
-      }
-      case "gadget_call": {
-        let parentBlockId;
-        if (event.parentId) {
-          parentBlockId = this.treeNodeToBlockId.get(event.parentId);
-        }
-        const previousLLMCallId = this.getCurrentLLMCallId();
-        if (parentBlockId) {
-          this.setCurrentLLMCall(parentBlockId);
-        }
-        const blockId = this.addGadget(event.invocationId, event.name, event.parameters);
-        this.treeNodeToBlockId.set(event.nodeId, blockId);
-        this.setCurrentLLMCall(previousLLMCallId);
-        break;
-      }
-      case "gadget_complete": {
-        const mediaOutputs = event.storedMedia?.map((m) => ({
-          kind: m.kind,
-          path: m.path,
-          mimeType: m.mimeType,
-          description: m.description
-        }));
-        this.completeGadget(event.invocationId, {
-          result: event.result,
-          executionTimeMs: event.executionTimeMs,
-          cost: event.cost,
-          mediaOutputs
-        });
-        break;
-      }
-      case "gadget_error": {
-        this.completeGadget(event.invocationId, {
-          error: event.error,
-          executionTimeMs: event.executionTimeMs
-        });
-        break;
-      }
-      case "gadget_skipped": {
-        const node = this.findGadgetByInvocationId(event.invocationId);
-        if (node) {
-          node.isComplete = true;
-          node.error = `Skipped: ${event.failedDependencyError}`;
-          this.updateBlock(node.id);
-        }
-        break;
-      }
-    }
+    return this.treeBridge.subscribeToTree(tree);
   }
   /**
    * Get block ID for a tree node ID.
    * Useful for external code that needs to correlate tree nodes with blocks.
    */
   getBlockIdForTreeNode(treeNodeId) {
-    return this.treeNodeToBlockId.get(treeNodeId);
+    return this.treeBridge.getBlockIdForTreeNode(treeNodeId);
   }
 };
 
@@ -7055,6 +7466,26 @@ var TUIController = class {
   }
 };
 
+// src/tui/event-router.ts
+var EventRouter = class {
+  constructor(blockRenderer) {
+    this.blockRenderer = blockRenderer;
+  }
+  /**
+   * Route an agent stream event to the appropriate renderer method.
+   *
+   * Only handles text/thinking events - gadgets and LLM calls are managed
+   * via ExecutionTree subscription in TreeSubscriptionManager.
+   */
+  handleEvent(event) {
+    if (event.type === "text") {
+      this.blockRenderer.addText(event.content);
+    } else if (event.type === "thinking") {
+      this.blockRenderer.addThinking(event.content, event.thinkingType);
+    }
+  }
+};
+
 // src/tui/hints-bar.ts
 var GRAY = "\x1B[90m";
 var RESET = "\x1B[0m";
@@ -7137,10 +7568,10 @@ var HintsBar = class {
 import { spawnSync as spawnSync2 } from "child_process";
 import { readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function openEditorSync(initialContent = "") {
   const editor = process.env.VISUAL || process.env.EDITOR || "vi";
-  const tmpFile = join2(tmpdir(), `llmist-input-${Date.now()}.txt`);
+  const tmpFile = join3(tmpdir(), `llmist-input-${Date.now()}.txt`);
   writeFileSync2(tmpFile, initialContent, "utf-8");
   try {
     const parts = editor.split(/\s+/);
@@ -7375,11 +7806,11 @@ var InputHandler = class {
    * @returns Promise that resolves with user's response
    */
   async waitForInput(question, gadgetName) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pendingInput = {
         question,
         gadgetName,
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.setActive();
@@ -7394,11 +7825,11 @@ var InputHandler = class {
    * @returns Promise that resolves with user's prompt
    */
   async waitForPrompt() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pendingInput = {
         question: "",
         gadgetName: "prompt",
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.setPendingPrompt();
@@ -7494,10 +7925,10 @@ var InputHandler = class {
       return;
     }
     if (this.pendingInput) {
-      const { resolve: resolve3 } = this.pendingInput;
+      const { resolve: resolve4 } = this.pendingInput;
       this.pendingInput = null;
       this.setIdle();
-      resolve3(value);
+      resolve4(value);
     } else if (this.midSessionHandler) {
       this.midSessionHandler(value);
       this.setIdle();
@@ -7657,6 +8088,104 @@ var InputHandler = class {
   }
 };
 
+// src/tui/key-action-handler.ts
+var KeyActionHandler = class {
+  constructor(controller, blockRenderer, statusBar, screenCtx, modalManager, layout) {
+    this.controller = controller;
+    this.blockRenderer = blockRenderer;
+    this.statusBar = statusBar;
+    this.screenCtx = screenCtx;
+    this.modalManager = modalManager;
+    this.layout = layout;
+  }
+  /**
+   * Handle high-level keyboard actions from KeyboardManager or InputHandler.
+   */
+  handleKeyAction(action) {
+    switch (action.type) {
+      case "ctrl_c": {
+        const result = this.controller.handleCtrlC();
+        if (result === "show_hint") {
+          this.blockRenderer.addText("\n[Press Ctrl+C again to quit]\n");
+        } else if (result === "quit") {
+          process.exit(130);
+        }
+        break;
+      }
+      case "cancel":
+        this.controller.triggerCancel();
+        this.controller.abort();
+        break;
+      case "toggle_focus_mode":
+        this.controller.toggleFocusMode();
+        break;
+      case "toggle_content_filter":
+        this.controller.toggleContentFilterMode();
+        break;
+      case "cycle_profile":
+        this.statusBar.cycleProfile();
+        break;
+      case "scroll_page": {
+        const body = this.layout.body;
+        if (!body.scroll) return;
+        const containerHeight = body.height;
+        const scrollAmount = Math.max(1, containerHeight - 2);
+        if (action.direction < 0) {
+          body.scroll(-scrollAmount);
+        } else {
+          body.scroll(scrollAmount);
+        }
+        this.blockRenderer.handleUserScroll();
+        this.screenCtx.renderNow();
+        break;
+      }
+      case "scroll_line": {
+        const body = this.layout.body;
+        if (!body.scroll) return;
+        body.scroll(action.direction);
+        this.blockRenderer.handleUserScroll();
+        this.screenCtx.renderNow();
+        break;
+      }
+      case "navigation":
+        switch (action.action) {
+          case "select_next":
+            this.blockRenderer.selectNext();
+            break;
+          case "select_previous":
+            this.blockRenderer.selectPrevious();
+            break;
+          case "select_first":
+            this.blockRenderer.selectFirst();
+            break;
+          case "select_last":
+            this.blockRenderer.selectLast();
+            this.blockRenderer.enableFollowMode();
+            break;
+          case "toggle_expand":
+            this.blockRenderer.toggleExpand();
+            break;
+          case "collapse":
+            this.blockRenderer.collapseOrDeselect();
+            break;
+        }
+        this.screenCtx.renderNow();
+        break;
+      case "raw_viewer":
+        void (async () => {
+          const selected = this.blockRenderer.getSelectedBlock();
+          if (!selected) return;
+          if (!isRawViewerNode(selected.node)) return;
+          await this.modalManager.showRawViewer(
+            this.screenCtx.screen,
+            createRawViewerData(selected.node, action.mode)
+          );
+        })();
+        break;
+    }
+  }
+};
+
 // src/tui/keymap.ts
 var KeyboardManager = class {
   config;
@@ -7857,7 +8386,7 @@ import { Box as Box3 } from "@unblessed/node";
 var MAX_PREVIEW_LINES = 10;
 var MAX_PARAM_VALUE_LENGTH = 60;
 function showApprovalDialog(screen, context) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const content = buildDialogContent(context);
     const dialog = new Box3({
       parent: screen,
@@ -7912,7 +8441,7 @@ function showApprovalDialog(screen, context) {
       if (response) {
         dialog.destroy();
         screen.render();
-        resolve3(response);
+        resolve4(response);
       }
     };
     dialog.on("keypress", handleKey);
@@ -7982,7 +8511,7 @@ var WHITE = "\x1B[37m";
 function showRawViewer(options) {
   let closeCallback = () => {
   };
-  const closed = new Promise((resolve3) => {
+  const closed = new Promise((resolve4) => {
     const {
       screen,
       mode,
@@ -8078,7 +8607,7 @@ ${error}`;
       helpBar.destroy();
       viewer.destroy();
       screen.render();
-      resolve3();
+      resolve4();
     };
     closeCallback = close;
     viewer.key(["escape", "q"], close);
@@ -8354,6 +8883,47 @@ function createScreen(options) {
   };
 }
 
+// src/tui/session-manager.ts
+var SessionManager = class {
+  constructor(blockRenderer, statusBar) {
+    this.blockRenderer = blockRenderer;
+    this.statusBar = statusBar;
+  }
+  /**
+   * Start a new session. Called at the start of each REPL turn.
+   */
+  startNewSession() {
+    this.blockRenderer.startNewSession();
+  }
+  /**
+   * Clear blocks from the previous session only.
+   * Keeps current content visible during the session.
+   */
+  clearPreviousSession() {
+    this.blockRenderer.clearPreviousSession();
+  }
+  /**
+   * Clear all blocks and reset BlockRenderer state.
+   * Prevents memory leaks between iterations.
+   */
+  clearAllBlocks() {
+    this.blockRenderer.clear();
+  }
+  /**
+   * Clear status bar activity state.
+   */
+  clearStatusBar() {
+    this.statusBar.clearActivity();
+  }
+  /**
+   * Full cleanup between REPL iterations.
+   */
+  resetAll() {
+    this.clearAllBlocks();
+    this.clearStatusBar();
+  }
+};
+
 // src/tui/status-bar.ts
 var CHARS_PER_TOKEN = 4;
 var SPINNER_FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -8880,6 +9450,195 @@ var StatusBar = class {
   }
 };
 
+// src/tui/tree-subscription-manager.ts
+var TreeSubscriptionManager = class {
+  constructor(blockRenderer, statusBar) {
+    this.blockRenderer = blockRenderer;
+    this.statusBar = statusBar;
+  }
+  treeUnsubscribe = null;
+  /**
+   * Subscribe to an ExecutionTree for automatic updates.
+   * Handles previous unsubscription and returns a combined unsubscribe function.
+   */
+  subscribe(tree) {
+    this.unsubscribe();
+    const unsubBlock = this.blockRenderer.subscribeToTree(tree);
+    const unsubStatus = this.statusBar.subscribeToTree(tree);
+    this.treeUnsubscribe = () => {
+      unsubBlock();
+      unsubStatus();
+    };
+    return () => this.unsubscribe();
+  }
+  /**
+   * Unsubscribe from the current tree if any.
+   */
+  unsubscribe() {
+    if (this.treeUnsubscribe) {
+      this.treeUnsubscribe();
+      this.treeUnsubscribe = null;
+    }
+  }
+};
+
+// src/tui/tui-app-effects.ts
+function applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx) {
+  statusBar.setFocusMode(mode);
+  if (mode === "input") {
+    inputHandler.activate();
+  } else {
+    inputHandler.deactivate();
+    layout.body.focus();
+  }
+  screenCtx.renderNow();
+}
+function applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx) {
+  blockRenderer.setContentFilterMode(mode);
+  statusBar.setContentFilterMode(mode);
+  screenCtx.renderNow();
+}
+
+// src/tui/tui-app-bootstrap.ts
+function createTUIAppDependencies(options) {
+  const screenCtx = createScreen({
+    stdin: options.stdin,
+    stdout: options.stdout,
+    title: "llmist"
+  });
+  const { screen } = screenCtx;
+  const showHints = options.showHints ?? true;
+  const layout = createBlockLayout(screen, showHints);
+  const hintsBar = createHintsBar(layout, screenCtx, showHints);
+  const statusBar = createStatusBar(layout, options.model, screenCtx);
+  const inputHandler = createInputHandler(layout, screenCtx, screen, showHints);
+  const blockRenderer = createBlockRenderer(layout, screenCtx);
+  wireHintsBar(blockRenderer, hintsBar);
+  const controller = createController(
+    layout,
+    statusBar,
+    inputHandler,
+    screenCtx,
+    blockRenderer,
+    hintsBar
+  );
+  const modalManager = new ModalManager();
+  const keyActionHandler = new KeyActionHandler(
+    controller,
+    blockRenderer,
+    statusBar,
+    screenCtx,
+    modalManager,
+    layout
+  );
+  const keyboardManager = new KeyboardManager({
+    screen,
+    getFocusMode: () => controller.getFocusMode(),
+    getContentFilterMode: () => controller.getContentFilterMode(),
+    isWaitingForREPLPrompt: () => inputHandler.isWaitingForREPLPrompt(),
+    hasPendingInput: () => inputHandler.hasPendingInput(),
+    isBlockExpanded: () => blockRenderer.getSelectedBlock()?.expanded ?? false,
+    onAction: (action) => {
+      keyActionHandler.handleKeyAction(action);
+    }
+  });
+  const subscriptionManager = new TreeSubscriptionManager(blockRenderer, statusBar);
+  const sessionManager = new SessionManager(blockRenderer, statusBar);
+  const eventRouter = new EventRouter(blockRenderer);
+  wireInputHandlers(inputHandler, keyboardManager, keyActionHandler, controller);
+  wireScreenEvents(layout, screen, blockRenderer);
+  keyboardManager.setup();
+  applyFocusMode(controller.getFocusMode(), layout, statusBar, inputHandler, screenCtx);
+  screenCtx.requestRender();
+  return {
+    screenCtx,
+    statusBar,
+    inputHandler,
+    blockRenderer,
+    controller,
+    modalManager,
+    subscriptionManager,
+    sessionManager,
+    eventRouter
+  };
+}
+function createHintsBar(layout, screenCtx, showHints) {
+  if (!showHints || !layout.hintsBar) {
+    return null;
+  }
+  return new HintsBar(layout.hintsBar, () => screenCtx.requestRender());
+}
+function createStatusBar(layout, model, screenCtx) {
+  return new StatusBar(
+    layout.statusBar,
+    model,
+    () => screenCtx.requestRender(),
+    () => screenCtx.renderNow()
+  );
+}
+function createInputHandler(layout, screenCtx, screen, showHints) {
+  return new InputHandler(
+    layout.inputBar,
+    layout.promptLabel,
+    layout.body,
+    screen,
+    () => screenCtx.requestRender(),
+    () => screenCtx.renderNow(),
+    showHints
+  );
+}
+function createBlockRenderer(layout, screenCtx) {
+  return new BlockRenderer(
+    layout.body,
+    () => screenCtx.requestRender(),
+    () => screenCtx.renderNow()
+  );
+}
+function wireHintsBar(blockRenderer, hintsBar) {
+  if (!hintsBar) {
+    return;
+  }
+  blockRenderer.onHasContentChange((hasContent) => {
+    hintsBar.setHasContent(hasContent);
+  });
+}
+function createController(layout, statusBar, inputHandler, screenCtx, blockRenderer, hintsBar) {
+  return new TUIController({
+    onFocusModeChange: (mode) => {
+      applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx);
+      hintsBar?.setFocusMode(mode);
+    },
+    onContentFilterModeChange: (mode) => {
+      applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx);
+      hintsBar?.setContentFilterMode(mode);
+    }
+  });
+}
+function wireInputHandlers(inputHandler, keyboardManager, keyActionHandler, controller) {
+  inputHandler.onCtrlC(() => keyboardManager.handleForwardedKey("C-c"));
+  inputHandler.onCtrlB(() => keyboardManager.handleForwardedKey("C-b"));
+  inputHandler.onCtrlK(() => keyboardManager.handleForwardedKey("C-k"));
+  inputHandler.onCtrlI(() => keyboardManager.handleForwardedKey("C-i"));
+  inputHandler.onCtrlJ(() => keyboardManager.handleForwardedKey("C-j"));
+  inputHandler.onCtrlP(() => keyboardManager.handleForwardedKey("C-p"));
+  inputHandler.onArrowUp(() => {
+    keyActionHandler.handleKeyAction({ type: "scroll_line", direction: -1 });
+  });
+  inputHandler.onArrowDown(() => {
+    keyActionHandler.handleKeyAction({ type: "scroll_line", direction: 1 });
+  });
+  inputHandler.setGetFocusMode(() => controller.getFocusMode());
+  inputHandler.setGetContentFilterMode(() => controller.getContentFilterMode());
+}
+function wireScreenEvents(layout, screen, blockRenderer) {
+  layout.body.on("scroll", () => {
+    blockRenderer.handleUserScroll();
+  });
+  screen.on("resize", () => {
+    blockRenderer.handleResize();
+  });
+}
+
 // src/tui/index.ts
 var TUIApp = class _TUIApp {
   screenCtx;
@@ -8889,135 +9648,36 @@ var TUIApp = class _TUIApp {
   // New extracted components
   controller;
   modalManager;
-  /** Unsubscribe function for tree subscription */
-  treeUnsubscribe = null;
-  constructor(screenCtx, statusBar, inputHandler, blockRenderer, controller, modalManager) {
+  subscriptionManager;
+  sessionManager;
+  eventRouter;
+  constructor(screenCtx, statusBar, inputHandler, blockRenderer, controller, modalManager, subscriptionManager, sessionManager, eventRouter) {
     this.screenCtx = screenCtx;
     this.statusBar = statusBar;
     this.inputHandler = inputHandler;
     this.blockRenderer = blockRenderer;
     this.controller = controller;
     this.modalManager = modalManager;
+    this.subscriptionManager = subscriptionManager;
+    this.sessionManager = sessionManager;
+    this.eventRouter = eventRouter;
   }
   /**
    * Create a new TUI application instance.
    */
   static async create(options) {
-    const screenCtx = createScreen({
-      stdin: options.stdin,
-      stdout: options.stdout,
-      title: "llmist"
-    });
-    const { screen } = screenCtx;
-    const showHints = options.showHints ?? true;
-    const layout = createBlockLayout(screen, showHints);
-    let hintsBar = null;
-    if (layout.hintsBar) {
-      hintsBar = new HintsBar(layout.hintsBar, () => screenCtx.requestRender());
-    }
-    const statusBar = new StatusBar(
-      layout.statusBar,
-      options.model,
-      () => screenCtx.requestRender(),
-      () => screenCtx.renderNow()
-    );
-    const inputHandler = new InputHandler(
-      layout.inputBar,
-      layout.promptLabel,
-      layout.body,
-      screen,
-      () => screenCtx.requestRender(),
-      () => screenCtx.renderNow(),
-      showHints
-    );
-    const blockRenderer = new BlockRenderer(
-      layout.body,
-      () => screenCtx.requestRender(),
-      () => screenCtx.renderNow()
-    );
-    if (hintsBar) {
-      blockRenderer.onHasContentChange((hasContent) => {
-        hintsBar.setHasContent(hasContent);
-      });
-    }
-    const controller = new TUIController({
-      onFocusModeChange: (mode) => {
-        applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx);
-        hintsBar?.setFocusMode(mode);
-      },
-      onContentFilterModeChange: (mode) => {
-        applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx);
-        hintsBar?.setContentFilterMode(mode);
-      }
-    });
-    const modalManager = new ModalManager();
-    const keyboardManager = new KeyboardManager({
-      screen,
-      getFocusMode: () => controller.getFocusMode(),
-      getContentFilterMode: () => controller.getContentFilterMode(),
-      isWaitingForREPLPrompt: () => inputHandler.isWaitingForREPLPrompt(),
-      hasPendingInput: () => inputHandler.hasPendingInput(),
-      isBlockExpanded: () => blockRenderer.getSelectedBlock()?.expanded ?? false,
-      onAction: (action) => {
-        handleKeyAction(
-          action,
-          controller,
-          blockRenderer,
-          statusBar,
-          screenCtx,
-          modalManager,
-          layout
-        );
-      }
-    });
-    const app = new _TUIApp(
-      screenCtx,
-      statusBar,
-      inputHandler,
-      blockRenderer,
-      controller,
-      modalManager
+    const dependencies = createTUIAppDependencies(options);
+    return new _TUIApp(
+      dependencies.screenCtx,
+      dependencies.statusBar,
+      dependencies.inputHandler,
+      dependencies.blockRenderer,
+      dependencies.controller,
+      dependencies.modalManager,
+      dependencies.subscriptionManager,
+      dependencies.sessionManager,
+      dependencies.eventRouter
     );
-    keyboardManager.setup();
-    inputHandler.onCtrlC(() => keyboardManager.handleForwardedKey("C-c"));
-    inputHandler.onCtrlB(() => keyboardManager.handleForwardedKey("C-b"));
-    inputHandler.onCtrlK(() => keyboardManager.handleForwardedKey("C-k"));
-    inputHandler.onCtrlI(() => keyboardManager.handleForwardedKey("C-i"));
-    inputHandler.onCtrlJ(() => keyboardManager.handleForwardedKey("C-j"));
-    inputHandler.onCtrlP(() => keyboardManager.handleForwardedKey("C-p"));
-    inputHandler.onArrowUp(() => {
-      handleKeyAction(
-        { type: "scroll_line", direction: -1 },
-        controller,
-        blockRenderer,
-        statusBar,
-        screenCtx,
-        modalManager,
-        layout
-      );
-    });
-    inputHandler.onArrowDown(() => {
-      handleKeyAction(
-        { type: "scroll_line", direction: 1 },
-        controller,
-        blockRenderer,
-        statusBar,
-        screenCtx,
-        modalManager,
-        layout
-      );
-    });
-    inputHandler.setGetFocusMode(() => controller.getFocusMode());
-    inputHandler.setGetContentFilterMode(() => controller.getContentFilterMode());
-    layout.body.on("scroll", () => {
-      blockRenderer.handleUserScroll();
-    });
-    screen.on("resize", () => {
-      blockRenderer.handleResize();
-    });
-    applyFocusMode(controller.getFocusMode(), layout, statusBar, inputHandler, screenCtx);
-    screenCtx.requestRender();
-    return app;
   }
   // ─────────────────────────────────────────────────────────────────────────────
   // Focus Mode Management (delegated to controller)
@@ -9053,11 +9713,7 @@ var TUIApp = class _TUIApp {
    * automatically by ExecutionTree subscription via subscribeToTree().
    */
   handleEvent(event) {
-    if (event.type === "text") {
-      this.blockRenderer.addText(event.content);
-    } else if (event.type === "thinking") {
-      this.blockRenderer.addThinking(event.content, event.thinkingType);
-    }
+    this.eventRouter.handleEvent(event);
   }
   /**
    * Show an LLM call starting.
@@ -9082,26 +9738,11 @@ var TUIApp = class _TUIApp {
   async showRawViewer(mode) {
     if (this.controller.getFocusMode() !== "browse") return;
     const selected = this.blockRenderer.getSelectedBlock();
-    if (!selected) return;
-    if (selected.node.type === "llm_call") {
-      const node = selected.node;
-      await this.modalManager.showRawViewer(this.screenCtx.screen, {
-        mode,
-        request: node.rawRequest,
-        response: node.rawResponse,
-        iteration: node.iteration,
-        model: node.model
-      });
-    } else if (selected.node.type === "gadget") {
-      const node = selected.node;
-      await this.modalManager.showRawViewer(this.screenCtx.screen, {
-        mode,
-        gadgetName: node.name,
-        parameters: node.parameters,
-        result: node.result,
-        error: node.error
-      });
-    }
+    if (!selected || !isRawViewerNode(selected.node)) return;
+    await this.modalManager.showRawViewer(
+      this.screenCtx.screen,
+      createRawViewerData(selected.node, mode)
+    );
   }
   /**
    * Show approval dialog for gadget execution.
@@ -9156,21 +9797,7 @@ var TUIApp = class _TUIApp {
    * Subscribe to an ExecutionTree for automatic block updates.
    */
   subscribeToTree(tree) {
-    if (this.treeUnsubscribe) {
-      this.treeUnsubscribe();
-    }
-    const unsubBlock = this.blockRenderer.subscribeToTree(tree);
-    const unsubStatus = this.statusBar.subscribeToTree(tree);
-    this.treeUnsubscribe = () => {
-      unsubBlock();
-      unsubStatus();
-    };
-    return () => {
-      if (this.treeUnsubscribe) {
-        this.treeUnsubscribe();
-        this.treeUnsubscribe = null;
-      }
-    };
+    return this.subscriptionManager.subscribe(tree);
   }
   // ─────────────────────────────────────────────────────────────────────────────
   // Memory Cleanup (REPL mode)
@@ -9182,21 +9809,21 @@ var TUIApp = class _TUIApp {
    * Call this after each agent run completes (after unsubscribing from tree).
    */
   clearBlockRenderer() {
-    this.blockRenderer.clear();
+    this.sessionManager.clearAllBlocks();
   }
   /**
    * Clear status bar activity state.
    * Called between REPL turns to prevent stale state.
    */
   clearStatusBar() {
-    this.statusBar.clearActivity();
+    this.sessionManager.clearStatusBar();
   }
   /**
    * Start a new session. Called at the start of each REPL turn.
    * Increments the session counter so new blocks get the new sessionId.
    */
   startNewSession() {
-    this.blockRenderer.startNewSession();
+    this.sessionManager.startNewSession();
   }
   /**
    * Clear blocks from the previous session only.
@@ -9204,7 +9831,7 @@ var TUIApp = class _TUIApp {
    * The previous session's content was kept visible during this session for context.
    */
   clearPreviousSession() {
-    this.blockRenderer.clearPreviousSession();
+    this.sessionManager.clearPreviousSession();
   }
   // ─────────────────────────────────────────────────────────────────────────────
   // Abort Control (delegated to controller)
@@ -9339,127 +9966,12 @@ var TUIApp = class _TUIApp {
    * Clean up and restore terminal.
    */
   destroy() {
-    if (this.treeUnsubscribe) {
-      this.treeUnsubscribe();
-      this.treeUnsubscribe = null;
-    }
+    this.subscriptionManager.unsubscribe();
     this.modalManager.closeAll();
     this.inputHandler.cancelPending();
     this.screenCtx.destroy();
   }
 };
-function applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx) {
-  statusBar.setFocusMode(mode);
-  if (mode === "input") {
-    inputHandler.activate();
-  } else {
-    inputHandler.deactivate();
-    layout.body.focus();
-  }
-  screenCtx.renderNow();
-}
-function applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx) {
-  blockRenderer.setContentFilterMode(mode);
-  statusBar.setContentFilterMode(mode);
-  screenCtx.renderNow();
-}
-function handleKeyAction(action, controller, blockRenderer, statusBar, screenCtx, modalManager, layout) {
-  switch (action.type) {
-    case "ctrl_c": {
-      const result = controller.handleCtrlC();
-      if (result === "show_hint") {
-        blockRenderer.addText("\n[Press Ctrl+C again to quit]\n");
-      } else if (result === "quit") {
-        process.exit(130);
-      }
-      break;
-    }
-    case "cancel":
-      controller.triggerCancel();
-      controller.abort();
-      break;
-    case "toggle_focus_mode":
-      controller.toggleFocusMode();
-      break;
-    case "toggle_content_filter":
-      controller.toggleContentFilterMode();
-      break;
-    case "cycle_profile":
-      statusBar.cycleProfile();
-      break;
-    case "scroll_page": {
-      const body = layout.body;
-      if (!body.scroll) return;
-      const containerHeight = body.height;
-      const scrollAmount = Math.max(1, containerHeight - 2);
-      if (action.direction < 0) {
-        body.scroll(-scrollAmount);
-      } else {
-        body.scroll(scrollAmount);
-      }
-      blockRenderer.handleUserScroll();
-      screenCtx.renderNow();
-      break;
-    }
-    case "scroll_line": {
-      const body = layout.body;
-      if (!body.scroll) return;
-      body.scroll(action.direction);
-      blockRenderer.handleUserScroll();
-      screenCtx.renderNow();
-      break;
-    }
-    case "navigation":
-      switch (action.action) {
-        case "select_next":
-          blockRenderer.selectNext();
-          break;
-        case "select_previous":
-          blockRenderer.selectPrevious();
-          break;
-        case "select_first":
-          blockRenderer.selectFirst();
-          break;
-        case "select_last":
-          blockRenderer.selectLast();
-          blockRenderer.enableFollowMode();
-          break;
-        case "toggle_expand":
-          blockRenderer.toggleExpand();
-          break;
-        case "collapse":
-          blockRenderer.collapseOrDeselect();
-          break;
-      }
-      screenCtx.renderNow();
-      break;
-    case "raw_viewer":
-      void (async () => {
-        const selected = blockRenderer.getSelectedBlock();
-        if (!selected) return;
-        if (selected.node.type === "llm_call") {
-          const node = selected.node;
-          await modalManager.showRawViewer(screenCtx.screen, {
-            mode: action.mode,
-            request: node.rawRequest,
-            response: node.rawResponse,
-            iteration: node.iteration,
-            model: node.model
-          });
-        } else if (selected.node.type === "gadget") {
-          const node = selected.node;
-          await modalManager.showRawViewer(screenCtx.screen, {
-            mode: action.mode,
-            gadgetName: node.name,
-            parameters: node.parameters,
-            result: node.result,
-            error: node.error
-          });
-        }
-      })();
-      break;
-  }
-}
 
 // src/agent-command.ts
 async function executeAgent(promptArg, options, env, commandName) {
@@ -9496,6 +10008,14 @@ async function executeAgent(promptArg, options, env, commandName) {
       registry.registerByClass(gadget);
     }
   }
+  let skillsConfig;
+  try {
+    const fullConfig = loadConfig();
+    skillsConfig = fullConfig.skills;
+  } catch {
+  }
+  const skillManager = new CLISkillManager();
+  const skillRegistry = await skillManager.loadAll(skillsConfig);
   let tui = null;
   if (useTUI) {
     tui = await TUIApp.create({
@@ -9534,7 +10054,7 @@ async function executeAgent(promptArg, options, env, commandName) {
   if (!useTUI) {
     process.once("SIGINT", () => process.exit(130));
   }
-  const DEFAULT_APPROVAL_REQUIRED = ["RunCommand", "WriteFile", "EditFile"];
+  const DEFAULT_APPROVAL_REQUIRED = ["RunCommand", "WriteFile", "EditFile", "DeleteFile"];
   const userApprovals = options.gadgetApproval ?? {};
   const gadgetApprovals = {
     ...userApprovals
@@ -9671,6 +10191,11 @@ ${ctx.gadgetName} is denied by configuration.`
             gadgetName: ctx.gadgetName,
             parameters: ctx.parameters
           });
+          if (response === "always") {
+            gadgetApprovals[ctx.gadgetName] = "allowed";
+          } else if (response === "deny") {
+            gadgetApprovals[ctx.gadgetName] = "denied";
+          }
           if (response === "yes" || response === "always") {
             return { action: "proceed" };
           }
@@ -9685,7 +10210,7 @@ Denied by user`
           action: "skip",
           syntheticResult: `status=denied
 
-${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
+${ctx.gadgetName} requires interactive approval. Enable TUI mode or adjust 'gadget-approval' in your config to allow this gadget.`
         };
       }
     }
@@ -9724,6 +10249,9 @@ ${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
   if (options.temperature !== void 0) {
     builder.withTemperature(options.temperature);
   }
+  if (skillRegistry.size > 0) {
+    builder.withSkills(skillRegistry);
+  }
   if (options.reasoning === false) {
     builder.withoutReasoning();
   } else if (options.reasoning !== void 0 || options.reasoningBudget !== void 0) {
@@ -9800,6 +10328,29 @@ ${ctx.gadgetName} requires interactive approval. Run in a terminal to approve.`
   );
   let currentAgent = null;
   const runAgentWithPrompt = async (userPrompt) => {
+    builder.clearPreActivatedSkills();
+    if (skillRegistry.size > 0 && userPrompt.startsWith("/")) {
+      const slashResult = parseSlashCommand(userPrompt, skillRegistry);
+      if (slashResult.isSkillInvocation) {
+        if (slashResult.isListCommand) {
+          const skills = skillRegistry.getUserInvocable();
+          const lines = skills.map((s) => `  /${s.name} \u2014 ${s.description}`);
+          const msg = skills.length > 0 ? `Available skills:
+${lines.join("\n")}` : "No skills available.";
+          if (tui) {
+            tui.showUserMessage(`/skills`);
+            tui.showUserMessage(msg);
+          } else {
+            env.stdout.write(`${msg}
+`);
+          }
+          return;
+        }
+        if (slashResult.skillName) {
+          builder.withSkill(slashResult.skillName, slashResult.arguments);
+        }
+      }
+    }
     if (tui) {
       tui.resetAbort();
       tui.startNewSession();
@@ -9924,11 +10475,11 @@ import {
 
 // src/llm-logging.ts
 import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { formatCallNumber as formatCallNumber2, formatLlmRequest } from "llmist";
 async function writeLogFile(dir, filename, content) {
   await mkdir(dir, { recursive: true });
-  await writeFile2(join3(dir, filename), content, "utf-8");
+  await writeFile2(join4(dir, filename), content, "utf-8");
 }
 
 // src/complete-command.ts
@@ -10156,7 +10707,7 @@ Profile: ${name}
     `  Temperature:     ${section.temperature !== void 0 ? section.temperature : "(default)"}
 `
   );
-  const gadgets = section.gadgets ?? section.gadget;
+  const gadgets = section.gadgets;
   if (gadgets && gadgets.length > 0) {
     env.stdout.write("\nGadgets:\n");
     for (const g of gadgets) {
@@ -10206,9 +10757,9 @@ System Prompt (${chars.toLocaleString()} chars, ${lines} lines):
 }
 
 // src/environment.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import readline from "readline";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import { createLogger, LLMist } from "llmist";
 var LOG_LEVEL_MAP = {
   silly: 0,
@@ -10229,7 +10780,7 @@ function createLoggerFactory(config, sessionLogDir) {
       }
     }
     if (sessionLogDir) {
-      const logFile = join4(sessionLogDir, "session.log.jsonl");
+      const logFile = join5(sessionLogDir, "session.log.jsonl");
       const originalLogFile = process.env.LLMIST_LOG_FILE;
       process.env.LLMIST_LOG_FILE = logFile;
       const logger = createLogger(options);
@@ -10248,22 +10799,22 @@ function createLoggerFactory(config, sessionLogDir) {
 }
 function createPromptFunction(stdin, stdout) {
   return (question) => {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const rl = readline.createInterface({
         input: stdin,
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${chalk6.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(chalk6.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(chalk7.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${chalk6.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
 `);
-      rl.question(chalk6.green.bold("You: "), (answer) => {
+      rl.question(chalk7.green.bold("You: "), (answer) => {
         rl.close();
-        resolve3(answer);
+        resolve4(answer);
       });
     });
   };
@@ -10342,12 +10893,12 @@ function registerCustomCommand(program, name, config, env, globalSubagents, glob
 }
 
 // src/gadget-command.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import { schemaToJSONSchema as schemaToJSONSchema2, validateGadgetSchema } from "llmist";
 
 // src/gadget-prompts.ts
 import { createInterface } from "readline/promises";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { schemaToJSONSchema } from "llmist";
 async function promptForParameters(schema, ctx) {
   if (!schema) {
@@ -10380,16 +10931,16 @@ ${issues}`);
 async function promptForField(rl, key, prop, required) {
   const isRequired = required.includes(key);
   const typeHint = formatTypeHint(prop);
-  const defaultHint = prop.default !== void 0 ? chalk7.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
-  const requiredMarker = isRequired ? chalk7.red("*") : "";
+  const defaultHint = prop.default !== void 0 ? chalk8.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
+  const requiredMarker = isRequired ? chalk8.red("*") : "";
   let prompt = `
-${chalk7.cyan.bold(key)}${requiredMarker}`;
+${chalk8.cyan.bold(key)}${requiredMarker}`;
   if (prop.description) {
-    prompt += chalk7.dim(` - ${prop.description}`);
+    prompt += chalk8.dim(` - ${prop.description}`);
   }
   prompt += `
   ${typeHint}${defaultHint}
-  ${chalk7.green(">")} `;
+  ${chalk8.green(">")} `;
   const answer = await rl.question(prompt);
   const trimmed = answer.trim();
   if (!trimmed) {
@@ -10405,20 +10956,20 @@ ${chalk7.cyan.bold(key)}${requiredMarker}`;
 }
 function formatTypeHint(prop) {
   if (prop.enum) {
-    return chalk7.yellow(`(${prop.enum.join(" | ")})`);
+    return chalk8.yellow(`(${prop.enum.join(" | ")})`);
   }
   if (prop.type === "array") {
     const items = prop.items;
     if (items?.enum) {
-      return chalk7.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
+      return chalk8.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
     }
     const itemType = items?.type ?? "any";
-    return chalk7.yellow(`(${itemType}[]) comma-separated`);
+    return chalk8.yellow(`(${itemType}[]) comma-separated`);
   }
   if (prop.type === "object" && prop.properties) {
-    return chalk7.yellow("(object) enter as JSON");
+    return chalk8.yellow("(object) enter as JSON");
   }
-  return chalk7.yellow(`(${prop.type ?? "any"})`);
+  return chalk8.yellow(`(${prop.type ?? "any"})`);
 }
 function parseValue(input, prop, key) {
   const type = prop.type;
@@ -10529,7 +11080,7 @@ Available gadgets:
 async function executeGadgetRun(file, options, env) {
   const cwd = process.cwd();
   const { gadget, name } = await selectGadget(file, options.name, cwd);
-  env.stderr.write(chalk8.cyan.bold(`
+  env.stderr.write(chalk9.cyan.bold(`
 \u{1F527} Running gadget: ${name}
 `));
   let params;
@@ -10540,7 +11091,7 @@ async function executeGadgetRun(file, options, env) {
       // Prompts go to stderr to keep stdout clean
     });
   } else {
-    env.stderr.write(chalk8.dim("Reading parameters from stdin...\n"));
+    env.stderr.write(chalk9.dim("Reading parameters from stdin...\n"));
     const stdinParams = await readStdinJson(env.stdin);
     if (gadget.parameterSchema) {
       const result2 = gadget.parameterSchema.safeParse(stdinParams);
@@ -10554,7 +11105,7 @@ ${issues}`);
       params = stdinParams;
     }
   }
-  env.stderr.write(chalk8.dim("\nExecuting...\n"));
+  env.stderr.write(chalk9.dim("\nExecuting...\n"));
   const startTime = Date.now();
   let result;
   let cost;
@@ -10581,7 +11132,7 @@ ${issues}`);
   }
   const elapsed = Date.now() - startTime;
   const costInfo = cost !== void 0 && cost > 0 ? ` (Cost: $${cost.toFixed(6)})` : "";
-  env.stderr.write(chalk8.green(`
+  env.stderr.write(chalk9.green(`
 \u2713 Completed in ${elapsed}ms${costInfo}
 
 `));
@@ -10617,37 +11168,37 @@ async function executeGadgetInfo(file, options, env) {
     return;
   }
   env.stdout.write("\n");
-  env.stdout.write(chalk8.cyan.bold(`${name}
+  env.stdout.write(chalk9.cyan.bold(`${name}
 `));
-  env.stdout.write(chalk8.cyan("\u2550".repeat(name.length)) + "\n\n");
-  env.stdout.write(chalk8.bold("Description:\n"));
+  env.stdout.write(chalk9.cyan("\u2550".repeat(name.length)) + "\n\n");
+  env.stdout.write(chalk9.bold("Description:\n"));
   env.stdout.write(`  ${gadget.description}
 
 `);
   if (gadget.parameterSchema) {
-    env.stdout.write(chalk8.bold("Parameters:\n"));
+    env.stdout.write(chalk9.bold("Parameters:\n"));
     const jsonSchema = schemaToJSONSchema2(gadget.parameterSchema, { target: "draft-7" });
     env.stdout.write(formatSchemaAsText(jsonSchema, "  ") + "\n\n");
   } else {
-    env.stdout.write(chalk8.dim("No parameters required.\n\n"));
+    env.stdout.write(chalk9.dim("No parameters required.\n\n"));
   }
   if (gadget.timeoutMs) {
-    env.stdout.write(chalk8.bold("Timeout:\n"));
+    env.stdout.write(chalk9.bold("Timeout:\n"));
     env.stdout.write(`  ${gadget.timeoutMs}ms
 
 `);
   }
   if (gadget.examples && gadget.examples.length > 0) {
-    env.stdout.write(chalk8.bold("Examples:\n"));
+    env.stdout.write(chalk9.bold("Examples:\n"));
     for (const example of gadget.examples) {
       if (example.comment) {
-        env.stdout.write(chalk8.dim(`  # ${example.comment}
+        env.stdout.write(chalk9.dim(`  # ${example.comment}
 `));
       }
-      env.stdout.write(`  Input: ${chalk8.cyan(JSON.stringify(example.params))}
+      env.stdout.write(`  Input: ${chalk9.cyan(JSON.stringify(example.params))}
 `);
       if (example.output !== void 0) {
-        env.stdout.write(`  Output: ${chalk8.green(example.output)}
+        env.stdout.write(`  Output: ${chalk9.green(example.output)}
 `);
       }
       env.stdout.write("\n");
@@ -10680,27 +11231,27 @@ function formatSchemaAsText(schema, indent = "") {
     const isRequired = required.includes(key);
     const enumValues = prop.enum;
     const defaultValue = prop.default;
-    let line = `${indent}${chalk8.cyan(key)}`;
+    let line = `${indent}${chalk9.cyan(key)}`;
     if (isRequired) {
-      line += chalk8.red("*");
+      line += chalk9.red("*");
     }
     if (type === "array") {
       const items = prop.items;
       const itemType = items?.type || "any";
-      line += chalk8.dim(` (${itemType}[])`);
+      line += chalk9.dim(` (${itemType}[])`);
     } else if (type === "object" && prop.properties) {
-      line += chalk8.dim(" (object)");
+      line += chalk9.dim(" (object)");
     } else {
-      line += chalk8.dim(` (${type})`);
+      line += chalk9.dim(` (${type})`);
     }
     if (defaultValue !== void 0) {
-      line += chalk8.dim(` [default: ${JSON.stringify(defaultValue)}]`);
+      line += chalk9.dim(` [default: ${JSON.stringify(defaultValue)}]`);
     }
     if (description) {
       line += `: ${description}`;
     }
     if (enumValues) {
-      line += chalk8.yellow(` - one of: ${enumValues.join(", ")}`);
+      line += chalk9.yellow(` - one of: ${enumValues.join(", ")}`);
     }
     lines.push(line);
     if (type === "object" && prop.properties) {
@@ -10740,20 +11291,20 @@ async function executeGadgetValidate(file, env) {
       throw new Error(`Validation issues:
 ${issues.map((i) => `  - ${i}`).join("\n")}`);
     }
-    env.stdout.write(chalk8.green.bold("\n\u2713 Valid\n\n"));
-    env.stdout.write(chalk8.bold("Gadgets found:\n"));
+    env.stdout.write(chalk9.green.bold("\n\u2713 Valid\n\n"));
+    env.stdout.write(chalk9.bold("Gadgets found:\n"));
     for (const gadget of gadgets) {
       const name = gadget.name ?? gadget.constructor.name;
-      const schemaInfo = gadget.parameterSchema ? chalk8.cyan("(with schema)") : chalk8.dim("(no schema)");
-      env.stdout.write(`  ${chalk8.bold(name)} ${schemaInfo}
+      const schemaInfo = gadget.parameterSchema ? chalk9.cyan("(with schema)") : chalk9.dim("(no schema)");
+      env.stdout.write(`  ${chalk9.bold(name)} ${schemaInfo}
 `);
-      env.stdout.write(chalk8.dim(`    ${gadget.description}
+      env.stdout.write(chalk9.dim(`    ${gadget.description}
 `));
     }
     env.stdout.write("\n");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    env.stdout.write(chalk8.red.bold(`
+    env.stdout.write(chalk9.red.bold(`
 \u2717 Invalid
 
 `));
@@ -10937,7 +11488,7 @@ function registerInitCommand(program, env) {
 }
 
 // src/models-command.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { MODEL_ALIASES } from "llmist";
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -10956,11 +11507,11 @@ async function handleModelsCommand(options, env) {
 function renderAllTables(textModels, imageModels, speechModels, verbose, stream) {
   const hasAnyModels = textModels.length > 0 || imageModels.length > 0 || speechModels.length > 0;
   if (!hasAnyModels) {
-    stream.write(chalk9.yellow("\nNo models found matching the specified criteria.\n\n"));
+    stream.write(chalk10.yellow("\nNo models found matching the specified criteria.\n\n"));
     return;
   }
-  stream.write(chalk9.bold.cyan("\nAvailable Models\n"));
-  stream.write(chalk9.cyan("=".repeat(80)) + "\n\n");
+  stream.write(chalk10.bold.cyan("\nAvailable Models\n"));
+  stream.write(chalk10.cyan("=".repeat(80)) + "\n\n");
   if (textModels.length > 0) {
     renderTextTable(textModels, verbose, stream);
   }
@@ -10971,12 +11522,12 @@ function renderAllTables(textModels, imageModels, speechModels, verbose, stream)
     renderSpeechTable(speechModels, verbose, stream);
   }
   if (textModels.length > 0) {
-    stream.write(chalk9.bold.magenta("Model Shortcuts\n"));
-    stream.write(chalk9.dim("\u2500".repeat(80)) + "\n");
+    stream.write(chalk10.bold.magenta("Model Shortcuts\n"));
+    stream.write(chalk10.dim("\u2500".repeat(80)) + "\n");
     const shortcuts = Object.entries(MODEL_ALIASES).sort((a, b) => a[0].localeCompare(b[0]));
     for (const [shortcut, fullName] of shortcuts) {
       stream.write(
-        chalk9.cyan(`  ${shortcut.padEnd(15)}`) + chalk9.dim(" \u2192 ") + chalk9.white(fullName) + "\n"
+        chalk10.cyan(`  ${shortcut.padEnd(15)}`) + chalk10.dim(" \u2192 ") + chalk10.white(fullName) + "\n"
       );
     }
     stream.write("\n");
@@ -10991,13 +11542,13 @@ function renderTextTable(models, verbose, stream) {
     }
     grouped.get(provider).push(model);
   }
-  stream.write(chalk9.bold.blue("\u{1F4DD} Text/LLM Models\n"));
-  stream.write(chalk9.dim("\u2500".repeat(80)) + "\n\n");
+  stream.write(chalk10.bold.blue("\u{1F4DD} Text/LLM Models\n"));
+  stream.write(chalk10.dim("\u2500".repeat(80)) + "\n\n");
   const providers = Array.from(grouped.keys()).sort();
   for (const provider of providers) {
     const providerModels = grouped.get(provider);
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk9.bold.yellow(`${providerName}
+    stream.write(chalk10.bold.yellow(`${providerName}
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream);
@@ -11014,58 +11565,58 @@ function renderCompactTable(models, stream) {
   const inputWidth = 10;
   const outputWidth = 10;
   stream.write(
-    chalk9.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
+    chalk10.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
   );
   stream.write(
-    chalk9.bold(
+    chalk10.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
   stream.write(
-    chalk9.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
+    chalk10.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
   );
   for (const model of models) {
     const contextFormatted = formatTokensLong(model.contextWindow);
     const inputPrice = `$${model.pricing.input.toFixed(2)}`;
     const outputPrice = `$${model.pricing.output.toFixed(2)}`;
     stream.write(
-      chalk9.green(model.modelId.padEnd(idWidth)) + "  " + chalk9.white(model.displayName.padEnd(nameWidth)) + "  " + chalk9.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk9.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk9.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      chalk10.green(model.modelId.padEnd(idWidth)) + "  " + chalk10.white(model.displayName.padEnd(nameWidth)) + "  " + chalk10.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk10.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk10.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
   stream.write(
-    chalk9.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
+    chalk10.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n"
   );
-  stream.write(chalk9.dim(`  * Prices are per 1M tokens
+  stream.write(chalk10.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream) {
   for (const model of models) {
-    stream.write(chalk9.bold.green(`
+    stream.write(chalk10.bold.green(`
   ${model.modelId}
 `));
-    stream.write(chalk9.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream.write(`  ${chalk9.dim("Name:")}         ${chalk9.white(model.displayName)}
+    stream.write(chalk10.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream.write(`  ${chalk10.dim("Name:")}         ${chalk10.white(model.displayName)}
 `);
     stream.write(
-      `  ${chalk9.dim("Context:")}      ${chalk9.yellow(formatTokensLong(model.contextWindow))}
+      `  ${chalk10.dim("Context:")}      ${chalk10.yellow(formatTokensLong(model.contextWindow))}
 `
     );
     stream.write(
-      `  ${chalk9.dim("Max Output:")}   ${chalk9.yellow(formatTokensLong(model.maxOutputTokens))}
+      `  ${chalk10.dim("Max Output:")}   ${chalk10.yellow(formatTokensLong(model.maxOutputTokens))}
 `
     );
     stream.write(
-      `  ${chalk9.dim("Pricing:")}      ${chalk9.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk9.dim("/")} ${chalk9.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk9.dim("(per 1M tokens)")}
+      `  ${chalk10.dim("Pricing:")}      ${chalk10.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk10.dim("/")} ${chalk10.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk10.dim("(per 1M tokens)")}
 `
     );
     if (model.pricing.cachedInput !== void 0) {
       stream.write(
-        `  ${chalk9.dim("Cached Input:")} ${chalk9.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+        `  ${chalk10.dim("Cached Input:")} ${chalk10.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `
       );
     }
     if (model.knowledgeCutoff) {
-      stream.write(`  ${chalk9.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream.write(`  ${chalk10.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -11076,20 +11627,20 @@ function renderVerboseTable(models, stream) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream.write(`  ${chalk9.dim("Features:")}     ${chalk9.blue(features.join(", "))}
+      stream.write(`  ${chalk10.dim("Features:")}     ${chalk10.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream.write(`  ${chalk9.dim("Family:")}       ${model.metadata.family}
+        stream.write(`  ${chalk10.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream.write(`  ${chalk9.dim("Released:")}     ${model.metadata.releaseDate}
+        stream.write(`  ${chalk10.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream.write(`  ${chalk9.dim("Notes:")}        ${chalk9.italic(model.metadata.notes)}
+        stream.write(`  ${chalk10.dim("Notes:")}        ${chalk10.italic(model.metadata.notes)}
 `);
       }
     }
@@ -11097,8 +11648,8 @@ function renderVerboseTable(models, stream) {
   stream.write("\n");
 }
 function renderImageTable(models, verbose, stream) {
-  stream.write(chalk9.bold.green("\u{1F3A8} Image Generation Models\n"));
-  stream.write(chalk9.dim("\u2500".repeat(80)) + "\n\n");
+  stream.write(chalk10.bold.green("\u{1F3A8} Image Generation Models\n"));
+  stream.write(chalk10.dim("\u2500".repeat(80)) + "\n\n");
   const grouped = /* @__PURE__ */ new Map();
   for (const model of models) {
     if (!grouped.has(model.provider)) {
@@ -11108,29 +11659,29 @@ function renderImageTable(models, verbose, stream) {
   }
   for (const [provider, providerModels] of Array.from(grouped.entries()).sort()) {
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk9.bold.yellow(`${providerName}
+    stream.write(chalk10.bold.yellow(`${providerName}
 `));
     if (verbose) {
       for (const model of providerModels) {
-        stream.write(chalk9.bold.green(`
+        stream.write(chalk10.bold.green(`
   ${model.modelId}
 `));
-        stream.write(chalk9.dim("  " + "\u2500".repeat(60)) + "\n");
-        stream.write(`  ${chalk9.dim("Name:")}      ${chalk9.white(model.displayName)}
+        stream.write(chalk10.dim("  " + "\u2500".repeat(60)) + "\n");
+        stream.write(`  ${chalk10.dim("Name:")}      ${chalk10.white(model.displayName)}
 `);
         stream.write(
-          `  ${chalk9.dim("Sizes:")}     ${chalk9.yellow(model.supportedSizes.join(", "))}
+          `  ${chalk10.dim("Sizes:")}     ${chalk10.yellow(model.supportedSizes.join(", "))}
 `
         );
         if (model.supportedQualities) {
           stream.write(
-            `  ${chalk9.dim("Qualities:")} ${chalk9.yellow(model.supportedQualities.join(", "))}
+            `  ${chalk10.dim("Qualities:")} ${chalk10.yellow(model.supportedQualities.join(", "))}
 `
           );
         }
-        stream.write(`  ${chalk9.dim("Max Images:")} ${chalk9.yellow(model.maxImages.toString())}
+        stream.write(`  ${chalk10.dim("Max Images:")} ${chalk10.yellow(model.maxImages.toString())}
 `);
-        stream.write(`  ${chalk9.dim("Pricing:")}   ${chalk9.cyan(formatImagePrice(model))}
+        stream.write(`  ${chalk10.dim("Pricing:")}   ${chalk10.cyan(formatImagePrice(model))}
 `);
         if (model.features) {
           const features = [];
@@ -11138,7 +11689,7 @@ function renderImageTable(models, verbose, stream) {
           if (model.features.transparency) features.push("transparency");
           if (model.features.conversational) features.push("conversational");
           if (features.length > 0) {
-            stream.write(`  ${chalk9.dim("Features:")}  ${chalk9.blue(features.join(", "))}
+            stream.write(`  ${chalk10.dim("Features:")}  ${chalk10.blue(features.join(", "))}
 `);
           }
         }
@@ -11148,27 +11699,27 @@ function renderImageTable(models, verbose, stream) {
       const nameWidth = 25;
       const sizesWidth = 20;
       const priceWidth = 15;
-      stream.write(chalk9.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
+      stream.write(chalk10.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
       stream.write(
-        chalk9.bold(
+        chalk10.bold(
           "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Sizes".padEnd(sizesWidth) + "  " + "Price".padEnd(priceWidth)
         ) + "\n"
       );
-      stream.write(chalk9.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
+      stream.write(chalk10.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
       for (const model of providerModels) {
         const sizes = model.supportedSizes.length > 2 ? model.supportedSizes.slice(0, 2).join(", ") + "..." : model.supportedSizes.join(", ");
         stream.write(
-          chalk9.green(model.modelId.padEnd(idWidth)) + "  " + chalk9.white(model.displayName.substring(0, nameWidth - 1).padEnd(nameWidth)) + "  " + chalk9.yellow(sizes.padEnd(sizesWidth)) + "  " + chalk9.cyan(formatImagePrice(model).padEnd(priceWidth)) + "\n"
+          chalk10.green(model.modelId.padEnd(idWidth)) + "  " + chalk10.white(model.displayName.substring(0, nameWidth - 1).padEnd(nameWidth)) + "  " + chalk10.yellow(sizes.padEnd(sizesWidth)) + "  " + chalk10.cyan(formatImagePrice(model).padEnd(priceWidth)) + "\n"
         );
       }
-      stream.write(chalk9.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
+      stream.write(chalk10.dim("\u2500".repeat(idWidth + nameWidth + sizesWidth + priceWidth + 6)) + "\n");
     }
     stream.write("\n");
   }
 }
 function renderSpeechTable(models, verbose, stream) {
-  stream.write(chalk9.bold.magenta("\u{1F3A4} Speech (TTS) Models\n"));
-  stream.write(chalk9.dim("\u2500".repeat(80)) + "\n\n");
+  stream.write(chalk10.bold.magenta("\u{1F3A4} Speech (TTS) Models\n"));
+  stream.write(chalk10.dim("\u2500".repeat(80)) + "\n\n");
   const grouped = /* @__PURE__ */ new Map();
   for (const model of models) {
     if (!grouped.has(model.provider)) {
@@ -11178,34 +11729,34 @@ function renderSpeechTable(models, verbose, stream) {
   }
   for (const [provider, providerModels] of Array.from(grouped.entries()).sort()) {
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk9.bold.yellow(`${providerName}
+    stream.write(chalk10.bold.yellow(`${providerName}
 `));
     if (verbose) {
       for (const model of providerModels) {
-        stream.write(chalk9.bold.green(`
+        stream.write(chalk10.bold.green(`
   ${model.modelId}
 `));
-        stream.write(chalk9.dim("  " + "\u2500".repeat(60)) + "\n");
-        stream.write(`  ${chalk9.dim("Name:")}    ${chalk9.white(model.displayName)}
+        stream.write(chalk10.dim("  " + "\u2500".repeat(60)) + "\n");
+        stream.write(`  ${chalk10.dim("Name:")}    ${chalk10.white(model.displayName)}
 `);
         stream.write(
-          `  ${chalk9.dim("Voices:")}  ${chalk9.yellow(model.voices.length.toString())} voices
+          `  ${chalk10.dim("Voices:")}  ${chalk10.yellow(model.voices.length.toString())} voices
 `
         );
         if (model.voices.length <= 6) {
-          stream.write(`            ${chalk9.dim(model.voices.join(", "))}
+          stream.write(`            ${chalk10.dim(model.voices.join(", "))}
 `);
         } else {
-          stream.write(`            ${chalk9.dim(model.voices.slice(0, 6).join(", ") + "...")}
+          stream.write(`            ${chalk10.dim(model.voices.slice(0, 6).join(", ") + "...")}
 `);
         }
-        stream.write(`  ${chalk9.dim("Formats:")} ${chalk9.yellow(model.formats.join(", "))}
+        stream.write(`  ${chalk10.dim("Formats:")} ${chalk10.yellow(model.formats.join(", "))}
 `);
         stream.write(
-          `  ${chalk9.dim("Max Input:")} ${chalk9.yellow(model.maxInputLength.toString())} chars
+          `  ${chalk10.dim("Max Input:")} ${chalk10.yellow(model.maxInputLength.toString())} chars
 `
         );
-        stream.write(`  ${chalk9.dim("Pricing:")} ${chalk9.cyan(formatSpeechPrice(model))}
+        stream.write(`  ${chalk10.dim("Pricing:")} ${chalk10.cyan(formatSpeechPrice(model))}
 `);
         if (model.features) {
           const features = [];
@@ -11213,7 +11764,7 @@ function renderSpeechTable(models, verbose, stream) {
           if (model.features.voiceInstructions) features.push("voice-instructions");
           if (model.features.languages) features.push(`${model.features.languages} languages`);
           if (features.length > 0) {
-            stream.write(`  ${chalk9.dim("Features:")} ${chalk9.blue(features.join(", "))}
+            stream.write(`  ${chalk10.dim("Features:")} ${chalk10.blue(features.join(", "))}
 `);
           }
         }
@@ -11224,23 +11775,23 @@ function renderSpeechTable(models, verbose, stream) {
       const voicesWidth = 12;
       const priceWidth = 18;
       stream.write(
-        chalk9.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
+        chalk10.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
       );
       stream.write(
-        chalk9.bold(
+        chalk10.bold(
           "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Voices".padEnd(voicesWidth) + "  " + "Price".padEnd(priceWidth)
         ) + "\n"
       );
       stream.write(
-        chalk9.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
+        chalk10.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
       );
       for (const model of providerModels) {
         stream.write(
-          chalk9.green(model.modelId.padEnd(idWidth)) + "  " + chalk9.white(model.displayName.substring(0, nameWidth - 1).padEnd(nameWidth)) + "  " + chalk9.yellow(`${model.voices.length} voices`.padEnd(voicesWidth)) + "  " + chalk9.cyan(formatSpeechPrice(model).padEnd(priceWidth)) + "\n"
+          chalk10.green(model.modelId.padEnd(idWidth)) + "  " + chalk10.white(model.displayName.substring(0, nameWidth - 1).padEnd(nameWidth)) + "  " + chalk10.yellow(`${model.voices.length} voices`.padEnd(voicesWidth)) + "  " + chalk10.cyan(formatSpeechPrice(model).padEnd(priceWidth)) + "\n"
         );
       }
       stream.write(
-        chalk9.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
+        chalk10.dim("\u2500".repeat(idWidth + nameWidth + voicesWidth + priceWidth + 6)) + "\n"
       );
     }
     stream.write("\n");
@@ -11332,8 +11883,8 @@ function registerModelsCommand(program, env) {
 // src/session.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
 
 // src/session-names.ts
 var ADJECTIVES = [
@@ -11468,16 +12019,16 @@ function generateSessionName() {
 
 // src/session.ts
 var currentSession;
-var SESSION_LOGS_BASE = join5(homedir3(), ".llmist", "logs");
+var SESSION_LOGS_BASE = join6(homedir4(), ".llmist", "logs");
 function findUniqueName(baseName) {
-  const baseDir = join5(SESSION_LOGS_BASE, baseName);
+  const baseDir = join6(SESSION_LOGS_BASE, baseName);
   if (!existsSync4(baseDir)) {
     return baseName;
   }
   let suffix = 2;
   while (suffix < 1e3) {
     const name = `${baseName}-${suffix}`;
-    const dir = join5(SESSION_LOGS_BASE, name);
+    const dir = join6(SESSION_LOGS_BASE, name);
     if (!existsSync4(dir)) {
       return name;
     }
@@ -11491,12 +12042,101 @@ async function initSession() {
   }
   const baseName = generateSessionName();
   const name = findUniqueName(baseName);
-  const logDir = join5(SESSION_LOGS_BASE, name);
+  const logDir = join6(SESSION_LOGS_BASE, name);
   await mkdir2(logDir, { recursive: true });
   currentSession = { name, logDir };
   return currentSession;
 }
 
+// src/skills/skill-command.ts
+function registerSkillCommand(program, env) {
+  const skillCmd = program.command("skill").description("Manage Agent Skills (SKILL.md)");
+  skillCmd.command("list").description("List available skills").action(async () => {
+    const config = safeLoadConfig();
+    const manager = new CLISkillManager();
+    const registry = await manager.loadAll(config?.skills);
+    const skills = registry.getAll();
+    if (skills.length === 0) {
+      env.stdout.write("No skills found.\n");
+      env.stdout.write(
+        "Add skills to ~/.llmist/skills/ or configure [skills].sources in ~/.llmist/cli.toml\n"
+      );
+      return;
+    }
+    env.stdout.write(`Found ${skills.length} skill(s):
+
+`);
+    for (const skill of skills) {
+      const flags = [];
+      if (!skill.isModelInvocable) flags.push("user-only");
+      if (!skill.isUserInvocable) flags.push("background");
+      if (skill.metadata.context === "fork") flags.push("fork");
+      if (skill.metadata.model) flags.push(`model:${skill.metadata.model}`);
+      const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+      const desc = skill.description.length > 80 ? `${skill.description.slice(0, 77)}...` : skill.description;
+      env.stdout.write(`  /${skill.name}${flagStr}
+`);
+      env.stdout.write(`    ${desc}
+
+`);
+    }
+  });
+  skillCmd.command("info <name>").description("Show detailed skill information").action(async (name) => {
+    const config = safeLoadConfig();
+    const manager = new CLISkillManager();
+    const registry = await manager.loadAll(config?.skills);
+    const skill = registry.get(name);
+    if (!skill) {
+      env.stderr.write(`Skill not found: ${name}
+`);
+      env.stderr.write(`Available skills: ${registry.getNames().join(", ") || "(none)"}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    env.stdout.write(`Skill: ${skill.name}
+`);
+    env.stdout.write(`Description: ${skill.description}
+`);
+    env.stdout.write(`Source: ${skill.sourcePath}
+`);
+    if (skill.metadata.model) env.stdout.write(`Model: ${skill.metadata.model}
+`);
+    if (skill.metadata.context) env.stdout.write(`Context: ${skill.metadata.context}
+`);
+    if (skill.metadata.agent) env.stdout.write(`Agent: ${skill.metadata.agent}
+`);
+    if (skill.metadata.allowedTools) {
+      env.stdout.write(`Allowed tools: ${skill.metadata.allowedTools.join(", ")}
+`);
+    }
+    if (skill.metadata.paths) {
+      env.stdout.write(`Paths: ${skill.metadata.paths.join(", ")}
+`);
+    }
+    const resources = skill.getResources();
+    if (resources.length > 0) {
+      env.stdout.write(`Resources: ${resources.length}
+`);
+      for (const r of resources) {
+        env.stdout.write(`  ${r.category}/${r.relativePath}
+`);
+      }
+    }
+    env.stdout.write("\n--- Instructions ---\n\n");
+    const instructions = await skill.getInstructions();
+    env.stdout.write(`${instructions}
+`);
+  });
+}
+function safeLoadConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return void 0;
+  }
+}
+
 // src/speech-command.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 var DEFAULT_SPEECH_MODEL = "tts-1";
@@ -11608,6 +12248,7 @@ function createProgram(env, config) {
   registerVisionCommand(program, env);
   registerModelsCommand(program, env);
   registerGadgetCommand(program, env);
+  registerSkillCommand(program, env);
   registerInitCommand(program, env);
   registerConfigCommand(program, env, config);
   if (config) {