terminal-pilot 0.0.27 → 0.0.29

package/dist/cli.js

@@ -65,12 +65,12 @@ var styleNames = Object.keys(ansiStyles);
 function replaceAll(value, search, replacement) {
   return value.split(search).join(replacement);
 }
-function applyStyles(text5, styles) {
+function applyStyles(text4, styles) {
   if (!supportsColor() || styles.length === 0) {
-    return text5;
+    return text4;
   }
   const open = styles.map((style) => style.open).join("");
-  const output = text5.includes(reset) ? replaceAll(text5, reset, `${reset}${open}`) : text5;
+  const output = text4.includes(reset) ? replaceAll(text4, reset, `${reset}${open}`) : text4;
   return `${open}${output}${reset}`;
 }
 function clampRgb(value) {
@@ -114,7 +114,7 @@ function bgRgbStyle(red, green, blue) {
   };
 }
 function createColor(styles = []) {
-  const builder = ((text5) => applyStyles(String(text5), styles));
+  const builder = ((text4) => applyStyles(String(text4), styles));
   for (const name of styleNames) {
     Object.defineProperty(builder, name, {
       configurable: true,
@@ -196,24 +196,24 @@ function createPalette(activeBrand, mode) {
     const number2 = isPurple ? color.hex("#0077cc") : active2;
     return withStyles(
       {
-        header: (text5) => active2.bold(text5),
-        divider: (text5) => color.hex("#666666")(text5),
-        prompt: (text5) => prompt2.bold(text5),
-        number: (text5) => number2.bold(text5),
-        intro: (text5) => color.bgHex(activeBrand.primary).white(` ${getThemeConfig().label} - ${text5} `),
+        header: (text4) => active2.bold(text4),
+        divider: (text4) => color.hex("#666666")(text4),
+        prompt: (text4) => prompt2.bold(text4),
+        number: (text4) => number2.bold(text4),
+        intro: (text4) => color.bgHex(activeBrand.primary).white(` ${getThemeConfig().label} - ${text4} `),
         get resolvedSymbol() {
           return active2("\u25C7");
         },
         get errorSymbol() {
           return color.hex("#cc0000")("\u25A0");
         },
-        accent: (text5) => prompt2.bold(text5),
-        muted: (text5) => color.hex("#666666")(text5),
-        success: (text5) => color.hex("#008800")(text5),
-        warning: (text5) => color.hex("#cc6600")(text5),
-        error: (text5) => color.hex("#cc0000")(text5),
-        info: (text5) => active2(text5),
-        badge: (text5) => color.bgHex("#cc6600").white(` ${text5} `)
+        accent: (text4) => prompt2.bold(text4),
+        muted: (text4) => color.hex("#666666")(text4),
+        success: (text4) => color.hex("#008800")(text4),
+        warning: (text4) => color.hex("#cc6600")(text4),
+        error: (text4) => color.hex("#cc0000")(text4),
+        info: (text4) => active2(text4),
+        badge: (text4) => color.bgHex("#cc6600").white(` ${text4} `)
       },
       {
         accent: { fg: isPurple ? "#006699" : activeBrand.primary, bold: true },
@@ -232,24 +232,24 @@ function createPalette(activeBrand, mode) {
   const number = isPurple ? color.cyanBright : active;
   return withStyles(
     {
-      header: (text5) => activeBright.bold(text5),
-      divider: (text5) => color.dim(text5),
-      prompt: (text5) => prompt(text5),
-      number: (text5) => number(text5),
-      intro: (text5) => activeBackground.white(` ${getThemeConfig().label} - ${text5} `),
+      header: (text4) => activeBright.bold(text4),
+      divider: (text4) => color.dim(text4),
+      prompt: (text4) => prompt(text4),
+      number: (text4) => number(text4),
+      intro: (text4) => activeBackground.white(` ${getThemeConfig().label} - ${text4} `),
       get resolvedSymbol() {
         return active("\u25C7");
       },
       get errorSymbol() {
         return color.red("\u25A0");
       },
-      accent: (text5) => prompt(text5),
-      muted: (text5) => color.dim(text5),
-      success: (text5) => color.green(text5),
-      warning: (text5) => color.yellow(text5),
-      error: (text5) => color.red(text5),
-      info: (text5) => active(text5),
-      badge: (text5) => color.bgYellow.black(` ${text5} `)
+      accent: (text4) => prompt(text4),
+      muted: (text4) => color.dim(text4),
+      success: (text4) => color.green(text4),
+      warning: (text4) => color.yellow(text4),
+      error: (text4) => color.red(text4),
+      info: (text4) => active(text4),
+      badge: (text4) => color.bgYellow.black(` ${text4} `)
     },
     {
       accent: { fg: isPurple ? "cyan" : activeBrand.primary, bold: true },
@@ -266,11 +266,11 @@ var light = createPalette(brands.purple, "light");
 
 // ../toolcraft-design/src/tokens/typography.ts
 var typography = {
-  bold: (text5) => color.bold(text5),
-  dim: (text5) => color.dim(text5),
-  italic: (text5) => color.italic(text5),
-  underline: (text5) => color.underline(text5),
-  strikethrough: (text5) => color.strikethrough(text5)
+  bold: (text4) => color.bold(text4),
+  dim: (text4) => color.dim(text4),
+  italic: (text4) => color.italic(text4),
+  underline: (text4) => color.underline(text4),
+  strikethrough: (text4) => color.strikethrough(text4)
 };
 
 // ../toolcraft-design/src/tokens/widths.ts
@@ -541,7 +541,7 @@ function renderMarkdownInline2(value) {
   return stripAnsi(value).replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
 }
 function writeTerminalMessage(msg, {
-  symbol = color.gray("\u2502"),
+  symbol: symbol2 = color.gray("\u2502"),
   secondarySymbol = color.gray("\u2502"),
   spacing: spacing2 = 1,
   withGuide = true
@@ -549,7 +549,7 @@ function writeTerminalMessage(msg, {
   const lines = [];
   const showGuide = withGuide !== false;
   const contentLines = msg.split("\n");
-  const prefix = showGuide ? `${symbol}  ` : "";
+  const prefix = showGuide ? `${symbol2}  ` : "";
   const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
   const emptyGuide = showGuide ? secondarySymbol : "";
   for (let index = 0; index < spacing2; index += 1) {
@@ -563,7 +563,7 @@ function writeTerminalMessage(msg, {
   if (firstLine.length > 0) {
     lines.push(`${prefix}${firstLine}`);
   } else {
-    lines.push(showGuide ? symbol : "");
+    lines.push(showGuide ? symbol2 : "");
   }
   for (const line of continuationLines) {
     if (line.length > 0) {
@@ -713,12 +713,12 @@ function createLogger(emitter) {
       log.message(`${label}
    ${value}`, { symbol: symbols.errorResolved });
     },
-    message(message2, symbol) {
+    message(message2, symbol2) {
       if (emitter) {
         emitter(message2);
         return;
       }
-      log.message(message2, { symbol: symbol ?? color.gray("\u2502") });
+      log.message(message2, { symbol: symbol2 ?? color.gray("\u2502") });
     }
   };
 }
@@ -1521,18 +1521,18 @@ function getStandalone(template, tagStart, tagEnd, kind) {
   if (!isWhitespace3(template.slice(lineStart, tagStart))) {
     return void 0;
   }
-  let cursor = tagEnd;
-  while (cursor < template.length && (template[cursor] === " " || template[cursor] === "	")) {
-    cursor += 1;
+  let cursor2 = tagEnd;
+  while (cursor2 < template.length && (template[cursor2] === " " || template[cursor2] === "	")) {
+    cursor2 += 1;
   }
-  if (template.startsWith("\r\n", cursor)) {
-    return { lineStart, nextIndex: cursor + 2 };
+  if (template.startsWith("\r\n", cursor2)) {
+    return { lineStart, nextIndex: cursor2 + 2 };
   }
-  if (template[cursor] === "\n") {
-    return { lineStart, nextIndex: cursor + 1 };
+  if (template[cursor2] === "\n") {
+    return { lineStart, nextIndex: cursor2 + 1 };
   }
-  if (cursor === template.length) {
-    return { lineStart, nextIndex: cursor };
+  if (cursor2 === template.length) {
+    return { lineStart, nextIndex: cursor2 };
   }
   return void 0;
 }
@@ -1630,13 +1630,13 @@ function lookup(context, name) {
   if (name === ".") {
     return { hit: true, value: callLambda(context.view, context.view) };
   }
-  let cursor = context;
-  while (cursor !== void 0) {
-    const result = name.includes(".") ? lookupDotted(cursor.view, name) : lookupName(cursor.view, name);
+  let cursor2 = context;
+  while (cursor2 !== void 0) {
+    const result = name.includes(".") ? lookupDotted(cursor2.view, name) : lookupName(cursor2.view, name);
     if (result.hit) {
-      return { hit: true, value: callLambda(result.value, cursor.view) };
+      return { hit: true, value: callLambda(result.value, cursor2.view) };
     }
-    cursor = cursor.parent;
+    cursor2 = cursor2.parent;
   }
   return { hit: false, value: void 0 };
 }
@@ -1800,6 +1800,12 @@ function hasProperty(value, key2) {
 import { spawn } from "node:child_process";
 import process2 from "node:process";
 
+// ../frontmatter/src/parse.ts
+import { LineCounter, parse, parseDocument } from "yaml";
+
+// ../frontmatter/src/stringify.ts
+import { stringify } from "yaml";
+
 // ../toolcraft-design/src/acp/writer.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
@@ -1820,11 +1826,629 @@ var REGION_MODAL = 1 << 4;
 var REGION_TOAST = 1 << 5;
 var REGION_ALL = REGION_HEADER | REGION_LIST | REGION_DETAIL | REGION_FOOTER | REGION_MODAL | REGION_TOAST;
 
-// ../toolcraft-design/src/prompts/index.ts
-import * as clack from "@clack/prompts";
+// ../toolcraft-design/src/prompts/interactive/glyphs.ts
+function supportsUnicode() {
+  if (!process.platform.startsWith("win")) {
+    return process.env.TERM !== "linux";
+  }
+  return Boolean(
+    process.env.CI || process.env.WT_SESSION || process.env.TERMINUS_SUBLIME || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm"
+  );
+}
+var UNICODE = supportsUnicode();
+function glyph(unicode, ascii) {
+  return UNICODE ? unicode : ascii;
+}
+var GLYPHS = {
+  stepActive: glyph("\u25C6", "*"),
+  stepCancel: glyph("\u25A0", "x"),
+  stepError: glyph("\u25B2", "x"),
+  stepSubmit: glyph("\u25C7", "o"),
+  barStart: glyph("\u250C", "T"),
+  bar: glyph("\u2502", "|"),
+  barEnd: glyph("\u2514", "-"),
+  radioActive: glyph("\u25CF", ">"),
+  radioInactive: glyph("\u25CB", " "),
+  checkboxActive: glyph("\u25FB", "[ ]"),
+  checkboxSelected: glyph("\u25FC", "[+]"),
+  checkboxInactive: glyph("\u25FB", "[ ]"),
+  passwordMask: glyph("\u2022", "*"),
+  ellipsis: "..."
+};
+function symbol(state) {
+  if (state === "cancel") return color.red(GLYPHS.stepCancel);
+  if (state === "error") return color.yellow(GLYPHS.stepError);
+  if (state === "submit") return color.green(GLYPHS.stepSubmit);
+  return color.cyan(GLYPHS.stepActive);
+}
+function symbolBar(state) {
+  if (state === "cancel") return color.red(GLYPHS.bar);
+  if (state === "error") return color.yellow(GLYPHS.bar);
+  if (state === "submit") return color.green(GLYPHS.bar);
+  return color.cyan(GLYPHS.bar);
+}
+
+// ../toolcraft-design/src/prompts/interactive/core.ts
+import { EventEmitter } from "node:events";
+import * as readline2 from "node:readline";
+
+// ../toolcraft-design/src/prompts/interactive/cancel-symbol.ts
+var CANCEL = /* @__PURE__ */ Symbol.for("poe.cancel");
+function isCancel(value) {
+  return value === CANCEL;
+}
+
+// ../toolcraft-design/src/prompts/interactive/keys.ts
+var aliases = {
+  k: "up",
+  j: "down",
+  h: "left",
+  l: "right"
+};
+var keyActions = {
+  up: "up",
+  down: "down",
+  left: "left",
+  right: "right",
+  space: "space",
+  return: "enter",
+  enter: "enter",
+  escape: "cancel"
+};
+function mapKey(name, char) {
+  if (char === "") {
+    return "cancel";
+  }
+  if (char === " ") {
+    return "space";
+  }
+  if (!name) {
+    return void 0;
+  }
+  return keyActions[name] ?? aliases[name];
+}
+
+// ../toolcraft-design/src/prompts/interactive/wrap.ts
+import { wrapAnsi } from "fast-wrap-ansi";
+import stringWidth from "fast-string-width";
+function getColumns(output) {
+  return Math.max(1, output.columns ?? 80);
+}
+function getRows(output) {
+  return Math.max(1, output.rows ?? 20);
+}
+function wrapFrame(output, frame) {
+  return wrapAnsi(frame, getColumns(output), { hard: true, trim: false });
+}
+
+// ../toolcraft-design/src/prompts/interactive/core.ts
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  move: (x, y) => {
+    let output = "";
+    if (x < 0) output += `\x1B[${-x}D`;
+    if (x > 0) output += `\x1B[${x}C`;
+    if (y < 0) output += `\x1B[${-y}A`;
+    if (y > 0) output += `\x1B[${y}B`;
+    return output;
+  }
+};
+var erase = {
+  down: "\x1B[J"
+};
+var Prompt = class extends EventEmitter {
+  state = "initial";
+  value;
+  error = "";
+  userInput = "";
+  _cursor = 0;
+  input;
+  output;
+  renderFrame;
+  validate;
+  signal;
+  trackValue;
+  previousFrame = "";
+  readlineInterface;
+  abortListener;
+  closed = false;
+  constructor(opts, trackValue = true) {
+    super();
+    this.input = opts.input ?? process.stdin;
+    this.output = opts.output ?? process.stdout;
+    this.renderFrame = opts.render;
+    this.validate = opts.validate;
+    this.signal = opts.signal;
+    this.value = opts.initialValue;
+    this.trackValue = trackValue;
+    this.userInput = opts.initialUserInput ?? "";
+    this._cursor = this.userInput.length;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  prompt() {
+    if (this.signal?.aborted) {
+      this.state = "cancel";
+      return Promise.resolve(CANCEL);
+    }
+    if (this.input.isTTY !== true) {
+      return this.promptNonTty();
+    }
+    return new Promise((resolve) => {
+      const onSubmit = (value) => resolve(value);
+      const onCancel = () => resolve(CANCEL);
+      this.once("submit", onSubmit);
+      this.once("cancel", onCancel);
+      this.abortListener = () => {
+        this.state = "cancel";
+        this.emit("finalize");
+        this.render();
+        this.close();
+      };
+      this.signal?.addEventListener("abort", this.abortListener, { once: true });
+      this.readlineInterface = readline2.createInterface({
+        input: this.input,
+        output: void 0,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      });
+      readline2.emitKeypressEvents(this.input, this.readlineInterface);
+      this.readlineInterface.prompt();
+      this.input.on("keypress", this.onKeypress);
+      if (this.input.setRawMode) {
+        this.input.setRawMode(true);
+      }
+      this.output.on("resize", this.render);
+      this.render();
+    });
+  }
+  promptNonTty() {
+    return Promise.reject(new Error("Interactive prompt requires a TTY. Set POE_NO_PROMPT=1 to accept defaults non-interactively."));
+  }
+  readNonTtyLine() {
+    return new Promise((resolve) => {
+      const rl = readline2.createInterface({ input: this.input, terminal: false });
+      let settled = false;
+      const settle = (value) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        rl.close();
+        resolve(value);
+      };
+      rl.once("line", settle);
+      rl.once("close", () => settle(rl.line));
+    });
+  }
+  setValue(value) {
+    this.value = value;
+    this.emit("value", value);
+  }
+  setError(message2) {
+    this.error = message2;
+  }
+  setUserInput(value) {
+    this.userInput = value;
+    this._cursor = Math.min(this._cursor, this.userInput.length);
+    this.emit("userInput", this.userInput);
+  }
+  clearUserInput() {
+    this.userInput = "";
+    this._cursor = 0;
+    this.emit("userInput", this.userInput);
+  }
+  onKeypress = (char, key2 = {}) => {
+    let action = mapKey(key2.name, char);
+    if (this.trackValue && char && char >= " " && key2.name !== "return" && key2.name !== "enter" && key2.name !== "escape") {
+      action = void 0;
+    }
+    if (this.trackValue && action !== "enter") {
+      this.updateTrackedInput(char, key2, action);
+    }
+    if (this.state === "error") {
+      this.state = "active";
+      this.error = "";
+    }
+    if (!this.trackValue && action) {
+      this.emit("cursor", action);
+    } else if (this.trackValue && action && action !== "enter") {
+      this.emit("cursor", action);
+    }
+    if (char && /^[yn]$/i.test(char)) {
+      this.emit("confirm", char.toLowerCase() === "y");
+    }
+    if (char) {
+      this.emit("key", char.toLowerCase(), key2);
+    }
+    if (action === "enter") {
+      const error3 = this.validate?.(this.value);
+      if (error3) {
+        this.error = error3 instanceof Error ? error3.message : error3;
+        this.state = "error";
+      } else {
+        this.state = "submit";
+      }
+    }
+    if (action === "cancel") {
+      this.state = "cancel";
+    }
+    if (this.state === "submit" || this.state === "cancel") {
+      this.emit("finalize");
+    }
+    this.render();
+    if (this.state === "submit" || this.state === "cancel") {
+      this.close();
+    }
+  };
+  updateTrackedInput(char, key2, action) {
+    if (key2.ctrl) {
+      if (key2.name === "a") {
+        this._cursor = 0;
+        return;
+      }
+      if (key2.name === "e") {
+        this._cursor = this.userInput.length;
+        return;
+      }
+      if (key2.name === "u") {
+        this.userInput = this.userInput.slice(this._cursor);
+        this._cursor = 0;
+        this.emit("userInput", this.userInput);
+        return;
+      }
+      if (key2.name === "k") {
+        this.userInput = this.userInput.slice(0, this._cursor);
+        this.emit("userInput", this.userInput);
+        return;
+      }
+    }
+    if (action === "left") {
+      this._cursor = Math.max(0, this._cursor - 1);
+      return;
+    }
+    if (action === "right") {
+      this._cursor = Math.min(this.userInput.length, this._cursor + 1);
+      return;
+    }
+    if (action === "cancel" || action === "up" || action === "down" || action === "space") {
+      return;
+    }
+    if (key2.name === "backspace" || char === "\b" || char === "\x7F") {
+      if (this._cursor > 0) {
+        this.userInput = `${this.userInput.slice(0, this._cursor - 1)}${this.userInput.slice(this._cursor)}`;
+        this._cursor -= 1;
+        this.emit("userInput", this.userInput);
+      }
+      return;
+    }
+    if (key2.name === "delete") {
+      if (this._cursor < this.userInput.length) {
+        this.userInput = `${this.userInput.slice(0, this._cursor)}${this.userInput.slice(this._cursor + 1)}`;
+        this.emit("userInput", this.userInput);
+      }
+      return;
+    }
+    if (!char || char < " " || key2.ctrl) {
+      return;
+    }
+    this.userInput = `${this.userInput.slice(0, this._cursor)}${char}${this.userInput.slice(this._cursor)}`;
+    this._cursor += char.length;
+    this.emit("userInput", this.userInput);
+  }
+  render = () => {
+    if (this.closed) {
+      return;
+    }
+    const frame = wrapFrame(this.output, this.renderFrame(this) ?? "");
+    if (frame === this.previousFrame) {
+      return;
+    }
+    if (!this.previousFrame) {
+      this.output.write(`${cursor.hide}${frame}`);
+      this.previousFrame = frame;
+      if (this.state === "initial") {
+        this.state = "active";
+      }
+      return;
+    }
+    const previousLineCount = this.previousFrame.split("\n").length - 1;
+    this.output.write(`${cursor.move(-999, -previousLineCount)}${erase.down}${frame}`);
+    this.previousFrame = frame;
+  };
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.input.removeListener("keypress", this.onKeypress);
+    this.output.removeListener("resize", this.render);
+    if (this.abortListener) {
+      this.signal?.removeEventListener("abort", this.abortListener);
+    }
+    this.output.write(`${cursor.show}
+`);
+    if (!process.platform.startsWith("win") && this.input.setRawMode) {
+      this.input.setRawMode(false);
+    }
+    this.readlineInterface?.close();
+    this.input.unpipe?.();
+    if (this.state === "cancel") {
+      this.emit("cancel");
+    } else {
+      this.emit("submit", this.value);
+    }
+    this.removeAllListeners();
+  }
+};
+
+// ../toolcraft-design/src/prompts/interactive/confirm.ts
+var ConfirmPrompt = class extends Prompt {
+  constructor(opts) {
+    super({
+      ...opts,
+      initialValue: opts.initialValue ?? true,
+      render: (prompt) => renderConfirmPrompt(prompt, opts)
+    }, false);
+    this.on("confirm", (value) => {
+      this.setValue(value);
+      this.state = "submit";
+      this.emit("finalize");
+      this.render();
+      this.close();
+    });
+    this.on("cursor", (action) => {
+      if (action === "up" || action === "down" || action === "left" || action === "right") {
+        this.setValue(!this.value);
+      }
+    });
+  }
+  promptNonTty() {
+    if (process.env.POE_NO_PROMPT === "1") {
+      return Promise.resolve(this.value ?? true);
+    }
+    return super.promptNonTty();
+  }
+};
+function choices(value) {
+  const yes = value ? `${color.green(GLYPHS.radioActive)} ${color.bold("Yes")}` : `${color.dim(GLYPHS.radioInactive)} ${color.dim("Yes")}`;
+  const no = value ? `${color.dim(GLYPHS.radioInactive)} ${color.dim("No")}` : `${color.green(GLYPHS.radioActive)} ${color.bold("No")}`;
+  return `${yes} ${color.dim("/")} ${no}`;
+}
+function renderConfirmPrompt(prompt, opts) {
+  if (prompt.state === "submit") {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}
+${color.gray(GLYPHS.bar)}  ${color.dim(prompt.value ? "Yes" : "No")}
+${color.green(GLYPHS.barEnd)}`;
+  }
+  if (prompt.state === "cancel") {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}
+${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(prompt.value ? "Yes" : "No")}
+${color.red(GLYPHS.barEnd)}`;
+  }
+  return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}
+${symbolBar(prompt.state)}  ${choices(prompt.value)}
+${color.cyan(GLYPHS.barEnd)}`;
+}
+function confirmPrompt(opts) {
+  return new ConfirmPrompt(opts).prompt();
+}
+
+// ../toolcraft-design/src/prompts/interactive/pagination.ts
+import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+function countLines(values) {
+  return values.reduce((sum, value) => sum + value.split("\n").length, 0);
+}
+function trimToRows(values, cursorOffset, rows, hasTop, hasBottom) {
+  const output = [...values];
+  while (countLines(output) > rows && output.length > 1) {
+    const removeFromTop = hasTop && cursorOffset > 0;
+    const removeFromBottom = hasBottom && cursorOffset < output.length - 1;
+    if (removeFromTop) {
+      output.shift();
+      cursorOffset -= 1;
+    } else if (removeFromBottom) {
+      output.pop();
+    } else {
+      output.pop();
+    }
+  }
+  return output;
+}
+function limitOptions(opts) {
+  const {
+    cursor: cursor2,
+    options,
+    style,
+    output,
+    maxItems = Number.POSITIVE_INFINITY,
+    columnPadding = 0,
+    rowPadding = 4
+  } = opts;
+  if (options.length === 0) {
+    return [];
+  }
+  const columns = Math.max(1, getColumns(output) - columnPadding);
+  const rowBudget = Math.max(getRows(output) - rowPadding, 0);
+  const visibleCount = Math.max(Math.min(maxItems, rowBudget), 5);
+  const cappedVisibleCount = Math.min(visibleCount, options.length);
+  let start = 0;
+  if (cursor2 >= cappedVisibleCount - 3) {
+    start = Math.max(Math.min(cursor2 - cappedVisibleCount + 3, options.length - cappedVisibleCount), 0);
+  }
+  const hasTopMarker = cappedVisibleCount < options.length && start > 0;
+  const hasBottomMarker = cappedVisibleCount < options.length && start + cappedVisibleCount < options.length;
+  const visible = options.slice(start, start + cappedVisibleCount).map((option, index) => wrapAnsi2(style(option, start + index === cursor2), columns, { hard: true, trim: false }));
+  const trimmed = trimToRows(
+    visible,
+    Math.max(cursor2 - start, 0),
+    Math.max(rowBudget - Number(hasTopMarker) - Number(hasBottomMarker), 1),
+    hasTopMarker,
+    hasBottomMarker
+  );
+  if (hasTopMarker) {
+    trimmed.unshift(color.dim(GLYPHS.ellipsis));
+  }
+  if (hasBottomMarker) {
+    trimmed.push(color.dim(GLYPHS.ellipsis));
+  }
+  return trimmed;
+}
+
+// ../toolcraft-design/src/prompts/interactive/select.ts
+var SelectPrompt = class extends Prompt {
+  options;
+  constructor(opts) {
+    if (opts.options.length === 0) {
+      throw new Error("Select prompt requires at least one option.");
+    }
+    if (opts.options.every((option) => option.disabled)) {
+      throw new Error("Select prompt requires at least one enabled option.");
+    }
+    const initialIndex = Math.max(opts.options.findIndex((option) => option.value === opts.initialValue), 0);
+    const cursor2 = findNonDisabled(initialIndex, 1, opts.options);
+    super({
+      ...opts,
+      initialValue: opts.options[cursor2]?.value,
+      render: (prompt) => renderSelectPrompt(prompt, opts)
+    }, false);
+    this.options = opts.options;
+    this._cursor = cursor2;
+    this.setValue(this.options[this._cursor]?.value);
+    this.on("cursor", (action) => {
+      if (action === "up" || action === "left") {
+        this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+      } else if (action === "down" || action === "right") {
+        this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+      }
+      this.setValue(this.options[this._cursor]?.value);
+    });
+  }
+  get visibleOptions() {
+    return this.options;
+  }
+  promptNonTty() {
+    if (process.env.POE_NO_PROMPT === "1") {
+      return Promise.resolve(this.value);
+    }
+    return super.promptNonTty();
+  }
+};
+function findNonDisabled(start, direction, options) {
+  if (options.every((option) => option.disabled)) {
+    return start;
+  }
+  let index = start;
+  for (let checked = 0; checked < options.length; checked += 1) {
+    index = (index + options.length) % options.length;
+    if (!options[index]?.disabled) {
+      return index;
+    }
+    index += direction;
+  }
+  return start;
+}
+function renderOption(option, active, submitted, cancelled) {
+  const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+  if (submitted) return color.dim(option.label);
+  if (cancelled) return color.dim.strikethrough(option.label);
+  if (option.disabled) return `${color.gray(GLYPHS.radioInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+  if (active) return `${color.green(GLYPHS.radioActive)} ${option.label}${hint}`;
+  return `${color.dim(GLYPHS.radioInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderSelectPrompt(prompt, opts) {
+  if (prompt.state === "submit" || prompt.state === "cancel") {
+    const option = prompt.visibleOptions[prompt.cursor];
+    const rendered = option ? renderOption(option, false, prompt.state === "submit", prompt.state === "cancel") : "";
+    const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}
+${color.gray(GLYPHS.bar)}  ${rendered}
+${end}`;
+  }
+  const lines = limitOptions({
+    cursor: prompt.cursor,
+    options: prompt.visibleOptions,
+    output: opts.output ?? process.stdout,
+    maxItems: opts.maxItems,
+    columnPadding: 3,
+    style: (option, active) => renderOption(option, active, false, false)
+  }).map((line) => `${color.cyan(GLYPHS.bar)}  ${line}`);
+  return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}
+${lines.join("\n")}
+${color.cyan(GLYPHS.barEnd)}`;
+}
+function selectPrompt(opts) {
+  return new SelectPrompt(opts).prompt();
+}
+
+// ../toolcraft-design/src/prompts/interactive/text.ts
+var TextPrompt = class extends Prompt {
+  constructor(opts) {
+    const initialUserInput = opts.initialValue ?? "";
+    super({
+      ...opts,
+      initialValue: initialUserInput,
+      initialUserInput,
+      render: (prompt) => renderTextPrompt(prompt, opts),
+      validate: opts.validate
+    });
+    this.on("userInput", (value) => this.setValue(value));
+    this.on("finalize", () => {
+      if (this.state === "submit") {
+        this.setValue(this.value || opts.defaultValue || "");
+      }
+    });
+  }
+  get userInputWithCursor() {
+    if (this.state === "submit") {
+      return this.userInput;
+    }
+    const before = this.userInput.slice(0, this.cursor);
+    const current = this.userInput[this.cursor];
+    const after = this.userInput.slice(this.cursor + 1);
+    if (current) {
+      return `${before}${color.inverse(current)}${after}`;
+    }
+    return `${before}${color.inverse("\u2588")}`;
+  }
+  promptNonTty() {
+    return this.readNonTtyLine();
+  }
+};
+function renderHeader2(prompt, message2) {
+  return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message2}`;
+}
+function renderTextPrompt(prompt, opts) {
+  const value = prompt.value ?? "";
+  if (prompt.state === "submit") {
+    return `${renderHeader2(prompt, opts.message)}
+${color.gray(GLYPHS.bar)}  ${color.dim(value)}
+${color.green(GLYPHS.barEnd)}`;
+  }
+  if (prompt.state === "cancel") {
+    return `${renderHeader2(prompt, opts.message)}
+${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}
+${color.red(GLYPHS.barEnd)}`;
+  }
+  const input = prompt.userInput.length > 0 ? prompt.userInputWithCursor : opts.placeholder ? `${color.inverse(opts.placeholder[0] ?? " ")}${color.dim(opts.placeholder.slice(1))}` : color.inverse("_");
+  if (prompt.state === "error") {
+    return `${renderHeader2(prompt, opts.message)}
+${symbolBar(prompt.state)}  ${input}
+${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+  }
+  return `${renderHeader2(prompt, opts.message)}
+${symbolBar(prompt.state)}  ${input}
+${color.cyan(GLYPHS.barEnd)}`;
+}
+function textPrompt(opts) {
+  return new TextPrompt(opts).prompt();
+}
 
 // ../toolcraft-design/src/prompts/primitives/cancel.ts
-import { isCancel } from "@clack/prompts";
 function cancel(msg = "") {
   if (resolveOutputFormat() !== "terminal") {
     return;
@@ -1887,14 +2511,14 @@ function note(message2, title) {
 var SPINNER_FRAMES = Object.freeze(["\u25D2", "\u25D0", "\u25D3", "\u25D1"]);
 
 // ../toolcraft-design/src/prompts/index.ts
-async function select2(opts) {
-  return clack.select(opts);
+async function select(opts) {
+  return selectPrompt(opts);
 }
-async function text3(opts) {
-  return clack.text(opts);
+async function text2(opts) {
+  return textPrompt(opts);
 }
-async function confirm2(opts) {
-  return clack.confirm(opts);
+async function confirm(opts) {
+  return confirmPrompt(opts);
 }
 
 // ../toolcraft/src/index.ts
@@ -2269,6 +2893,12 @@ function cloneRequires(requires) {
 function cloneStringArray(values) {
   return values === void 0 ? void 0 : [...values];
 }
+function cloneCommandExamples(examples) {
+  return (examples ?? []).map((example) => ({
+    title: example.title,
+    params: { ...example.params }
+  }));
+}
 function cloneStringRecord(values) {
   return values === void 0 ? void 0 : { ...values };
 }
@@ -2533,9 +3163,11 @@ function createBaseCommand(config2) {
     kind: "command",
     name: config2.name,
     description: config2.description,
+    examples: cloneCommandExamples(config2.examples),
     aliases: [...config2.aliases ?? []],
     positional: [...config2.positional ?? []],
     params: config2.params,
+    result: config2.result,
     secrets: cloneSecrets(config2.secrets),
     scope: resolveCommandScope(config2.scope, void 0),
     confirm: config2.confirm ?? false,
@@ -2547,6 +3179,8 @@ function createBaseCommand(config2) {
   Object.defineProperty(command, commandConfigSymbol, {
     value: {
       scope: cloneScope(config2.scope),
+      examples: cloneCommandExamples(config2.examples),
+      result: config2.result,
       humanInLoop: config2.humanInLoop,
       secrets: cloneSecrets(config2.secrets),
       requires: cloneRequires(config2.requires),
@@ -2595,9 +3229,11 @@ function materializeCommand(command, inherited) {
     kind: "command",
     name: command.name,
     description: command.description,
+    examples: cloneCommandExamples(internal.examples),
     aliases: [...command.aliases],
     positional: [...command.positional],
     params: command.params,
+    result: internal.result,
     secrets: mergeSecrets(inherited.secrets, internal.secrets),
     scope: resolveCommandScope(internal.scope, inherited.scope),
     confirm: command.confirm,
@@ -2609,6 +3245,8 @@ function materializeCommand(command, inherited) {
   Object.defineProperty(materialized, commandConfigSymbol, {
     value: {
       scope: cloneScope(internal.scope),
+      examples: cloneCommandExamples(internal.examples),
+      result: internal.result,
       humanInLoop: internal.humanInLoop,
       secrets: cloneSecrets(internal.secrets),
       requires: cloneRequires(internal.requires),
@@ -2850,7 +3488,7 @@ var AnchorNotFoundError = class extends Error {
 };
 
 // ../task-list/src/backends/gh-issues-client.ts
-import { text as text4 } from "node:stream/consumers";
+import { text as text3 } from "node:stream/consumers";
 
 // ../process-runner/src/docker/context.ts
 import { execSync } from "node:child_process";
@@ -3059,8 +3697,8 @@ async function resolveAuth(options) {
     stderr: "pipe"
   });
   const [stdout, , result] = await Promise.all([
-    handle.stdout === null ? Promise.resolve("") : text4(handle.stdout),
-    handle.stderr === null ? Promise.resolve("") : text4(handle.stderr),
+    handle.stdout === null ? Promise.resolve("") : text3(handle.stdout),
+    handle.stderr === null ? Promise.resolve("") : text3(handle.stderr),
     handle.result
   ]);
   const token = stdout.trim();
@@ -4259,7 +4897,7 @@ function parseQualifiedId(qualifiedId, listName) {
 
 // ../task-list/src/backends/markdown-dir.ts
 import path7 from "node:path";
-import { parseDocument, stringify } from "yaml";
+import { parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 
 // ../task-list/src/schema/task.schema.json
 var task_schema_default = {
@@ -4450,7 +5088,7 @@ function splitTaskDocument(content, filePath, mode) {
   };
 }
 function readFrontmatter(frontmatterContent, filePath) {
-  const document = parseDocument(frontmatterContent);
+  const document = parseDocument2(frontmatterContent);
   if (document.errors.length > 0) {
     throw malformedTask(filePath, "frontmatter");
   }
@@ -4520,7 +5158,7 @@ function createTask(list, id, frontmatter, body, mode, sourcePath) {
 }
 function serializeTaskDocument(frontmatter, description) {
   return `---
-${stringify(frontmatter)}---
+${stringify2(frontmatter)}---
 
 ${description}`;
 }
@@ -5258,7 +5896,7 @@ async function markdownDirBackend(deps) {
 
 // ../task-list/src/backends/yaml-file.ts
 import path8 from "node:path";
-import { isMap, parseDocument as parseDocument2 } from "yaml";
+import { isMap, parseDocument as parseDocument3 } from "yaml";
 
 // ../task-list/src/schema/store.schema.json
 var store_schema_default = {
@@ -5435,7 +6073,7 @@ function buildFiredTaskRecord(existing, to, metadataPatch) {
 function parseStoreDocument(filePath, content) {
   let document;
   try {
-    document = parseDocument2(content, { keepSourceTokens: true, prettyErrors: false });
+    document = parseDocument3(content, { keepSourceTokens: true, prettyErrors: false });
   } catch {
     throw malformedStore(filePath, "yaml");
   }
@@ -5612,7 +6250,7 @@ async function ensureStorePath(deps) {
     deps.fs,
     deps.path,
     serializeDocument(
-      parseDocument2(
+      parseDocument3(
         [
           `$schema: ${STORE_SCHEMA_ID}`,
           `kind: ${STORE_KIND}`,
@@ -7616,8 +8254,8 @@ function validateAuthorizationCallbackBinding(callback, expected) {
 function createAuthorizationError(error3, description) {
   return new Error(`OAuth authorization failed: ${error3} \u2014 ${description}`);
 }
-function escapeHtml2(text5) {
-  return text5.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+function escapeHtml2(text4) {
+  return text4.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function buildSuccessPage(landingPage) {
   const title = landingPage?.title ?? "Connected";
@@ -10164,6 +10802,9 @@ function isCallToolResult(value) {
   if (!isObjectRecord5(value) || !Array.isArray(value.content)) {
     return false;
   }
+  if (value.structuredContent !== void 0 && !isObjectRecord5(value.structuredContent)) {
+    return false;
+  }
   if (value.isError !== void 0 && typeof value.isError !== "boolean") {
     return false;
   }
@@ -10903,13 +11544,13 @@ var proxyNodeSymbol = /* @__PURE__ */ Symbol("toolcraft.mcpProxyNode");
 var proxyConnectionSymbol = /* @__PURE__ */ Symbol("toolcraft.mcpProxyConnection");
 var shutdownDisposers = /* @__PURE__ */ new Set();
 function getInternalGroupConfig2(group) {
-  const symbol = Object.getOwnPropertySymbols(group).find(
+  const symbol2 = Object.getOwnPropertySymbols(group).find(
     (candidate) => candidate.description === GROUP_CONFIG_SYMBOL_DESCRIPTION
   );
-  if (symbol === void 0) {
+  if (symbol2 === void 0) {
     return {};
   }
-  return group[symbol] ?? {};
+  return group[symbol2] ?? {};
 }
 function isProxyNode(node) {
   return node[proxyNodeSymbol] === true;
@@ -10956,23 +11597,38 @@ function createProxyCommand(parent, tool, commandName, connection) {
   if (params17.kind !== "object") {
     throw new Error(`upstream tool "${tool.name}" must define an object input schema`);
   }
+  const result = tool.outputSchema === void 0 ? void 0 : convertJsonSchema(tool.outputSchema);
+  if (result !== void 0 && result.kind !== "object") {
+    throw new Error(`upstream tool "${tool.name}" must define an object output schema`);
+  }
   return markProxyNode({
     kind: "command",
     name: commandName,
     description: tool.description,
+    examples: [],
     aliases: [],
     positional: [],
     params: params17,
+    ...result === void 0 ? {} : { result },
     secrets: cloneSecrets2(parent.secrets),
     scope: cloneScope2(parent.scope) ?? ["cli", "sdk"],
     confirm: false,
     requires: parent.requires,
     handler: async (ctx) => {
       const client = await ensureConnected(connection);
-      return client.callTool({
+      const toolResult = await client.callTool({
         name: tool.name,
         arguments: ctx.params
       });
+      if (result === void 0) {
+        return toolResult;
+      }
+      if (toolResult.structuredContent === void 0) {
+        throw new Error(
+          `upstream tool "${tool.name}" declared outputSchema but returned no structuredContent`
+        );
+      }
+      return toolResult.structuredContent;
     },
     render: void 0
   });
@@ -11103,12 +11759,12 @@ async function fetchCache(name, config2) {
   try {
     logger2.info(`MCP ${name}: listing tools`);
     const tools = [];
-    let cursor;
+    let cursor2;
     do {
-      const page = await client.listTools(cursor === void 0 ? {} : { cursor });
+      const page = await client.listTools(cursor2 === void 0 ? {} : { cursor: cursor2 });
       tools.push(...page.tools);
-      cursor = page.nextCursor;
-    } while (cursor !== void 0);
+      cursor2 = page.nextCursor;
+    } while (cursor2 !== void 0);
     logger2.info(`MCP ${name}: found ${tools.length} tools`);
     const upstream = client.serverInfo ?? {
       name,
@@ -11846,10 +12502,15 @@ async function writeErrorReport(context) {
 
 // ../toolcraft/src/number-schema.ts
 function isValidNumberSchemaValue(value, schema) {
-  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value));
+  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value)) && (schema.minimum === void 0 || value >= schema.minimum) && (schema.maximum === void 0 || value <= schema.maximum);
 }
 function getExpectedNumberDescription(schema) {
-  return schema.jsonType === "integer" ? "an integer" : "a number";
+  const type2 = schema.jsonType === "integer" ? "an integer" : "a number";
+  const bounds = [
+    schema.minimum === void 0 ? void 0 : `greater than or equal to ${schema.minimum}`,
+    schema.maximum === void 0 ? void 0 : `less than or equal to ${schema.maximum}`
+  ].filter((bound) => bound !== void 0);
+  return bounds.length === 0 ? type2 : `${type2} ${bounds.join(" and ")}`;
 }
 
 // ../toolcraft/src/renderer.ts
@@ -11882,8 +12543,8 @@ function extractMcpPayload(envelope) {
     return structuredContent;
   }
   if (Array.isArray(envelope.content)) {
-    const text5 = envelope.content.filter(isMcpTextContent).map((block) => block.text).join("\n");
-    return text5.length > 0 ? text5 : void 0;
+    const text4 = envelope.content.filter(isMcpTextContent).map((block) => block.text).join("\n");
+    return text4.length > 0 ? text4 : void 0;
   }
   return void 0;
 }
@@ -12441,6 +13102,7 @@ function collectFields(schema, casing, globalLongOptionFlags, path24 = [], inher
           globalLongOptionFlags
         ),
         optionFlag: toOptionFlag([...nextPath, childSchema.discriminator], casing),
+        longAliases: [],
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
         description: childSchema.description,
@@ -12494,6 +13156,7 @@ function collectFields(schema, casing, globalLongOptionFlags, path24 = [], inher
           globalLongOptionFlags
         ),
         optionFlag: toOptionFlag(controlPath, casing),
+        longAliases: [],
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
         description: childSchema.description,
@@ -12576,6 +13239,9 @@ function collectFields(schema, casing, globalLongOptionFlags, path24 = [], inher
       optionAttribute: toOptionAttribute(nextPath, casing),
       commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing, globalLongOptionFlags),
       optionFlag: toOptionFlag(nextPath, casing),
+      longAliases: [...childSchema.cliAliases ?? []].map(
+        (alias) => alias.startsWith("--") ? alias : `--${alias}`
+      ),
       shortFlag: childSchema.short,
       schema: childSchema,
       description: childSchema.description,
@@ -12634,9 +13300,9 @@ function formatOptionFlags(field, globalLongOptionFlags) {
     return `-${field.shortFlag}`;
   }
   if (field.shortFlag === void 0) {
-    return field.optionFlag;
+    return [field.optionFlag, ...field.longAliases].join(", ");
   }
-  return `-${field.shortFlag}, ${field.optionFlag}`;
+  return [`-${field.shortFlag}`, field.optionFlag, ...field.longAliases].join(", ");
 }
 function formatPositionalToken(field) {
   const optionalPositional = field.optional || field.hasDefault;
@@ -12916,24 +13582,34 @@ function getGlobalLongOptionFlags(presetsEnabled, versionEnabled, controls) {
   }
   return new Set(flags);
 }
-function validateUniqueOptionFlags(fields) {
+function validateUniqueOptionFlags(fields, globalLongOptionFlags) {
   const fieldsByFlag = /* @__PURE__ */ new Map();
   for (const field of fields) {
     if (field.positionalIndex !== void 0) {
       continue;
     }
-    const existing = fieldsByFlag.get(field.optionFlag);
-    if (existing !== void 0) {
-      throw new UserError(
-        `Parameters "${existing.displayPath}" and "${field.displayPath}" use conflicting CLI flag "${field.optionFlag}".`
-      );
+    for (const flag of [field.optionFlag, ...field.longAliases]) {
+      if (globalLongOptionFlags.has(flag)) {
+        if (flag === field.optionFlag && field.shortFlag !== void 0) {
+          continue;
+        }
+        throw new UserError(
+          `Parameter "${field.displayPath}" uses reserved CLI flag "${flag}". Add a short flag or rename the parameter.`
+        );
+      }
+      const existing = fieldsByFlag.get(flag);
+      if (existing !== void 0) {
+        throw new UserError(
+          `Parameters "${existing.displayPath}" and "${field.displayPath}" use conflicting CLI flag "${flag}".`
+        );
+      }
+      fieldsByFlag.set(flag, field);
     }
-    fieldsByFlag.set(field.optionFlag, field);
   }
 }
 function createCommanderOption(flags, description, field) {
   const option = new Option(flags, description);
-  if (field.commanderOptionAttribute !== field.optionAttribute) {
+  if (field.commanderOptionAttribute !== field.optionAttribute || field.longAliases.length > 0) {
     option.attributeName = () => field.commanderOptionAttribute;
   }
   return option;
@@ -13254,6 +13930,26 @@ function formatSecretDescription(secret) {
   }
   return secret.optional === true ? "Optional secret" : "Required secret";
 }
+function formatExampleValue(value) {
+  if (typeof value === "string" && value.length > 0 && !value.includes(" ")) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function formatExampleCommand(breadcrumb, rootUsageName, params17) {
+  const commandPath = buildUsageLine(breadcrumb, rootUsageName, "");
+  const flags = Object.entries(params17).map(([key2, value]) => {
+    const flag = `--${key2}`;
+    return typeof value === "boolean" ? value ? flag : `--no-${key2}` : `${flag} ${formatExampleValue(value)}`;
+  });
+  return [commandPath, ...flags].filter((token) => token.length > 0).join(" ");
+}
+function formatExampleRows(examples, breadcrumb, rootUsageName) {
+  return examples.map(
+    (example) => `${example.title}
+  ${formatExampleCommand(breadcrumb, rootUsageName, example.params)}`
+  );
+}
 function wrapOptionalCommandParameterToken(token, optional) {
   return optional ? `[${token}]` : token;
 }
@@ -13412,6 +14108,12 @@ ${formatHelpOptionList(optionRows)}`);
 ${formatHelpOptionList(secretRows)}`
     );
   }
+  if (command.examples.length > 0) {
+    sections.push(
+      `${text.sectionHeader("Examples")}
+${formatExampleRows(command.examples, breadcrumb, rootUsageName).join("\n")}`
+    );
+  }
   const positionalFields = fields.filter((f) => f.positionalIndex !== void 0);
   const usageSuffix = positionalFields.length > 0 ? `[OPTIONS] ${positionalFields.map(formatPositionalToken).join(" ")}` : "[OPTIONS]";
   return renderHelpDocument({
@@ -13487,7 +14189,7 @@ function createNodeCommand(node, casing, globalLongOptionFlags, execute, presets
     const command = new CommanderCommand(node.name);
     const collected = collectFields(node.params, casing, globalLongOptionFlags);
     const fields = assignPositionals(collected.fields, node.positional);
-    validateUniqueOptionFlags(fields);
+    validateUniqueOptionFlags(fields, globalLongOptionFlags);
     if (node.description !== void 0) {
       command.description(node.description);
     }
@@ -13618,26 +14320,26 @@ function parseDebugStackMode(value) {
   );
 }
 function setNestedValue(target, path24, value) {
-  let cursor = target;
+  let cursor2 = target;
   for (let index = 0; index < path24.length - 1; index += 1) {
     const segment = path24[index] ?? "";
-    const existing = Object.prototype.hasOwnProperty.call(cursor, segment) ? cursor[segment] : void 0;
+    const existing = Object.prototype.hasOwnProperty.call(cursor2, segment) ? cursor2[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
-      cursor = existing;
+      cursor2 = existing;
       continue;
     }
     const next = {};
-    Object.defineProperty(cursor, segment, {
+    Object.defineProperty(cursor2, segment, {
       value: next,
       enumerable: true,
       configurable: true,
       writable: true
     });
-    cursor = next;
+    cursor2 = next;
   }
   const leaf = path24[path24.length - 1];
   if (leaf !== void 0) {
-    Object.defineProperty(cursor, leaf, {
+    Object.defineProperty(cursor2, leaf, {
       value,
       enumerable: true,
       configurable: true,
@@ -13671,7 +14373,7 @@ async function promptForField(field) {
       label: enumOptionLabel(schema, value),
       value
     }));
-    const selected = await select2({
+    const selected = await select({
       message: field.description ?? fieldPromptLabel(field),
       options,
       initialValue: field.hasDefault ? field.defaultValue : void 0
@@ -13683,7 +14385,7 @@ async function promptForField(field) {
     return selected;
   }
   if (field.schema.kind === "boolean") {
-    const selected = await confirm2({
+    const selected = await confirm({
       message: fieldPromptLabel(field),
       initialValue: field.hasDefault ? Boolean(field.defaultValue) : void 0
     });
@@ -13693,7 +14395,7 @@ async function promptForField(field) {
     }
     return selected;
   }
-  const entered = await text3({
+  const entered = await text2({
     message: fieldPromptLabel(field),
     initialValue: field.hasDefault && field.defaultValue !== void 0 ? formatResolvedValue(field.defaultValue) : void 0
   });
@@ -14168,12 +14870,12 @@ function createFixtureEnvValues(command) {
   }
   return values;
 }
-async function resolveFixtureRuntime(command, services, requirementOptions) {
+async function resolveFixtureRuntime(command, services, requirementOptions, runtimeFetch) {
   const selector = process.env.TOOLCRAFT_FIXTURE;
   if (selector === void 0 || selector.length === 0) {
     return {
       env: createEnv2(),
-      fetch: globalThis.fetch,
+      fetch: runtimeFetch,
       fs: createFs2(),
       isFixture: false,
       requirementOptions,
@@ -14312,22 +15014,22 @@ function consumeFieldValue(args, index, schema, label, inlineValue) {
   if (schema.kind === "array") {
     const values = [];
     let nextIndex = index;
-    let cursor = index + 1;
-    while (cursor < args.length) {
-      const token = args[cursor] ?? "";
+    let cursor2 = index + 1;
+    while (cursor2 < args.length) {
+      const token = args[cursor2] ?? "";
       if (token.startsWith("-")) {
         break;
       }
       const parsed = parseArrayValue(token, schema, label);
       if (parsed === null) {
         return {
-          nextIndex: cursor,
+          nextIndex: cursor2,
           value: null
         };
       }
       values.push(...parsed);
-      nextIndex = cursor;
-      cursor += 1;
+      nextIndex = cursor2;
+      cursor2 += 1;
     }
     if (values.length === 0) {
       throw new InvalidArgumentError(`option '${label}' argument missing`);
@@ -14860,7 +15562,7 @@ function getResolvedFlags(command) {
   const flags = command.optsWithGlobals();
   return flags;
 }
-async function executeCommand(state, services, requirementOptions, runtimeOptions, onErrorReportContext) {
+async function executeCommand(state, services, requirementOptions, runtimeFetch, runtimeOptions, onErrorReportContext) {
   const logger2 = createLogger();
   const primitives = {
     logger: logger2,
@@ -14872,7 +15574,12 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
   const resolvedFlags = optionValues;
   const output = resolveOutput(resolvedFlags);
   const shouldPrompt = !resolvedFlags.yes && Boolean(process.stdin.isTTY);
-  const runtime = await resolveFixtureRuntime(state.command, services, requirementOptions);
+  const runtime = await resolveFixtureRuntime(
+    state.command,
+    services,
+    requirementOptions,
+    runtimeFetch
+  );
   const preflightContext = {
     ...runtime.services,
     secrets: runtime.secrets,
@@ -14915,7 +15622,7 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
             logger2.resolved(field.displayPath, formatResolvedValue(value));
           }
         }
-        const proceed = await confirm2({
+        const proceed = await confirm({
           message: "Proceed?",
           initialValue: true
         });
@@ -15403,6 +16110,7 @@ async function runCLI(roots, options = {}) {
   const casing = options.casing ?? "kebab";
   const services = options.services ?? {};
   const runtimeOptions = options.humanInLoop ?? {};
+  const runtimeFetch = options.fetch ?? globalThis.fetch;
   const version = options.version ?? findEntrypointPackageMetadata(process.argv[1])?.version;
   const rootUsageName = options.rootUsageName ?? inferProgramName(process.argv);
   const controls = resolveCLIControls(options.controls);
@@ -15444,6 +16152,7 @@ async function runCLI(roots, options = {}) {
       state,
       servicesWithBuiltIns,
       requirementOptions,
+      runtimeFetch,
       runtimeOptions,
       (context) => {
         errorReportContext = context;
@@ -15522,7 +16231,7 @@ async function runCLI(roots, options = {}) {
 import { randomUUID as randomUUID6 } from "node:crypto";
 
 // src/terminal-session.ts
-import { EventEmitter } from "node:events";
+import { EventEmitter as EventEmitter2 } from "node:events";
 import { accessSync, chmodSync, constants } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -15771,6 +16480,10 @@ var TerminalBuffer = class {
   }
   _writePrintable(ch) {
     const width = this._cellWidth(ch);
+    if (width === 0) {
+      this._appendCombiningMark(ch);
+      return;
+    }
     if (this._autoWrap && this._pendingWrap) {
       this._cursorX = 0;
       this._newline();
@@ -15805,11 +16518,40 @@ var TerminalBuffer = class {
   _cellWidth(ch) {
     const codePoint = ch.codePointAt(0);
     if (codePoint === void 0) return 0;
+    if (isCombiningCodePoint2(codePoint)) {
+      return 0;
+    }
     if (codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12350 || codePoint >= 12353 && codePoint <= 13247 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127488 && codePoint <= 131069 || codePoint >= 131072 && codePoint <= 262141) {
       return Math.min(2, this._cols);
     }
     return 1;
   }
+  _appendCombiningMark(ch) {
+    const target = this._findCombiningTarget();
+    if (target === null) {
+      return;
+    }
+    const cell = this._screen[target.y]?.[target.x];
+    if (cell === null || cell === void 0) {
+      return;
+    }
+    cell[1] += ch;
+  }
+  _findCombiningTarget() {
+    const startX = this._pendingWrap ? this._cursorX : this._cursorX - 1;
+    for (let y = this._cursorY; y >= 0; y -= 1) {
+      const row = this._screen[y];
+      if (row === void 0) {
+        continue;
+      }
+      for (let x = y === this._cursorY ? startX : this._cols - 1; x >= 0; x -= 1) {
+        if (row[x] !== null) {
+          return { x, y };
+        }
+      }
+    }
+    return null;
+  }
   _setChar(y, x, ch) {
     const row = this._screen[y];
     if (row && x >= 0 && x < this._cols) {
@@ -15950,7 +16692,8 @@ var TerminalBuffer = class {
       case "J":
         if (p0 === 0) {
           this._eraseLine(this._cursorY, this._cursorX, this._cols - 1);
-          for (let y = this._cursorY + 1; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
+          for (let y = this._cursorY + 1; y < this._rows; y++)
+            this._eraseLine(y, 0, this._cols - 1);
         } else if (p0 === 1) {
           for (let y = 0; y < this._cursorY; y++) this._eraseLine(y, 0, this._cols - 1);
           this._eraseLine(this._cursorY, 0, this._cursorX);
@@ -16315,6 +17058,9 @@ function createDefaultStyleState() {
     strikethrough: false
   };
 }
+function isCombiningCodePoint2(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071;
+}
 function serializeStyleState(state) {
   const codes = [];
   if (state.bold) {
@@ -16368,6 +17114,8 @@ var NAMED_KEY_LOWER = new Map(
   Object.entries(NAMED_KEY_SEQUENCES).map(([k, v]) => [k.toLowerCase(), v])
 );
 var VALID_KEYS_HINT = `Valid keys: ${Object.keys(NAMED_KEY_SEQUENCES).join(", ")}, Control+<letter>, Alt+<key>`;
+var NAMED_KEY_PATTERN = Object.keys(NAMED_KEY_SEQUENCES).map(caseInsensitivePattern).join("|");
+var TERMINAL_KEY_PATTERN = `^(?:${NAMED_KEY_PATTERN}|.|[Cc][Oo][Nn][Tt][Rr][Oo][Ll]\\+[A-Za-z]|[Aa][Ll][Tt]\\+.+)$`;
 function unknownKeyError(key2) {
   return new Error(`Unknown terminal key: ${key2}. ${VALID_KEYS_HINT}`);
 }
@@ -16410,6 +17158,18 @@ function controlKeyToSequence(controlKey) {
   }
   return String.fromCharCode(charCode - 64);
 }
+function caseInsensitivePattern(value) {
+  let pattern = "";
+  for (const character of value) {
+    const lower = character.toLowerCase();
+    const upper = character.toUpperCase();
+    pattern += lower === upper ? escapePatternCharacter(character) : `[${upper}${lower}]`;
+  }
+  return pattern;
+}
+function escapePatternCharacter(character) {
+  return character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
 
 // src/terminal-screen.ts
 var TerminalScreen = class {
@@ -16420,12 +17180,12 @@ var TerminalScreen = class {
   constructor({
     lines,
     rawLines,
-    cursor,
+    cursor: cursor2,
     size
   }) {
     this.lines = Object.freeze(lines.map((line) => stripAnsi4(line)));
     this.rawLines = Object.freeze([...rawLines]);
-    this.cursor = Object.freeze({ ...cursor });
+    this.cursor = Object.freeze({ ...cursor2 });
     this.size = Object.freeze({ ...size });
     Object.freeze(this);
   }
@@ -16461,7 +17221,7 @@ var TerminalSession = class {
   exitCode = null;
   pty;
   terminal;
-  emitter = new EventEmitter();
+  emitter = new EventEmitter2();
   exitPromise;
   rawBuffer = "";
   lastDataAt = Date.now();
@@ -16509,14 +17269,14 @@ var TerminalSession = class {
       });
     });
   }
-  async type(text5) {
-    for (const character of text5) {
+  async type(text4) {
+    for (const character of text4) {
       await this.send(character);
       await sleep(TYPE_DELAY_MS);
     }
   }
-  async fill(text5) {
-    await this.send(text5.replace(/\r?\n/g, "\r"));
+  async fill(text4) {
+    await this.send(text4.replace(/\r?\n/g, "\r"));
   }
   async press(key2) {
     await this.send(keyToSequence(key2));
@@ -16738,25 +17498,25 @@ function splitHistoryLines(input) {
 function normalizeHistoryBuffer(input) {
   let output = "";
   let line = "";
-  let cursor = 0;
+  let cursor2 = 0;
   for (const character of input) {
     if (character === "\r") {
-      cursor = 0;
+      cursor2 = 0;
       continue;
     }
     if (character === "\b") {
-      cursor = Math.max(0, cursor - 1);
+      cursor2 = Math.max(0, cursor2 - 1);
       continue;
     }
     if (character === "\n") {
       output += `${line}
 `;
       line = "";
-      cursor = 0;
+      cursor2 = 0;
       continue;
     }
-    line = `${line.slice(0, cursor)}${character}${line.slice(cursor + 1)}`;
-    cursor += 1;
+    line = `${line.slice(0, cursor2)}${character}${line.slice(cursor2 + 1)}`;
+    cursor2 += 1;
   }
   return output + line;
 }
@@ -16849,7 +17609,11 @@ function createTerminalPilotRuntime(options = {}) {
   const pendingNames = /* @__PURE__ */ new Set();
   let pilotPromise;
   function getRequestedName(name, env) {
-    return name ?? env?.get(SESSION_ENV_VAR);
+    const requestedName = name ?? env?.get(SESSION_ENV_VAR);
+    if (requestedName !== void 0 && requestedName.trim().length === 0) {
+      throw new UserError("Session name must not be empty.");
+    }
+    return requestedName;
   }
   async function getPilot() {
     pilotPromise ??= launchPilot();
@@ -16885,7 +17649,9 @@ function createTerminalPilotRuntime(options = {}) {
     const sessionId = nameToId.get(name);
     if (sessionId === void 0) {
       const active = await listSessions2();
-      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+      throw new UserError(
+        `Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
     }
     const pilot = await getPilot();
     try {
@@ -16893,7 +17659,9 @@ function createTerminalPilotRuntime(options = {}) {
     } catch {
       forgetSession(name, sessionId);
       const active = await listSessions2();
-      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+      throw new UserError(
+        `Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
     }
   }
   async function listSessions2() {
@@ -16924,6 +17692,9 @@ function createTerminalPilotRuntime(options = {}) {
   }
   return {
     async createSession(params17, env) {
+      if (params17.command.trim().length === 0) {
+        throw new UserError("Command must not be empty.");
+      }
       const requestedName = getRequestedName(params17.session, env) ?? nextSessionName();
       await discardExitedSessionName(requestedName);
       if (nameToId.has(requestedName) || pendingNames.has(requestedName)) {
@@ -16989,7 +17760,9 @@ function createTerminalPilotRuntime(options = {}) {
 
 // src/commands/close-session.ts
 var params = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var closeSession = defineCommand({
   name: "close-session",
@@ -16997,19 +17770,28 @@ var closeSession = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(params17.session, env);
+    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(
+      params17.session,
+      env
+    );
     return { exitCode };
   }
 });
 
 // src/commands/create-session.ts
 var params2 = S.Object({
-  command: S.String({ description: "Command to execute" }),
+  command: S.String({ description: "Command to execute", minLength: 1, pattern: "\\S" }),
   args: S.Optional(S.Array(S.String(), { description: "Command arguments" })),
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
   cwd: S.Optional(S.String({ description: "Working directory" })),
-  cols: S.Optional(S.Number({ description: "Terminal width in columns" })),
-  rows: S.Optional(S.Number({ description: "Terminal height in rows" })),
+  cols: S.Optional(
+    S.Number({ description: "Terminal width in columns", jsonType: "integer", minimum: 1 })
+  ),
+  rows: S.Optional(
+    S.Number({ description: "Terminal height in rows", jsonType: "integer", minimum: 1 })
+  ),
   observe: S.Optional(S.Boolean({ description: "Mirror PTY output to stderr" }))
 });
 var createSession = defineCommand({
@@ -17019,7 +17801,10 @@ var createSession = defineCommand({
   positional: ["command", "args"],
   params: params2,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(params17, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(
+      params17,
+      env
+    );
     return { session: namedSession.name, pid: namedSession.session.pid };
   }
 });
@@ -17027,7 +17812,9 @@ var createSession = defineCommand({
 // src/commands/fill.ts
 var params3 = S.Object({
   text: S.String({ description: "Text to write to the session" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var fill = defineCommand({
   name: "fill",
@@ -17036,7 +17823,10 @@ var fill = defineCommand({
   positional: ["text"],
   params: params3,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.fill(params17.text);
     return void 0;
   }
@@ -17044,7 +17834,9 @@ var fill = defineCommand({
 
 // src/commands/get-session.ts
 var params4 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var getSession = defineCommand({
   name: "get-session",
@@ -17052,7 +17844,10 @@ var getSession = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params4,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     return {
       session: namedSession.name,
       pid: namedSession.session.pid,
@@ -17080,7 +17875,7 @@ var claudeCodeAgent = {
       CLAUDE_CODE_ENABLE_TELEMETRY: "1"
     }
   },
-  configPath: "~/.claude/settings.json",
+  configPath: "~/.claude.json",
   branding: {
     colors: {
       dark: "#C15F3C",
@@ -17095,7 +17890,12 @@ var claudeDesktopAgent = {
   name: "claude-desktop",
   label: "Claude Desktop",
   summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.claude/settings.json",
+  configPath: "~/.config/Claude/claude_desktop_config.json",
+  configPaths: {
+    darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+    linux: "~/.config/Claude/claude_desktop_config.json",
+    win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
+  },
   branding: {
     colors: {
       dark: "#D97757",
@@ -17139,7 +17939,7 @@ var cursorAgent = {
   label: "Cursor",
   summary: "Cursor's CLI coding agent.",
   binaryName: "cursor-agent",
-  configPath: "~/.cursor/cli-config.json",
+  configPath: "~/.cursor/mcp.json",
   branding: {
     colors: {
       dark: "#FFFFFF",
@@ -17179,7 +17979,7 @@ var openCodeAgent = {
       OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
     }
   },
-  configPath: "~/.config/opencode/config.json",
+  configPath: "~/.config/opencode/opencode.json",
   branding: {
     colors: {
       dark: "#4A4F55",
@@ -17197,7 +17997,7 @@ var kimiAgent = {
   aliases: ["kimi-cli"],
   binaryName: "kimi",
   apiShapes: ["openai-chat-completions"],
-  configPath: "~/.kimi/config.toml",
+  configPath: "~/.kimi/mcp.json",
   branding: {
     colors: {
       dark: "#7B68EE",
@@ -17468,7 +18268,7 @@ function detectIndent(content) {
   }
   return "  ";
 }
-function parse3(content) {
+function parse4(content) {
   if (!content || content.trim() === "") {
     return {};
   }
@@ -17593,7 +18393,7 @@ function applyObjectUpdate(content, path24, current, next) {
   return result;
 }
 var jsonFormat = {
-  parse: parse3,
+  parse: parse4,
   serialize,
   serializeUpdate,
   merge,
@@ -17605,7 +18405,7 @@ import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 function isConfigObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parse4(content) {
+function parse5(content) {
   if (!content || content.trim() === "") {
     return {};
   }
@@ -17671,7 +18471,7 @@ function prune2(obj, shape) {
   return { changed, result };
 }
 var tomlFormat = {
-  parse: parse4,
+  parse: parse5,
   serialize: serialize2,
   merge: merge2,
   prune: prune2
@@ -17682,7 +18482,7 @@ import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function isConfigObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parse5(content) {
+function parse6(content) {
   if (!content || content.trim() === "") {
     return {};
   }
@@ -17748,7 +18548,7 @@ function prune3(obj, shape) {
   return { changed, result };
 }
 var yamlFormat = {
-  parse: parse5,
+  parse: parse6,
   serialize: serialize3,
   merge: merge3,
   prune: prune3
@@ -18897,8 +19697,10 @@ var listSessions = defineCommand({
 
 // src/commands/press-key.ts
 var params7 = S.Object({
-  key: S.String({ description: "Named key to press" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  key: S.String({ description: "Named key to press", pattern: TERMINAL_KEY_PATTERN }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var pressKey = defineCommand({
   name: "press-key",
@@ -18907,16 +19709,36 @@ var pressKey = defineCommand({
   positional: ["key"],
   params: params7,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    assertTerminalKey(params17.key);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.press(params17.key);
     return void 0;
   }
 });
+function assertTerminalKey(key2) {
+  try {
+    keyToSequence(key2);
+  } catch (error3) {
+    throw new UserError(error3 instanceof Error ? error3.message : String(error3));
+  }
+}
 
 // src/commands/read-history.ts
 var params8 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  last: S.Optional(S.Number({ short: "n", description: "Return only the last N lines" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  last: S.Optional(
+    S.Number({
+      short: "n",
+      description: "Return only the last N lines",
+      jsonType: "integer",
+      minimum: 0
+    })
+  )
 });
 var readHistory = defineCommand({
   name: "read-history",
@@ -18924,7 +19746,10 @@ var readHistory = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params8,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const lines = await namedSession.session.history({ last: params17.last });
     return { lines, exitCode: namedSession.session.exitCode };
   }
@@ -18932,7 +19757,9 @@ var readHistory = defineCommand({
 
 // src/commands/read-screen.ts
 var params9 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var readScreen = defineCommand({
   name: "read-screen",
@@ -18940,7 +19767,10 @@ var readScreen = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params9,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const screen = await namedSession.session.screen();
     return {
       lines: [...screen.lines],
@@ -18953,9 +19783,11 @@ var readScreen = defineCommand({
 
 // src/commands/resize.ts
 var params10 = S.Object({
-  cols: S.Number({ description: "Terminal width in columns" }),
-  rows: S.Number({ description: "Terminal height in rows" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  cols: S.Number({ description: "Terminal width in columns", jsonType: "integer", minimum: 1 }),
+  rows: S.Number({ description: "Terminal height in rows", jsonType: "integer", minimum: 1 }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var resize = defineCommand({
   name: "resize",
@@ -18963,7 +19795,10 @@ var resize = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params10,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.resize(params17.cols, params17.rows);
     return void 0;
   }
@@ -18975,6 +19810,9 @@ import { rename as rename4, rm, writeFile as writeFile6 } from "node:fs/promises
 
 // ../terminal-png/src/ansi-parser.ts
 var ESC2 = "\x1B";
+var TAB_WIDTH = 8;
+var MAX_TERMINAL_ROWS = 1e3;
+var MAX_TERMINAL_COLUMNS = 1e3;
 function createDefaultStyle() {
   return {
     fg: null,
@@ -19009,17 +19847,17 @@ function colorsEqual(left, right) {
   }
   return false;
 }
-function pushRun(runs, style, text5) {
-  if (text5.length === 0) {
+function pushRun(runs, style, text4) {
+  if (text4.length === 0) {
     return;
   }
   const previous = runs.at(-1);
-  if (previous && text5 !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
-    previous.text += text5;
+  if (previous && text4 !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
+    previous.text += text4;
     return;
   }
   runs.push({
-    text: text5,
+    text: text4,
     fg: style.fg,
     bg: style.bg,
     bold: style.bold,
@@ -19259,10 +20097,34 @@ function positionParameter(params17, index, fallback) {
   const value = toInteger(params17.split(";")[index]);
   return value === null || value < 1 ? fallback : value;
 }
+function modeParameter(params17, fallback) {
+  const value = toInteger(params17.split(";")[0]);
+  return value === null ? fallback : value;
+}
+function displayWidth3(text4) {
+  if (text4 === "	") {
+    return TAB_WIDTH;
+  }
+  const codePoint = text4.codePointAt(0);
+  if (codePoint === void 0) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function hasRenderableCell(line) {
+  return (line ?? []).some((cell) => cell !== void 0 && cell.text.length > 0);
+}
 function buildRuns(lines, lineBreakStyles) {
   const runs = [];
   const defaultStyle = createDefaultStyle();
-  for (let row = 0; row < lines.length; row += 1) {
+  let lastRow = lines.length - 1;
+  while (lastRow > 0 && !hasRenderableCell(lines[lastRow]) && lineBreakStyles[lastRow - 1] === void 0) {
+    lastRow -= 1;
+  }
+  for (let row = 0; row <= lastRow; row += 1) {
     const line = lines[row] ?? [];
     let lastCell = line.length - 1;
     while (lastCell >= 0 && line[lastCell] === void 0) {
@@ -19272,7 +20134,7 @@ function buildRuns(lines, lineBreakStyles) {
       const cell = line[column] ?? { text: " ", style: defaultStyle };
       pushRun(runs, cell.style, cell.text);
     }
-    if (row < lines.length - 1) {
+    if (row < lastRow) {
       pushRun(runs, lineBreakStyles[row] ?? defaultStyle, "\n");
     }
   }
@@ -19284,7 +20146,21 @@ function parseAnsi2(input) {
   let style = createDefaultStyle();
   let row = 0;
   let column = 0;
+  let savedRow = 0;
+  let savedColumn = 0;
   let index = 0;
+  const clampRow = (nextRow) => {
+    if (nextRow < 0) {
+      return 0;
+    }
+    return Math.min(nextRow, MAX_TERMINAL_ROWS - 1);
+  };
+  const clampColumn = (nextColumn) => {
+    if (nextColumn < 0) {
+      return 0;
+    }
+    return Math.min(nextColumn, MAX_TERMINAL_COLUMNS - 1);
+  };
   const ensureLine = () => {
     while (lines.length <= row) {
       lines.push([]);
@@ -19292,12 +20168,64 @@ function parseAnsi2(input) {
   };
   const moveDown = (keepColumn) => {
     lineBreakStyles[row] = cloneStyle(style);
-    row += 1;
+    row = clampRow(row + 1);
     if (!keepColumn) {
       column = 0;
     }
     ensureLine();
   };
+  const eraseLine = (mode) => {
+    const line = lines[row] ?? [];
+    if (mode === 1) {
+      for (let cell = 0; cell <= column; cell += 1) {
+        delete line[cell];
+      }
+      return;
+    }
+    if (mode === 2) {
+      lines[row] = [];
+      return;
+    }
+    line.splice(column);
+  };
+  const eraseDisplay = (mode) => {
+    if (mode === 1) {
+      for (let lineRow = 0; lineRow < row; lineRow += 1) {
+        lines[lineRow] = [];
+      }
+      eraseLine(1);
+      return;
+    }
+    if (mode === 2 || mode === 3) {
+      lines.length = 0;
+      lineBreakStyles.length = 0;
+      ensureLine();
+      return;
+    }
+    eraseLine(0);
+    lines.splice(row + 1);
+    lineBreakStyles.splice(row);
+  };
+  const saveCursor = () => {
+    savedRow = row;
+    savedColumn = column;
+  };
+  const restoreCursor = () => {
+    row = clampRow(savedRow);
+    column = clampColumn(savedColumn);
+    ensureLine();
+  };
+  const writeText = (text4) => {
+    const width = displayWidth3(text4);
+    if (width === 0) {
+      return;
+    }
+    lines[row][column] = { text: text4, style: cloneStyle(style) };
+    for (let offset = 1; offset < width && column + offset < MAX_TERMINAL_COLUMNS; offset += 1) {
+      lines[row][column + offset] = { text: "", style: cloneStyle(style) };
+    }
+    column = clampColumn(column + width);
+  };
   while (index < input.length) {
     const char = input[index];
     if (char === "\n") {
@@ -19320,39 +20248,74 @@ function parseAnsi2(input) {
       index += 1;
       continue;
     }
+    if (char === "	") {
+      const nextTabStop = Math.min(
+        Math.floor(column / TAB_WIDTH) * TAB_WIDTH + TAB_WIDTH,
+        MAX_TERMINAL_COLUMNS
+      );
+      while (column < nextTabStop) {
+        writeText(" ");
+      }
+      index += 1;
+      continue;
+    }
     if (char === ESC2 && input[index + 1] === "]") {
       index = parseOscEnd(input, index);
       continue;
     }
+    if (char === ESC2 && input[index + 1] === "7") {
+      saveCursor();
+      index += 2;
+      continue;
+    }
+    if (char === ESC2 && input[index + 1] === "8") {
+      restoreCursor();
+      index += 2;
+      continue;
+    }
     const csiPrefixLength = char === "\x9B" ? 1 : char === ESC2 && input[index + 1] === "[" ? 2 : null;
     if (csiPrefixLength !== null) {
       const sequence = parseCsi(input, index, csiPrefixLength);
       if (sequence.final === "m") {
         style = applySgr(style, sequence.params);
       } else if (sequence.final === "G") {
-        column = positionParameter(sequence.params, 0, 1) - 1;
+        column = clampColumn(positionParameter(sequence.params, 0, 1) - 1);
       } else if (sequence.final === "C") {
-        column += positionParameter(sequence.params, 0, 1);
+        column = clampColumn(column + positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "D") {
         column = Math.max(0, column - positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "A") {
-        row = Math.max(0, row - positionParameter(sequence.params, 0, 1));
+        row = clampRow(row - positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "B") {
-        row += positionParameter(sequence.params, 0, 1);
+        row = clampRow(row + positionParameter(sequence.params, 0, 1));
         ensureLine();
+      } else if (sequence.final === "E") {
+        row = clampRow(row + positionParameter(sequence.params, 0, 1));
+        column = 0;
+        ensureLine();
+      } else if (sequence.final === "F") {
+        row = clampRow(row - positionParameter(sequence.params, 0, 1));
+        column = 0;
       } else if (sequence.final === "H" || sequence.final === "f") {
-        row = positionParameter(sequence.params, 0, 1) - 1;
-        column = positionParameter(sequence.params, 1, 1) - 1;
+        row = clampRow(positionParameter(sequence.params, 0, 1) - 1);
+        column = clampColumn(positionParameter(sequence.params, 1, 1) - 1);
         ensureLine();
+      } else if (sequence.final === "K") {
+        eraseLine(modeParameter(sequence.params, 0));
+      } else if (sequence.final === "J") {
+        eraseDisplay(modeParameter(sequence.params, 0));
+      } else if (sequence.final === "s") {
+        saveCursor();
+      } else if (sequence.final === "u") {
+        restoreCursor();
       }
       index = sequence.end;
       continue;
     }
     const codePoint = input.codePointAt(index);
-    const text5 = codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
-    lines[row][column] = { text: text5, style: cloneStyle(style) };
-    column += 1;
-    index += text5.length;
+    const text4 = codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
+    writeText(text4);
+    index += text4.length;
   }
   return buildRuns(lines, lineBreakStyles);
 }
@@ -19759,14 +20722,14 @@ function splitIntoLines(runs) {
 }
 function measureLines(lines) {
   return Math.max(
-    ...lines.map((line) => displayWidth3(line.map((run) => run.text).join("")) * CHARACTER_WIDTH),
+    ...lines.map((line) => displayWidth4(line.map((run) => run.text).join("")) * CHARACTER_WIDTH),
     0
   );
 }
-function displayWidth3(text5, startColumn = 0) {
+function displayWidth4(text4, startColumn = 0) {
   const segmenter = new Intl.Segmenter();
   let column = startColumn;
-  for (const { segment } of segmenter.segment(text5)) {
+  for (const { segment } of segmenter.segment(text4)) {
     if (segment === "	") {
       column += 8 - column % 8;
       continue;
@@ -19825,7 +20788,7 @@ function renderBackgrounds(line, startX, y, height) {
   let column = 0;
   const rectangles = [];
   for (const run of line) {
-    const width = displayWidth3(run.text, column);
+    const width = displayWidth4(run.text, column);
     const background = resolveBackgroundColor(run);
     if (background !== BACKGROUND && width > 0) {
       rectangles.push(`<rect x="${formatNumber(startX + column * CHARACTER_WIDTH)}" y="${formatNumber(y)}" width="${formatNumber(width * CHARACTER_WIDTH)}" height="${formatNumber(height)}" fill="${escapeXmlAttribute(background)}" />`);
@@ -19859,8 +20822,8 @@ function renderRun(run) {
   if (run.dim) {
     attributes.push('opacity="0.7"');
   }
-  const text5 = run.conceal ? " ".repeat(displayWidth3(run.text)) : run.text;
-  return `<tspan ${attributes.join(" ")}>${escapeXmlText(text5)}</tspan>`;
+  const text4 = run.conceal ? " ".repeat(displayWidth4(run.text)) : run.text;
+  return `<tspan ${attributes.join(" ")}>${escapeXmlText(text4)}</tspan>`;
 }
 function renderWindowControls() {
   return [
@@ -19908,13 +20871,16 @@ async function renderTerminalPng(ansiText, options = {}) {
   if (options.padding !== void 0 && (!Number.isInteger(options.padding) || options.padding < 0)) {
     throw new Error("Padding must be a non-negative integer.");
   }
+  if (options.output !== void 0 && options.output.length === 0) {
+    throw new Error("Output path must not be empty.");
+  }
   const runs = parseAnsi2(ansiText);
   const svg = renderSvg(runs, {
     padding: options.padding,
     window: options.window
   });
   const png = renderPng(svg);
-  if (options.output) {
+  if (options.output !== void 0) {
     const temporaryPath = `${options.output}.${randomUUID10()}.tmp`;
     let temporaryCreated = false;
     try {
@@ -19940,10 +20906,19 @@ function isAlreadyExistsError3(error3) {
 
 // src/commands/screenshot.ts
 var params11 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
   output: S.String({ short: "o", description: "Path to the output PNG file" }),
   window: S.Optional(S.Boolean({ description: "Include terminal window chrome", default: true })),
-  padding: S.Optional(S.Number({ short: "p", description: "Padding around terminal content" }))
+  padding: S.Optional(
+    S.Number({
+      short: "p",
+      description: "Padding around terminal content",
+      jsonType: "integer",
+      minimum: 0
+    })
+  )
 });
 var screenshot = defineCommand({
   name: "screenshot",
@@ -19951,7 +20926,10 @@ var screenshot = defineCommand({
   scope: ["cli"],
   params: params11,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const screen = await namedSession.session.screen();
     await renderTerminalPng(screen.rawLines.join("\n"), {
       output: params17.output,
@@ -19965,7 +20943,9 @@ var screenshot = defineCommand({
 // src/commands/send-signal.ts
 var params12 = S.Object({
   signal: S.String({ description: "Signal to send to the session process" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var sendSignal = defineCommand({
   name: "send-signal",
@@ -19974,7 +20954,10 @@ var sendSignal = defineCommand({
   positional: ["signal"],
   params: params12,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.signal(params17.signal);
     return void 0;
   }
@@ -19983,7 +20966,9 @@ var sendSignal = defineCommand({
 // src/commands/type.ts
 var params13 = S.Object({
   text: S.String({ description: "Text to write to the session" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var type = defineCommand({
   name: "type",
@@ -19992,7 +20977,10 @@ var type = defineCommand({
   positional: ["text"],
   params: params13,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.type(params17.text);
     return void 0;
   }
@@ -20070,9 +21058,17 @@ async function folderExists(fs4, folderPath) {
 
 // src/commands/wait-for.ts
 var params15 = S.Object({
-  pattern: S.String({ description: "Regular expression pattern to wait for" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" })),
+  pattern: S.String({
+    description: "Regular expression pattern to wait for",
+    minLength: 1,
+    pattern: "\\S"
+  }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  timeout: S.Optional(
+    S.Number({ short: "t", description: "Maximum wait time in milliseconds", minimum: 0 })
+  ),
   literal: S.Optional(
     S.Boolean({
       short: "l",
@@ -20087,17 +21083,33 @@ var waitFor = defineCommand({
   positional: ["pattern"],
   params: params15,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    if (params17.pattern.trim().length === 0) {
+      throw new UserError("Wait pattern must not be empty.");
+    }
+    assertTimeout2(params17.timeout);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const pattern = params17.literal === true ? params17.pattern : new RegExp(params17.pattern);
     const line = params17.timeout === void 0 ? await namedSession.session.waitFor(pattern) : await namedSession.session.waitFor(pattern, { timeout: params17.timeout });
     return { matched: true, line };
   }
 });
+function assertTimeout2(timeout) {
+  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new UserError("Timeout must be a finite non-negative number.");
+  }
+}
 
 // src/commands/wait-for-exit.ts
 var params16 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  timeout: S.Optional(
+    S.Number({ short: "t", description: "Maximum wait time in milliseconds", minimum: 0 })
+  )
 });
 var waitForExit2 = defineCommand({
   name: "wait-for-exit",
@@ -20105,7 +21117,13 @@ var waitForExit2 = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params16,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    if (params17.timeout !== void 0 && (!Number.isFinite(params17.timeout) || params17.timeout < 0)) {
+      throw new UserError("Timeout must be a finite non-negative number.");
+    }
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const exitCode = await namedSession.session.waitForExit(
       params17.timeout === void 0 ? void 0 : { timeout: params17.timeout }
     );