@wrongstack/cli 0.318.0 → 0.319.0

package/dist/cli-context-LH4QP4W2.js

@@ -0,0 +1,3369 @@
+import {
+  applySimpleUiFullAutoProfile,
+  detectProjectFacts,
+  isSimpleUiFullAuto,
+  makePromptDelegate,
+  renderAgentsTemplate,
+  renderDiff
+} from "./chunk-VFCJOWJB.js";
+import {
+  theme as theme2
+} from "./chunk-QD544J2B.js";
+import {
+  parseWebuiSessionChildOptions,
+  writeWebuiSessionChildError
+} from "./chunk-GPPRNAKW.js";
+import {
+  fmtTok,
+  patchConfig
+} from "./chunk-TYO2OVAD.js";
+import {
+  subcommands
+} from "./chunk-OZDE3OWD.js";
+import {
+  renderDeepHelp,
+  renderFocusedHelp
+} from "./chunk-P2OKBDCH.js";
+import {
+  handleHelpVersionShortCircuit
+} from "./chunk-VWCZL4OH.js";
+import {
+  DEFAULT_PORT
+} from "./chunk-7JBKXVMK.js";
+import "./chunk-HXJYHAR4.js";
+import "./chunk-Q5GTM25S.js";
+import {
+  discoverAndMergeProviders
+} from "./chunk-52C7PD2H.js";
+import {
+  applyNodeEnvDefault,
+  applySessionShellDefault,
+  runPreflight
+} from "./chunk-PCBJSXYV.js";
+import "./chunk-QAC263FZ.js";
+import {
+  CLI_VERSION
+} from "./chunk-XJXDOF63.js";
+import {
+  addFromCatalog,
+  boxBottom,
+  boxDivider,
+  boxRow,
+  boxTop,
+  runAuthLocal,
+  runOAuthLoginMenu,
+  runPicker,
+  saveToGlobalConfig,
+  theme
+} from "./chunk-XHIEA6LG.js";
+import "./chunk-2VMJ3E5Z.js";
+import "./chunk-B4JLSXZB.js";
+import {
+  isKeylessLocalProvider,
+  visibleModelIds
+} from "./chunk-VUVOMXWP.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
+import {
+  parseArgs
+} from "./chunk-GGGUZSAU.js";
+import "./chunk-E4I2TF5S.js";
+import {
+  mutateConfigProviders,
+  normalizeKeys,
+  resolveActiveApiKey,
+  writeKeysBack
+} from "./chunk-XPX432BZ.js";
+import {
+  runUpdateCommand
+} from "./chunk-DE7BZDNK.js";
+import "./chunk-U3SS4NRH.js";
+import "./chunk-YLQEGYV4.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/cli-context.ts
+import { TOKENS as TOKENS3 } from "@wrongstack/core/kernel";
+import { writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { setOAuthTokenPersister } from "@wrongstack/providers";
+
+// src/boot/container-wiring.ts
+import { DefaultPathResolver } from "@wrongstack/core/infrastructure";
+import { EventBus as CoreEventBus, TOKENS } from "@wrongstack/core/kernel";
+import { createDefaultContainer } from "@wrongstack/runtime";
+
+// src/cli-bundled-prompts.ts
+import { createRequire } from "node:module";
+import * as path from "node:path";
+function resolveBundledPromptsDir() {
+  try {
+    const req = createRequire(import.meta.url);
+    const corePkg = req.resolve("@wrongstack/core/package.json");
+    return path.join(path.dirname(corePkg), "data", "prompts");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli-bundled-skills.ts
+import { createRequire as createRequire2 } from "node:module";
+import * as path2 from "node:path";
+function resolveBundledSkillsDir() {
+  try {
+    const req = createRequire2(import.meta.url);
+    const corePkg = req.resolve("@wrongstack/core/package.json");
+    return path2.join(path2.dirname(corePkg), "skills");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/boot/container-wiring.ts
+function wireContainer(deps) {
+  const pathResolver = new DefaultPathResolver(deps.cwd);
+  const events = new CoreEventBus();
+  events.setLogger(deps.logger);
+  const container = createDefaultContainer({
+    config: deps.config,
+    wpaths: deps.wpaths,
+    logger: deps.logger,
+    modelsRegistry: deps.modelsRegistry,
+    events,
+    permission: {
+      yolo: deps.config.yolo,
+      promptDelegate: makePromptDelegate(deps.reader)
+    },
+    compactor: {
+      preserveK: deps.config.context.preserveK,
+      eliseThreshold: deps.config.context.eliseThreshold
+    },
+    bundledSkillsDir: deps.config.features.skills ? resolveBundledSkillsDir() : void 0,
+    bundledPromptsDir: deps.config.features.prompts === false ? void 0 : resolveBundledPromptsDir()
+  });
+  container.bind(TOKENS.PathResolver, () => pathResolver);
+  container.bind(TOKENS.Renderer, () => deps.renderer);
+  container.bind(TOKENS.InputReader, () => deps.reader);
+  return { pathResolver, events, container };
+}
+
+// src/boot/launch-menu.ts
+import * as fs from "node:fs/promises";
+import { HQ_CLI_DEFAULT_HOST } from "@wrongstack/core/hq";
+import { atomicWrite, color, isStdinTTY, setRawMode } from "@wrongstack/core/utils";
+
+// src/boot/launch-banner.ts
+var STACK_ORANGE = { r: 253, g: 159, b: 2 };
+var SIGNAL_PINK = { r: 254, g: 46, b: 95 };
+function mixRgb(a, b, t) {
+  const clamped = Math.min(1, Math.max(0, t));
+  return {
+    r: Math.round(a.r + (b.r - a.r) * clamped),
+    g: Math.round(a.g + (b.g - a.g) * clamped),
+    b: Math.round(a.b + (b.b - a.b) * clamped)
+  };
+}
+function fg(c) {
+  return `\x1B[38;2;${c.r};${c.g};${c.b}m`;
+}
+function colorsEnabled() {
+  const flag = (value) => value !== void 0 && value.trim() !== "" && !/^(0|false|no|off)$/i.test(value.trim());
+  if (flag(process.env.NO_COLOR)) return false;
+  if (flag(process.env.FORCE_COLOR)) return true;
+  return process.stdout.isTTY === true;
+}
+var WORDMARK_GLYPH_BITS = Object.freeze({
+  W: Object.freeze(["10001", "10001", "10001", "10101", "10101", "10101", "01010"]),
+  R: Object.freeze(["11110", "10001", "10001", "11110", "10100", "10010", "10001"]),
+  O: Object.freeze(["01110", "10001", "10001", "10001", "10001", "10001", "01110"]),
+  N: Object.freeze(["10001", "11001", "11001", "10101", "10011", "10011", "10001"]),
+  G: Object.freeze(["01110", "10001", "10000", "10111", "10001", "10001", "01110"]),
+  S: Object.freeze(["01111", "10000", "10000", "01110", "00001", "00001", "11110"]),
+  T: Object.freeze(["11111", "00100", "00100", "00100", "00100", "00100", "00100"]),
+  A: Object.freeze(["01110", "10001", "10001", "11111", "10001", "10001", "10001"]),
+  C: Object.freeze(["01111", "10000", "10000", "10000", "10000", "10000", "01111"]),
+  K: Object.freeze(["10001", "10010", "10100", "11000", "10100", "10010", "10001"])
+});
+var WORDMARK = "WRONGSTACK";
+var WORDMARK_PIXEL_ROWS = 7;
+var WORDMARK_ROWS = Math.ceil(WORDMARK_PIXEL_ROWS / 2);
+var GLYPH_WIDTH = 5;
+var WORDMARK_WIDTH = WORDMARK.length * GLYPH_WIDTH + WORDMARK.length - 1;
+function packedCell(top, bottom) {
+  if (top === "1" && bottom === "1") return "\u2588";
+  if (top === "1") return "\u2580";
+  if (bottom === "1") return "\u2584";
+  return " ";
+}
+function packedGlyphRow(glyph, row) {
+  const top = glyph[row * 2] ?? "";
+  const bottom = glyph[row * 2 + 1] ?? "";
+  return Array.from(
+    { length: GLYPH_WIDTH },
+    (_, column) => packedCell(top[column], bottom[column])
+  ).join("");
+}
+var WORDMARK_LINES = Object.freeze(
+  Array.from(
+    { length: WORDMARK_ROWS },
+    (_, row) => [...WORDMARK].map((letter) => {
+      const glyph = WORDMARK_GLYPH_BITS[letter];
+      return glyph ? packedGlyphRow(glyph, row) : " ".repeat(GLYPH_WIDTH);
+    }).join(" ")
+  )
+);
+function gradientLine(text, colorOn) {
+  if (!colorOn) return text;
+  const length = text.length;
+  let out = "\x1B[1m";
+  for (let i = 0; i < length; i++) {
+    const ch = text[i];
+    if (ch === " ") {
+      out += ch;
+      continue;
+    }
+    const t = length > 1 ? i / (length - 1) : 0.5;
+    out += `${fg(mixRgb(STACK_ORANGE, SIGNAL_PINK, t))}${ch}`;
+  }
+  return `${out}\x1B[0m`;
+}
+function dimLine(text, colorOn) {
+  return colorOn ? `\x1B[2m${text}\x1B[22m` : text;
+}
+var MARK_COLS = 5;
+var PINK_HOME = 1;
+var MARK_WIDTH = MARK_COLS * 2 + (MARK_COLS - 1);
+function buildMarkLines(colorOn) {
+  const orange = colorOn ? fg(STACK_ORANGE) : "";
+  const pink = colorOn ? fg(SIGNAL_PINK) : "";
+  const reset = colorOn ? "\x1B[0m" : "";
+  return Array.from({ length: 3 }, (_, row) => {
+    const cells = Array.from({ length: MARK_COLS }, (_2, column) => {
+      if (column === PINK_HOME && (row === 1 || row === 2)) return `${pink}\u2588\u2588${reset}`;
+      if (row < 2 && column !== PINK_HOME) return `${orange}\u2588\u2588${reset}`;
+      return "  ";
+    });
+    return cells.join(" ").trimEnd();
+  });
+}
+function launchBannerLines(columns, version) {
+  const colorOn = colorsEnabled();
+  const tagline = version ? `v${version} \xB7 the wrong stack for all the right reasons` : "the wrong stack for all the right reasons";
+  if (columns < WORDMARK_WIDTH + 4) {
+    const compact = "\u2590\u2588\u258C W R O N G S T A C K";
+    return [gradientLine(compact, colorOn), dimLine(tagline, colorOn)];
+  }
+  const markPad = " ".repeat(Math.max(0, Math.floor((WORDMARK_WIDTH - MARK_WIDTH) / 2)));
+  const tagPad = " ".repeat(Math.max(0, Math.floor((WORDMARK_WIDTH - tagline.length) / 2)));
+  return [
+    ...buildMarkLines(colorOn).map((line) => markPad + line),
+    "",
+    ...WORDMARK_LINES.map((line) => gradientLine(line, colorOn)),
+    tagPad + dimLine(tagline, colorOn)
+  ];
+}
+
+// src/boot/launch-menu.ts
+var DEFAULT_PORTS = {
+  webui: 3456,
+  simpleui: 3466,
+  hq: DEFAULT_PORT
+};
+var DEFAULT_HOST = "127.0.0.1";
+var HQ_DEFAULT_HOST = HQ_CLI_DEFAULT_HOST;
+function bindsPort(mode) {
+  return mode !== "tui-repl" && mode !== "desktop";
+}
+function defaultHostFor(mode) {
+  return mode === "hq" ? HQ_DEFAULT_HOST : DEFAULT_HOST;
+}
+var MODE_OPTIONS = [
+  {
+    key: 1,
+    mode: "tui-repl",
+    label: "TUI / REPL",
+    hint: "interactive terminal (default)",
+    icon: "\u2328"
+  },
+  {
+    key: 2,
+    mode: "webui",
+    label: "WebUI",
+    hint: `browser-based project UI (port ${DEFAULT_PORTS.webui})`,
+    icon: "\u{1F310}"
+  },
+  {
+    key: 3,
+    mode: "simpleui",
+    label: "SimpleUI",
+    hint: `lightweight browser UI (port ${DEFAULT_PORTS.simpleui})`,
+    icon: "\u{1F4C4}"
+  },
+  {
+    key: 4,
+    mode: "hq",
+    label: "HQ",
+    hint: `project-independent dashboard (port ${DEFAULT_PORT})`,
+    icon: "\u{1F4CA}"
+  },
+  {
+    key: 5,
+    mode: "desktop",
+    label: "Desktop",
+    hint: "Electron app (alias: --desktop)",
+    icon: "\u{1F5A5}"
+  }
+];
+var MENU_TIMEOUT_MS = 8e3;
+var SUMMARY_TIMEOUT_MS = 5e3;
+var PORT_TIMEOUT_MS = 8e3;
+function shouldSkipMenu(argv, flags, positional) {
+  if (flags["no-menu"] === true) return true;
+  if (flags["webui"] === true) return true;
+  if (flags["webui-session-child"] === true) return true;
+  if (flags["simpleui"] === true) return true;
+  if (flags["hq"] === true) return true;
+  if (flags["desktop"] === true) return true;
+  if (flags["no-interactive"] === true) return true;
+  if (flags["skip"] === true) return true;
+  if (typeof flags["prompt"] === "string") return true;
+  if (!isStdinTTY()) return true;
+  if (positional.length > 0) return true;
+  void argv;
+  return false;
+}
+async function runLaunchMenu(deps) {
+  if (shouldSkipMenu(deps.argv, deps.flags, deps.positional)) {
+    return null;
+  }
+  const { renderer, reader, lastChoice } = deps;
+  const ports = { ...DEFAULT_PORTS, ...deps.defaultPorts ?? {} };
+  writeBanner(renderer);
+  if (lastChoice) {
+    const accept = await promptSummaryGate(deps);
+    if (accept === "use-last") {
+      return finalize(lastChoice, ports);
+    }
+    if (accept === "cancel") {
+      return { ...lastChoice, cancelled: true };
+    }
+  }
+  renderer.write(`
+  ${color.amber("?")} Choose how to run WrongStack:
+
+`);
+  const arrowPick = await promptModeArrow(deps);
+  let choice;
+  if (arrowPick) {
+    if (arrowPick.cancelled) {
+      return { mode: "tui-repl", cancelled: true };
+    }
+    choice = { mode: arrowPick.mode };
+  } else {
+    for (const opt of MODE_OPTIONS) {
+      renderer.write(
+        `    ${color.bold(String(opt.key))}) ${opt.icon}  ${color.bold(opt.label)}  ${color.dim(opt.hint)}
+`
+      );
+    }
+    renderer.write(`
+  ${color.dim("\u2500".repeat(48))}
+`);
+    const answer = (await reader.readLine(
+      `  ${color.amber("?")} Mode ${color.dim("[1-5, q to quit]")} ${color.dim(`(auto 1 in ${MENU_TIMEOUT_MS / 1e3}s)`)} `,
+      { timeoutMs: MENU_TIMEOUT_MS, defaultAnswer: "1" }
+    )).trim().toLowerCase();
+    if (answer === "q" || answer === "quit") {
+      renderer.write(color.dim("  Goodbye!\n"));
+      return { mode: "tui-repl", cancelled: true };
+    }
+    const picked = MODE_OPTIONS.find((o) => String(o.key) === answer || o.mode === answer);
+    choice = picked ? { mode: picked.mode } : { mode: "tui-repl" };
+  }
+  if (bindsPort(choice.mode)) {
+    const port = await promptPort(deps, ports[choice.mode]);
+    choice.port = port;
+    const defaultHost = defaultHostFor(choice.mode);
+    const host = await promptHost(deps, defaultHost);
+    if (host !== defaultHost) choice.host = host;
+  }
+  return finalize(choice, ports);
+}
+function writeBanner(renderer) {
+  const columns = process.stdout.columns ?? 80;
+  renderer.write("\n");
+  for (const line of launchBannerLines(columns, CLI_VERSION)) {
+    renderer.write(`  ${line}
+`);
+  }
+}
+function canUseArrowMenu() {
+  if (process.env.VITEST || process.env.NODE_ENV === "test") return false;
+  const stdin = process.stdin;
+  return isStdinTTY() && process.stdout.isTTY === true && typeof stdin.setRawMode === "function";
+}
+async function promptModeArrow(deps) {
+  if (!canUseArrowMenu()) return null;
+  const { renderer } = deps;
+  const stdin = process.stdin;
+  const out = (s) => renderer.write(s);
+  return await new Promise((resolve2) => {
+    let index = 0;
+    let drawn = 0;
+    let remaining = Math.round(MENU_TIMEOUT_MS / 1e3);
+    let countdown = true;
+    let settled = false;
+    let interval;
+    const wasRaw = stdin.isRaw === true;
+    const wasPaused = stdin.isPaused();
+    const rows = () => {
+      const lines = [];
+      for (let i = 0; i < MODE_OPTIONS.length; i++) {
+        const opt = MODE_OPTIONS[i];
+        const selected = i === index;
+        const pointer = selected ? color.pink("\u276F") : " ";
+        const label = selected ? color.amber(color.bold(opt.label)) : color.bold(opt.label);
+        lines.push(
+          `  ${pointer} ${color.dim(String(opt.key))} ${opt.icon}  ${label}  ${color.dim(opt.hint)}`
+        );
+      }
+      lines.push("");
+      const auto = countdown ? color.dim(` \xB7 auto-launches ${MODE_OPTIONS[index].label} in ${remaining}s`) : "";
+      lines.push(`  ${color.dim("\u2191\u2193 move \xB7 Enter launch \xB7 1-5 jump \xB7 q quit")}${auto}`);
+      return lines;
+    };
+    const paint = () => {
+      const lines = rows();
+      let frame = drawn > 0 ? `\x1B[${drawn}A` : "";
+      frame += `${lines.map((line) => `\x1B[2K${line}`).join("\n")}
+`;
+      out(frame);
+      drawn = lines.length;
+    };
+    const stopInput = () => {
+      if (interval) {
+        clearInterval(interval);
+        interval = void 0;
+      }
+      stdin.off("data", onData);
+      stdin.off("close", onClose);
+      try {
+        setRawMode(stdin, wasRaw);
+      } catch {
+      }
+      if (wasPaused) stdin.pause();
+    };
+    const settle = (result, finalLine) => {
+      if (settled) return;
+      settled = true;
+      stopCountdown();
+      stopInput();
+      if (drawn > 0) out(`\x1B[${drawn}A`);
+      out("\x1B[0J");
+      out(finalLine);
+      out("\x1B[?25h");
+      resolve2(result);
+    };
+    const pick = () => {
+      const opt = MODE_OPTIONS[index];
+      settle(
+        { cancelled: false, mode: opt.mode },
+        `  ${color.green("\u2714")} ${opt.icon}  ${color.bold(opt.label)}  ${color.dim(opt.hint)}
+`
+      );
+    };
+    const cancel = () => {
+      settle({ cancelled: true, mode: "tui-repl" }, color.dim("  Goodbye!\n"));
+    };
+    const stopCountdown = () => {
+      if (!countdown) return;
+      countdown = false;
+      if (interval) {
+        clearInterval(interval);
+        interval = void 0;
+      }
+    };
+    const onData = (buf) => {
+      const key = buf.toString("utf8");
+      stopCountdown();
+      if (key === "" || key === "q" || key === "Q" || key === "\x1B") {
+        cancel();
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        pick();
+        return;
+      }
+      if (key === "\x1B[A" || key === "\x1BOA" || key === "k") {
+        index = (index + MODE_OPTIONS.length - 1) % MODE_OPTIONS.length;
+        paint();
+        return;
+      }
+      if (key === "\x1B[B" || key === "\x1BOB" || key === "j") {
+        index = (index + 1) % MODE_OPTIONS.length;
+        paint();
+        return;
+      }
+      if (/^[0-9]$/.test(key)) {
+        const digit = Number.parseInt(key, 10);
+        if (digit >= 1 && digit <= MODE_OPTIONS.length) {
+          index = digit - 1;
+          pick();
+          return;
+        }
+      }
+      paint();
+    };
+    const onClose = () => {
+      settle({ cancelled: true, mode: "tui-repl" }, "");
+    };
+    try {
+      setRawMode(stdin, true);
+      stdin.resume();
+    } catch {
+      resolve2(null);
+      return;
+    }
+    out("\x1B[?25l");
+    paint();
+    stdin.on("data", onData);
+    stdin.once("close", onClose);
+    interval = setInterval(() => {
+      remaining -= 1;
+      if (remaining <= 0) {
+        pick();
+        return;
+      }
+      paint();
+    }, 1e3);
+  });
+}
+async function promptSummaryGate(deps) {
+  const { renderer, reader, lastChoice } = deps;
+  if (!lastChoice) return "re-prompt";
+  const modeLabel = describeMode(lastChoice.mode);
+  const portStr = typeof lastChoice.port === "number" ? ` \xB7 port ${color.bold(String(lastChoice.port))}` : "";
+  const hostStr = typeof lastChoice.host === "string" ? ` \xB7 host ${color.dim(lastChoice.host)}` : "";
+  renderer.write(`
+  ${color.dim("\u2500".repeat(48))}
+`);
+  renderer.write(
+    `  ${color.cyan("\u23CE")}  ${color.dim("Last settings:")} ${color.bold(modeLabel)}${portStr}${hostStr}
+`
+  );
+  renderer.write(`  ${color.dim("\u2500".repeat(48))}
+`);
+  const answer = (await reader.readLine(
+    `  ${color.amber("?")} Continue with these? ${color.dim("[Y/n/q]")} ${color.dim("(auto Y in 5s)")} `,
+    { timeoutMs: SUMMARY_TIMEOUT_MS, defaultAnswer: "y" }
+  )).trim().toLowerCase();
+  if (answer === "q" || answer === "quit") {
+    renderer.write(color.dim("  Goodbye!\n"));
+    return "cancel";
+  }
+  if (answer === "n" || answer === "no") return "re-prompt";
+  return "use-last";
+}
+async function promptPort(deps, defaultPort) {
+  const { renderer, reader } = deps;
+  const maxRetries = 3;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const answer = (await reader.readLine(
+      `  ${color.amber("?")} Port ${color.dim(`[${defaultPort}]`)} ${color.dim("(Enter = default, q = cancel)")} `,
+      { timeoutMs: PORT_TIMEOUT_MS, defaultAnswer: "" }
+    )).trim();
+    if (answer === "" || answer === "\n") return defaultPort;
+    if (answer === "q" || answer === "quit") return defaultPort;
+    const parsed = Number.parseInt(answer, 10);
+    if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536) {
+      return parsed;
+    }
+    renderer.writeWarning(`  Invalid port "${answer}". Use 1\u201365535.
+`);
+  }
+  return defaultPort;
+}
+async function promptHost(deps, defaultHost) {
+  const { renderer, reader } = deps;
+  renderer.write(
+    `  ${color.dim("\u2139")} Press Enter to bind to ${color.bold(defaultHost)}${defaultHost === HQ_DEFAULT_HOST ? " (all interfaces)" : " (loopback)"}.
+`
+  );
+  const answer = (await reader.readLine(
+    `  ${color.amber("?")} Host ${color.dim(`[${defaultHost}]`)} ${color.dim("(Enter = default, q = cancel)")} `,
+    { timeoutMs: PORT_TIMEOUT_MS, defaultAnswer: "" }
+  )).trim();
+  if (answer === "" || answer === "q" || answer === "quit") return defaultHost;
+  return answer;
+}
+function finalize(choice, ports) {
+  if (!bindsPort(choice.mode)) return { ...choice, cancelled: false };
+  const fallback = ports[choice.mode];
+  return {
+    ...choice,
+    port: typeof choice.port === "number" ? choice.port : fallback,
+    host: choice.host ?? defaultHostFor(choice.mode),
+    cancelled: false
+  };
+}
+function describeMode(mode) {
+  switch (mode) {
+    case "tui-repl":
+      return "TUI / REPL";
+    case "webui":
+      return "WebUI";
+    case "simpleui":
+      return "SimpleUI";
+    case "hq":
+      return "HQ";
+    case "desktop":
+      return "Desktop";
+    default: {
+      const exhaustive = mode;
+      return String(exhaustive);
+    }
+  }
+}
+function applyLaunchMenuToArgv(argv, result) {
+  if (result.cancelled) return argv;
+  const out = [...argv];
+  switch (result.mode) {
+    case "tui-repl":
+      return out;
+    case "webui":
+      if (typeof result.port === "number") out.push(`--port=${result.port}`);
+      if (typeof result.host === "string") out.push(`--host=${result.host}`);
+      out.push("--webui");
+      return out;
+    case "simpleui":
+      if (typeof result.port === "number") out.push(`--port=${result.port}`);
+      if (typeof result.host === "string") out.push(`--host=${result.host}`);
+      out.push("--simpleui");
+      return out;
+    case "hq":
+      if (typeof result.port === "number") out.push(`--port=${result.port}`);
+      if (typeof result.host === "string") out.push(`--host=${result.host}`);
+      out.push("--hq");
+      return out;
+    case "desktop":
+      out.push("--desktop");
+      return out;
+    default: {
+      const exhaustive = result.mode;
+      void exhaustive;
+      return out;
+    }
+  }
+}
+function toPersistedMenuChoice(result) {
+  if (result.cancelled) return void 0;
+  if (result.mode === "tui-repl") return void 0;
+  const port = typeof result.port === "number" && Number.isFinite(result.port) && result.port > 0 && result.port < 65536 ? result.port : void 0;
+  return {
+    mode: result.mode,
+    ...port !== void 0 ? { port } : {},
+    ...typeof result.host === "string" && result.host.length > 0 ? { host: result.host } : {}
+  };
+}
+async function persistMenuChoice(globalConfigPath, choice) {
+  let fileExists = false;
+  try {
+    await fs.access(globalConfigPath);
+    fileExists = true;
+  } catch {
+  }
+  let existing = {};
+  try {
+    const raw = await fs.readFile(globalConfigPath, "utf8");
+    existing = JSON.parse(raw);
+  } catch (err) {
+    if (fileExists) {
+      throw new Error(
+        `Refusing to overwrite corrupt config at ${globalConfigPath} (${err.message}). Fix or move the file aside before retrying.`,
+        { cause: err }
+      );
+    }
+    existing = {};
+  }
+  const launch = existing.launch ?? {};
+  existing.launch = { ...launch, menuChoice: choice };
+  await atomicWrite(globalConfigPath, JSON.stringify(existing, null, 2), {
+    mode: 384
+  });
+}
+
+// src/boot/short-circuit-desktop.ts
+import { spawn } from "node:child_process";
+import { createRequire as createRequire3 } from "node:module";
+import * as path3 from "node:path";
+import { color as color2 } from "@wrongstack/core/utils";
+function stripDesktopLauncherArgs(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg) continue;
+    if (arg === "--desktop" || arg.startsWith("--desktop=")) continue;
+    if (i === 0 && arg === "desktop") continue;
+    out.push(arg);
+  }
+  return out;
+}
+async function handleDesktopShortCircuit(flags, argv) {
+  if (flags["desktop"] !== true) return null;
+  return launchDesktop(stripDesktopLauncherArgs(argv));
+}
+async function launchDesktop(args) {
+  const req = createRequire3(import.meta.url);
+  let launcherPath;
+  try {
+    const desktopPkgPath = req.resolve("@wrongstack/desktop/package.json");
+    launcherPath = path3.join(path3.dirname(desktopPkgPath), "bin", "wrongstack-desktop.js");
+  } catch {
+    process.stderr.write(
+      [
+        color2.red("\u2717 WrongStack Desktop is not installed."),
+        "",
+        "Install the desktop package:",
+        "  npm install -g @wrongstack/desktop",
+        "",
+        "The umbrella package also supports desktop when installed with optional dependencies:",
+        "  npm install -g wrongstack",
+        ""
+      ].join("\n")
+    );
+    return 1;
+  }
+  return await new Promise((resolve2) => {
+    const child = spawn(process.execPath, [launcherPath, ...args], {
+      stdio: "inherit",
+      env: process.env,
+      windowsHide: false
+    });
+    child.once("error", (err) => {
+      process.stderr.write(
+        `${color2.red("\u2717 Failed to start WrongStack Desktop:")} ${err.message}
+`
+      );
+      resolve2(1);
+    });
+    child.once("exit", (code, signal) => {
+      if (typeof code === "number") resolve2(code);
+      else resolve2(signal ? 1 : 0);
+    });
+  });
+}
+
+// src/boot/short-circuit-hq.ts
+import * as net from "node:net";
+import {
+  HQ_CLI_DEFAULT_HOST as HQ_CLI_DEFAULT_HOST2,
+  isLoopbackHost,
+  readHqRuntimeFileSync,
+  resolveHqDataDir
+} from "@wrongstack/core/hq";
+import { color as color3, isPidAlive } from "@wrongstack/core/utils";
+async function isHqAlreadyRunning(dataDir) {
+  const marker = readHqRuntimeFileSync(dataDir);
+  if (!marker) return null;
+  if (marker.pid && isPidAlive(marker.pid)) return marker;
+  return null;
+}
+async function isPortInUse(host, port) {
+  return new Promise((resolve2) => {
+    const server = net.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve2(true);
+      } else {
+        resolve2(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close(() => resolve2(false));
+    });
+    server.listen(port, host);
+  });
+}
+async function handleHqShortCircuit(flags) {
+  if (flags["hq"] !== true) return null;
+  const { startHqServer } = await import("./hq-server-OARPUSQJ.js");
+  const tunnelRequested = flags["tunnel"] === true;
+  const host = typeof flags["host"] === "string" ? flags["host"] : tunnelRequested ? "127.0.0.1" : HQ_CLI_DEFAULT_HOST2;
+  if (tunnelRequested && !isLoopbackHost(host)) {
+    process.stderr.write(
+      `${color3.red("\u2717")} --tunnel requires a loopback origin. Remove --host or use --host 127.0.0.1.
+`
+    );
+    return 1;
+  }
+  let port;
+  if (typeof flags["port"] === "string" && flags["port"].trim() !== "") {
+    const parsed = Number.parseInt(flags["port"], 10);
+    if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536) {
+      port = parsed;
+    } else {
+      process.stderr.write(`${color3.red("\u2717")} Invalid --port value: ${flags["port"]}
+`);
+      return 1;
+    }
+  } else port = DEFAULT_PORT;
+  const dataDir = typeof flags["data-dir"] === "string" ? flags["data-dir"] : void 0;
+  const password = typeof flags["password"] === "string" ? flags["password"] : process.env.WRONGSTACK_HQ_PASSWORD;
+  if (password !== void 0 && password.length < 8) {
+    process.stderr.write(`${color3.red("\u2717")} HQ password must be at least 8 characters.
+`);
+    return 1;
+  }
+  const userProvidedPort = typeof flags["port"] === "string" && flags["port"].trim() !== "" || port !== DEFAULT_PORT;
+  const resolvedDataDir = dataDir ?? resolveHqDataDir();
+  const existing = await isHqAlreadyRunning(resolvedDataDir);
+  if (existing) {
+    process.stderr.write(
+      `${color3.red("\u2717")} HQ is already running at ${existing.url} (PID ${existing.pid}). Stop it first or use a different --data-dir.
+`
+    );
+    return 1;
+  }
+  if (await isPortInUse(host, port)) {
+    process.stderr.write(
+      `${color3.red("\u2717")} Port ${port} is already in use. Choose a different port or stop the process using it.
+`
+    );
+    return 1;
+  }
+  let tokenTtlMs;
+  const rawTtl = typeof flags["hq-token-ttl"] === "string" ? flags["hq-token-ttl"] : process.env.WRONGSTACK_HQ_TOKEN_TTL;
+  if (rawTtl !== void 0 && rawTtl.length > 0) {
+    const { parseTokenTtlValue } = await import("./hq-ttl-KUO3AU7X.js");
+    const parsed = parseTokenTtlValue(rawTtl);
+    if (parsed.error) {
+      process.stderr.write(`${color3.red("\u2717")} Invalid --hq-token-ttl: ${parsed.error}
+`);
+      return 1;
+    }
+    tokenTtlMs = parsed.value;
+  }
+  let handle;
+  try {
+    handle = await startHqServer({
+      host,
+      port,
+      strictPort: flags["strict-port"] === true,
+      exactPort: userProvidedPort,
+      allowInsecureOpen: flags["insecure-open"] === true,
+      secureCookies: tunnelRequested,
+      requireBrowserAuth: tunnelRequested,
+      ...dataDir !== void 0 ? { dataDir } : {},
+      ...password !== void 0 ? { password } : {},
+      ...tokenTtlMs !== void 0 ? { tokenTtlMs } : {}
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (err instanceof Error && "code" in err && err.code === "EADDRINUSE") {
+      process.stderr.write(
+        `${color3.red("\u2717")} Port ${port} is already in use. Please choose a different port.
+`
+      );
+    } else {
+      process.stderr.write(`${color3.red("\u2717")} Failed to start HQ server: ${msg}
+`);
+    }
+    return 1;
+  }
+  let tunnel;
+  let browserUrl = handle.firstRunSetup?.browserUrl ?? `http://${handle.host}:${handle.port}`;
+  if (tunnelRequested) {
+    if (handle.firstRunSetup !== void 0 && !handle.firstRunSetup.browserTokenMode && !handle.firstRunSetup.passwordMode) {
+      await handle.close();
+      process.stderr.write(
+        `${color3.red("\u2717")} Refusing to publish HQ in open mode. Set --password or create a browser token first.
+`
+      );
+      return 1;
+    }
+    try {
+      const { buildPublicHqUrl, startHqQuickTunnel } = await import("./hq-tunnel-LO55RCZE.js");
+      const originHost = handle.host === "::1" ? "[::1]" : handle.host;
+      tunnel = await startHqQuickTunnel(`http://${originHost}:${handle.port}`, {
+        onUnexpectedExit: (message) => process.stderr.write(`${color3.yellow("!")} ${message}
+`)
+      });
+      handle.trustPublicOrigin(new URL(tunnel.url).origin);
+      browserUrl = buildPublicHqUrl(
+        tunnel.url,
+        handle.firstRunSetup?.browserUrl,
+        handle.firstRunSetup?.passwordMode !== true
+      );
+      process.stdout.write(`
+${color3.green("Cloudflare Quick Tunnel ready:")} ${browserUrl}
+`);
+      process.stdout.write(
+        `${color3.dim("Temporary development URL; DNS may need a few seconds, it changes on restart and ends when HQ stops.")}
+`
+      );
+    } catch (err) {
+      await handle.close();
+      process.stderr.write(
+        `${color3.red("\u2717")} Failed to start Cloudflare Quick Tunnel: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return 1;
+    }
+  }
+  if (flags["open"] === true) {
+    try {
+      const { openBrowser } = await import("@wrongstack/webui-server");
+      openBrowser(browserUrl);
+    } catch {
+    }
+  }
+  await new Promise((resolve2) => {
+    const shutdown = async () => {
+      const results = await Promise.allSettled([
+        ...tunnel ? [tunnel.close()] : [],
+        handle.close()
+      ]);
+      const failure = results.find(
+        (result) => result.status === "rejected"
+      );
+      if (failure) {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "hq.server_close_failed",
+            message: String(failure.reason),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+      resolve2();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  return 0;
+}
+
+// src/boot.ts
+import * as fs7 from "node:fs/promises";
+import { createRequire as createRequire4 } from "node:module";
+import * as os from "node:os";
+import * as path8 from "node:path";
+import { fileURLToPath } from "node:url";
+import { toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
+import { DefaultLogger } from "@wrongstack/core/infrastructure";
+import { TOKENS as TOKENS2 } from "@wrongstack/core/kernel";
+import { DefaultModelsRegistry } from "@wrongstack/core/models";
+import { ToolRegistry } from "@wrongstack/core/registry";
+import { normalizeTokenSavingTier } from "@wrongstack/core/types";
+import { isSetupProvider, SETUP_MODEL_ID, SETUP_PROVIDER_ID } from "@wrongstack/providers";
+import { color as color11, isStdinTTY as isStdinTTY2, writeErr } from "@wrongstack/core/utils";
+import { createDefaultContainer as createDefaultContainer2 } from "@wrongstack/runtime";
+import { registerBuiltinToolTier } from "@wrongstack/tools/tool-tier";
+
+// src/boot/config-backup-recovery.ts
+import * as fs2 from "node:fs/promises";
+import * as path4 from "node:path";
+import { atomicWrite as atomicWrite2, backupConfigFile, color as color4, toErrorMessage } from "@wrongstack/core/utils";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function providerIds(value) {
+  if (!isRecord(value)) return [];
+  const providers = value["providers"];
+  return isRecord(providers) ? Object.keys(providers) : [];
+}
+async function defaultProfileProvidersAreEmpty(profilePath) {
+  try {
+    const parsed = JSON.parse(await fs2.readFile(profilePath, "utf8"));
+    return providerIds(parsed).length === 0;
+  } catch {
+    return false;
+  }
+}
+function profileSnapshotTimestamp(fileName, fallback) {
+  const match = /^profiles-default-config-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})\.json$/i.exec(
+    fileName
+  );
+  if (!match) return fallback;
+  const [, year, month, day, hour, minute, second, millisecond] = match;
+  return Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millisecond)
+  );
+}
+async function findLatestProviderBackup(globalRoot) {
+  const directory = path4.join(globalRoot, "config-history");
+  const candidates = [];
+  let entries;
+  try {
+    entries = await fs2.readdir(directory, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !/^profiles-default-config-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}\.json$/i.test(entry.name)) {
+      continue;
+    }
+    const filePath = path4.join(directory, entry.name);
+    try {
+      const stat2 = await fs2.stat(filePath);
+      candidates.push({
+        filePath,
+        fileName: entry.name,
+        modifiedAtMs: profileSnapshotTimestamp(entry.name, stat2.mtimeMs)
+      });
+    } catch {
+    }
+  }
+  candidates.sort((a, b) => b.modifiedAtMs - a.modifiedAtMs);
+  for (const candidate of candidates) {
+    try {
+      const raw = await fs2.readFile(candidate.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const ids = providerIds(parsed);
+      if (ids.length === 0) continue;
+      return { ...candidate, raw, providerIds: ids };
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function restoreDefaultProfileBackup(opts) {
+  await backupConfigFile(opts.profilePath, { globalRoot: opts.globalRoot });
+  await fs2.mkdir(path4.dirname(opts.profilePath), { recursive: true });
+  await atomicWrite2(opts.profilePath, opts.backup.raw, { mode: 384 });
+}
+async function maybeRestoreDefaultProfileFromBackup(opts) {
+  if (!await defaultProfileProvidersAreEmpty(opts.profilePath)) return false;
+  const backup = await findLatestProviderBackup(opts.globalRoot);
+  if (!backup) return false;
+  const shownProviders = backup.providerIds.slice(0, 5).join(", ");
+  const remainder = backup.providerIds.length - 5;
+  const providerSummary = remainder > 0 ? `${shownProviders} +${remainder}` : shownProviders;
+  opts.renderer.write(
+    `
+  ${color4.amber("\u25CB")} ${color4.bold("default")} profile has no saved providers.
+  ${color4.dim("Latest usable backup:")} ${color4.bold(backup.fileName)} ${color4.dim(`(${backup.providerIds.length} provider: ${providerSummary})`)}
+`
+  );
+  const answer = (await opts.reader.readLine(
+    `  ${color4.amber("?")} Restore all settings from this backup? ${color4.dim("[Y/n]")} `
+  )).trim().toLowerCase();
+  if (answer === "n" || answer === "no") return false;
+  try {
+    await restoreDefaultProfileBackup({
+      backup,
+      globalRoot: opts.globalRoot,
+      profilePath: opts.profilePath
+    });
+    opts.renderer.write(
+      `  ${color4.green("\u2713")} Restored all settings from ${color4.dim(backup.fileName)}
+`
+    );
+    return true;
+  } catch (err) {
+    opts.renderer.writeWarning(`Could not restore config backup: ${toErrorMessage(err)}
+`);
+    return false;
+  }
+}
+
+// src/boot/system-prompt-menu.ts
+import {
+  countSystemPromptTokens,
+  persistSystemPromptVariant,
+  readSavedSystemPromptVariant,
+  SYSTEM_PROMPT_VARIANT_OPTIONS,
+  SYSTEM_PROMPT_VARIANTS
+} from "@wrongstack/core/agent";
+import { color as color8 } from "@wrongstack/core/utils";
+
+// src/pre-launch/first-run.ts
+import { hasProviderCredential } from "@wrongstack/core/models";
+import { color as color5, toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+import { PROVIDER_DEFINITIONS } from "@wrongstack/providers/definitions";
+async function hasAnyCredential(config, modelsRegistry, env = process.env) {
+  for (const cfg of Object.values(config.providers ?? {})) {
+    if (!cfg) continue;
+    if (resolveActiveApiKey(cfg) !== void 0) return true;
+    if (isKeylessLocalProvider({ apiBase: cfg.baseUrl, envVars: cfg.envVars })) return true;
+    if ((cfg.envVars ?? []).some((name) => !!env[name])) return true;
+  }
+  for (const definition of Object.values(PROVIDER_DEFINITIONS)) {
+    if (definition.envVars.some((name) => !!env[name])) return true;
+  }
+  try {
+    const catalog = await modelsRegistry.listProviders();
+    for (const provider of catalog) {
+      if (hasProviderCredential(provider, config, env)) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function renderWelcome(renderer) {
+  renderer.write("\n");
+  renderer.write(`${boxTop("Welcome to WrongStack")}
+`);
+  renderer.write(
+    `${boxRow(color5.dim("No model is connected yet. Pick how you want to connect one:"))}
+`
+  );
+  renderer.write(`${boxDivider()}
+`);
+  renderer.write(
+    `${boxRow(
+      `${theme.accent("1")}  ${color5.bold("Sign in with a subscription")}  ${color5.dim("ChatGPT \xB7 Claude \xB7 GitHub Copilot")}`
+    )}
+`
+  );
+  renderer.write(
+    `${boxRow(
+      `${theme.accent("2")}  ${color5.bold("Add an API key")}              ${color5.dim("Anthropic \xB7 OpenAI \xB7 Google \xB7 OpenRouter \xB7 \u2026")}`
+    )}
+`
+  );
+  renderer.write(
+    `${boxRow(
+      `${theme.accent("3")}  ${color5.bold("Use a local server")}          ${color5.dim("Ollama \xB7 LM Studio \xB7 vLLM \xB7 OmniRoute")}`
+    )}
+`
+  );
+  renderer.write(
+    `${boxRow(
+      `${theme.accent("4")}  ${color5.bold("Continue without a key")}      ${color5.dim("setup mode \u2014 explore the app, no model")}`
+    )}
+`
+  );
+  renderer.write(`${boxDivider()}
+`);
+  renderer.write(
+    `${boxRow(color5.dim("You can change this any time with /auth inside the app, or `wstack auth`."))}
+`
+  );
+  renderer.write(`${boxBottom()}
+`);
+}
+async function runFirstRunSetup(deps) {
+  const { renderer, reader } = deps;
+  const authDeps = {
+    renderer,
+    reader,
+    modelsRegistry: deps.modelsRegistry,
+    vault: deps.vault,
+    profileConfigPath: deps.profileConfigPath
+  };
+  for (; ; ) {
+    renderWelcome(renderer);
+    const answer = (await reader.readLine(
+      `
+${color5.amber("?")} Choose ${color5.dim("(1-4)")} ${color5.dim("[q to quit]")}: `
+    )).trim().toLowerCase();
+    if (!answer || answer === "q" || answer === "quit" || answer === "exit") {
+      renderer.write(
+        `
+  ${color5.dim("No provider configured. Run")} ${color5.bold("wstack auth")} ${color5.dim("when you are ready.")}
+
+`
+      );
+      return { kind: "quit" };
+    }
+    if (answer === "4" || answer === "setup" || answer === "skip") {
+      return { kind: "setup-mode" };
+    }
+    const flow = answer === "1" || answer === "signin" || answer === "login" ? () => runOAuthLoginMenu(authDeps) : answer === "2" || answer === "key" || answer === "api" ? () => addFromCatalog(authDeps) : answer === "3" || answer === "local" ? () => runAuthLocal(authDeps) : void 0;
+    if (!flow) {
+      renderer.writeError(`Unknown selection: "${answer}"`);
+      continue;
+    }
+    try {
+      await flow();
+    } catch (err) {
+      renderer.writeWarning(`Setup step did not complete: ${toErrorMessage2(err)}
+`);
+    }
+    let updated;
+    try {
+      updated = await deps.reloadConfig();
+    } catch (err) {
+      renderer.writeWarning(`Could not re-read config: ${toErrorMessage2(err)}
+`);
+      continue;
+    }
+    if (await hasAnyCredential(updated, deps.modelsRegistry)) {
+      return { kind: "configured" };
+    }
+    renderer.writeWarning("Still no usable credential \u2014 pick another option.\n");
+  }
+}
+
+// src/pre-launch/launch-prompts.ts
+import * as fs3 from "node:fs/promises";
+import { atomicWrite as atomicWrite3, color as color6 } from "@wrongstack/core/utils";
+var LaunchAbortedError = class extends Error {
+  exitCode = 0;
+  constructor() {
+    super("Launch cancelled by user");
+    this.name = "LaunchAbortedError";
+  }
+};
+async function runLaunchPrompts(opts) {
+  const { renderer, reader, modePinned, yoloPinned, autonomyPinned, lastChoices } = opts;
+  if (modePinned !== void 0 && yoloPinned !== void 0 && autonomyPinned !== void 0) {
+    return {
+      mode: modePinned,
+      yolo: yoloPinned,
+      autonomy: autonomyPinned
+    };
+  }
+  if (!lastChoices) {
+    return {
+      mode: modePinned ?? "tui",
+      yolo: yoloPinned ?? true,
+      autonomy: autonomyPinned ?? "auto"
+    };
+  }
+  const hasOverride = modePinned !== void 0 && modePinned !== lastChoices.mode || yoloPinned !== void 0 && yoloPinned !== lastChoices.yolo || autonomyPinned !== void 0 && autonomyPinned !== lastChoices.autonomy;
+  if (lastChoices && !hasOverride) {
+    const effective = {
+      mode: modePinned ?? lastChoices.mode,
+      yolo: yoloPinned ?? lastChoices.yolo,
+      autonomy: autonomyPinned ?? lastChoices.autonomy
+    };
+    const onOff = (v) => v ? color6.green("on") : color6.dim("off");
+    const modeLabel = effective.mode.toUpperCase();
+    renderer.write(
+      `
+  ${color6.dim("Last settings:")} ${color6.bold(modeLabel)} \xB7 YOLO ${onOff(effective.yolo)} \xB7 Autonomy ${effective.autonomy === "auto" ? color6.green("auto") : color6.dim("off")}
+`
+    );
+    const answer = (await reader.readLine(
+      `  ${color6.amber("?")} Continue with these? ${color6.dim("[Y/n/q]")} ${color6.dim("(auto Y in 5s)")} `,
+      { timeoutMs: 5e3, defaultAnswer: "y" }
+    )).trim().toLowerCase();
+    if (answer === "q") {
+      renderer.write(color6.dim("  Goodbye!\n"));
+      throw new LaunchAbortedError();
+    }
+    if (answer !== "n" && answer !== "no") {
+      const badges2 = buildBadges(effective);
+      const badgeStr2 = badges2.length > 0 ? ` (${badges2.join(" \xB7 ")})` : "";
+      renderer.write(
+        `
+  ${color6.green("\u25B6")} Launching in ${color6.bold(modeLabel)} mode${badgeStr2}
+
+`
+      );
+      return effective;
+    }
+  }
+  let mode;
+  if (modePinned) {
+    mode = modePinned;
+  } else {
+    const answer = (await reader.readLine(
+      `
+  ${color6.amber("?")} Interactive mode: ${color6.bold("T")}UI / ${color6.bold("R")}EPL ${color6.dim("[T/r/q]")} `
+    )).trim().toLowerCase();
+    if (answer === "q") {
+      renderer.write(color6.dim("  Goodbye!\n"));
+      throw new LaunchAbortedError();
+    }
+    mode = answer === "r" || answer === "repl" ? "repl" : "tui";
+  }
+  let yolo;
+  if (yoloPinned !== void 0 && yoloPinned === lastChoices?.yolo) {
+    yolo = yoloPinned;
+  } else {
+    const answer = (await reader.readLine(
+      `  ${color6.amber("?")} YOLO mode ${color6.dim("(auto-approve tool calls)")} ${color6.dim("[Y/n/q]")} `
+    )).trim().toLowerCase();
+    if (answer === "q") {
+      renderer.write(color6.dim("  Goodbye!\n"));
+      throw new LaunchAbortedError();
+    }
+    yolo = answer !== "n" && answer !== "no";
+  }
+  let autonomy;
+  if (autonomyPinned !== void 0 && autonomyPinned === lastChoices?.autonomy) {
+    autonomy = autonomyPinned;
+  } else {
+    const answer = (await reader.readLine(
+      `  ${color6.amber("?")} Autonomy mode ${color6.dim("(auto-continue \u2014 agent picks next step)")} ${color6.dim("[Y/n/q]")} `
+    )).trim().toLowerCase();
+    if (answer === "q") {
+      renderer.write(color6.dim("  Goodbye!\n"));
+      throw new LaunchAbortedError();
+    }
+    autonomy = answer !== "n" && answer !== "no" ? "auto" : "off";
+  }
+  const badges = buildBadges({ mode, yolo, autonomy });
+  const badgeStr = badges.length > 0 ? ` (${badges.join(" \xB7 ")})` : "";
+  renderer.write(
+    `
+  ${color6.green("\u25B6")} Launching in ${color6.bold(mode.toUpperCase())} mode${badgeStr}
+
+`
+  );
+  return { mode, yolo, autonomy };
+}
+function buildBadges(chosen) {
+  const badges = [];
+  if (chosen.yolo) badges.push(color6.yellow("YOLO"));
+  if (chosen.autonomy !== "off")
+    badges.push(color6.magenta(`AUTONOMY:${chosen.autonomy.toUpperCase()}`));
+  return badges;
+}
+async function persistLaunchChoices(configPath, choices) {
+  let fileExists = false;
+  try {
+    await fs3.access(configPath);
+    fileExists = true;
+  } catch {
+  }
+  let existing = {};
+  try {
+    const raw = await fs3.readFile(configPath, "utf8");
+    existing = JSON.parse(raw);
+  } catch (err) {
+    if (fileExists) {
+      throw new Error(
+        `Refusing to overwrite corrupt config at ${configPath} (${err.message}). Fix or move the file aside before retrying.`,
+        { cause: err }
+      );
+    }
+    existing = {};
+  }
+  existing.yolo = choices.yolo;
+  existing.launch = {
+    mode: choices.mode,
+    autonomy: choices.autonomy
+  };
+  await atomicWrite3(configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+}
+
+// src/pre-launch/project-check.ts
+import * as fs4 from "node:fs/promises";
+import * as path5 from "node:path";
+import { color as color7, toErrorMessage as toErrorMessage3 } from "@wrongstack/core/utils";
+var MANIFESTS = [
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "Makefile",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "composer.json",
+  "Gemfile"
+];
+async function detectProjectKind(projectRoot) {
+  try {
+    await fs4.access(path5.join(projectRoot, ".wrongstack", "AGENTS.md"));
+    return "initialized";
+  } catch {
+  }
+  for (const m of MANIFESTS) {
+    try {
+      await fs4.access(path5.join(projectRoot, m));
+      return "project";
+    } catch {
+    }
+  }
+  return "empty";
+}
+async function scaffoldAgentsMd(projectRoot) {
+  const dir = path5.join(projectRoot, ".wrongstack");
+  const file = path5.join(dir, "AGENTS.md");
+  const facts = await detectProjectFacts(projectRoot);
+  const body = renderAgentsTemplate(facts);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(file, body, "utf8");
+  return file;
+}
+async function runProjectCheck(opts) {
+  const { projectRoot, cwd, renderer, reader } = opts;
+  const kind = await detectProjectKind(projectRoot);
+  if (kind === "initialized") {
+    renderer.write(
+      `
+  ${color7.green("\u2713")} Project initialized ${color7.dim(`(${path5.join(projectRoot, ".wrongstack", "AGENTS.md")})`)}
+`
+    );
+    return true;
+  }
+  if (kind === "project") {
+    renderer.write(
+      `
+  ${color7.amber("\u25CF")} Project detected ${color7.dim(`(${projectRoot})`)} but ${color7.bold(".wrongstack/AGENTS.md")} is missing.
+`
+    );
+    const answer2 = (await reader.readLine(
+      `  ${color7.amber("?")} Scaffold ${color7.bold("AGENTS.md")} now? ${color7.dim("[y/N/q]")} `
+    )).trim().toLowerCase();
+    if (answer2 === "q") {
+      renderer.write(color7.dim("  Cancelled.\n"));
+      return false;
+    }
+    if (answer2 === "y" || answer2 === "yes") {
+      try {
+        const file = await scaffoldAgentsMd(projectRoot);
+        renderer.write(`  ${color7.green("\u2713")} Wrote ${color7.dim(file)}
+`);
+      } catch (err) {
+        renderer.writeError(`Failed to scaffold AGENTS.md: ${toErrorMessage3(err)}`);
+      }
+    }
+    return true;
+  }
+  const gitDir = path5.join(projectRoot, ".git");
+  let hasGit = false;
+  try {
+    await fs4.access(gitDir);
+    hasGit = true;
+  } catch {
+  }
+  if (!hasGit) {
+    renderer.write(
+      `
+  ${color7.dim("\u25CB")} ${color7.dim(`No project manifest in ${projectRoot} \u2014 running in a scratch directory.`)}
+`
+    );
+    const answer2 = (await reader.readLine(
+      `  ${color7.amber("?")} No git repo found. ${color7.bold("Initialize git?")} ${color7.dim("[y/N/q]")} `
+    )).trim().toLowerCase();
+    if (answer2 === "q") {
+      renderer.write(color7.dim("  Cancelled.\n"));
+      return false;
+    }
+    if (answer2 === "y" || answer2 === "yes") {
+      try {
+        const { spawn: spawn2 } = await import("node:child_process");
+        await new Promise((resolve2, reject) => {
+          const child = spawn2("git", ["init"], {
+            cwd,
+            signal: AbortSignal.timeout(1e4),
+            windowsHide: true
+          });
+          child.on("error", reject);
+          child.on(
+            "close",
+            (code) => code === 0 ? resolve2() : reject(new Error(`git init failed with ${code}`))
+          );
+        });
+        renderer.write(`  ${color7.green("\u2713")} Git repository initialized
+`);
+      } catch (err) {
+        renderer.writeError(`git init failed: ${toErrorMessage3(err)}
+`);
+      }
+    }
+  } else {
+    renderer.write(
+      `
+  ${color7.dim("\u25CB")} ${color7.dim(`No project manifest in ${projectRoot} \u2014 running in a scratch directory.`)}
+`
+    );
+  }
+  const answer = (await reader.readLine(`  ${color7.amber("?")} Continue anyway? ${color7.dim("[Y/n/q]")} `)).trim().toLowerCase();
+  if (answer === "q" || answer === "n" || answer === "no") {
+    renderer.write(color7.dim("  Cancelled.\n"));
+    return false;
+  }
+  return true;
+}
+
+// src/boot/system-prompt-menu.ts
+var SYSTEM_PROMPT_OPTIONS = SYSTEM_PROMPT_VARIANT_OPTIONS;
+var SUMMARY_TIMEOUT_MS2 = 5e3;
+function flagOn(value) {
+  if (value === true) return true;
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+function isSystemPromptPinned(flags) {
+  return flagOn(flags["system-pro"]) || flagOn(flags["system-lite"]) || typeof flags["system-prompt"] === "string";
+}
+function shouldSkipSystemPromptMenu(flags) {
+  if (isSystemPromptPinned(flags)) return true;
+  if (flags["no-menu"] === true) return true;
+  if (flags["no-interactive"] === true) return true;
+  if (flags["skip"] === true) return true;
+  if (flags["webui"] === true) return true;
+  return false;
+}
+function labelFor(variant) {
+  return SYSTEM_PROMPT_OPTIONS.find((o) => o.variant === variant)?.label ?? variant;
+}
+async function runSystemPromptMenu(deps) {
+  const { renderer, reader, paths, lastVariant } = deps;
+  const tokens = await countSystemPromptTokens(paths);
+  const defaultVariant = lastVariant ?? "default";
+  if (lastVariant) {
+    const answer2 = (await reader.readLine(
+      `  ${color8.amber("?")} Continue with ${color8.bold(labelFor(lastVariant))} system prompt ${color8.dim(`(~${fmtTok(tokens[lastVariant])} tokens)`)}? ${color8.dim("[Y/n/q]")} ${color8.dim("(auto Y in 5s)")} `,
+      { timeoutMs: SUMMARY_TIMEOUT_MS2, defaultAnswer: "y" }
+    )).trim().toLowerCase();
+    if (answer2 === "q" || answer2 === "quit") throw new LaunchAbortedError();
+    if (answer2 !== "n" && answer2 !== "no") return lastVariant;
+  }
+  renderer.write(`
+  ${color8.amber("?")} System prompt:
+`);
+  for (const [index, opt] of SYSTEM_PROMPT_OPTIONS.entries()) {
+    const num2 = index + 1;
+    const isDefault = opt.variant === defaultVariant;
+    const marker = isDefault ? color8.cyan("\u25CF") : color8.dim("\u25CB");
+    const label = isDefault ? color8.bold(opt.label) : opt.label;
+    renderer.write(
+      `    ${color8.dim(`${num2}.`)} ${marker} ${label.padEnd(9)} ${color8.dim(`~${fmtTok(tokens[opt.variant])} tokens`)}  ${color8.dim(opt.hint)}
+`
+    );
+  }
+  const answer = (await reader.readLine(
+    `
+  ${color8.amber("?")} Select system prompt ${color8.dim(`[1-${SYSTEM_PROMPT_OPTIONS.length}, Enter = ${labelFor(defaultVariant)}, q to quit]`)}: `
+  )).trim().toLowerCase();
+  if (answer === "q" || answer === "quit") throw new LaunchAbortedError();
+  if (!answer) return defaultVariant;
+  const num = Number.parseInt(answer, 10);
+  if (!Number.isNaN(num) && num >= 1 && num <= SYSTEM_PROMPT_OPTIONS.length) {
+    return SYSTEM_PROMPT_OPTIONS[num - 1].variant;
+  }
+  const byName = SYSTEM_PROMPT_OPTIONS.find(
+    (o) => o.label.toLowerCase() === answer || o.variant === answer
+  );
+  if (byName) return byName.variant;
+  return defaultVariant;
+}
+async function maybeRunSystemPromptMenu(opts) {
+  if (!opts.isInteractiveTTY) return { aborted: false, changed: false };
+  if (shouldSkipSystemPromptMenu(opts.flags)) return { aborted: false, changed: false };
+  let savedVariant;
+  try {
+    savedVariant = await readSavedSystemPromptVariant(opts.profileConfigPath);
+    const chosen = await runSystemPromptMenu({
+      renderer: opts.renderer,
+      reader: opts.reader,
+      lastVariant: savedVariant,
+      paths: opts.paths
+    });
+    if (chosen === savedVariant) return { variant: chosen, aborted: false, changed: false };
+    try {
+      await persistSystemPromptVariant(opts.profileConfigPath, chosen);
+    } catch (err) {
+      return { variant: chosen, aborted: false, changed: true, persistError: err };
+    }
+    return { variant: chosen, aborted: false, changed: true };
+  } catch (err) {
+    if (err instanceof LaunchAbortedError) return { aborted: true, changed: false };
+    throw err;
+  }
+}
+
+// src/boot-config.ts
+import { bootConfig as coreBootConfig } from "@wrongstack/core/infrastructure";
+async function bootConfig(flags) {
+  const isWebui = !!flags["webui"];
+  const opts = {
+    flags,
+    appLabel: "wstack",
+    ...isWebui ? { skipIdentityValidation: true } : {}
+  };
+  const { cwd, projectRoot, userHome, wpaths, pathResolver, config, vault } = await coreBootConfig(opts);
+  return {
+    paths: { cwd, projectRoot, userHome, wpaths, pathResolver },
+    config,
+    vault
+  };
+}
+
+// src/input-reader.ts
+import * as fs5 from "node:fs/promises";
+import * as path6 from "node:path";
+import * as readline from "node:readline";
+import {
+  resolveWstackPaths,
+  setOutputLineGuard,
+  setRawMode as setRawMode2,
+  writeOut
+} from "@wrongstack/core/utils";
+var ReadlineInputReader = class {
+  rl;
+  historyFile;
+  history = [];
+  pending = false;
+  suppressNextHistory = false;
+  constructor(opts = {}) {
+    this.historyFile = opts.historyFile ?? resolveWstackPaths({ projectRoot: process.cwd() }).historyFile;
+  }
+  async loadHistory() {
+    try {
+      const raw = await fs5.readFile(this.historyFile, "utf8");
+      this.history = raw.split("\n").filter(Boolean).slice(-1e3);
+    } catch {
+      this.history = [];
+    }
+  }
+  async saveHistory() {
+    try {
+      await fs5.mkdir(path6.dirname(this.historyFile), { recursive: true });
+      await fs5.writeFile(this.historyFile, this.history.slice(-1e3).join("\n"));
+    } catch {
+    }
+  }
+  shouldPersistHistory(line) {
+    return !/^\s*\/(?:telegram-setup|tg-setup)\s+\d+:[A-Za-z0-9_-]+(?:\s|$)/i.test(line);
+  }
+  ensure() {
+    if (!this.rl) {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        history: this.history,
+        terminal: process.stdin.isTTY
+      });
+    }
+    return this.rl;
+  }
+  async readLine(prompt, timeoutOpts) {
+    if (this.history.length === 0) await this.loadHistory();
+    while (this.pending) {
+      await new Promise((resolve2) => setTimeout(resolve2, 50));
+    }
+    this.pending = true;
+    try {
+      if (this.rl) {
+        const old = this.rl;
+        this.rl = void 0;
+        await new Promise((resolve2) => {
+          if (old.closed) {
+            resolve2();
+          } else {
+            old.once("close", resolve2);
+            old.close();
+          }
+        });
+      }
+      const fresh = this.ensure();
+      this.installPromptGuard(fresh);
+      const line = await new Promise((resolve2) => {
+        let settled = false;
+        let timeoutHandle;
+        const settle = (line2) => {
+          if (settled) return;
+          settled = true;
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          setOutputLineGuard(null);
+          resolve2(line2);
+        };
+        if (timeoutOpts) {
+          timeoutHandle = setTimeout(() => {
+            if (!settled) {
+              fresh.write(`${timeoutOpts.defaultAnswer}
+`);
+            }
+          }, timeoutOpts.timeoutMs);
+        }
+        fresh.question(prompt ?? "> ", (line2) => {
+          const persistHistory = !this.suppressNextHistory && this.shouldPersistHistory(line2);
+          this.suppressNextHistory = false;
+          if (line2.trim() && persistHistory) {
+            this.history.push(line2);
+            this.saveHistory().then(void 0, () => {
+            });
+          }
+          settle(line2);
+        });
+        fresh.once("close", () => settle(""));
+        fresh.on?.("error", (_e) => settle(""));
+      }).then((result) => {
+        if (this.rl === fresh) this.rl = void 0;
+        fresh.close();
+        return result;
+      });
+      return line;
+    } finally {
+      this.pending = false;
+    }
+  }
+  /**
+   * Install the out-of-band write guard for the active prompt. When a log
+   * line or other async output lands while the user is mid-type, the guard
+   * clears the draft row, lets the message print, then repaints the prompt
+   * and the in-progress draft (cursor preserved) via readline's own
+   * refresh. Without it, each async write leaves the half-typed line
+   * stranded as a fresh scrollback row.
+   *
+   * No-op on non-TTY output (piped/redirected) — there's no draft to
+   * protect and the ANSI clear/repaint would be noise in a file.
+   */
+  installPromptGuard(rl) {
+    const out = process.stdout;
+    if (!out.isTTY) {
+      setOutputLineGuard(null);
+      return;
+    }
+    setOutputLineGuard({
+      suspend() {
+        readline.cursorTo(out, 0);
+        readline.clearLine(out, 0);
+      },
+      resume() {
+        try {
+          rl.prompt(true);
+        } catch {
+        }
+      }
+    });
+  }
+  async readKey(prompt, options) {
+    setOutputLineGuard(null);
+    writeOut(prompt);
+    return new Promise((resolve2) => {
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      const wasPaused = stdin.isPaused();
+      setRawMode2(stdin, true);
+      stdin.resume();
+      const onData = (buf) => {
+        const key = buf.toString();
+        if (key === "") {
+          cleanup();
+          writeOut("\n");
+          resolve2("");
+          return;
+        }
+        const opt = options.find(
+          (o) => o.key.toLowerCase() === key.toLowerCase() || o.value === key
+        );
+        if (opt) {
+          cleanup();
+          writeOut(`${opt.key}
+`);
+          resolve2(opt.value);
+        }
+      };
+      const onClose = () => {
+        cleanup();
+        resolve2("");
+      };
+      const cleanup = () => {
+        stdin.off("data", onData);
+        stdin.off("close", onClose);
+        setRawMode2(stdin, wasRaw);
+        if (wasPaused) stdin.pause();
+      };
+      stdin.on("data", onData);
+      stdin.on("close", onClose);
+    });
+  }
+  /**
+   * Read a line of input while masking each character with a bullet so the
+   * user gets visual confirmation that bytes are arriving (especially on
+   * paste, which previously felt like nothing happened). Pasted chunks
+   * are echoed as a run of bullets, Backspace/DEL erases one bullet, and
+   * Ctrl+U / Ctrl+T are honored. Non-TTY input is read normally — there's
+   * nothing to hide when piped, and echoing bullets to a file is noise.
+   *
+   * Returns the raw entered string (no trim — caller decides).
+   */
+  async readSecret(prompt) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      this.suppressNextHistory = true;
+      return this.readLine(prompt);
+    }
+    setOutputLineGuard(null);
+    this.rl?.close();
+    this.rl = void 0;
+    writeOut(prompt);
+    return new Promise((resolve2) => {
+      let buf = "";
+      const wasRaw = stdin.isRaw;
+      const cleanup = () => {
+        stdin.off("data", onData);
+        setRawMode2(stdin, wasRaw);
+        stdin.pause();
+      };
+      try {
+        setRawMode2(stdin, true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+      } catch (setupErr) {
+        setRawMode2(stdin, wasRaw);
+        stdin.pause();
+        throw setupErr;
+      }
+      const eraseChar = () => {
+        writeOut("\b \b");
+      };
+      const eraseAll = () => {
+        for (let i = 0; i < buf.length; i++) eraseChar();
+      };
+      const onData = (chunk) => {
+        for (const ch of chunk) {
+          if (ch === "\r" || ch === "\n") {
+            cleanup();
+            writeOut(`  ${dim(`[${buf.length} chars]`)}
+`);
+            resolve2(buf);
+            return;
+          }
+          if (ch === "") {
+            cleanup();
+            writeOut("\n");
+            resolve2("");
+            return;
+          }
+          if (ch === "") {
+            eraseAll();
+            buf = "";
+            continue;
+          }
+          if (ch === "") {
+            const m = buf.match(/(\S+\s*)$/);
+            const drop = m ? m[0].length : buf.length;
+            for (let i = 0; i < drop; i++) eraseChar();
+            buf = buf.slice(0, buf.length - drop);
+            continue;
+          }
+          if (ch === "\x7F" || ch === "\b") {
+            if (buf.length > 0) {
+              buf = buf.slice(0, -1);
+              eraseChar();
+            }
+            continue;
+          }
+          if (ch < " ") continue;
+          buf += ch;
+          writeOut("\u2022");
+        }
+      };
+      stdin.on("data", onData);
+    });
+  }
+  async close() {
+    setOutputLineGuard(null);
+    await this.saveHistory();
+    this.rl?.close();
+    this.rl = void 0;
+  }
+};
+function dim(s) {
+  if (!process.stdout.isTTY) return s;
+  return `\x1B[2m${s}\x1B[22m`;
+}
+
+// src/launch-hints.ts
+import * as fs6 from "node:fs/promises";
+import * as path7 from "node:path";
+import { color as color9 } from "@wrongstack/core/utils";
+var GROUPS = [
+  {
+    title: "Autonomy",
+    items: [
+      { key: "/goal <text>", blurb: "lock in a verifiable mission \u2014 only Esc / Ctrl+C interrupt" },
+      {
+        key: "/autonomy eternal",
+        blurb: "sense \u2192 decide \u2192 execute \u2192 reflect loop until you stop it"
+      },
+      {
+        key: '--eternal "<mission>"',
+        blurb: "boot directly into the eternal-autonomy engine with a mission"
+      },
+      {
+        key: "/autonomy on|suggest",
+        blurb: "self-driving: auto-pick next step or just suggest it"
+      }
+    ]
+  },
+  {
+    title: "Agents & fleet",
+    items: [
+      {
+        key: "/delegate [--role=<role>] <task>",
+        blurb: "route work to a specialist; omit --role for automatic selection"
+      },
+      {
+        key: "/spawn [-p <provider>] [-m <model>] [-n <name>] <task>",
+        blurb: "launch one isolated subagent with optional runtime overrides"
+      },
+      {
+        key: "/agents [list|show <id>|stream on|off]",
+        blurb: "open the TUI monitor, inspect a subagent, or control its activity stream"
+      },
+      {
+        key: "/fleet status|usage|kill|log|manifest",
+        blurb: "inspect and control the active subagent fleet"
+      }
+    ]
+  },
+  {
+    title: "Steering",
+    items: [
+      {
+        key: "Esc (while busy)",
+        blurb: "soft interrupt \u2014 next message carries a STEERING preamble"
+      },
+      { key: "/steer <text>", blurb: "mid-flight redirect, works when Esc is eaten by tmux" },
+      { key: "/btw <note>", blurb: "non-aborting nudge \u2014 agent folds it in at its next step" },
+      {
+        key: "Ctrl+C \xD7 1 / \xD7 2 / \xD7 3",
+        blurb: "cancel iteration \xB7 force-exit Ink \xB7 hard exit(130)"
+      }
+    ]
+  },
+  {
+    title: "Modes & context",
+    items: [
+      {
+        key: "/mode",
+        blurb: "switch persona: code-reviewer, debugger, architect, tester, devops, \u2026"
+      },
+      { key: "/model", blurb: "two-step provider \u2192 model picker, hot-swap at runtime" },
+      { key: "/yolo on|off|toggle", blurb: "auto-approve tool calls without restart" },
+      {
+        key: "/context mode frugal|balanced|deep|archival",
+        blurb: "pick how aggressively history is trimmed"
+      },
+      { key: "/compact", blurb: "manually compact the in-flight context window" },
+      {
+        key: "/plan show|add|start|done",
+        blurb: "strategic roadmap, survives /resume across sessions"
+      }
+    ]
+  },
+  {
+    title: "Workspace tools",
+    items: [
+      {
+        key: "@<query>",
+        blurb: "search project files and insert a path into the prompt"
+      },
+      {
+        key: "Alt+V  \xB7  /image",
+        blurb: "attach a clipboard image in the TUI"
+      },
+      {
+        key: "/mcp  \xB7  wstack mcp add <name>",
+        blurb: "inspect or connect MCP servers"
+      },
+      {
+        key: "/plugin install|enable|disable <name>",
+        blurb: "manage optional integrations such as Telegram or LSP"
+      },
+      {
+        key: "/skill  \xB7  /init  \xB7  /commit",
+        blurb: "browse skills \xB7 scaffold project guidance \xB7 draft a commit"
+      },
+      {
+        key: "/diag  \xB7  wstack usage  \xB7  wstack resume <id>",
+        blurb: "inspect diagnostics, review costs, or continue an earlier session"
+      }
+    ]
+  }
+];
+var HINT_COUNT = GROUPS.reduce((n, g) => n + g.items.length, 0);
+var HINT_GROUP_COUNT = GROUPS.length;
+var HINT_GROUP_TITLES = GROUPS.map((g) => g.title);
+function shouldSuppress(flags) {
+  if (flags["no-hints"] === true) return true;
+  if (flags["hints"] === false) return true;
+  const env = process.env.WRONGSTACK_NO_HINTS;
+  if (env && env !== "0" && env.toLowerCase() !== "false") return true;
+  return false;
+}
+var DEFAULT_TERM_WIDTH = 80;
+var MIN_TERM_WIDTH = 20;
+var HINT_INDENT = "     ";
+var HINT_CONTINUATION_INDENT = "       ";
+var wrap = (n) => (n % GROUPS.length + GROUPS.length) % GROUPS.length;
+function displayWidth(value) {
+  return [...value].length;
+}
+function wrapWords(value, firstWidth, continuationWidth = firstWidth) {
+  const words = value.trim().split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = "";
+  let width = Math.max(1, firstWidth);
+  for (const sourceWord of words) {
+    let word = sourceWord;
+    while (word) {
+      if (line) {
+        if (displayWidth(line) + 1 + displayWidth(word) <= width) {
+          line += ` ${word}`;
+          word = "";
+        } else {
+          lines.push(line);
+          line = "";
+          width = Math.max(1, continuationWidth);
+        }
+        continue;
+      }
+      if (displayWidth(word) <= width) {
+        line = word;
+        word = "";
+      } else {
+        const characters = [...word];
+        lines.push(characters.slice(0, width).join(""));
+        word = characters.slice(width).join("");
+        width = Math.max(1, continuationWidth);
+      }
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+function renderHintLines(item, termWidth) {
+  const inline = `${HINT_INDENT}${item.key}  \u2014 ${item.blurb}`;
+  if (displayWidth(inline) <= termWidth) {
+    return [`${HINT_INDENT}${color9.bold(item.key)}  ${color9.dim("\u2014")} ${color9.dim(item.blurb)}`];
+  }
+  const lines = [];
+  const keyLines = wrapWords(
+    item.key,
+    termWidth - displayWidth(HINT_INDENT),
+    termWidth - displayWidth(HINT_CONTINUATION_INDENT)
+  );
+  keyLines.forEach((line, index) => {
+    const indent = index === 0 ? HINT_INDENT : HINT_CONTINUATION_INDENT;
+    lines.push(`${indent}${color9.bold(line)}`);
+  });
+  const blurbLines = wrapWords(
+    `\u2014 ${item.blurb}`,
+    termWidth - displayWidth(HINT_CONTINUATION_INDENT)
+  );
+  for (const line of blurbLines) lines.push(`${HINT_CONTINUATION_INDENT}${color9.dim(line)}`);
+  return lines;
+}
+function renderHeaderLines(group, groupIndex, termWidth) {
+  const progress = `${groupIndex + 1}/${GROUPS.length}`;
+  const plain = `  ${group.title}  ${progress}`;
+  if (displayWidth(plain) <= termWidth) {
+    return [
+      `  ${color9.cyan("\u25C7")} ${color9.bold(group.title)} ${color9.dim(progress)}`,
+      `  ${color9.dim("\u2500".repeat(Math.min(termWidth - 2, 48)))}`
+    ];
+  }
+  return [
+    `  ${color9.cyan("\u25C7")} ${color9.bold(group.title)}`,
+    `  ${color9.dim("\u2500".repeat(Math.min(termWidth - 2, 48)))}`
+  ];
+}
+function renderFooterLines(termWidth) {
+  const footer = "/help lists everything \xB7 hide with --no-hints";
+  if (displayWidth(`  ${footer}`) <= termWidth) {
+    return [
+      `  ${color9.dim("\u2500".repeat(Math.min(termWidth - 2, 48)))}`,
+      `  ${color9.dim(`${color9.bold("/help")} lists everything \xB7 hide with ${color9.bold("--no-hints")}`)}`
+    ];
+  }
+  return [...wrapWords(footer, termWidth - 2).map((line) => `  ${color9.dim(line)}`)];
+}
+async function pickGroupIndex(opts) {
+  if (typeof opts.groupIndex === "number") return wrap(opts.groupIndex);
+  if (opts.cursorFile) {
+    try {
+      let current = 0;
+      try {
+        const raw = await fs6.readFile(opts.cursorFile, "utf8");
+        const parsed = Number.parseInt(raw.trim(), 10);
+        if (Number.isFinite(parsed)) current = wrap(parsed);
+      } catch {
+      }
+      await fs6.mkdir(path7.dirname(opts.cursorFile), { recursive: true });
+      await fs6.writeFile(opts.cursorFile, String(wrap(current + 1)));
+      return current;
+    } catch {
+    }
+  }
+  return Math.floor(Math.random() * GROUPS.length);
+}
+async function printLaunchHints(renderer, flags, opts = {}) {
+  if (shouldSuppress(flags)) return;
+  const idx = await pickGroupIndex(opts);
+  const group = GROUPS[idx];
+  if (!group) return;
+  const termWidth = Math.max(
+    MIN_TERM_WIDTH,
+    Math.floor(opts.termWidth ?? process.stdout.columns ?? DEFAULT_TERM_WIDTH)
+  );
+  const lines = [];
+  lines.push("");
+  lines.push(...renderHeaderLines(group, idx, termWidth));
+  for (const item of group.items) lines.push(...renderHintLines(item, termWidth));
+  lines.push("");
+  lines.push(...renderFooterLines(termWidth));
+  lines.push("");
+  renderer.write(`${lines.join("\n")}
+`);
+}
+
+// src/renderer.ts
+import { color as color10 } from "@wrongstack/core/utils";
+var TerminalRenderer = class _TerminalRenderer {
+  out;
+  err;
+  lineStart = true;
+  /** When true, stdout-bound rendering is disabled (for non-terminal UI surfaces). */
+  silent = false;
+  /**
+   * When true, Ink exclusively owns the terminal. Both stdout and stderr
+   * rendering must be disabled: either stream can interleave with Ink's
+   * cursor updates and make the TUI flicker or leave stray debug notes.
+   */
+  tuiActive = false;
+  /**
+   * Per-tool on-screen result render mode. Defaults to `'extend'` so
+   * existing callers without `setResultRenderMode` see full content.
+   * `setResultRenderMode(name, mode)` overrides the entry for `name`; the
+   * override is one-shot for that name (the default reasserts after the
+   * next write) so callers can set the mode right before each tool call
+   * without leaking state across unrelated tool calls.
+   */
+  renderModes = /* @__PURE__ */ new Map();
+  /** Mode applied when no entry is set for a given tool name. */
+  static DEFAULT_RENDER_MODE = "extend";
+  /** Maximum number of one-shot hints retained when callers abandon a result. */
+  static MAX_RENDER_MODES = 256;
+  /** Lines kept per tool family in `extend` mode. */
+  static EXTEND_PREVIEW_LINES = 10;
+  constructor(opts = {}) {
+    this.out = opts.out ?? process.stdout;
+    this.err = opts.err ?? process.stderr;
+  }
+  /**
+   * Toggle stdout suppression for non-terminal UI surfaces such as WebUI.
+   * Diagnostics continue to flow to stderr. Idempotent.
+   */
+  setSilent(silent) {
+    this.silent = silent;
+  }
+  isSilent() {
+    return this.silent;
+  }
+  /**
+   * Toggle exclusive TUI ownership of both terminal streams. Unlike
+   * {@link setSilent}, TUI mode suppresses stderr as well as stdout and clears
+   * any CLI-only result mode staged before Ink took ownership. While active,
+   * new result-mode hints are ignored. The two flags compose with OR semantics
+   * for stdout suppression only; TUI ownership adds the other behaviors.
+   * Enable immediately before starting Ink and disable in the paired
+   * `finally`, only after the TUI has fully exited.
+   */
+  setTuiActive(active) {
+    if (active) this.renderModes.clear();
+    this.tuiActive = active;
+  }
+  isTuiActive() {
+    return this.tuiActive;
+  }
+  suppressStdout() {
+    return this.silent || this.tuiActive;
+  }
+  setResultRenderMode(name, mode) {
+    if (this.suppressStdout()) return;
+    if (this.renderModes.delete(name)) {
+      this.renderModes.set(name, mode);
+      return;
+    }
+    if (this.renderModes.size >= _TerminalRenderer.MAX_RENDER_MODES) {
+      const oldestName = this.renderModes.keys().next().value;
+      if (oldestName !== void 0) this.renderModes.delete(oldestName);
+    }
+    this.renderModes.set(name, mode);
+  }
+  getRenderMode(name) {
+    return this.renderModes.get(name) ?? _TerminalRenderer.DEFAULT_RENDER_MODE;
+  }
+  clearRenderMode(name) {
+    this.renderModes.delete(name);
+  }
+  write(input) {
+    if (this.suppressStdout()) return;
+    const text = typeof input === "string" ? input : input.text;
+    if (!text) return;
+    const rendered = renderMarkdown(text);
+    this.out.write(rendered);
+    this.lineStart = rendered.endsWith("\n");
+  }
+  writeLine(text = "") {
+    if (this.suppressStdout()) return;
+    if (!this.lineStart) this.out.write("\n");
+    if (text) this.out.write(`${text}
+`);
+    else this.out.write("\n");
+    this.lineStart = true;
+  }
+  writeBlock(block) {
+    if (block.type === "tool_result") {
+      const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+      this.writeToolResult(block.name ?? "result", text, !!block.is_error);
+      return;
+    }
+    if (this.suppressStdout()) return;
+    if (block.type === "text") {
+      this.write(block);
+    } else if (block.type === "tool_use") {
+      this.writeToolCall(block.name, block.input);
+    }
+  }
+  writeToolCall(name, input) {
+    if (this.suppressStdout()) return;
+    if (!this.lineStart) this.out.write("\n");
+    const arrow = theme2.primary("\u2192");
+    const display = formatInputSummary(input);
+    this.out.write(`${arrow} ${theme2.bold(name)}${display ? color10.dim(` ${display}`) : ""}
+`);
+    this.lineStart = true;
+  }
+  writeToolResult(name, content, isError) {
+    if (this.suppressStdout()) {
+      this.clearRenderMode(name);
+      return;
+    }
+    const txt = typeof content === "string" ? content : safeStringify(content);
+    const prefix = isError ? theme2.error("\u2718") : theme2.success("\u2713");
+    const renderMode = this.getRenderMode(name);
+    this.clearRenderMode(name);
+    const bodyText = extractBodyText(content, name);
+    if (isError) {
+      const firstLine = txt.split("\n")[0] ?? "";
+      const truncated = firstLine.length > 200 ? `${firstLine.slice(0, 197)}\u2026` : firstLine;
+      this.out.write(`  ${prefix} ${color10.dim(truncated)}
+`);
+      this.lineStart = true;
+      return;
+    }
+    const isEditLike = name === "edit" || name === "write";
+    const diff = extractDiff(content);
+    if (isEditLike && diff) {
+      this.out.write(`  ${prefix} ${color10.dim(summarize(content, name))}
+`);
+      const rendered = renderDiff(diff).split("\n").map((l) => `      ${l}`).join("\n");
+      this.out.write(`${rendered}
+`);
+      this.lineStart = true;
+      return;
+    }
+    const summary = summarize(content, name);
+    const isReadLike = name === "read" || name === "grep" || name === "glob" || name === "bash" || name === "exec";
+    if (renderMode === "simple") {
+      this.out.write(`  ${prefix} ${color10.dim(summary || compactSingleLine(bodyText))}
+`);
+      this.lineStart = true;
+      return;
+    }
+    const previewLines = isEditLike ? 0 : isReadLike ? _TerminalRenderer.EXTEND_PREVIEW_LINES : 2;
+    const lines = bodyText.split("\n");
+    const head = lines.slice(0, previewLines).map((l) => l.replace(/\s+$/, ""));
+    const moreCount = Math.max(0, lines.length - head.length);
+    this.out.write(`  ${prefix} ${color10.dim(summary)}
+`);
+    for (const l of head) {
+      const capped = l.length > 200 ? `${l.slice(0, 197)}\u2026` : l;
+      this.out.write(`      ${color10.dim(capped)}
+`);
+    }
+    if (moreCount > 0) {
+      this.out.write(
+        `      ${color10.dim(`+${moreCount} more line${moreCount === 1 ? "" : "s"}`)}
+`
+      );
+    }
+    this.lineStart = true;
+  }
+  writeDiff(diff) {
+    if (this.suppressStdout()) return;
+    if (!this.lineStart) this.out.write("\n");
+    this.out.write(`${renderDiff(diff)}
+`);
+    this.lineStart = true;
+  }
+  writeWarning(text) {
+    if (this.tuiActive) return;
+    this.err.write(`${theme2.warn("\u26A0")} ${text}
+`);
+  }
+  writeError(text) {
+    if (this.tuiActive) return;
+    this.err.write(`${theme2.error("\u2718")} ${text}
+`);
+  }
+  writeInfo(text) {
+    if (this.tuiActive) return;
+    this.err.write(`${theme2.info("\u2139")} ${text}
+`);
+  }
+  /**
+   * Write text to stderr verbatim: no glyph prefix, no markdown processing.
+   *
+   * Deliberately stricter than writeWarning/writeError/writeInfo, which emit
+   * *diagnostics* and are suppressed only when a TUI owns the terminal (so
+   * they survive silent mode). This method is for informational mirrors of
+   * stdout output, where the stdout copy already carries the full content —
+   * in silent mode the operator asked for machine-only output, so the mirror
+   * is dropped rather than leaked onto a quieter stream. It therefore honors
+   * the full {@link suppressStdout} gate.
+   *
+   * Used by `wstack mailbox serve` to route the human-readable startup banner
+   * away from stdout, keeping the mailbox_serve_started JSON line cleanly
+   * pipeable (`mailbox serve | jq`).
+   */
+  writeStderr(text) {
+    if (this.suppressStdout()) return;
+    this.err.write(text);
+  }
+  clear() {
+    if (this.suppressStdout()) return;
+    this.out.write("\x1B[2J\x1B[H");
+    this.lineStart = true;
+  }
+  /**
+   * Write a flashy agent completion banner for delegate tool results.
+   * Renders a box like:
+   * ┌─────────────────────────────────────┐
+   * │  ✓ [role] done in 4m 32s           │
+   * │    127 iterations · 341 tools        │
+   * │    Found 14 bugs across 6 files...   │
+   * └─────────────────────────────────────┘
+   */
+  writeAgentSummary(summary, ok) {
+    if (this.suppressStdout()) return;
+    if (!this.lineStart) this.out.write("\n");
+    const lines = summary.split("\n");
+    const icon = ok ? theme2.success("\u2713") : theme2.error("\u2718");
+    const firstLine = `${icon} ${lines[0] ?? summary}`;
+    const body = lines.slice(1);
+    const maxWidth = Math.min(process.stdout.columns ?? 80, 120);
+    const contentWidth = Math.max(
+      firstLine.length,
+      body.reduce((a, l) => Math.max(a, l.length), 0)
+    );
+    const boxWidth = Math.min(Math.max(contentWidth + 4, 44), maxWidth);
+    const thick = "\u2501".repeat(boxWidth - 2);
+    const thin = "\u2500".repeat(boxWidth - 2);
+    this.out.write(`
+ ${theme2.primary("\u250C")}${thick}${theme2.primary("\u2510")}
+`);
+    const centre = (s) => {
+      const inner = ` ${s} `;
+      const padLen = Math.max(0, boxWidth - 2 - s.length);
+      const left = Math.floor(padLen / 2);
+      const right = padLen - left;
+      return `${" ".repeat(left)}${inner}${" ".repeat(right)}`;
+    };
+    this.out.write(` ${theme2.primary("\u2502")}${centre(firstLine)}${theme2.primary("\u2502")}
+`);
+    for (const l of body) {
+      this.out.write(
+        ` ${theme2.primary("\u2502")} ${l}${" ".repeat(Math.max(0, boxWidth - 3 - l.length))}${theme2.primary("\u2502")}
+`
+      );
+    }
+    this.out.write(` ${theme2.primary("\u2514")}${thin}${theme2.primary("\u2518")}
+`);
+    this.lineStart = true;
+  }
+  /**
+   * Render subagent completion banners from a RunResult.
+   * Uses `delegateSummaries` when available (populated by delegate tool),
+   * otherwise falls back to scanning message history.
+   */
+  writeDelegateSummaries(result) {
+    if (this.suppressStdout()) return;
+    if (result.delegateSummaries) {
+      for (const { summary, ok } of result.delegateSummaries) {
+        if (!summary) continue;
+        this.writeAgentSummary(summary, ok);
+      }
+      return;
+    }
+    if (!result.messages) return;
+    for (const msg of result.messages) {
+      const m = msg;
+      if (!Array.isArray(m.content)) continue;
+      for (const block of m.content) {
+        const b = block;
+        if (b.type !== "tool_result" || b.name !== "delegate") continue;
+        let obj;
+        try {
+          obj = typeof b.content === "string" ? JSON.parse(b.content) : b.content;
+        } catch {
+          continue;
+        }
+        const o = obj;
+        if (o.summary) {
+          this.writeAgentSummary(o.summary, o.ok ?? true);
+        }
+      }
+    }
+  }
+};
+function renderMarkdown(s) {
+  let out = s;
+  out = out.replace(/^(#{1,6}) (.+)$/gm, (_m, hashes, text) => {
+    return theme2.primary(theme2.bold(`${hashes} ${text}`));
+  });
+  out = out.replace(/```([a-zA-Z0-9_+-]*)\n([\s\S]*?)```/g, (_m, _lang, code) => {
+    return color10.gray(`
+\u250C\u2500
+${code.replace(/^/gm, "\u2502 ")}\u2514\u2500`);
+  });
+  out = out.replace(/`([^`\n]+)`/g, (_m, code) => theme2.accent(code));
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_m, text) => theme2.bold(text));
+  out = out.replace(
+    /(^|[^*])\*([^*\n]+)\*([^*]|$)/g,
+    (_m, l, t, r) => `${l}${color10.italic(t)}${r}`
+  );
+  return out;
+}
+function formatInputSummary(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  if (typeof obj["path"] === "string") return obj["path"];
+  if (typeof obj["url"] === "string") return obj["url"];
+  if (typeof obj["command"] === "string") {
+    const cmd = obj["command"];
+    return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+  }
+  if (typeof obj["pattern"] === "string") return obj["pattern"];
+  return "";
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractBodyText(value, name) {
+  let v = value;
+  if (typeof value === "string") {
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        v = JSON.parse(value);
+      } catch {
+        return value;
+      }
+    } else {
+      return value;
+    }
+  }
+  if (typeof v !== "object" || v === null) {
+    return safeStringify(value);
+  }
+  const o = v;
+  if (name === "read" && typeof o["text"] === "string") return o["text"];
+  if (name === "bash") {
+    const output = typeof o["output"] === "string" ? o["output"] : "";
+    const error = typeof o["error"] === "string" ? o["error"] : "";
+    if (output && error) return `${output}
+${error}`;
+    return output || error || "";
+  }
+  if (name === "exec") {
+    const stdout = typeof o["stdout"] === "string" ? o["stdout"] : "";
+    const stderr = typeof o["stderr"] === "string" ? o["stderr"] : "";
+    if (stdout && stderr) return `${stdout}
+${stderr}`;
+    return stdout || stderr || "";
+  }
+  return safeStringify(value);
+}
+function extractDiff(value) {
+  if (typeof value === "object" && value !== null) {
+    const d = value.diff;
+    if (typeof d === "string" && d.length > 0) return d;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed.diff === "string" && parsed.diff.length > 0) {
+          return parsed.diff;
+        }
+      } catch {
+      }
+    }
+    if (/^---[^\n]*\n\+\+\+/m.test(value)) return value;
+  }
+  return null;
+}
+function summarize(value, name) {
+  let v = value;
+  if (typeof value === "string") {
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        v = JSON.parse(value);
+      } catch {
+      }
+    }
+  }
+  if (typeof v === "object" && v !== null) {
+    const o = v;
+    if (name === "edit") {
+      const path9 = typeof o["path"] === "string" ? o["path"] : "";
+      const reps = typeof o["replacements"] === "number" ? o["replacements"] : 0;
+      return `${path9}  ${reps} replacement${reps === 1 ? "" : "s"}`.trim();
+    }
+    if (name === "write") {
+      const path9 = typeof o["path"] === "string" ? o["path"] : "";
+      const bytes = typeof o["bytes"] === "number" ? o["bytes"] : void 0;
+      return bytes !== void 0 ? `${path9}  ${bytes}B` : path9;
+    }
+    if (name === "read") {
+      return summarizeRead(o);
+    }
+    if (name === "bash") {
+      return summarizeBash(o);
+    }
+    if (name === "exec") {
+      return summarizeExec(o);
+    }
+    if (typeof o["count"] === "number") {
+      return `${o["count"]} match${o["count"] === 1 ? "" : "es"}`;
+    }
+  }
+  return "";
+}
+function summarizeRead(o) {
+  const path9 = typeof o["path"] === "string" ? o["path"] : "";
+  const total = typeof o["total_lines"] === "number" ? o["total_lines"] : void 0;
+  const truncated = o["truncated"] === true;
+  const cached = o["cached"] === true;
+  const note = typeof o["note"] === "string" ? o["note"] : void 0;
+  const parts = [];
+  if (path9) parts.push(path9);
+  if (total !== void 0) parts.push(`${total} line${total === 1 ? "" : "s"}`);
+  const flags = [];
+  if (truncated) flags.push("truncated");
+  if (cached) flags.push("cached");
+  if (flags.length > 0) parts.push(`(${flags.join(", ")})`);
+  let summary = parts.join("  ").trim();
+  if (note) summary = summary ? `${summary} \u2014 ${note}` : note;
+  return summary;
+}
+function summarizeBash(o) {
+  const exit = typeof o["exit_code"] === "number" ? o["exit_code"] : void 0;
+  const output = typeof o["output"] === "string" ? o["output"] : "";
+  const lines = output ? output.split("\n").length : 0;
+  const parts = [];
+  if (exit !== void 0) parts.push(`exit=${exit}`);
+  else if (o["exit_code"] === null) parts.push("backgrounded");
+  if (o["timed_out"] === true) parts.push("timed out");
+  if (lines > 0) parts.push(`${lines} output line${lines === 1 ? "" : "s"}`);
+  if (output.length > 0) parts.push(`${output.length}B`);
+  return parts.join("  ");
+}
+function summarizeExec(o) {
+  const command = typeof o["command"] === "string" ? o["command"] : "";
+  const args = Array.isArray(o["args"]) ? o["args"].filter((a) => typeof a === "string") : [];
+  const exit = typeof o["exitCode"] === "number" ? o["exitCode"] : void 0;
+  const stdout = typeof o["stdout"] === "string" ? o["stdout"] : "";
+  const stderr = typeof o["stderr"] === "string" ? o["stderr"] : "";
+  const outLines = stdout ? stdout.split("\n").length : 0;
+  const errLines = stderr ? stderr.split("\n").length : 0;
+  const totalBytes = stdout.length + stderr.length;
+  const parts = [];
+  const invocation = [command, ...args].filter(Boolean).join(" ");
+  if (invocation) parts.push(`$ ${invocation}`);
+  if (exit !== void 0) parts.push(`exit=${exit}`);
+  if (outLines > 0) parts.push(`${outLines} stdout line${outLines === 1 ? "" : "s"}`);
+  if (errLines > 0) parts.push(`${errLines} stderr line${errLines === 1 ? "" : "s"}`);
+  if (totalBytes > 0) parts.push(`${totalBytes}B`);
+  return parts.join("  ");
+}
+function compactSingleLine(text) {
+  const first = text.split("\n")[0]?.trim() ?? "";
+  if (!first) return "(no output)";
+  return first.length > 200 ? `${first.slice(0, 197)}\u2026` : first;
+}
+
+// src/boot.ts
+var GITHUB_PROVIDERS_OVERLAY_URL = "https://raw.githubusercontent.com/WrongStack/WrongStack/main/packages/cli/data/providers.json";
+function resolveBundledOverlayFile() {
+  try {
+    return fileURLToPath(new URL("../data/providers.json", import.meta.url));
+  } catch {
+    return void 0;
+  }
+}
+async function validateSavedProviderModel(config, modelsRegistry) {
+  const providerId = config.provider;
+  const modelId = config.model;
+  if (!providerId || !modelId) return { ok: false, reason: "missing provider/model" };
+  if (isSetupProvider(providerId)) return { ok: true };
+  const saved = config.providers?.[providerId];
+  const lookupId = saved?.type && saved.type !== providerId ? saved.type : providerId;
+  const catalogProvider = await modelsRegistry.getProvider(lookupId).catch(() => void 0);
+  if (!catalogProvider && !saved?.family)
+    return { ok: false, reason: `provider "${providerId}" is no longer available` };
+  const hasCredential = (catalogProvider?.envVars ?? saved?.envVars ?? []).some(
+    (envVar) => Boolean(process.env[envVar])
+  ) || saved !== void 0 && resolveActiveApiKey(saved) !== void 0 || isKeylessLocalProvider({
+    apiBase: saved?.baseUrl ?? catalogProvider?.apiBase,
+    envVars: saved?.envVars ?? catalogProvider?.envVars
+  });
+  if (!hasCredential) return { ok: false, reason: `provider "${providerId}" has no usable key` };
+  const visible = visibleModelIds(
+    providerId,
+    config,
+    (catalogProvider?.models ?? []).map((m) => m.id),
+    saved
+  );
+  if (visible.length > 0 && !visible.includes(modelId)) {
+    return {
+      ok: false,
+      reason: `model "${modelId}" is no longer available for provider "${providerId}"`
+    };
+  }
+  return { ok: true };
+}
+async function autoSelectSavedProvider(config, modelsRegistry) {
+  const providers = config.providers ?? {};
+  const entries = config.provider && providers[config.provider] ? [[config.provider, providers[config.provider]]] : Object.entries(providers);
+  for (const [id, cfg] of entries) {
+    if (!cfg) continue;
+    let model = cfg.models?.[0];
+    if (!model) {
+      const catalogId = cfg.type && cfg.type !== id ? cfg.type : id;
+      const catalog = await modelsRegistry.getProvider(catalogId).catch(() => void 0);
+      model = catalog?.models?.[0]?.id;
+    }
+    if (model) return { provider: id, model };
+  }
+  return void 0;
+}
+function resolveBundledSkillsDir2() {
+  try {
+    const req = createRequire4(import.meta.url);
+    const corePkg = req.resolve("@wrongstack/core/package.json");
+    return path8.join(path8.dirname(corePkg), "skills");
+  } catch {
+    return void 0;
+  }
+}
+function resolveBundledPromptsDir2() {
+  try {
+    const req = createRequire4(import.meta.url);
+    const corePkg = req.resolve("@wrongstack/core/package.json");
+    return path8.join(path8.dirname(corePkg), "data", "prompts");
+  } catch {
+    return void 0;
+  }
+}
+function isHomeDirectory(cwd, userHome) {
+  if (!cwd || !userHome) return false;
+  return path8.resolve(cwd) === path8.resolve(userHome);
+}
+function shouldPrintYoloNotice(lastChoices, yoloPinned, yolo) {
+  return !lastChoices && yoloPinned === void 0 && yolo;
+}
+async function boot(argv) {
+  const { flags, positional } = parseArgs(argv);
+  if (positional[0] === "update") {
+    const renderer2 = new TerminalRenderer();
+    return runUpdateCommand(positional.slice(1), {
+      cwd: process.cwd(),
+      userHome: os.homedir(),
+      renderer: renderer2,
+      flags
+    });
+  }
+  if (positional[0] === "resume" && positional[1] && !subcommands["__noop_resume_marker"]) {
+    flags["resume"] = positional[1];
+    positional.splice(0, 2);
+  }
+  let bootResult;
+  try {
+    bootResult = await bootConfig(flags);
+  } catch (err) {
+    writeErr(`Config error: ${toErrorMessage4(err)}
+`);
+    return 2;
+  }
+  let { paths, config, vault } = bootResult;
+  let first = positional[0];
+  const mayOfferConfigRecovery = isStdinTTY2() && (positional.length === 0 || first === "quick") && (!config.activeProfile || config.activeProfile === "default") && typeof flags["prompt"] !== "string" && !flags["webui"] && !flags["no-interactive"] && !flags["skip"];
+  const renderer = new TerminalRenderer();
+  const reader = new ReadlineInputReader({ historyFile: paths.wpaths.historyFile });
+  if (mayOfferConfigRecovery) {
+    const restored = await maybeRestoreDefaultProfileFromBackup({
+      globalRoot: paths.wpaths.globalRoot,
+      profilePath: paths.wpaths.profileConfig("default"),
+      renderer,
+      reader
+    });
+    if (restored) {
+      try {
+        bootResult = await bootConfig(flags);
+        ({ paths, config, vault } = bootResult);
+      } catch (err) {
+        writeErr(`Config error after backup restore: ${toErrorMessage4(err)}
+`);
+        await reader.close();
+        return 2;
+      }
+    }
+  }
+  config = applySimpleUiFullAutoProfile(config, flags);
+  const simpleUiFullAuto = isSimpleUiFullAuto(flags);
+  const { cwd, projectRoot, userHome, wpaths, pathResolver } = paths;
+  const profileConfigPath = activeProfileConfigPath(wpaths, config);
+  void pathResolver;
+  if (first === "quick") {
+    flags["quick"] = true;
+    flags["tui"] = true;
+    positional.splice(0, 1);
+    first = void 0;
+    const plugins = config?.plugins ?? [];
+    if (plugins.length === 0) {
+      console.debug("[wrongstack:quick] No plugins configured");
+    } else {
+      for (const p of plugins) {
+        const name = typeof p === "string" ? p : p.name;
+        const enabled = typeof p === "object" && p.enabled === false ? " (disabled)" : "";
+        console.debug(`[wrongstack:quick] plugin: ${name}${enabled}`);
+      }
+    }
+  }
+  const logger = new DefaultLogger({
+    level: config.log.level,
+    file: wpaths.logFile,
+    // Suppress stderr output in TUI mode: plugin/library log messages
+    // (e.g. Telegram "getUpdates failed") write directly to stderr and
+    // bypass Ink, which breaks the Static/live boundary.
+    // Logs still go to the disk file for post-hoc debugging.
+    stderr: !flags.tui
+  });
+  const modelsRegistry = new DefaultModelsRegistry({
+    cacheFile: wpaths.modelsCache,
+    // Force a refresh attempt once per CLI process. Model metadata changes faster
+    // than releases (new model ids, corrected context windows), and stale cache
+    // here directly affects runtime behavior like context bars and compaction.
+    // If the network is unavailable, DefaultModelsRegistry still falls back to
+    // stale cache or the bundled overlay instead of failing startup.
+    ttlSeconds: 0,
+    // Curated overlay merged on top of models.dev: fetched from GitHub raw for
+    // freshness, with the bundled file as the offline floor.
+    overlayUrl: GITHUB_PROVIDERS_OVERLAY_URL,
+    overlayFile: resolveBundledOverlayFile(),
+    overlayCacheFile: wpaths.modelsOverlayCache
+  });
+  const subcommandHandler = first ? subcommands[first] : void 0;
+  if (first && subcommandHandler) {
+    if (flags["help"] === true || flags["h"] === true) {
+      const deepSub = positional[1];
+      if (deepSub && renderDeepHelp(`${first}:${deepSub}`, renderer)) {
+        await reader.close();
+        return 0;
+      }
+      if (renderFocusedHelp(first, renderer)) {
+        await reader.close();
+        return 0;
+      }
+    }
+    const container = createDefaultContainer2({
+      config,
+      wpaths,
+      logger,
+      modelsRegistry,
+      bundledSkillsDir: config.features.skills ? resolveBundledSkillsDir2() : void 0,
+      bundledPromptsDir: config.features.prompts === false ? void 0 : resolveBundledPromptsDir2()
+    });
+    const sessionStore = container.resolve(TOKENS2.SessionStore);
+    const skillLoader = container.resolve(TOKENS2.SkillLoader);
+    const toolRegistryForSubcmd = new ToolRegistry();
+    registerBuiltinToolTier({
+      registry: toolRegistryForSubcmd,
+      tier: normalizeTokenSavingTier(config.features.tokenSavingMode)
+    });
+    const code = await subcommandHandler(positional.slice(1), {
+      config,
+      renderer,
+      reader,
+      sessionStore,
+      skillLoader,
+      toolRegistry: toolRegistryForSubcmd,
+      modelsRegistry,
+      paths: wpaths,
+      vault,
+      cwd,
+      projectRoot,
+      userHome,
+      flags
+    });
+    await reader.close();
+    return code;
+  }
+  if (isHomeDirectory(cwd, userHome)) {
+    writeErr(
+      `
+  ${color11.red(color11.bold("\u26A0 This is not a working directory."))}
+  ${color11.red("Please open wstack in a project folder.")}
+
+`
+    );
+    await reader.close();
+    return 1;
+  }
+  if (!flags["no-models-refresh"]) {
+    try {
+      await modelsRegistry.refresh();
+      logger.info("models.dev catalog refreshed");
+    } catch (err) {
+      const msg = toErrorMessage4(err);
+      logger.warn(`models.dev refresh failed (${msg}); using cached catalog`);
+    }
+  }
+  try {
+    await discoverAndMergeProviders({
+      config,
+      registry: modelsRegistry,
+      cacheDir: path8.dirname(wpaths.modelsCache),
+      logger
+    });
+  } catch (err) {
+    logger.debug(`provider auto-discovery skipped: ${toErrorMessage4(err)}`);
+  }
+  const isSingleShot = positional.length > 0 || typeof flags["prompt"] === "string";
+  const isInteractiveTTY = isStdinTTY2() && !isSingleShot && !flags["webui"] && !flags["no-interactive"] && !flags["skip"];
+  if (isInteractiveTTY) {
+    await checkGitInCwd({ cwd, renderer, reader });
+    const cont = await runProjectCheck({ projectRoot, cwd, renderer, reader });
+    if (!cont) {
+      await reader.close();
+      return 0;
+    }
+  }
+  const wantsTui = flags["tui"] === true && flags["no-tui"] !== true;
+  if (wantsTui && (!process.stdout.isTTY || !process.stdin.isTTY)) {
+    writeErr(
+      "wstack: --tui requires an interactive terminal on both stdin and stdout.\n       Drop the flag (use the plain REPL) or run wstack directly without piping.\n"
+    );
+    await reader.close();
+    return 2;
+  }
+  const providerFlag = typeof flags["provider"] === "string" ? flags["provider"] : void 0;
+  const modelFlag = typeof flags["model"] === "string" ? flags["model"] : void 0;
+  const noInteractiveMode = flags["webui"] || flags["no-interactive"];
+  if (noInteractiveMode && (!config.provider || !config.model)) {
+    if (providerFlag && modelFlag) {
+      config = patchConfig(config, { provider: providerFlag, model: modelFlag });
+    } else {
+      const picked = await autoSelectSavedProvider(config, modelsRegistry);
+      if (picked) config = patchConfig(config, picked);
+    }
+  }
+  if (!(!!providerFlag && !!modelFlag)) {
+    if (isStdinTTY2() && !noInteractiveMode) {
+      let picked;
+      let skipPicker = false;
+      if (isSetupProvider(config.provider)) {
+        skipPicker = true;
+        renderer.write(
+          `
+  ${color11.amber("\u25B6")} ${color11.bold("Setup mode")} ${color11.dim("\u2014 no model connected. Run")} ${color11.bold("/auth")} ${color11.dim("to connect one.")}
+
+`
+        );
+      } else if (!await hasAnyCredential(config, modelsRegistry)) {
+        const outcome = await runFirstRunSetup({
+          renderer,
+          reader,
+          modelsRegistry,
+          vault,
+          profileConfigPath,
+          reloadConfig: async () => (await bootConfig(flags)).config
+        });
+        if (outcome.kind === "quit") {
+          await reader.close();
+          return 0;
+        }
+        if (outcome.kind === "setup-mode") {
+          config = patchConfig(config, { provider: SETUP_PROVIDER_ID, model: SETUP_MODEL_ID });
+          await saveToGlobalConfig(profileConfigPath, SETUP_PROVIDER_ID, SETUP_MODEL_ID);
+          skipPicker = true;
+        } else {
+          try {
+            const reloaded = await bootConfig(flags);
+            config = reloaded.config;
+            vault = reloaded.vault;
+          } catch (err) {
+            writeErr(`Config error after setup: ${toErrorMessage4(err)}
+`);
+            await reader.close();
+            return 2;
+          }
+        }
+      }
+      const savedProvider = config.provider;
+      const savedModel = config.model;
+      if (!skipPicker && savedProvider && savedModel) {
+        const savedStatus = await validateSavedProviderModel(config, modelsRegistry);
+        renderer.write(
+          `
+  ${color11.dim("Last settings:")} ${color11.bold(savedProvider)} / ${color11.bold(savedModel)}
+`
+        );
+        if (!savedStatus.ok) {
+          renderer.writeWarning(
+            `Saved provider/model is no longer usable (${savedStatus.reason ?? "unknown reason"}); choose a provider.
+`
+          );
+        } else {
+          const answer = (await reader.readLine(
+            `  ${color11.amber("?")} Continue with these? ${color11.dim("[Y/n/q]")} ${color11.dim("(auto Y in 5s)")} `,
+            { timeoutMs: 5e3, defaultAnswer: "y" }
+          )).trim().toLowerCase();
+          if (answer === "q") {
+            renderer.write(color11.dim("  Goodbye!\n"));
+            await reader.close();
+            return 0;
+          }
+          if (answer !== "n" && answer !== "no") {
+            skipPicker = true;
+            renderer.write(
+              `
+  ${color11.green("\u25B6")} ${color11.bold(savedProvider)} / ${color11.bold(savedModel)}
+
+`
+            );
+          }
+        }
+      }
+      if (!skipPicker) {
+        picked = await runPicker({
+          modelsRegistry,
+          renderer,
+          reader,
+          config,
+          defaultProvider: providerFlag ?? config.provider,
+          defaultModel: modelFlag ?? config.model
+        });
+      }
+      if (!picked && !skipPicker) {
+        if (!config.provider || !config.model) {
+          renderer.write(
+            `
+  ${color11.dim("No provider selected.")}
+  ${color11.dim("Run")} ${color11.bold("wstack auth")} ${color11.dim("to add a key or sign in, or start with no model:")}
+  ${color11.bold(`wstack --provider ${SETUP_PROVIDER_ID} --model ${SETUP_MODEL_ID}`)}
+
+`
+          );
+          await reader.close();
+          return 2;
+        }
+      }
+      if (picked) {
+        const prevProvider = config.provider;
+        const prevModel = config.model;
+        config = patchConfig(config, { provider: picked.provider, model: picked.model });
+        if (picked.provider !== prevProvider || picked.model !== prevModel) {
+          const saved = await saveToGlobalConfig(profileConfigPath, picked.provider, picked.model);
+          if (saved) {
+            renderer.writeInfo(`Saved ${picked.provider}/${picked.model} as default.
+`);
+          } else {
+            renderer.writeWarning(
+              `Could not save ${picked.provider}/${picked.model} to config. Check permissions or disk space.
+`
+            );
+          }
+        }
+      }
+    } else if (!config.provider || !config.model) {
+      writeErr(
+        `No provider or model configured. Run \`wstack auth\`, or pass --provider <id> --model <id>.
+To start the app with no model connected, pass --provider ${SETUP_PROVIDER_ID} --model ${SETUP_MODEL_ID}.
+`
+      );
+      await reader.close();
+      return 2;
+    } else {
+      const savedStatus = await validateSavedProviderModel(config, modelsRegistry);
+      if (!savedStatus.ok) {
+        writeErr(
+          `Saved provider/model is no longer usable (${savedStatus.reason ?? "unknown reason"}). Run \`wstack auth\` or pass --provider <id> --model <id>.
+`
+        );
+        await reader.close();
+        return 2;
+      }
+    }
+  }
+  if (flags["webui"]) {
+    flags["tui"] = false;
+    flags["no-tui"] = true;
+  }
+  if (isInteractiveTTY) {
+    const promptMenu = await maybeRunSystemPromptMenu({
+      isInteractiveTTY,
+      flags,
+      renderer,
+      reader,
+      profileConfigPath,
+      paths: {
+        globalDir: wpaths.globalInstructions,
+        projectDir: wpaths.inProjectInstructions
+      }
+    });
+    if (promptMenu.aborted) {
+      await reader.close();
+      return 0;
+    }
+    if (promptMenu.changed && promptMenu.variant) {
+      config = patchConfig(config, { systemPrompt: { variant: promptMenu.variant } });
+    }
+    if (promptMenu.persistError) {
+      renderer.writeWarning(
+        `Could not save system prompt variant to config: ${toErrorMessage4(promptMenu.persistError)}
+`
+      );
+    }
+    let modePinned;
+    if (flags["no-tui"]) modePinned = "repl";
+    else if (flags["tui"]) modePinned = "tui";
+    const yoloPinned = flags["no-yolo"] === true ? false : flags["yolo"] === true ? true : void 0;
+    let autonomyPinned;
+    if (flags["no-autonomy"] === true) autonomyPinned = "off";
+    else if (flags["eternal"] === true)
+      autonomyPinned = "off";
+    else if (typeof flags["autonomy"] === "string") {
+      const v = flags["autonomy"].toLowerCase();
+      autonomyPinned = v === "off" || v === "no" || v === "false" ? "off" : "auto";
+    } else if (flags["autonomy"] === true) {
+      autonomyPinned = "auto";
+    }
+    const lastChoices = config.launch ? {
+      mode: config.launch.mode ?? "tui",
+      yolo: config.yolo ?? true,
+      autonomy: config.launch.autonomy ?? "auto"
+    } : void 0;
+    let choices;
+    try {
+      choices = await runLaunchPrompts({
+        renderer,
+        reader,
+        modePinned,
+        yoloPinned,
+        autonomyPinned,
+        lastChoices
+      });
+    } catch (err) {
+      if (err instanceof LaunchAbortedError) {
+        await reader.close();
+        return 0;
+      }
+      throw err;
+    }
+    if (choices.mode === "tui") {
+      flags["tui"] = true;
+      flags["no-tui"] = false;
+    } else {
+      flags["tui"] = false;
+      flags["no-tui"] = true;
+    }
+    if (choices.yolo !== config.yolo) config = patchConfig(config, { yolo: choices.yolo });
+    flags["autonomy"] = choices.autonomy;
+    if (shouldPrintYoloNotice(lastChoices, yoloPinned, choices.yolo)) {
+      writeErr(
+        `
+  ${color11.yellow("YOLO is on")}: non-denied tool calls, including shell and file writes, run without confirmation.
+  ${color11.dim("Explicit deny rules still apply. Use")} --no-yolo ${color11.dim("or")} /yolo off ${color11.dim("to require prompts.")}
+
+`
+      );
+    }
+    if ((flags["skip-index"] || flags["skip"]) && config.indexing) {
+      config = patchConfig(config, {
+        indexing: { ...config.indexing, onSessionStart: false }
+      });
+    }
+    if (!simpleUiFullAuto) {
+      try {
+        const toPersist = flags["webui"] ? { ...choices, mode: lastChoices?.mode ?? config.launch?.mode ?? "tui" } : choices;
+        await persistLaunchChoices(profileConfigPath, toPersist);
+      } catch {
+      }
+    }
+    await printLaunchHints(renderer, flags, {
+      cursorFile: path8.join(wpaths.cacheDir, "hint-cursor")
+    });
+  } else {
+    const nonInteractiveAutonomy = !simpleUiFullAuto && (flags["no-autonomy"] === true || config.autonomy?.defaultMode === "off") ? "off" : "auto";
+    const effectiveChoices = config.launch ? {
+      mode: flags["no-tui"] ? "repl" : config.launch.mode ?? "tui",
+      yolo: config.yolo ?? true,
+      autonomy: nonInteractiveAutonomy
+    } : {
+      mode: "repl",
+      yolo: true,
+      autonomy: nonInteractiveAutonomy
+    };
+    if (effectiveChoices.mode === "repl") {
+      flags["tui"] = false;
+      flags["no-tui"] = true;
+    }
+    flags["autonomy"] = effectiveChoices.autonomy;
+  }
+  flags["director"] = true;
+  return {
+    config,
+    vault,
+    wpaths,
+    cwd,
+    projectRoot,
+    userHome,
+    flags,
+    positional,
+    modelsRegistry,
+    renderer,
+    reader,
+    logger,
+    needsSetup: !noInteractiveMode ? false : !config.provider || !config.model
+  };
+}
+async function checkGitInCwd(opts) {
+  const { cwd, renderer, reader } = opts;
+  const cwdGit = path8.join(cwd, ".git");
+  let hasCwdGit = false;
+  try {
+    await fs7.access(cwdGit);
+    hasCwdGit = true;
+  } catch {
+  }
+  if (!hasCwdGit) {
+    renderer.write(
+      `
+  ${color11.amber("\u25CB")} This folder has no ${color11.bold(".git")} repository.
+`
+    );
+    const answer = (await reader.readLine(`  ${color11.amber("?")} Initialize one here? ${color11.dim("[y/N]")} `)).trim().toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      try {
+        const { spawn: spawn2 } = await import("node:child_process");
+        await new Promise((resolve2, reject) => {
+          const child = spawn2("git", ["init"], {
+            cwd,
+            signal: AbortSignal.timeout(1e4),
+            windowsHide: true
+          });
+          child.on("error", reject);
+          child.on(
+            "close",
+            (code) => code === 0 ? resolve2() : reject(new Error(`git init failed with ${code}`))
+          );
+        });
+        renderer.write(`  ${color11.green("\u2713")} Git repository initialized
+`);
+        hasCwdGit = true;
+      } catch (err) {
+        renderer.writeError(`git init failed: ${toErrorMessage4(err)}
+`);
+      }
+    }
+  }
+  const parentDir = path8.dirname(cwd);
+  if (parentDir !== cwd) {
+    try {
+      await fs7.access(path8.join(parentDir, ".git"));
+      renderer.write(
+        `  ${color11.dim("\u2139")} A ${color11.bold(".git")} repo exists in the parent directory: ${color11.dim(parentDir)}
+`
+      );
+    } catch {
+    }
+  }
+}
+
+// src/cli-context.ts
+async function initializeCli(argv) {
+  applyNodeEnvDefault();
+  applySessionShellDefault();
+  const earlyFlags = parseArgs(argv).flags;
+  const earlyExit = await handleHelpVersionShortCircuit(argv);
+  if (earlyExit !== null) return earlyExit;
+  const desktopExit = await handleDesktopShortCircuit(earlyFlags, argv);
+  if (desktopExit !== null) return desktopExit;
+  const { flags: _earlyForMenu, positional: _positionalForMenu } = parseArgs(argv);
+  let webuiSessionChild;
+  if (_earlyForMenu["webui-session-child"] === true) {
+    try {
+      webuiSessionChild = parseWebuiSessionChildOptions(_earlyForMenu) ?? void 0;
+    } catch (err) {
+      const readyFile = typeof _earlyForMenu["ready-file"] === "string" ? _earlyForMenu["ready-file"] : void 0;
+      if (readyFile) {
+        await writeWebuiSessionChildError(readyFile, {
+          runtimeId: typeof _earlyForMenu["runtime-id"] === "string" ? _earlyForMenu["runtime-id"] : void 0,
+          parentShellId: typeof _earlyForMenu["parent-shell-id"] === "string" ? _earlyForMenu["parent-shell-id"] : void 0,
+          phase: "validate_args",
+          recoverable: false,
+          error: err
+        }).catch(() => void 0);
+      }
+      writeErr2(
+        `WebUI session child argument error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return 2;
+    }
+  }
+  const launchMenuReader = new ReadlineInputReader();
+  let menuResult;
+  try {
+    menuResult = await runLaunchMenu({
+      argv,
+      flags: _earlyForMenu,
+      positional: _positionalForMenu,
+      renderer: new TerminalRenderer(),
+      reader: launchMenuReader,
+      // Last-saved menu choice wiring is intentionally minimal here:
+      // we only honor it when the user has *also* chosen no other
+      // surface flag. The persisted record is updated lazily inside
+      // boot() via a follow-up patch in the wiring layer, but the
+      // menu itself stays stateless so unit tests don't need to mock
+      // a ConfigStore. Users who want the saved-port shortcut without
+      // the menu can pass `--no-menu --webui --port=<saved>`.
+      lastChoice: void 0
+    });
+  } finally {
+    await launchMenuReader.close();
+  }
+  let effectiveArgv = argv;
+  if (menuResult !== null) {
+    if (menuResult.cancelled) {
+      return 0;
+    }
+    effectiveArgv = applyLaunchMenuToArgv(argv, menuResult);
+    const augmentedFlags = parseArgs(effectiveArgv).flags;
+    if (menuResult.mode === "hq") {
+      const hqAfterMenu = await handleHqShortCircuit(augmentedFlags);
+      if (hqAfterMenu !== null) return hqAfterMenu;
+    }
+    if (menuResult.mode === "desktop") {
+      const desktopAfterMenu = await handleDesktopShortCircuit(augmentedFlags, effectiveArgv);
+      if (desktopAfterMenu !== null) return desktopAfterMenu;
+    }
+  }
+  const effectiveFlags = parseArgs(effectiveArgv).flags;
+  try {
+    webuiSessionChild = webuiSessionChild ?? parseWebuiSessionChildOptions(effectiveFlags) ?? void 0;
+  } catch (err) {
+    const readyFile = typeof effectiveFlags["ready-file"] === "string" ? effectiveFlags["ready-file"] : void 0;
+    if (readyFile) {
+      await writeWebuiSessionChildError(readyFile, {
+        runtimeId: typeof effectiveFlags["runtime-id"] === "string" ? effectiveFlags["runtime-id"] : void 0,
+        parentShellId: typeof effectiveFlags["parent-shell-id"] === "string" ? effectiveFlags["parent-shell-id"] : void 0,
+        phase: "validate_args",
+        recoverable: false,
+        error: err
+      }).catch(() => void 0);
+    }
+    writeErr2(
+      `WebUI session child argument error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return 2;
+  }
+  if (webuiSessionChild) {
+    try {
+      process.chdir(webuiSessionChild.workingDir);
+      if (webuiSessionChild.resume && webuiSessionChild.sessionId) {
+        const currentResume = effectiveFlags["resume"];
+        if (typeof currentResume === "string" && currentResume !== webuiSessionChild.sessionId) {
+          throw new Error(
+            `--resume ${currentResume} conflicts with --session-id ${webuiSessionChild.sessionId}`
+          );
+        }
+        if (currentResume !== webuiSessionChild.sessionId) {
+          effectiveArgv = [...effectiveArgv, "--resume", webuiSessionChild.sessionId];
+        }
+      }
+    } catch (err) {
+      await writeWebuiSessionChildError(webuiSessionChild.readyFile, {
+        protocolVersion: webuiSessionChild.protocolVersion,
+        runtimeId: webuiSessionChild.runtimeId,
+        parentShellId: webuiSessionChild.parentShellId,
+        phase: "validate_args",
+        recoverable: false,
+        error: err
+      }).catch(() => void 0);
+      writeErr2(
+        `WebUI session child argument error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return 2;
+    }
+  }
+  const hqExit = await handleHqShortCircuit(effectiveFlags);
+  if (hqExit !== null) return hqExit;
+  const ctx = await boot(effectiveArgv);
+  if (typeof ctx === "number") return ctx;
+  if (menuResult !== null) {
+    const persisted = toPersistedMenuChoice(menuResult);
+    if (persisted) {
+      try {
+        await persistMenuChoice(activeProfileConfigPath(ctx.wpaths, ctx.config), persisted);
+      } catch (err) {
+        ctx.logger.debug(
+          `launch-menu: failed to persist menu choice (${err instanceof Error ? err.message : String(err)})`
+        );
+      }
+    }
+  }
+  const { config, vault, wpaths, cwd, modelsRegistry, renderer, reader, logger } = ctx;
+  const { updateInfo: refreshedUpdateInfo } = await runPreflight(config, ctx.updateInfo);
+  const profileConfigPath = activeProfileConfigPath(wpaths, config);
+  setOAuthTokenPersister((providerId, creds) => {
+    void mutateConfigProviders(profileConfigPath, vault, (all) => {
+      const p = all[providerId];
+      if (!p) return;
+      const keys = normalizeKeys(p);
+      const active = p.activeKey ? keys.find((k) => k.label === p.activeKey) : keys[0];
+      if (!active) return;
+      active.apiKey = creds.accessToken;
+      active.refreshToken = creds.refreshToken;
+      active.expiresAt = new Date(creds.expiresAt).toISOString();
+      if (creds.accountId) active.accountId = creds.accountId;
+      writeKeysBack(p, keys);
+    }).catch(() => {
+    });
+  });
+  const { events, container } = wireContainer({
+    config,
+    wpaths,
+    cwd,
+    logger,
+    reader,
+    renderer,
+    modelsRegistry
+  });
+  const configStore = container.resolve(TOKENS3.ConfigStore);
+  return {
+    ...ctx,
+    updateInfo: refreshedUpdateInfo,
+    events,
+    container,
+    configStore,
+    webuiSessionChild
+  };
+}
+export {
+  initializeCli
+};
+//# sourceMappingURL=cli-context-LH4QP4W2.js.map