@goah/cli 0.13.1 → 0.13.3

package/dist/cli.js

@@ -25,14 +25,14 @@ import {
   streamEvents,
   updateWorkspaceRunnerProfile,
   writeDefaultConfig
-} from "./chunk-PFEV3HWI.js";
+} from "./chunk-KJ4HJCTK.js";
 import {
   runnerManifests,
   runnerPlugin
-} from "./chunk-VWEV4LTH.js";
+} from "./chunk-D2DVAH37.js";
 import "./chunk-YH6YJ2IB.js";
 import "./chunk-QBD6EJ2Z.js";
-import "./chunk-X7UWW2PN.js";
+import "./chunk-7E7V6OIU.js";
 import "./chunk-6M3OOCKO.js";
 import "./chunk-K26BVR6O.js";
 import "./chunk-IIJQ3DW4.js";
@@ -50,9 +50,9 @@ import {
 import "./chunk-XPQKM3L7.js";
 
 // node_modules/.dist-original/cli.js
-import { spawn as spawn3 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { join as join6, resolve as resolve3 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { closeSync as closeSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { join as join7, resolve as resolve3 } from "node:path";
 
 // ../../node_modules/marked/lib/marked.esm.js
 function M() {
@@ -1293,6 +1293,12 @@ var Xt = g.parseInline;
 var Vt = b.parse;
 var Yt = x.lex;
 
+// ../../node_modules/@earendil-works/pi-tui/dist/autocomplete.js
+import { spawn } from "child_process";
+import { readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join } from "path";
+
 // ../../node_modules/@earendil-works/pi-tui/dist/fuzzy.js
 function fuzzyMatch(query, text) {
   const queryLower = query.toLowerCase();
@@ -1382,6 +1388,568 @@ function fuzzyFilter(items, query, getText) {
   return results.map((r) => r.item);
 }
 
+// ../../node_modules/@earendil-works/pi-tui/dist/autocomplete.js
+var PATH_DELIMITERS = /* @__PURE__ */ new Set([" ", "	", '"', "'", "="]);
+function toDisplayPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildFdPathQuery(query) {
+  const normalized = toDisplayPath(query);
+  if (!normalized.includes("/")) {
+    return normalized;
+  }
+  const hasTrailingSeparator = normalized.endsWith("/");
+  const trimmed = normalized.replace(/^\/+|\/+$/g, "");
+  if (!trimmed) {
+    return normalized;
+  }
+  const separatorPattern = "[\\\\/]";
+  const segments = trimmed.split("/").filter(Boolean).map((segment) => escapeRegex(segment));
+  if (segments.length === 0) {
+    return normalized;
+  }
+  let pattern = segments.join(separatorPattern);
+  if (hasTrailingSeparator) {
+    pattern += separatorPattern;
+  }
+  return pattern;
+}
+function findLastDelimiter(text) {
+  for (let i = text.length - 1; i >= 0; i -= 1) {
+    if (PATH_DELIMITERS.has(text[i] ?? "")) {
+      return i;
+    }
+  }
+  return -1;
+}
+function findUnclosedQuoteStart(text) {
+  let inQuotes = false;
+  let quoteStart = -1;
+  for (let i = 0; i < text.length; i += 1) {
+    if (text[i] === '"') {
+      inQuotes = !inQuotes;
+      if (inQuotes) {
+        quoteStart = i;
+      }
+    }
+  }
+  return inQuotes ? quoteStart : null;
+}
+function isTokenStart(text, index) {
+  return index === 0 || PATH_DELIMITERS.has(text[index - 1] ?? "");
+}
+function extractQuotedPrefix(text) {
+  const quoteStart = findUnclosedQuoteStart(text);
+  if (quoteStart === null) {
+    return null;
+  }
+  if (quoteStart > 0 && text[quoteStart - 1] === "@") {
+    if (!isTokenStart(text, quoteStart - 1)) {
+      return null;
+    }
+    return text.slice(quoteStart - 1);
+  }
+  if (!isTokenStart(text, quoteStart)) {
+    return null;
+  }
+  return text.slice(quoteStart);
+}
+function parsePathPrefix(prefix) {
+  if (prefix.startsWith('@"')) {
+    return { rawPrefix: prefix.slice(2), isAtPrefix: true, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith('"')) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: false, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith("@")) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: true, isQuotedPrefix: false };
+  }
+  return { rawPrefix: prefix, isAtPrefix: false, isQuotedPrefix: false };
+}
+function buildCompletionValue(path4, options) {
+  const needsQuotes = options.isQuotedPrefix || path4.includes(" ");
+  const prefix = options.isAtPrefix ? "@" : "";
+  if (!needsQuotes) {
+    return `${prefix}${path4}`;
+  }
+  const openQuote = `${prefix}"`;
+  const closeQuote = '"';
+  return `${openQuote}${path4}${closeQuote}`;
+}
+async function walkDirectoryWithFd(baseDir, fdPath, query, maxResults, signal) {
+  const args2 = [
+    "--base-directory",
+    baseDir,
+    "--max-results",
+    String(maxResults),
+    "--type",
+    "f",
+    "--type",
+    "d",
+    "--follow",
+    "--hidden",
+    "--exclude",
+    ".git",
+    "--exclude",
+    ".git/*",
+    "--exclude",
+    ".git/**"
+  ];
+  if (toDisplayPath(query).includes("/")) {
+    args2.push("--full-path");
+  }
+  if (query) {
+    args2.push(buildFdPathQuery(query));
+  }
+  return await new Promise((resolve4) => {
+    if (signal.aborted) {
+      resolve4([]);
+      return;
+    }
+    const child = spawn(fdPath, args2, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let resolved = false;
+    const finish = (results) => {
+      if (resolved)
+        return;
+      resolved = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve4(results);
+    };
+    const onAbort = () => {
+      if (child.exitCode === null) {
+        child.kill("SIGKILL");
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.on("error", () => {
+      finish([]);
+    });
+    child.on("close", (code) => {
+      if (signal.aborted || code !== 0 || !stdout) {
+        finish([]);
+        return;
+      }
+      const lines = stdout.trim().split("\n").filter(Boolean);
+      const results = [];
+      for (const line of lines) {
+        const displayLine = toDisplayPath(line);
+        const hasTrailingSeparator = displayLine.endsWith("/");
+        const normalizedPath = hasTrailingSeparator ? displayLine.slice(0, -1) : displayLine;
+        if (normalizedPath === ".git" || normalizedPath.startsWith(".git/") || normalizedPath.includes("/.git/")) {
+          continue;
+        }
+        results.push({
+          path: displayLine,
+          isDirectory: hasTrailingSeparator
+        });
+      }
+      finish(results);
+    });
+  });
+}
+var CombinedAutocompleteProvider = class {
+  commands;
+  basePath;
+  fdPath;
+  constructor(commands = [], basePath, fdPath = null) {
+    this.commands = commands;
+    this.basePath = basePath;
+    this.fdPath = fdPath;
+  }
+  async getSuggestions(lines, cursorLine, cursorCol, options) {
+    const currentLine = lines[cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    const atPrefix = this.extractAtPrefix(textBeforeCursor);
+    if (atPrefix) {
+      const { rawPrefix, isQuotedPrefix } = parsePathPrefix(atPrefix);
+      const suggestions2 = await this.getFuzzyFileSuggestions(rawPrefix, {
+        isQuotedPrefix,
+        signal: options.signal
+      });
+      if (suggestions2.length === 0)
+        return null;
+      return {
+        items: suggestions2,
+        prefix: atPrefix
+      };
+    }
+    if (!options.force && textBeforeCursor.startsWith("/")) {
+      const spaceIndex = textBeforeCursor.indexOf(" ");
+      if (spaceIndex === -1) {
+        const prefix = textBeforeCursor.slice(1);
+        const commandItems = this.commands.map((cmd) => {
+          const name = "name" in cmd ? cmd.name : cmd.value;
+          const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : void 0;
+          const desc = cmd.description ?? "";
+          const fullDesc = hint ? desc ? `${hint} \u2014 ${desc}` : hint : desc;
+          return {
+            name,
+            label: name,
+            description: fullDesc || void 0
+          };
+        });
+        const filtered = fuzzyFilter(commandItems, prefix, (item) => item.name).map((item) => ({
+          value: item.name,
+          label: item.label,
+          ...item.description && { description: item.description }
+        }));
+        if (filtered.length === 0)
+          return null;
+        return {
+          items: filtered,
+          prefix: textBeforeCursor
+        };
+      }
+      const commandName = textBeforeCursor.slice(1, spaceIndex);
+      const argumentText = textBeforeCursor.slice(spaceIndex + 1);
+      const command = this.commands.find((cmd) => {
+        const name = "name" in cmd ? cmd.name : cmd.value;
+        return name === commandName;
+      });
+      if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
+        return null;
+      }
+      const argumentSuggestions = await command.getArgumentCompletions(argumentText);
+      if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) {
+        return null;
+      }
+      return {
+        items: argumentSuggestions,
+        prefix: argumentText
+      };
+    }
+    const pathMatch = this.extractPathPrefix(textBeforeCursor, options.force ?? false);
+    if (pathMatch === null) {
+      return null;
+    }
+    const suggestions = this.getFileSuggestions(pathMatch);
+    if (suggestions.length === 0)
+      return null;
+    return {
+      items: suggestions,
+      prefix: pathMatch
+    };
+  }
+  applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+    const currentLine = lines[cursorLine] || "";
+    const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+    const afterCursor = currentLine.slice(cursorCol);
+    const isQuotedPrefix = prefix.startsWith('"') || prefix.startsWith('@"');
+    const hasLeadingQuoteAfterCursor = afterCursor.startsWith('"');
+    const hasTrailingQuoteInItem = item.value.endsWith('"');
+    const adjustedAfterCursor = isQuotedPrefix && hasTrailingQuoteInItem && hasLeadingQuoteAfterCursor ? afterCursor.slice(1) : afterCursor;
+    const isSlashCommand = prefix.startsWith("/") && beforePrefix.trim() === "" && !prefix.slice(1).includes("/");
+    if (isSlashCommand) {
+      const newLine2 = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;
+      const newLines2 = [...lines];
+      newLines2[cursorLine] = newLine2;
+      return {
+        lines: newLines2,
+        cursorLine,
+        cursorCol: beforePrefix.length + item.value.length + 2
+        // +2 for "/" and space
+      };
+    }
+    if (prefix.startsWith("@")) {
+      const isDirectory2 = item.label.endsWith("/");
+      const suffix = isDirectory2 ? "" : " ";
+      const newLine2 = `${beforePrefix + item.value}${suffix}${adjustedAfterCursor}`;
+      const newLines2 = [...lines];
+      newLines2[cursorLine] = newLine2;
+      const hasTrailingQuote2 = item.value.endsWith('"');
+      const cursorOffset2 = isDirectory2 && hasTrailingQuote2 ? item.value.length - 1 : item.value.length;
+      return {
+        lines: newLines2,
+        cursorLine,
+        cursorCol: beforePrefix.length + cursorOffset2 + suffix.length
+      };
+    }
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    if (textBeforeCursor.includes("/") && textBeforeCursor.includes(" ")) {
+      const newLine2 = beforePrefix + item.value + adjustedAfterCursor;
+      const newLines2 = [...lines];
+      newLines2[cursorLine] = newLine2;
+      const isDirectory2 = item.label.endsWith("/");
+      const hasTrailingQuote2 = item.value.endsWith('"');
+      const cursorOffset2 = isDirectory2 && hasTrailingQuote2 ? item.value.length - 1 : item.value.length;
+      return {
+        lines: newLines2,
+        cursorLine,
+        cursorCol: beforePrefix.length + cursorOffset2
+      };
+    }
+    const newLine = beforePrefix + item.value + adjustedAfterCursor;
+    const newLines = [...lines];
+    newLines[cursorLine] = newLine;
+    const isDirectory = item.label.endsWith("/");
+    const hasTrailingQuote = item.value.endsWith('"');
+    const cursorOffset = isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
+    return {
+      lines: newLines,
+      cursorLine,
+      cursorCol: beforePrefix.length + cursorOffset
+    };
+  }
+  // Extract @ prefix for fuzzy file suggestions
+  extractAtPrefix(text) {
+    const quotedPrefix = extractQuotedPrefix(text);
+    if (quotedPrefix?.startsWith('@"')) {
+      return quotedPrefix;
+    }
+    const lastDelimiterIndex = findLastDelimiter(text);
+    const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
+    if (text[tokenStart] === "@") {
+      return text.slice(tokenStart);
+    }
+    return null;
+  }
+  // Extract a path-like prefix from the text before cursor
+  extractPathPrefix(text, forceExtract = false) {
+    const quotedPrefix = extractQuotedPrefix(text);
+    if (quotedPrefix) {
+      return quotedPrefix;
+    }
+    const lastDelimiterIndex = findLastDelimiter(text);
+    const pathPrefix = lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1);
+    if (forceExtract) {
+      return pathPrefix;
+    }
+    if (pathPrefix.includes("/") || pathPrefix.startsWith(".") || pathPrefix.startsWith("~/")) {
+      return pathPrefix;
+    }
+    if (pathPrefix === "" && text.endsWith(" ")) {
+      return pathPrefix;
+    }
+    return null;
+  }
+  // Expand home directory (~/) to actual home path
+  expandHomePath(path4) {
+    if (path4.startsWith("~/")) {
+      const expandedPath = join(homedir(), path4.slice(2));
+      return path4.endsWith("/") && !expandedPath.endsWith("/") ? `${expandedPath}/` : expandedPath;
+    } else if (path4 === "~") {
+      return homedir();
+    }
+    return path4;
+  }
+  resolveScopedFuzzyQuery(rawQuery) {
+    const normalizedQuery = toDisplayPath(rawQuery);
+    const slashIndex = normalizedQuery.lastIndexOf("/");
+    if (slashIndex === -1) {
+      return null;
+    }
+    const displayBase = normalizedQuery.slice(0, slashIndex + 1);
+    const query = normalizedQuery.slice(slashIndex + 1);
+    let baseDir;
+    if (displayBase.startsWith("~/")) {
+      baseDir = this.expandHomePath(displayBase);
+    } else if (displayBase.startsWith("/")) {
+      baseDir = displayBase;
+    } else {
+      baseDir = join(this.basePath, displayBase);
+    }
+    try {
+      if (!statSync(baseDir).isDirectory()) {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return { baseDir, query, displayBase };
+  }
+  scopedPathForDisplay(displayBase, relativePath) {
+    const normalizedRelativePath = toDisplayPath(relativePath);
+    if (displayBase === "/") {
+      return `/${normalizedRelativePath}`;
+    }
+    return `${toDisplayPath(displayBase)}${normalizedRelativePath}`;
+  }
+  // Get file/directory suggestions for a given path prefix
+  getFileSuggestions(prefix) {
+    try {
+      let searchDir;
+      let searchPrefix;
+      const { rawPrefix, isAtPrefix, isQuotedPrefix } = parsePathPrefix(prefix);
+      let expandedPrefix = rawPrefix;
+      if (expandedPrefix.startsWith("~")) {
+        expandedPrefix = this.expandHomePath(expandedPrefix);
+      }
+      const isRootPrefix = rawPrefix === "" || rawPrefix === "./" || rawPrefix === "../" || rawPrefix === "~" || rawPrefix === "~/" || rawPrefix === "/" || isAtPrefix && rawPrefix === "";
+      if (isRootPrefix) {
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = expandedPrefix;
+        } else {
+          searchDir = join(this.basePath, expandedPrefix);
+        }
+        searchPrefix = "";
+      } else if (rawPrefix.endsWith("/")) {
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = expandedPrefix;
+        } else {
+          searchDir = join(this.basePath, expandedPrefix);
+        }
+        searchPrefix = "";
+      } else {
+        const dir = dirname(expandedPrefix);
+        const file = basename(expandedPrefix);
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = dir;
+        } else {
+          searchDir = join(this.basePath, dir);
+        }
+        searchPrefix = file;
+      }
+      const entries = readdirSync(searchDir, { withFileTypes: true });
+      const suggestions = [];
+      for (const entry of entries) {
+        if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
+          continue;
+        }
+        let isDirectory = entry.isDirectory();
+        if (!isDirectory && entry.isSymbolicLink()) {
+          try {
+            const fullPath = join(searchDir, entry.name);
+            isDirectory = statSync(fullPath).isDirectory();
+          } catch {
+          }
+        }
+        let relativePath;
+        const name = entry.name;
+        const displayPrefix = rawPrefix;
+        if (displayPrefix.endsWith("/")) {
+          relativePath = displayPrefix + name;
+        } else if (displayPrefix.includes("/") || displayPrefix.includes("\\")) {
+          if (displayPrefix.startsWith("~/")) {
+            const homeRelativeDir = displayPrefix.slice(2);
+            const dir = dirname(homeRelativeDir);
+            relativePath = `~/${dir === "." ? name : join(dir, name)}`;
+          } else if (displayPrefix.startsWith("/")) {
+            const dir = dirname(displayPrefix);
+            if (dir === "/") {
+              relativePath = `/${name}`;
+            } else {
+              relativePath = `${dir}/${name}`;
+            }
+          } else {
+            relativePath = join(dirname(displayPrefix), name);
+            if (displayPrefix.startsWith("./") && !relativePath.startsWith("./")) {
+              relativePath = `./${relativePath}`;
+            }
+          }
+        } else {
+          if (displayPrefix.startsWith("~")) {
+            relativePath = `~/${name}`;
+          } else {
+            relativePath = name;
+          }
+        }
+        relativePath = toDisplayPath(relativePath);
+        const pathValue = isDirectory ? `${relativePath}/` : relativePath;
+        const value = buildCompletionValue(pathValue, {
+          isDirectory,
+          isAtPrefix,
+          isQuotedPrefix
+        });
+        suggestions.push({
+          value,
+          label: name + (isDirectory ? "/" : "")
+        });
+      }
+      suggestions.sort((a, b2) => {
+        const aIsDir = a.value.endsWith("/");
+        const bIsDir = b2.value.endsWith("/");
+        if (aIsDir && !bIsDir)
+          return -1;
+        if (!aIsDir && bIsDir)
+          return 1;
+        return a.label.localeCompare(b2.label);
+      });
+      return suggestions;
+    } catch (_e2) {
+      return [];
+    }
+  }
+  // Score an entry against the query (higher = better match)
+  // isDirectory adds bonus to prioritize folders
+  scoreEntry(filePath, query, isDirectory) {
+    const fileName = basename(filePath);
+    const lowerFileName = fileName.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    let score = 0;
+    if (lowerFileName === lowerQuery)
+      score = 100;
+    else if (lowerFileName.startsWith(lowerQuery))
+      score = 80;
+    else if (lowerFileName.includes(lowerQuery))
+      score = 50;
+    else if (filePath.toLowerCase().includes(lowerQuery))
+      score = 30;
+    if (isDirectory && score > 0)
+      score += 10;
+    return score;
+  }
+  // Fuzzy file search using fd (fast, respects .gitignore)
+  async getFuzzyFileSuggestions(query, options) {
+    if (!this.fdPath || options.signal.aborted) {
+      return [];
+    }
+    try {
+      const scopedQuery = this.resolveScopedFuzzyQuery(query);
+      const fdBaseDir = scopedQuery?.baseDir ?? this.basePath;
+      const fdQuery = scopedQuery?.query ?? query;
+      const entries = await walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100, options.signal);
+      if (options.signal.aborted) {
+        return [];
+      }
+      const scoredEntries = entries.map((entry) => ({
+        ...entry,
+        score: fdQuery ? this.scoreEntry(entry.path, fdQuery, entry.isDirectory) : 1
+      })).filter((entry) => entry.score > 0);
+      scoredEntries.sort((a, b2) => b2.score - a.score);
+      const topEntries = scoredEntries.slice(0, 20);
+      const suggestions = [];
+      for (const { path: entryPath, isDirectory } of topEntries) {
+        const pathWithoutSlash = isDirectory ? entryPath.slice(0, -1) : entryPath;
+        const displayPath = scopedQuery ? this.scopedPathForDisplay(scopedQuery.displayBase, pathWithoutSlash) : pathWithoutSlash;
+        const entryName = basename(pathWithoutSlash);
+        const completionPath = isDirectory ? `${displayPath}/` : displayPath;
+        const value = buildCompletionValue(completionPath, {
+          isDirectory,
+          isAtPrefix: true,
+          isQuotedPrefix: options.isQuotedPrefix
+        });
+        suggestions.push({
+          value,
+          label: entryName + (isDirectory ? "/" : ""),
+          description: displayPath
+        });
+      }
+      return suggestions;
+    } catch {
+      return [];
+    }
+  }
+  // Check if we should trigger file completion (called on Tab key)
+  shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+    const currentLine = lines[cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    if (textBeforeCursor.trim().startsWith("/") && !textBeforeCursor.trim().includes(" ")) {
+      return false;
+    }
+    return true;
+  }
+};
+
 // ../../node_modules/get-east-asian-width/lookup-data.js
 var ambiguousMinimalCodePoint = 161;
 var ambiguousMaximumCodePoint = 1114109;
@@ -2467,6 +3035,92 @@ var _kittyProtocolActive = false;
 function setKittyProtocolActive(active) {
   _kittyProtocolActive = active;
 }
+var Key = {
+  // Special keys
+  escape: "escape",
+  esc: "esc",
+  enter: "enter",
+  return: "return",
+  tab: "tab",
+  space: "space",
+  backspace: "backspace",
+  delete: "delete",
+  insert: "insert",
+  clear: "clear",
+  home: "home",
+  end: "end",
+  pageUp: "pageUp",
+  pageDown: "pageDown",
+  up: "up",
+  down: "down",
+  left: "left",
+  right: "right",
+  f1: "f1",
+  f2: "f2",
+  f3: "f3",
+  f4: "f4",
+  f5: "f5",
+  f6: "f6",
+  f7: "f7",
+  f8: "f8",
+  f9: "f9",
+  f10: "f10",
+  f11: "f11",
+  f12: "f12",
+  // Symbol keys
+  backtick: "`",
+  hyphen: "-",
+  equals: "=",
+  leftbracket: "[",
+  rightbracket: "]",
+  backslash: "\\",
+  semicolon: ";",
+  quote: "'",
+  comma: ",",
+  period: ".",
+  slash: "/",
+  exclamation: "!",
+  at: "@",
+  hash: "#",
+  dollar: "$",
+  percent: "%",
+  caret: "^",
+  ampersand: "&",
+  asterisk: "*",
+  leftparen: "(",
+  rightparen: ")",
+  underscore: "_",
+  plus: "+",
+  pipe: "|",
+  tilde: "~",
+  leftbrace: "{",
+  rightbrace: "}",
+  colon: ":",
+  lessthan: "<",
+  greaterthan: ">",
+  question: "?",
+  // Single modifiers
+  ctrl: (key) => `ctrl+${key}`,
+  shift: (key) => `shift+${key}`,
+  alt: (key) => `alt+${key}`,
+  super: (key) => `super+${key}`,
+  // Combined modifiers
+  ctrlShift: (key) => `ctrl+shift+${key}`,
+  shiftCtrl: (key) => `shift+ctrl+${key}`,
+  ctrlAlt: (key) => `ctrl+alt+${key}`,
+  altCtrl: (key) => `alt+ctrl+${key}`,
+  shiftAlt: (key) => `shift+alt+${key}`,
+  altShift: (key) => `alt+shift+${key}`,
+  ctrlSuper: (key) => `ctrl+super+${key}`,
+  superCtrl: (key) => `super+ctrl+${key}`,
+  shiftSuper: (key) => `shift+super+${key}`,
+  superShift: (key) => `super+shift+${key}`,
+  altSuper: (key) => `alt+super+${key}`,
+  superAlt: (key) => `super+alt+${key}`,
+  // Triple modifiers
+  ctrlShiftAlt: (key) => `ctrl+shift+alt+${key}`,
+  ctrlShiftSuper: (key) => `ctrl+shift+super+${key}`
+};
 var SYMBOL_KEYS = /* @__PURE__ */ new Set([
   "`",
   "-",
@@ -3496,8 +4150,14 @@ function parseTerminalColorSchemeReport(data) {
 
 // ../../node_modules/@earendil-works/pi-tui/dist/terminal-image.js
 import { execSync } from "node:child_process";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
 var cachedCapabilities = null;
 var cellDimensions = { widthPx: 9, heightPx: 18 };
+function getCellDimensions() {
+  return cellDimensions;
+}
 function setCellDimensions(dims) {
   cellDimensions = dims;
 }
@@ -3575,6 +4235,41 @@ function isImageLine(line) {
   }
   return line.includes(KITTY_PREFIX) || line.includes(ITERM2_PREFIX);
 }
+function allocateImageId() {
+  return Math.floor(Math.random() * 4294967294) + 1;
+}
+function encodeKitty(base64Data, options = {}) {
+  const CHUNK_SIZE = 4096;
+  const params = ["a=T", "f=100", "q=2"];
+  if (options.moveCursor === false)
+    params.push("C=1");
+  if (options.columns)
+    params.push(`c=${options.columns}`);
+  if (options.rows)
+    params.push(`r=${options.rows}`);
+  if (options.imageId)
+    params.push(`i=${options.imageId}`);
+  if (base64Data.length <= CHUNK_SIZE) {
+    return `\x1B_G${params.join(",")};${base64Data}\x1B\\`;
+  }
+  const chunks = [];
+  let offset = 0;
+  let isFirst = true;
+  while (offset < base64Data.length) {
+    const chunk = base64Data.slice(offset, offset + CHUNK_SIZE);
+    const isLast = offset + CHUNK_SIZE >= base64Data.length;
+    if (isFirst) {
+      chunks.push(`\x1B_G${params.join(",")},m=1;${chunk}\x1B\\`);
+      isFirst = false;
+    } else if (isLast) {
+      chunks.push(`\x1B_Gm=0;${chunk}\x1B\\`);
+    } else {
+      chunks.push(`\x1B_Gm=1;${chunk}\x1B\\`);
+    }
+    offset += CHUNK_SIZE;
+  }
+  return chunks.join("");
+}
 function deleteKittyImage(imageId) {
   return `\x1B_Ga=d,d=I,i=${imageId},q=2\x1B\\`;
 }
@@ -3584,7 +4279,36 @@ function deleteAllKittyImages() {
 function deleteAllKittyPlacements() {
   return "\x1B_Ga=d,d=a,q=2\x1B\\";
 }
+function encodeITerm2(base64Data, options = {}) {
+  const params = [
+    `inline=${options.inline !== false ? 1 : 0}`,
+    `size=${Buffer.byteLength(base64Data, "base64")}`
+  ];
+  if (options.width !== void 0)
+    params.push(`width=${options.width}`);
+  if (options.height !== void 0)
+    params.push(`height=${options.height}`);
+  if (options.name) {
+    const nameBase64 = Buffer.from(options.name).toString("base64");
+    params.push(`name=${nameBase64}`);
+  }
+  if (options.preserveAspectRatio === false) {
+    params.push("preserveAspectRatio=0");
+  }
+  return `\x1B]1337;File=${params.join(";")}:${base64Data}\x07`;
+}
 var kittyImageMetadata = /* @__PURE__ */ new Map();
+var kittyTransmissionGeneration = 0;
+function registerKittyImageMetadata(metadata) {
+  kittyTransmissionGeneration += 1;
+  kittyImageMetadata.delete(metadata.imageId);
+  kittyImageMetadata.set(metadata.imageId, { ...metadata, transmissionGeneration: kittyTransmissionGeneration });
+  if (kittyImageMetadata.size > 1e3) {
+    const oldestImageId = kittyImageMetadata.keys().next().value;
+    if (oldestImageId !== void 0)
+      kittyImageMetadata.delete(oldestImageId);
+  }
+}
 function getRegisteredKittyImageMetadata(line) {
   const controls = /\x1b_G([^;]*);/.exec(line)?.[1];
   if (!controls)
@@ -3672,9 +4396,203 @@ function cropKittyImageLine(line, hiddenRows, visibleRows) {
   controls.push(`y=${sourceY}`, `h=${sourceHeight}`, `r=${croppedRows}`);
   return `${line.slice(0, match.index)}\x1B_G${controls.join(",")};${line.slice(match.index + match[0].length)}`;
 }
+function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeightCells, cellDimensions2 = { widthPx: 9, heightPx: 18 }) {
+  const maxWidth = Math.max(1, Math.floor(maxWidthCells));
+  const maxHeight = maxHeightCells === void 0 ? void 0 : Math.max(1, Math.floor(maxHeightCells));
+  const imageWidth = Math.max(1, imageDimensions.widthPx);
+  const imageHeight = Math.max(1, imageDimensions.heightPx);
+  const widthScale = maxWidth * cellDimensions2.widthPx / imageWidth;
+  const heightScale = maxHeight === void 0 ? widthScale : maxHeight * cellDimensions2.heightPx / imageHeight;
+  const scale = Math.min(widthScale, heightScale);
+  const scaledWidthPx = imageWidth * scale;
+  const scaledHeightPx = imageHeight * scale;
+  const columns = Math.ceil(scaledWidthPx / cellDimensions2.widthPx);
+  const rows = Math.ceil(scaledHeightPx / cellDimensions2.heightPx);
+  return {
+    columns: Math.max(1, Math.min(maxWidth, columns)),
+    rows: Math.max(1, maxHeight === void 0 ? rows : Math.min(maxHeight, rows))
+  };
+}
+function getPngDimensions(base64Data) {
+  try {
+    const buffer = Buffer.from(base64Data, "base64");
+    if (buffer.length < 24) {
+      return null;
+    }
+    if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) {
+      return null;
+    }
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    return { widthPx: width, heightPx: height };
+  } catch {
+    return null;
+  }
+}
+function getJpegDimensions(base64Data) {
+  try {
+    const buffer = Buffer.from(base64Data, "base64");
+    if (buffer.length < 2) {
+      return null;
+    }
+    if (buffer[0] !== 255 || buffer[1] !== 216) {
+      return null;
+    }
+    let offset = 2;
+    while (offset < buffer.length - 9) {
+      if (buffer[offset] !== 255) {
+        offset++;
+        continue;
+      }
+      const marker = buffer[offset + 1];
+      if (marker >= 192 && marker <= 194) {
+        const height = buffer.readUInt16BE(offset + 5);
+        const width = buffer.readUInt16BE(offset + 7);
+        return { widthPx: width, heightPx: height };
+      }
+      if (offset + 3 >= buffer.length) {
+        return null;
+      }
+      const length = buffer.readUInt16BE(offset + 2);
+      if (length < 2) {
+        return null;
+      }
+      offset += 2 + length;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getGifDimensions(base64Data) {
+  try {
+    const buffer = Buffer.from(base64Data, "base64");
+    if (buffer.length < 10) {
+      return null;
+    }
+    const sig = buffer.slice(0, 6).toString("ascii");
+    if (sig !== "GIF87a" && sig !== "GIF89a") {
+      return null;
+    }
+    const width = buffer.readUInt16LE(6);
+    const height = buffer.readUInt16LE(8);
+    return { widthPx: width, heightPx: height };
+  } catch {
+    return null;
+  }
+}
+function getWebpDimensions(base64Data) {
+  try {
+    const buffer = Buffer.from(base64Data, "base64");
+    if (buffer.length < 30) {
+      return null;
+    }
+    const riff = buffer.slice(0, 4).toString("ascii");
+    const webp = buffer.slice(8, 12).toString("ascii");
+    if (riff !== "RIFF" || webp !== "WEBP") {
+      return null;
+    }
+    const chunk = buffer.slice(12, 16).toString("ascii");
+    if (chunk === "VP8 ") {
+      if (buffer.length < 30)
+        return null;
+      const width = buffer.readUInt16LE(26) & 16383;
+      const height = buffer.readUInt16LE(28) & 16383;
+      return { widthPx: width, heightPx: height };
+    } else if (chunk === "VP8L") {
+      if (buffer.length < 25)
+        return null;
+      const bits = buffer.readUInt32LE(21);
+      const width = (bits & 16383) + 1;
+      const height = (bits >> 14 & 16383) + 1;
+      return { widthPx: width, heightPx: height };
+    } else if (chunk === "VP8X") {
+      if (buffer.length < 30)
+        return null;
+      const width = (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1;
+      const height = (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1;
+      return { widthPx: width, heightPx: height };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getImageDimensions(base64Data, mimeType) {
+  if (mimeType === "image/png") {
+    return getPngDimensions(base64Data);
+  }
+  if (mimeType === "image/jpeg") {
+    return getJpegDimensions(base64Data);
+  }
+  if (mimeType === "image/gif") {
+    return getGifDimensions(base64Data);
+  }
+  if (mimeType === "image/webp") {
+    return getWebpDimensions(base64Data);
+  }
+  return null;
+}
+function renderImage(base64Data, imageDimensions, options = {}) {
+  const caps = getCapabilities();
+  if (!caps.images) {
+    return null;
+  }
+  const maxWidth = options.maxWidthCells ?? 80;
+  const size = calculateImageCellSize(imageDimensions, maxWidth, options.maxHeightCells, getCellDimensions());
+  if (caps.images === "kitty") {
+    if (options.imageId !== void 0) {
+      registerKittyImageMetadata({
+        imageId: options.imageId,
+        columns: size.columns,
+        rows: size.rows,
+        widthPx: imageDimensions.widthPx,
+        heightPx: imageDimensions.heightPx
+      });
+    }
+    const sequence = encodeKitty(base64Data, {
+      columns: size.columns,
+      rows: size.rows,
+      imageId: options.imageId,
+      moveCursor: options.moveCursor
+    });
+    return { sequence, columns: size.columns, rows: size.rows, imageId: options.imageId };
+  }
+  if (caps.images === "iterm2") {
+    const sequence = encodeITerm2(base64Data, {
+      width: size.columns,
+      height: "auto",
+      preserveAspectRatio: options.preserveAspectRatio ?? true
+    });
+    return { sequence, columns: size.columns, rows: size.rows };
+  }
+  return null;
+}
 function hyperlink(text, url) {
   return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
 }
+function shortenImagePath(filename) {
+  const home = homedir2();
+  if (home && (filename === home || filename.startsWith(`${home}/`) || filename.startsWith(`${home}\\`))) {
+    return `~${filename.slice(home.length)}`;
+  }
+  return filename;
+}
+function imageFallback(mimeType, dimensions, filename) {
+  const parts = [];
+  if (filename) {
+    const display = shortenImagePath(filename);
+    if (getCapabilities().hyperlinks && isAbsolute(filename)) {
+      parts.push(hyperlink(display, pathToFileURL(filename).href));
+    } else {
+      parts.push(display);
+    }
+  }
+  parts.push(`[${mimeType}]`);
+  if (dimensions)
+    parts.push(`${dimensions.widthPx}x${dimensions.heightPx}`);
+  return `[Image: ${parts.join(" ")}]`;
+}
 
 // ../../node_modules/@earendil-works/pi-tui/dist/tui.js
 function isFocusable(component) {
@@ -6494,6 +7412,125 @@ function allocateStackSizes(entries, intrinsicSizes, availableSize, gap) {
   return sizes;
 }
 
+// ../../node_modules/@earendil-works/pi-tui/dist/components/h-stack.js
+var HStack = class extends Stack {
+  layoutType = "hstack";
+  constructor(children = [], options = {}) {
+    super(children, options);
+  }
+  render(width) {
+    const safeWidth = Math.max(1, width);
+    const viewport = { width: safeWidth, height: Number.MAX_SAFE_INTEGER };
+    const entries = visibleStackEntries(this.entries, viewport);
+    if (entries.length === 0)
+      return [];
+    const intrinsicWidths = entries.map((entry) => {
+      const lines = entry.component.render(safeWidth);
+      return lines.reduce((max, line) => Math.max(max, visibleWidth(line)), 0);
+    });
+    const widths = allocateStackSizes(entries, intrinsicWidths, safeWidth, this.gap);
+    const rendered = entries.map((entry, index) => widths[index] === 0 ? [] : entry.component.render(widths[index]));
+    const height = rendered.reduce((max, lines) => Math.max(max, lines.length), 0);
+    const result = Array.from({ length: height }, () => "");
+    let x2 = 0;
+    for (let index = 0; index < rendered.length; index++) {
+      const lines = rendered[index];
+      const childWidth = widths[index];
+      let offset = 0;
+      if (this.align === "center")
+        offset = Math.floor((height - lines.length) / 2);
+      else if (this.align === "end")
+        offset = height - lines.length;
+      for (let row = 0; row < lines.length; row++) {
+        const target = row + offset;
+        if (target < 0 || target >= result.length)
+          continue;
+        result[target] = compositeTuiLine(result[target], lines[row], x2, childWidth, safeWidth);
+      }
+      x2 += childWidth + this.gap;
+    }
+    return result;
+  }
+};
+
+// ../../node_modules/@earendil-works/pi-tui/dist/components/image.js
+var Image = class {
+  base64Data;
+  mimeType;
+  dimensions;
+  theme;
+  options;
+  imageId;
+  cachedLines;
+  cachedWidth;
+  constructor(base64Data, mimeType, theme2, options = {}, dimensions) {
+    this.base64Data = base64Data;
+    this.mimeType = mimeType;
+    this.theme = theme2;
+    this.options = options;
+    this.dimensions = dimensions || getImageDimensions(base64Data, mimeType) || { widthPx: 800, heightPx: 600 };
+    this.imageId = options.imageId;
+  }
+  /** Get the Kitty image ID used by this image (if any). */
+  getImageId() {
+    return this.imageId;
+  }
+  invalidate() {
+    this.cachedLines = void 0;
+    this.cachedWidth = void 0;
+  }
+  render(width) {
+    if (this.cachedLines && this.cachedWidth === width) {
+      return this.cachedLines;
+    }
+    const maxWidth = Math.max(1, Math.min(width - 2, this.options.maxWidthCells ?? 60));
+    const cellDimensions2 = getCellDimensions();
+    const defaultMaxHeight = Math.max(1, Math.ceil(maxWidth * cellDimensions2.widthPx / cellDimensions2.heightPx));
+    const maxHeight = this.options.maxHeightCells ?? defaultMaxHeight;
+    const caps = getCapabilities();
+    let lines;
+    if (caps.images) {
+      if (caps.images === "kitty" && this.imageId === void 0) {
+        this.imageId = allocateImageId();
+      }
+      const result = renderImage(this.base64Data, this.dimensions, {
+        maxWidthCells: maxWidth,
+        maxHeightCells: maxHeight,
+        imageId: this.imageId,
+        moveCursor: false
+      });
+      if (result) {
+        if (result.imageId) {
+          this.imageId = result.imageId;
+        }
+        if (caps.images === "kitty") {
+          lines = [result.sequence];
+          for (let i = 0; i < result.rows - 1; i++) {
+            lines.push("");
+          }
+        } else {
+          lines = [];
+          for (let i = 0; i < result.rows - 1; i++) {
+            lines.push("");
+          }
+          const rowOffset = result.rows - 1;
+          const moveUp = rowOffset > 0 ? `\x1B[${rowOffset}A` : "";
+          lines.push(moveUp + result.sequence);
+        }
+      } else {
+        const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
+        lines = [truncateToWidth(this.theme.fallbackColor(fallback), width)];
+      }
+    } else {
+      const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
+      lines = [truncateToWidth(this.theme.fallbackColor(fallback), width)];
+    }
+    this.cachedLines = lines;
+    this.cachedWidth = width;
+    return lines;
+  }
+};
+
 // ../../node_modules/@earendil-works/pi-tui/dist/components/input.js
 var segmenter = getGraphemeSegmenter();
 var Input = class {
@@ -11260,7 +12297,7 @@ async function reloadDaemon(stateDir, configPath) {
 // node_modules/.dist-original/welcome.js
 import { DatabaseSync } from "node:sqlite";
 import { existsSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // node_modules/.dist-original/tui-theme.js
 var enabled = !process.env.NO_COLOR && process.env.TERM !== "dumb";
@@ -11273,8 +12310,8 @@ var tuiTheme = {
   userMessage: (value) => paint("38;5;236;48;5;230", value),
   strong: (value) => paint("1", value),
   underline: (value) => paint("4", value),
-  muted: (value) => paint("2", value),
-  subtle: (value) => paint("2", value),
+  muted: (value) => paint("38;5;243", value),
+  subtle: (value) => paint("38;5;244", value),
   success: (value) => paint("38;5;35", value),
   warning: (value) => paint("38;5;214", value),
   error: (value) => paint("38;5;196", value),
@@ -11286,15 +12323,15 @@ var WELCOME_TEAM_SLOTS = 3;
 var WELCOME_HANDOFF_SLOTS = 2;
 var WELCOME_CONVERSATION_SLOTS = 240;
 var GOAH_TERMINAL_MARK = [
-  "        \u2584\u2584",
-  "      \u2584\u2580\u2580  \u2588\u2584",
-  "   \u2584\u2584\u2588\u2588\u2580\u2588\u2580\u2580 \u2588",
-  "  \u2588\u2580 \u2588 \u2588\u2588\u2588\u2588 \u2588 \u2584\u2588",
-  "   \u2580\u2580\u2588\u2588\u2584\u2588\u2580\u2584\u2588\u2580\u2580\u2580",
-  "      \u2580\u2584\u2584\u2584\u2580\u2580"
+  "\u2800\u2800\u2800\u2880\u28F4\u281F\u281B\u2832\u2840\u2800\u2800\u2800",
+  "\u2800\u2800\u2880\u28FF\u28E5\u2836\u2836\u281E\u28BB\u281B\u2812\u2800",
+  "\u28F0\u281E\u28BB\u284F\u28F0\u28FE\u28F6\u2844\u28B8\u285F\u28B3\u2844",
+  "\u283B\u28E6\u28F8\u28C7\u28D9\u28FF\u28DF\u28C1\u28FF\u28F4\u283E\u2803",
+  "\u2800\u2800\u2809\u28BF\u2849\u2809\u28C9\u28FF\u2803\u2800\u2800\u2800",
+  "\u2800\u2800\u2800\u2808\u281B\u281B\u280B\u2801\u2800\u2800\u2800\u2800"
 ];
 function welcomeSnapshot(stateDir, runner) {
-  const database = join4(stateDir, "ledger.sqlite");
+  const database = join5(stateDir, "ledger.sqlite");
   if (!existsSync(database))
     return { root: null, team: [], handoffs: [], conversation: [], runner: runner.runner, target: runner.target };
   const db = new DatabaseSync(database, { readOnly: true });
@@ -11314,7 +12351,7 @@ function welcomeSnapshot(stateDir, runner) {
         return [{ agent: row.actor, result: "" }];
       }
     });
-    const itemRows = db.prepare("SELECT i.type,i.data FROM turn_items i JOIN turns t ON t.id=i.turn_id JOIN threads th ON th.id=t.thread_id WHERE th.agent='ceo' AND t.trigger_kind='user_message' AND t.status<>'in_progress' AND i.status='completed' AND i.type IN ('user_message','assistant_message') AND (i.type='user_message' OR t.goal_id IS NULL OR EXISTS (SELECT 1 FROM events e WHERE e.stream_id='turn:'||t.id AND e.type='response.committed' AND json_extract(e.data,'$.messageItemId')=i.id)) ORDER BY i.rowid DESC LIMIT ?").all(WELCOME_CONVERSATION_SLOTS);
+    const itemRows = db.prepare("SELECT i.type,i.data FROM turn_items i JOIN turns t ON t.id=i.turn_id JOIN threads th ON th.id=t.thread_id WHERE th.agent='ceo' AND t.trigger_kind='user_message' AND t.status='completed' AND i.status='completed' AND i.type IN ('user_message','assistant_message') AND (i.type='user_message' OR t.goal_id IS NULL OR EXISTS (SELECT 1 FROM events e WHERE e.stream_id='turn:'||t.id AND e.type='response.committed' AND json_extract(e.data,'$.messageItemId')=i.id)) ORDER BY i.rowid DESC LIMIT ?").all(WELCOME_CONVERSATION_SLOTS);
     const conversation = itemRows.reverse().flatMap((row) => {
       try {
         const data = JSON.parse(row.data);
@@ -11328,18 +12365,9 @@ function welcomeSnapshot(stateDir, runner) {
     db.close();
   }
 }
-function renderWelcome(snapshot, hasHistory) {
-  const lines = ["", ...GOAH_TERMINAL_MARK.map((line) => tuiTheme.accent(line)), "", `  ${tuiTheme.strong(hasHistory ? "Welcome back." : "Ready when you are.")}`, `  ${tuiTheme.accent(snapshot.target)} ${tuiTheme.muted(`\xB7 ${snapshot.runner}`)}`];
-  if (!snapshot.root)
-    lines.push(`  ${tuiTheme.muted("Chat normally \xB7 /goal for durable work \xB7 /help")}`);
-  if (snapshot.team.length)
-    lines.push(`  ${tuiTheme.muted(`${snapshot.team.length} Goal Agent${snapshot.team.length === 1 ? "" : "s"} in the organization`)}`);
-  lines.push("");
-  return lines;
-}
 
 // node_modules/.dist-original/setup-wizard.js
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // node_modules/.dist-original/searchable-select.js
 var SearchableSelect = class {
@@ -11576,13 +12604,13 @@ function summarize(config) {
 function openUrl(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args2 = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  spawn(command, args2, { detached: true, stdio: "ignore" }).unref();
+  spawn2(command, args2, { detached: true, stdio: "ignore" }).unref();
 }
 
 // node_modules/.dist-original/tui.js
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync2, mkdirSync, openSync } from "node:fs";
-import { join as join5, resolve as resolve2 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { closeSync, existsSync as existsSync2, mkdirSync, openSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join6, resolve as resolve2 } from "node:path";
 var HeaderBar = class {
   runner;
   target;
@@ -11636,7 +12664,10 @@ var ConversationView = class {
   liveThinking = "";
   thinkingActive = false;
   constructor(initial) {
-    this.entries = [{ kind: "text", content: initial.join("\n") }];
+    this.entries = initial.length ? [{ kind: "text", content: initial.join("\n") }] : [];
+  }
+  addComponent(component) {
+    this.entries.push({ kind: "component", component });
   }
   addText(content) {
     this.entries.push({ kind: "text", content });
@@ -11711,7 +12742,7 @@ var ConversationView = class {
       this.entries.splice(1, this.entries.length - 240);
   }
   render(width) {
-    const rendered = this.entries.flatMap((entry) => entry.kind === "markdown" ? [...new Markdown(entry.content, 2, 0, markdownTheme).render(width), ""] : entry.kind === "user" ? renderUserMessage(entry.content, width) : entry.kind === "thinking" ? [tuiTheme.muted("  thinking"), ...new Markdown(entry.content, 2, 0, markdownTheme, { color: tuiTheme.muted, italic: true }).render(width), ""] : entry.kind === "tool" ? new Text(toolActivityLine(entry), 2, 0).render(width) : new Text(entry.content, 2, 0).render(width));
+    const rendered = this.entries.flatMap((entry) => entry.kind === "component" ? entry.component.render(width) : entry.kind === "markdown" ? [...new Markdown(entry.content, 2, 0, markdownTheme).render(width), ""] : entry.kind === "user" ? renderUserMessage(entry.content, width) : entry.kind === "thinking" ? [tuiTheme.muted("  thinking"), ...new Markdown(entry.content, 2, 0, markdownTheme, { color: tuiTheme.muted, italic: true }).render(width), ""] : entry.kind === "tool" ? new Text(toolActivityLine(entry), 2, 0).render(width) : new Text(entry.content, 2, 0).render(width));
     if (this.liveThinking)
       rendered.push(tuiTheme.muted("  thinking"), ...new Markdown(this.liveThinking, 2, 0, markdownTheme, { color: tuiTheme.muted, italic: true }).render(width));
     else if (this.thinkingActive)
@@ -11723,6 +12754,48 @@ var ConversationView = class {
   invalidate() {
   }
 };
+var WelcomeLockup = class {
+  mark;
+  details;
+  horizontal;
+  constructor(snapshot, hasHistory, imageData = null) {
+    this.mark = imageData ? new Image(imageData, "image/png", { fallbackColor: tuiTheme.accent }, { maxWidthCells: 10, maxHeightCells: 5, filename: "Goah" }) : new Text(GOAH_TERMINAL_MARK.map((line) => tuiTheme.accent(line)).join("\n"), 0, 0);
+    const lines = [
+      tuiTheme.strong(hasHistory ? "Welcome back." : "Ready when you are."),
+      `${tuiTheme.accent(snapshot.target)} ${tuiTheme.muted(`\xB7 ${snapshot.runner}`)}`
+    ];
+    if (!snapshot.root)
+      lines.push(tuiTheme.muted("Chat normally \xB7 /goal for durable work \xB7 /help"));
+    if (snapshot.team.length)
+      lines.push(tuiTheme.muted(`${snapshot.team.length} Goal Agent${snapshot.team.length === 1 ? "" : "s"} in the organization`));
+    this.details = new Text(lines.join("\n"), 0, 0);
+    this.horizontal = new HStack([
+      { component: this.mark, basis: 14, shrink: 0 },
+      { component: this.details, grow: 1, minSize: 24 }
+    ], { gap: 2, align: "center" });
+  }
+  render(width) {
+    const contentWidth = Math.max(1, width - 4);
+    if (width < 58) {
+      return ["", ...this.mark.render(Math.min(14, contentWidth)).map((line) => `  ${line}`), "", ...this.details.render(contentWidth).map((line) => `  ${line}`), ""];
+    }
+    return ["", ...this.horizontal.render(contentWidth).map((line) => `  ${line}`), ""];
+  }
+  invalidate() {
+    this.mark.invalidate();
+    this.details.invalidate();
+    this.horizontal.invalidate();
+  }
+};
+function terminalLogoData() {
+  if (getCapabilities().images !== "kitty")
+    return null;
+  try {
+    return readFileSync2(new URL("./console/goah-orbital-mark.png", import.meta.url)).toString("base64");
+  } catch {
+    return null;
+  }
+}
 var StreamCoordinator = class {
   #active = null;
   #pending = null;
@@ -11780,7 +12853,7 @@ var StreamCoordinator = class {
   }
 };
 function renderUserMessage(content, width) {
-  return new Text(content, 2, 1, tuiTheme.userMessage).render(width);
+  return new Text(content, 2, 0, tuiTheme.userMessage).render(width);
 }
 function renderTuiHeader(width, runner, target, version) {
   const brand = " GOAH ";
@@ -11800,40 +12873,76 @@ function statusText(mode, queued = 0) {
     return tuiTheme.accent("opening setup\u2026");
   return `${tuiTheme.muted("ready")}  ${tuiTheme.accent("/help")}`;
 }
+var TUI_COMMANDS = [
+  { name: "goal", action: "goal", description: "Start or revise durable work", argumentHint: "<objective>", acceptsArguments: true, requiresArgument: true },
+  { name: "model", action: "model", description: "Choose a provider and model", argumentHint: "[provider/model]", acceptsArguments: true },
+  { name: "status", action: "status", description: "Inspect the current workspace" },
+  { name: "setup", action: "setup", description: "Configure Goah", argumentHint: "[runner|model|auth]", acceptsArguments: true },
+  { name: "records", action: "records", description: "Browse current work records", argumentHint: "[goal]", acceptsArguments: true },
+  { name: "history", action: "records", description: "Show a Goal's record history", argumentHint: "<goal>", acceptsArguments: true, requiresArgument: true },
+  { name: "observe", action: "goal", description: "Set how the active Goal is observed", argumentHint: "<method>", acceptsArguments: true, requiresArgument: true },
+  { name: "login", action: "login", description: "Add provider credentials", argumentHint: "[provider]", acceptsArguments: true },
+  { name: "logout", action: "logout", description: "Remove provider credentials", argumentHint: "[provider]", acceptsArguments: true },
+  { name: "stop", action: "stop", description: "Stop the current Turn" },
+  { name: "help", action: "help", description: "Show all commands" },
+  { name: "quit", action: "quit", description: "Leave Goah", aliases: ["exit"] }
+];
+function commandDefinition(text) {
+  const token = text.trim().split(/\s+/, 1)[0] ?? "";
+  if (!token.startsWith("/"))
+    return null;
+  const name = token.slice(1);
+  const definition = TUI_COMMANDS.find((candidate) => candidate.name === name || candidate.aliases?.includes(name));
+  if (!definition)
+    return null;
+  return { definition, hasArguments: Boolean(text.trim().slice(token.length).trim()) };
+}
+function commandAwaitingArgument(text) {
+  const match = commandDefinition(text);
+  return match && match.definition.requiresArgument && !match.hasArguments ? `/${match.definition.name} ` : null;
+}
+function createTuiAutocompleteProvider(basePath = process.cwd()) {
+  const commands = TUI_COMMANDS.map(({ name, description, argumentHint, getArgumentCompletions }) => ({ name, ...description ? { description } : {}, ...argumentHint ? { argumentHint } : {}, ...getArgumentCompletions ? { getArgumentCompletions } : {} }));
+  return new CombinedAutocompleteProvider(commands, basePath);
+}
+function renderTuiCommandHelp() {
+  return [tuiTheme.strong("Commands"), ...TUI_COMMANDS.map((command) => {
+    const invocation = `/${command.name}${command.argumentHint ? ` ${command.argumentHint}` : ""}`;
+    return `  ${invocation.padEnd(28)} ${tuiTheme.muted(command.description ?? "")}`;
+  }), "", tuiTheme.strong("Keyboard"), `  ${"Ctrl+C".padEnd(28)} ${tuiTheme.muted("Clear input \xB7 interrupt current Turn \xB7 exit when idle")}`, `  ${"Ctrl+D".padEnd(28)} ${tuiTheme.muted("Exit when idle")}`, ""].join("\n");
+}
 function classifyTuiInput(value, busy) {
   const text = value.trim();
   if (!text)
     return { action: "empty", text };
-  if (text === "/quit" || text === "/exit")
-    return { action: "quit", text };
-  if (text === "/help")
-    return { action: "help", text };
-  if (text === "/status")
-    return { action: "status", text };
-  if (text === "/records" || text.startsWith("/records ") || text.startsWith("/history "))
-    return { action: "records", text };
-  if (text === "/stop")
-    return { action: "stop", text };
-  if (text === "/model" || text.startsWith("/model "))
-    return { action: "model", text };
-  if (text === "/login" || text.startsWith("/login "))
-    return { action: "login", text };
-  if (text === "/logout" || text.startsWith("/logout "))
-    return { action: "logout", text };
-  if (text === "/setup" || text.startsWith("/setup "))
-    return { action: "setup", text };
-  if (text.startsWith("/goal ") || text.startsWith("/observe "))
-    return { action: "goal", text };
+  const command = commandDefinition(text);
+  if (command) {
+    if (command.hasArguments && !command.definition.acceptsArguments)
+      return { action: "unknown", text };
+    return { action: command.definition.action, text };
+  }
   if (text.startsWith("/"))
     return { action: "unknown", text };
   return { action: busy ? "steer" : "send", text };
 }
+function classifyTuiControlKey(data, inputText, busy) {
+  if (isKeyRelease(data))
+    return "forward";
+  if (matchesKey(data, Key.ctrl("c"))) {
+    if (inputText.length > 0)
+      return "clear";
+    return busy ? "interrupt" : "exit";
+  }
+  if (matchesKey(data, Key.ctrl("d")) && !inputText && !busy)
+    return "exit";
+  return "forward";
+}
 async function runGoahTui(configPath, stateDir, initialMessage) {
   if (!process.stdout.isTTY || !process.stdin.isTTY)
     return runNonInteractive(configPath, stateDir, initialMessage);
   const runner = readRunnerDisplay(configPath);
   const snapshot = welcomeSnapshot(stateDir, runner);
-  const welcome = renderWelcome(snapshot, Boolean(snapshot.root || snapshot.handoffs.length || snapshot.conversation.length));
+  const hasHistory = Boolean(snapshot.root || snapshot.handoffs.length || snapshot.conversation.length);
   await ensureDaemon(configPath, stateDir);
   const liveSnapshot = await requestControl(stateDir, { op: "status" }).catch(() => null);
   const liveTurns = liveSnapshot && typeof liveSnapshot === "object" && !Array.isArray(liveSnapshot) && Array.isArray(liveSnapshot.turns) ? liveSnapshot.turns : [];
@@ -11842,7 +12951,8 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
   const tui = new TuiAltScreen(terminal, true, void 0, { mouse: true });
   terminal.setTitle(`Goah \xB7 ${runner.target}`);
   const headerView = new HeaderBar(runner.runner, runner.target, installedVersion());
-  const transcriptView = new ConversationView(welcome);
+  const transcriptView = new ConversationView([]);
+  transcriptView.addComponent(new WelcomeLockup(snapshot, hasHistory, terminalLogoData()));
   for (const row of snapshot.conversation)
     if (row.speaker === "You")
       transcriptView.addUser(row.text);
@@ -11854,13 +12964,14 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
     borderColor: tuiTheme.accent,
     selectList: { selectedPrefix: tuiTheme.accent, selectedText: tuiTheme.strong, description: tuiTheme.muted, scrollInfo: tuiTheme.muted, noMatch: tuiTheme.error }
   }, { paddingX: 1, autocompleteMaxVisible: 6 });
+  input.setAutocompleteProvider(createTuiAutocompleteProvider());
   const statusView = new Text(statusText("ready"), 1, 0);
   const shell = new VStack([
     { component: headerView, basis: 1, shrink: 0 },
     { component: conversationScroll, grow: 1, minSize: 1 },
     { component: goalView, basis: 1, shrink: 0 },
     { component: statusView, basis: 1, shrink: 0 },
-    { component: input, basis: "auto", minSize: 3, maxSize: 8, shrink: 0 }
+    { component: input, basis: "auto", minSize: 3, maxSize: 11, shrink: 0 }
   ]);
   const busy = { active: false };
   const queued = [];
@@ -11870,6 +12981,7 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
   let steeringTail = Promise.resolve();
   let configuring = false;
   let exiting = false;
+  let interrupting = false;
   const push = (line) => {
     transcriptView.addText(line);
     tui.requestRender();
@@ -11902,6 +13014,7 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
   };
   const finishIdle = async () => {
     busy.active = false;
+    interrupting = false;
     await refreshGoalBar(stateDir, goalView, tui);
     statusView.setText(statusText(queuedTurnIds.length || queued.length ? "queued" : "ready", queuedTurnIds.length + queued.length));
     continuePending();
@@ -12017,6 +13130,7 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
       if (!streams.complete(controller))
         return;
       busy.active = false;
+      interrupting = false;
       await refreshGoalBar(stateDir, goalView, tui);
       statusView.setText(statusText("ready"));
       continuePending();
@@ -12137,6 +13251,11 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
     push(await reloadDaemon(stateDir, configPath) ? "Configuration updated \u2014 applies to the next Turn." : "Configuration saved \u2014 restart Goah to apply it.");
   });
   input.onSubmit = (line) => {
+    const waiting = commandAwaitingArgument(line);
+    if (waiting) {
+      input.setText(waiting);
+      return;
+    }
     const { action, text } = classifyTuiInput(line, busy.active);
     input.setText("");
     if (action === "quit") {
@@ -12147,10 +13266,7 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
       return;
     }
     if (action === "help") {
-      push(`${tuiTheme.strong("Commands")}
-  /model  /login  /logout  /setup  /status
-  /records  /history  /goal  /observe  /stop  /quit
-`);
+      push(renderTuiCommandHelp());
       return;
     }
     if (action === "status") {
@@ -12203,10 +13319,22 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
   tui.setFocus(input);
   const { promise: exited, resolve: resolveExit } = Promise.withResolvers();
   tui.addInputListener((data) => {
-    if (data !== "")
+    const action = classifyTuiControlKey(data, input.getText(), busy.active);
+    if (action === "forward")
       return void 0;
+    if (action === "clear") {
+      input.setText("");
+      tui.requestRender();
+      return { consume: true };
+    }
+    if (action === "interrupt" && !interrupting) {
+      interrupting = true;
+      statusView.setText(`${tuiTheme.warning("stopping")}  ${tuiTheme.muted("press Ctrl+C again to exit")}`);
+      tui.requestRender();
+      void stopCeoWake(stateDir, push);
+      return { consume: true };
+    }
     exiting = true;
-    push(busy.active ? "Detached \u2014 the current Turn continues in the daemon. Use /stop before detaching when you intend to cancel it." : "Detached.");
     streams.abortAll();
     tui.stop();
     resolveExit();
@@ -12465,8 +13593,8 @@ async function ensureDaemon(configPath, stateDir) {
       await new Promise((resolveWait) => setTimeout(resolveWait, 50));
   }
   mkdirSync(stateDir, { recursive: true });
-  const log = openSync(join5(stateDir, "daemon.log"), "a");
-  spawn2(process.execPath, [process.argv[1], "start", "--config", resolve2(configPath)], { cwd: process.cwd(), detached: true, stdio: ["ignore", log, log], env: process.env }).unref();
+  const log = openSync(join6(stateDir, "daemon.log"), "a");
+  spawn3(process.execPath, [process.argv[1], "start", "--config", resolve2(configPath)], { cwd: process.cwd(), detached: true, stdio: ["ignore", log, log], env: process.env }).unref();
   closeSync(log);
   const deadline = Date.now() + 1e4;
   while (Date.now() < deadline) {
@@ -12826,7 +13954,7 @@ async function main() {
       const goal = command === "goal-complete" ? supervisor.completeGoal({ goalId: id, revision: current.revision, reason: required("--reason"), evidence: evidence() }, actor) : supervisor.transitionGoal(id, command === "goal-pause" ? "paused" : "active", actor);
       console.log(JSON.stringify({ goal }, null, 2));
     } else if (command === "dashboard") {
-      const path4 = option("--output") ?? join6(config.stateDir, "status.html");
+      const path4 = option("--output") ?? join7(config.stateDir, "status.html");
       writeFileSync(path4, (await import("./dist-KNR2XL6J.js")).renderDashboard(ledger));
       console.log(path4);
     } else
@@ -12863,8 +13991,8 @@ async function ensureDaemon2(configPath, stateDir) {
       await new Promise((resolveWait) => setTimeout(resolveWait, 50));
   }
   mkdirSync2(stateDir, { recursive: true });
-  const log = openSync2(join6(stateDir, "daemon.log"), "a");
-  const child = spawn3(process.execPath, [process.argv[1], "start", "--config", resolve3(configPath)], { cwd: process.cwd(), detached: true, stdio: ["ignore", log, log], env: process.env });
+  const log = openSync2(join7(stateDir, "daemon.log"), "a");
+  const child = spawn4(process.execPath, [process.argv[1], "start", "--config", resolve3(configPath)], { cwd: process.cwd(), detached: true, stdio: ["ignore", log, log], env: process.env });
   closeSync2(log);
   child.unref();
   const deadline = Date.now() + 1e4;
@@ -12880,7 +14008,7 @@ async function ensureDaemon2(configPath, stateDir) {
 function openUrl2(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args2 = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = spawn3(command, args2, { detached: true, stdio: "ignore" });
+  const child = spawn4(command, args2, { detached: true, stdio: "ignore" });
   child.unref();
 }
 function remoteRequest(command) {
@@ -13072,7 +14200,7 @@ async function runRunnerCommand(command, commandArgs, configPath) {
 async function runRunnerEarly(configPath) {
   const action = args[1] ?? "list";
   if (action === "list") {
-    for (const manifest of (await import("./runner-registry-M776E3SE.js")).runnerManifests())
+    for (const manifest of (await import("./runner-registry-GD4BYCQC.js")).runnerManifests())
       console.log(`${manifest.id.padEnd(16)} ${manifest.description}`);
     return;
   }
@@ -13132,7 +14260,7 @@ async function runRunnerManagement(config, configPath) {
         throw new Error("usage: goah runner profile assign AGENT PROFILE");
       if (!config.runnerProfiles?.some((profile) => profile.id === profileId))
         throw new Error(`Runner Profile not found: ${profileId}`);
-      const raw = JSON.parse(readFileSync2(resolve3(configPath), "utf8"));
+      const raw = JSON.parse(readFileSync3(resolve3(configPath), "utf8"));
       const target = raw.profiles?.find((profile) => profile.agent === agent);
       if (!target)
         throw new Error(`Agent profile not found: ${agent}`);
@@ -13173,12 +14301,12 @@ async function runDaemonCommand(config, configPath) {
     return;
   }
   if (action === "logs") {
-    const path4 = join6(config.stateDir, "daemon.log");
+    const path4 = join7(config.stateDir, "daemon.log");
     if (!existsSync3(path4)) {
       console.log(`No daemon log at ${path4}`);
       return;
     }
-    console.log(readFileSync2(path4, "utf8").split("\n").slice(-100).join("\n"));
+    console.log(readFileSync3(path4, "utf8").split("\n").slice(-100).join("\n"));
     return;
   }
   if (action === "stop" || action === "restart") {
@@ -13211,7 +14339,7 @@ function stdioInteraction() {
   };
 }
 function packageVersion() {
-  return JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8")).version;
+  return JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8")).version;
 }
 function closestCommand(value) {
   let best = null;