terminal-pilot 0.0.27 → 0.0.28

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,
@@ -11882,8 +12538,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 +13097,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 +13151,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 +13234,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 +13295,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 +13577,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 +13925,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 +14103,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 +14184,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 +14315,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 +14368,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 +14380,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 +14390,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 +14865,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 +15009,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 +15557,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 +15569,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 +15617,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 +16105,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 +16147,7 @@ async function runCLI(roots, options = {}) {
       state,
       servicesWithBuiltIns,
       requirementOptions,
+      runtimeFetch,
       runtimeOptions,
       (context) => {
         errorReportContext = context;
@@ -15522,7 +16226,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";
@@ -16420,12 +17124,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 +17165,7 @@ var TerminalSession = class {
   exitCode = null;
   pty;
   terminal;
-  emitter = new EventEmitter();
+  emitter = new EventEmitter2();
   exitPromise;
   rawBuffer = "";
   lastDataAt = Date.now();
@@ -16509,14 +17213,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 +17442,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;
 }
@@ -17468,7 +18172,7 @@ function detectIndent(content) {
   }
   return "  ";
 }
-function parse3(content) {
+function parse4(content) {
   if (!content || content.trim() === "") {
     return {};
   }
@@ -17593,7 +18297,7 @@ function applyObjectUpdate(content, path24, current, next) {
   return result;
 }
 var jsonFormat = {
-  parse: parse3,
+  parse: parse4,
   serialize,
   serializeUpdate,
   merge,
@@ -17605,7 +18309,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 +18375,7 @@ function prune2(obj, shape) {
   return { changed, result };
 }
 var tomlFormat = {
-  parse: parse4,
+  parse: parse5,
   serialize: serialize2,
   merge: merge2,
   prune: prune2
@@ -17682,7 +18386,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 +18452,7 @@ function prune3(obj, shape) {
   return { changed, result };
 }
 var yamlFormat = {
-  parse: parse5,
+  parse: parse6,
   serialize: serialize3,
   merge: merge3,
   prune: prune3
@@ -19009,17 +19713,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,
@@ -19349,10 +20053,10 @@ function parseAnsi2(input) {
       continue;
     }
     const codePoint = input.codePointAt(index);
-    const text5 = codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
-    lines[row][column] = { text: text5, style: cloneStyle(style) };
+    const text4 = codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
+    lines[row][column] = { text: text4, style: cloneStyle(style) };
     column += 1;
-    index += text5.length;
+    index += text4.length;
   }
   return buildRuns(lines, lineBreakStyles);
 }
@@ -19763,10 +20467,10 @@ function measureLines(lines) {
     0
   );
 }
-function displayWidth3(text5, startColumn = 0) {
+function displayWidth3(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;
@@ -19859,8 +20563,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(displayWidth3(run.text)) : run.text;
+  return `<tspan ${attributes.join(" ")}>${escapeXmlText(text4)}</tspan>`;
 }
 function renderWindowControls() {
   return [