@narumitw/pi-btw 0.54.0 → 0.54.2

package/dist/index.ts

@@ -0,0 +1,2879 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/btw.ts
+import {
+  clampThinkingLevel,
+  getSupportedThinkingLevels
+} from "@earendil-works/pi-ai";
+import {
+  BorderedLoader
+} from "@earendil-works/pi-coding-agent";
+
+// src/bring-to-main.ts
+import {
+  Key,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+var RESERVED_APP_ROWS = 3;
+var GRAPHEME_SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function getAnsweredTurns(turns) {
+  return turns.filter(
+    (turn) => turn.kind === "answered"
+  );
+}
+function buildQuickBringToMainSegments(turns, scope) {
+  const answered = getAnsweredTurns(turns);
+  const selected = scope.kind === "latest" ? answered.slice(-1) : scope.kind === "from" ? answered.slice(Math.max(0, scope.answeredTurnIndex)) : answered;
+  return selected.flatMap((turn) => [
+    { role: "user", text: turn.question },
+    { role: "assistant", text: turn.answer }
+  ]);
+}
+function buildBtwSelectionLines(turns) {
+  return buildQuickBringToMainSegments(turns, { kind: "entire" }).flatMap(
+    (segment) => segment.text.split("\n").map((text) => ({ role: segment.role, text }))
+  );
+}
+function segmentsFromLineRange(lines, anchor, cursor) {
+  if (lines.length === 0) return [];
+  const start = Math.max(0, Math.min(anchor, cursor, lines.length - 1));
+  const end = Math.max(0, Math.min(Math.max(anchor, cursor), lines.length - 1));
+  const segments = [];
+  for (const line of lines.slice(start, end + 1)) {
+    const previous = segments.at(-1);
+    if (previous?.role === line.role) {
+      previous.text += `
+${line.text}`;
+    } else {
+      segments.push({ role: line.role, text: line.text });
+    }
+  }
+  return segments;
+}
+function segmentsFromTextRange(lines, anchor, cursor) {
+  if (lines.length === 0) return [];
+  const first = clampTextPosition(lines, anchor);
+  const second = clampTextPosition(lines, cursor);
+  const [start, end] = compareTextPositions(first, second) <= 0 ? [first, second] : [second, first];
+  if (compareTextPositions(start, end) === 0) return [];
+  const segments = [];
+  for (let lineIndex = start.line; lineIndex <= end.line; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (!line) continue;
+    const characters = splitGraphemes(line.text);
+    const from = lineIndex === start.line ? start.column : 0;
+    const to = lineIndex === end.line ? end.column : characters.length;
+    const text = characters.slice(from, to).join("");
+    if (text) {
+      const previous = segments.at(-1);
+      if (previous?.role === line.role) previous.text += text;
+      else segments.push({ role: line.role, text });
+    }
+    const crossesSameRoleLine = lineIndex < end.line && lines[lineIndex + 1]?.role === line.role;
+    if (crossesSameRoleLine) {
+      const current = segments.at(-1);
+      if (current?.role === line.role) current.text += "\n";
+      else segments.push({ role: line.role, text: "\n" });
+    }
+  }
+  return segments;
+}
+function estimateBringToMainTokens(segments) {
+  return Math.ceil(
+    Buffer.byteLength(segments.map((segment) => segment.text).join("\n"), "utf8") / 4
+  );
+}
+function summarizeBringToMain(segments) {
+  return {
+    lines: segments.reduce((count, segment) => count + segment.text.split("\n").length, 0),
+    messages: segments.length,
+    tokens: estimateBringToMainTokens(segments)
+  };
+}
+function formatBtwBringToMain(segments) {
+  const body = segments.map(
+    (segment) => `${segment.role === "user" ? "User" : "Assistant"}:
+${escapeBringToMainText(segment.text)}`
+  ).join("\n\n");
+  return [
+    "The following context was brought back from a /btw side discussion.",
+    "Treat it as discussion context, not as work already completed.",
+    "",
+    "<btw_context>",
+    body,
+    "</btw_context>"
+  ].join("\n");
+}
+var BtwTextRangeSelector = class {
+  constructor(tui, theme, keybindings, turns, onAction, initialState) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.onAction = onAction;
+    this.lines = buildBtwSelectionLines(turns);
+    if (initialState) {
+      this.cursor = clampTextPosition(this.lines, initialState.cursor);
+      this.anchor = initialState.anchor ? clampTextPosition(this.lines, initialState.anchor) : void 0;
+      this.lineAnchor = initialState.lineAnchor === void 0 ? void 0 : Math.max(0, Math.min(this.lines.length - 1, initialState.lineAnchor));
+      this.preferredColumn = Math.max(0, initialState.preferredColumn);
+      this.scrollOffset = Math.max(0, initialState.scrollOffset);
+      this.horizontalOffset = Math.max(0, initialState.horizontalOffset);
+    }
+  }
+  tui;
+  theme;
+  keybindings;
+  onAction;
+  lines;
+  cursor = { line: 0, column: 0 };
+  anchor;
+  lineAnchor;
+  preferredColumn = 0;
+  scrollOffset = 0;
+  horizontalOffset = 0;
+  warning;
+  finished = false;
+  getState() {
+    return {
+      cursor: { ...this.cursor },
+      anchor: this.anchor ? { ...this.anchor } : void 0,
+      lineAnchor: this.lineAnchor,
+      preferredColumn: this.preferredColumn,
+      scrollOffset: this.scrollOffset,
+      horizontalOffset: this.horizontalOffset
+    };
+  }
+  render(width) {
+    const safeWidth = Math.max(1, width);
+    const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS);
+    const showStatus = availableRows >= 4;
+    const showFooter = availableRows >= 3;
+    const viewportHeight = Math.max(
+      1,
+      availableRows - 1 - (showStatus ? 1 : 0) - (showFooter ? 1 : 0)
+    );
+    this.keepCursorVisible(viewportHeight);
+    const textWidth = Math.max(1, safeWidth - visibleWidth("\u25CF> Assistant \u2502 "));
+    this.keepCursorHorizontallyVisible(textWidth);
+    const range = this.getSelectionRange();
+    const lineRange = this.getLineSelectionRange();
+    const visible = this.lines.slice(this.scrollOffset, this.scrollOffset + viewportHeight);
+    const rows = visible.map((line, visibleIndex) => {
+      const lineIndex = this.scrollOffset + visibleIndex;
+      const role = line.role === "user" ? "User" : "Assistant";
+      const lineSelected = lineRange ? lineIndex >= lineRange.start && lineIndex <= lineRange.end : false;
+      const prefix = `${lineSelected ? "\u25CF" : " "}${lineIndex === this.cursor.line ? ">" : " "} ${role.padEnd(9)} \u2502 `;
+      const text = this.renderTextLine(line, lineIndex, range, lineSelected);
+      return truncateToWidth(
+        lineIndex === this.cursor.line ? this.theme.fg("accent", prefix) + text : prefix + text,
+        safeWidth,
+        ""
+      );
+    });
+    const selected = this.getSelectedSegments();
+    const summary = summarizeBringToMain(selected);
+    const status = selected.length === 0 ? "Selected: none" : `Selected: ${summary.lines} ${summary.lines === 1 ? "line" : "lines"} \xB7 ${summary.messages} ${summary.messages === 1 ? "message" : "messages"} \xB7 ~${summary.tokens} ${summary.tokens === 1 ? "token" : "tokens"}`;
+    const confirm = confirmKeyLabel(this.keybindings);
+    const back = keybindingLabel(this.keybindings, "tui.select.cancel", ["ctrl+c"]);
+    const vertical = `${keybindingLabel(this.keybindings, "tui.select.up")}/${keybindingLabel(this.keybindings, "tui.select.down")}`;
+    const confirmUsesSpace = this.keybindings.matches(" ", "tui.select.confirm");
+    const detailedFooter = this.warning ? `${this.warning} \u2022 ${confirmUsesSpace ? "Shift+Arrows select" : "Space lines \u2022 Shift+Arrows text"} \u2022 ${back} back \u2022 Ctrl+C close` : this.lineAnchor !== void 0 ? `${confirmUsesSpace ? `${vertical} extend lines` : `Space clear \u2022 ${vertical} extend lines`} \u2022 Shift+Arrows text \u2022 ${confirm} bring \u2022 ${back} back \u2022 Ctrl+C close` : `Shift+Arrows select \u2022 Arrows move${confirmUsesSpace ? "" : " \u2022 Space lines"} \u2022 ${confirm} bring \u2022 ${back} back \u2022 Ctrl+C close`;
+    const criticalFooter = `${confirm} bring \u2022 ${back} back \u2022 Ctrl+C close`;
+    const footer = visibleWidth(detailedFooter) <= safeWidth ? detailedFooter : criticalFooter;
+    return fitRows(
+      [
+        truncateToWidth(
+          this.theme.fg("accent", this.theme.bold("Select text to bring to main")),
+          safeWidth,
+          ""
+        ),
+        ...showStatus ? [truncateToWidth(this.theme.fg("muted", status), safeWidth, "")] : [],
+        ...rows,
+        ...showFooter ? [
+          truncateToWidth(
+            this.theme.fg(this.warning ? "warning" : "muted", footer),
+            safeWidth,
+            ""
+          )
+        ] : []
+      ],
+      availableRows
+    );
+  }
+  handleInput(data) {
+    if (this.finished) return;
+    if (matchesKey(data, Key.ctrl("c"))) {
+      this.finish({ kind: "close" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.finish({ kind: "back" });
+      return;
+    }
+    if (matchesConfirm(data, this.keybindings)) {
+      if (this.lines.length > 0) {
+        const segments = this.getSelectedSegments();
+        if (segments.length === 0) {
+          this.warning = "Select text first";
+          this.tui.requestRender();
+        } else {
+          this.finish({ kind: "confirm", segments });
+        }
+      }
+      return;
+    }
+    if (matchesKey(data, Key.space)) {
+      this.anchor = void 0;
+      this.lineAnchor = this.lineAnchor === void 0 ? this.cursor.line : void 0;
+      this.afterMove();
+      return;
+    }
+    if (matchesKey(data, Key.shift("left"))) {
+      this.moveHorizontal(-1, true);
+      return;
+    }
+    if (matchesKey(data, Key.shift("right"))) {
+      this.moveHorizontal(1, true);
+      return;
+    }
+    if (matchesKey(data, Key.shift("up"))) {
+      this.moveVertical(-1, true);
+      return;
+    }
+    if (matchesKey(data, Key.shift("down"))) {
+      this.moveVertical(1, true);
+      return;
+    }
+    if (matchesKey(data, Key.left)) {
+      this.moveHorizontal(-1, false);
+      return;
+    }
+    if (matchesKey(data, Key.right)) {
+      this.moveHorizontal(1, false);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.up")) {
+      this.moveVertical(-1, false);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.down")) {
+      this.moveVertical(1, false);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.pageUp")) {
+      this.moveVertical(-10, false);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.pageDown")) {
+      this.moveVertical(10, false);
+      return;
+    }
+  }
+  invalidate() {
+  }
+  renderTextLine(line, lineIndex, range, lineSelected) {
+    const characters = splitGraphemes(line.text);
+    let rendered = this.horizontalOffset > 0 ? this.theme.fg("muted", "\u2026") : "";
+    let buffer = "";
+    let bufferSelected = false;
+    const flush = () => {
+      if (!buffer) return;
+      rendered += bufferSelected ? this.theme.bg("selectedBg", this.theme.fg("text", buffer)) : buffer;
+      buffer = "";
+    };
+    for (let column = this.horizontalOffset; column <= characters.length; column += 1) {
+      if (range && lineIndex === range.start.line && column === range.start.column) {
+        flush();
+        rendered += this.theme.fg("accent", "[");
+      }
+      if (lineIndex === this.cursor.line && column === this.cursor.column) {
+        flush();
+        rendered += this.theme.fg("accent", "\u2502");
+      }
+      if (range && lineIndex === range.end.line && column === range.end.column) {
+        flush();
+        rendered += this.theme.fg("accent", "]");
+      }
+      const character = characters[column];
+      if (character === void 0) continue;
+      const selected = lineSelected || (range ? positionFallsInside(lineIndex, column, range) : false);
+      if (buffer && selected !== bufferSelected) flush();
+      bufferSelected = selected;
+      buffer += escapeTerminalControls(character);
+    }
+    flush();
+    return rendered;
+  }
+  getSelectionRange() {
+    if (!this.anchor || compareTextPositions(this.anchor, this.cursor) === 0) return void 0;
+    return compareTextPositions(this.anchor, this.cursor) < 0 ? { start: this.anchor, end: this.cursor } : { start: this.cursor, end: this.anchor };
+  }
+  getLineSelectionRange() {
+    return this.lineAnchor === void 0 ? void 0 : {
+      start: Math.min(this.lineAnchor, this.cursor.line),
+      end: Math.max(this.lineAnchor, this.cursor.line)
+    };
+  }
+  getSelectedSegments() {
+    if (this.lineAnchor !== void 0) {
+      return segmentsFromLineRange(this.lines, this.lineAnchor, this.cursor.line);
+    }
+    return this.anchor ? segmentsFromTextRange(this.lines, this.anchor, this.cursor) : [];
+  }
+  moveHorizontal(delta, extend) {
+    if (this.lines.length === 0) return;
+    if (!extend) this.lineAnchor = void 0;
+    if (!extend && this.anchor) {
+      const range = this.getSelectionRange();
+      if (range) this.cursor = delta < 0 ? range.start : range.end;
+      this.anchor = void 0;
+      this.preferredColumn = this.cursor.column;
+      this.afterMove();
+      return;
+    }
+    this.beginOrClearSelection(extend);
+    const line = this.lines[this.cursor.line];
+    const length = line ? splitGraphemes(line.text).length : 0;
+    if (delta < 0) {
+      if (this.cursor.column > 0) this.cursor = { ...this.cursor, column: this.cursor.column - 1 };
+      else if (this.cursor.line > 0) {
+        const previousLine = this.lines[this.cursor.line - 1];
+        this.cursor = {
+          line: this.cursor.line - 1,
+          column: previousLine ? splitGraphemes(previousLine.text).length : 0
+        };
+      }
+    } else if (this.cursor.column < length) {
+      this.cursor = { ...this.cursor, column: this.cursor.column + 1 };
+    } else if (this.cursor.line < this.lines.length - 1) {
+      this.cursor = { line: this.cursor.line + 1, column: 0 };
+    }
+    this.preferredColumn = this.cursor.column;
+    this.afterMove();
+  }
+  moveVertical(delta, extend) {
+    if (this.lines.length === 0) return;
+    if (extend || this.lineAnchor === void 0) this.beginOrClearSelection(extend);
+    const line = Math.max(0, Math.min(this.lines.length - 1, this.cursor.line + delta));
+    const target = this.lines[line];
+    this.cursor = {
+      line,
+      column: Math.min(this.preferredColumn, target ? splitGraphemes(target.text).length : 0)
+    };
+    this.afterMove();
+  }
+  beginOrClearSelection(extend) {
+    if (extend) this.lineAnchor = void 0;
+    if (extend && !this.anchor) this.anchor = { ...this.cursor };
+    if (!extend) this.anchor = void 0;
+  }
+  afterMove() {
+    this.warning = void 0;
+    this.tui.requestRender();
+  }
+  keepCursorVisible(height) {
+    if (height <= 0) return;
+    if (this.cursor.line < this.scrollOffset) this.scrollOffset = this.cursor.line;
+    if (this.cursor.line >= this.scrollOffset + height) {
+      this.scrollOffset = this.cursor.line - height + 1;
+    }
+  }
+  keepCursorHorizontallyVisible(width) {
+    const characters = splitGraphemes(this.lines[this.cursor.line]?.text ?? "");
+    const displayWidths = characters.map(
+      (character) => visibleWidth(escapeTerminalControls(character))
+    );
+    const currentWidth = displayWidths[this.cursor.column] ?? 0;
+    let usedWidth = 1 + Math.min(currentWidth, Math.max(0, width - 1));
+    let offset = this.cursor.column;
+    for (let index = this.cursor.column - 1; index >= 0; index -= 1) {
+      const nextWidth = usedWidth + (displayWidths[index] ?? 0) + (index > 0 ? 1 : 0);
+      if (nextWidth > width) break;
+      usedWidth += displayWidths[index] ?? 0;
+      offset = index;
+    }
+    this.horizontalOffset = offset;
+  }
+  finish(action) {
+    if (this.finished) return;
+    this.finished = true;
+    this.onAction(action);
+  }
+};
+function clampTextPosition(lines, position) {
+  const line = Math.max(0, Math.min(lines.length - 1, position.line));
+  const text = lines[line]?.text ?? "";
+  return {
+    line,
+    column: Math.max(0, Math.min(splitGraphemes(text).length, position.column))
+  };
+}
+function confirmKeyLabel(keybindings) {
+  return keybindingLabel(keybindings, "tui.select.confirm", ["ctrl+c"], "enter");
+}
+function matchesConfirm(data, keybindings) {
+  if (matchesKey(data, Key.ctrl("c"))) return false;
+  const hasUsableBinding = keybindings.getKeys("tui.select.confirm").map(String).some((key) => key.toLowerCase() !== "ctrl+c");
+  return keybindings.matches(data, "tui.select.confirm") || !hasUsableBinding && matchesKey(data, Key.enter);
+}
+function keybindingLabel(keybindings, keybinding, excluded = [], fallback) {
+  const key = keybindings.getKeys(keybinding).map(String).find((candidate) => !excluded.includes(candidate.toLowerCase()));
+  return formatKeyLabel(key ?? fallback ?? keybinding);
+}
+function formatKeyLabel(key) {
+  return key.split("+").map((part) => {
+    const lower = part.toLowerCase();
+    if (lower === "ctrl") return "Ctrl";
+    if (lower === "alt") return "Alt";
+    if (lower === "shift") return "Shift";
+    if (lower === "escape" || lower === "esc") return "Esc";
+    if (lower === "enter" || lower === "return") return "Enter";
+    if (lower === "pageup") return "PgUp";
+    if (lower === "pagedown") return "PgDn";
+    return part.length === 1 ? part.toUpperCase() : `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`;
+  }).join("+");
+}
+function splitGraphemes(text) {
+  return [...GRAPHEME_SEGMENTER.segment(text)].map(({ segment }) => segment);
+}
+function compareTextPositions(first, second) {
+  return first.line === second.line ? first.column - second.column : first.line - second.line;
+}
+function positionFallsInside(line, column, range) {
+  const position = { line, column };
+  return compareTextPositions(position, range.start) >= 0 && compareTextPositions(position, range.end) < 0;
+}
+function fitRows(rows, availableRows) {
+  if (rows.length <= availableRows) return rows;
+  if (availableRows <= 1) return rows.slice(0, 1);
+  return [rows[0] ?? "", ...rows.slice(rows.length - availableRows + 1)];
+}
+function escapeBringToMainText(text) {
+  return [...text].map((character) => {
+    if (character === "\n") return character;
+    if (character === "	") return "    ";
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code >= 127 && code <= 159) {
+      return `\\x${code.toString(16).padStart(2, "0")}`;
+    }
+    return character;
+  }).join("").replace(/<btw_context(?=[ \t\r\n>])/g, "&lt;btw_context").replace(
+    /<\/btw_context[ \t\r\n]*>/g,
+    (terminator) => terminator.replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+  );
+}
+function escapeTerminalControls(text) {
+  return [...text].map((character) => {
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code >= 127 && code <= 159) {
+      return `\\x${code.toString(16).padStart(2, "0")}`;
+    }
+    return character;
+  }).join("");
+}
+
+// src/fullscreen-ui.ts
+import { spawn } from "node:child_process";
+import {
+  TuiAltScreen,
+  truncateToWidth as truncateToWidth2
+} from "@earendil-works/pi-tui";
+
+// src/text.ts
+function sanitizeSingleLine(text) {
+  return [...text.replace(/[\r\n\t]/gu, " ")].filter((character) => {
+    const code = character.charCodeAt(0);
+    return code > 31 && (code < 127 || code > 159);
+  }).join("").replace(/ +/gu, " ").trim();
+}
+
+// src/fullscreen-ui.ts
+var FullscreenUiDisposedError = class extends Error {
+  constructor() {
+    super("The dedicated pi-btw UI was disposed.");
+    this.name = "FullscreenUiDisposedError";
+  }
+};
+async function runBtwFullscreen(ctx, run, dependencies = {}) {
+  const createTui = dependencies.createTui ?? ((parent) => createBtwFullscreenTui(parent, dependencies.openUrl ?? openUrlInBrowser));
+  let liveEditorText = ctx.ui.getEditorText();
+  let restoreEditor = false;
+  const outcome = await ctx.ui.custom(
+    (parent, theme, keybindings, done) => new BtwFullscreenHost(
+      parent,
+      theme,
+      keybindings,
+      ctx,
+      run,
+      (value) => {
+        try {
+          liveEditorText = ctx.ui.getEditorText();
+          restoreEditor = true;
+        } catch {
+        }
+        done(value);
+      },
+      createTui
+    )
+  );
+  if (restoreEditor) {
+    try {
+      if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+    } catch {
+    }
+  }
+  if (outcome.kind === "failed") throw outcome.error;
+  return outcome.value;
+}
+function createBtwFullscreenTui(parent, openUrl) {
+  return new TuiAltScreen(parent.terminal, parent.getShowHardwareCursor(), void 0, {
+    mouse: true,
+    openUrl
+  });
+}
+function openUrlInBrowser(target) {
+  const [command, args] = process.platform === "darwin" ? ["open", [target]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", target]] : ["xdg-open", [target]];
+  spawn(command, args, { stdio: "ignore", detached: true }).on("error", () => {
+  }).unref();
+}
+var BtwFullscreenHost = class {
+  constructor(parent, theme, keybindings, ctx, run, done, createTui) {
+    this.parent = parent;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.ctx = ctx;
+    this.run = run;
+    this.done = done;
+    this.createTui = createTui;
+    queueMicrotask(() => void this.start());
+  }
+  parent;
+  theme;
+  keybindings;
+  ctx;
+  run;
+  done;
+  createTui;
+  fullscreen;
+  cancelActiveCustom;
+  started = false;
+  disposed = false;
+  finished = false;
+  render(width) {
+    return [truncateToWidth2(this.theme.fg("muted", "Opening btw side thread\u2026"), width)];
+  }
+  invalidate() {
+  }
+  dispose() {
+    if (this.disposed || this.finished) return;
+    this.disposed = true;
+    this.cancelActiveCustom?.();
+  }
+  async start() {
+    if (this.started || this.finished) return;
+    this.started = true;
+    let outcome;
+    let parentStopped = false;
+    let fullscreenCreated = false;
+    try {
+      if (this.disposed) throw new FullscreenUiDisposedError();
+      this.parent.stop({ preserveScreen: true });
+      parentStopped = true;
+      if (this.disposed) throw new FullscreenUiDisposedError();
+      this.fullscreen = this.createTui(this.parent);
+      fullscreenCreated = true;
+      this.fullscreen.start();
+      outcome = { kind: "completed", value: await this.run(this.createContext()) };
+    } catch (error) {
+      outcome = { kind: "failed", error };
+    }
+    let cleanupError;
+    try {
+      this.cancelActiveCustom?.();
+    } catch (error) {
+      cleanupError = error;
+    }
+    if (fullscreenCreated) {
+      try {
+        this.fullscreen?.stop({ preserveScreen: true });
+      } catch (error) {
+        cleanupError ??= error;
+      }
+    }
+    if (parentStopped) {
+      try {
+        this.parent.start();
+        this.parent.renderNow(false);
+      } catch (error) {
+        cleanupError ??= error;
+      }
+    }
+    if (cleanupError !== void 0) outcome = { kind: "failed", error: cleanupError };
+    this.finished = true;
+    this.done(outcome);
+  }
+  createContext() {
+    const ui = new Proxy(this.ctx.ui, {
+      get: (target, property) => {
+        if (property === "custom") {
+          return (factory, options) => this.showCustom(factory, options);
+        }
+        if (property === "notify") {
+          return (message, level) => {
+            target.notify(message, level);
+            const display = sanitizeSingleLine(message);
+            if (display) this.fullscreen?.flash?.(display);
+          };
+        }
+        const value = Reflect.get(target, property, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+    return new Proxy(this.ctx, {
+      get: (target, property) => property === "ui" ? ui : Reflect.get(target, property, target)
+    });
+  }
+  showCustom(factory, options) {
+    const fullscreen = this.fullscreen;
+    if (!fullscreen || this.disposed || this.finished) {
+      return Promise.reject(new FullscreenUiDisposedError());
+    }
+    if (this.cancelActiveCustom) {
+      return Promise.reject(new Error("pi-btw attempted to open overlapping custom UI."));
+    }
+    return new Promise((resolve, reject) => {
+      let component;
+      let overlay;
+      let mounted = false;
+      let layoutMounted = false;
+      let factorySettled = false;
+      let closed = false;
+      let promiseSettled = false;
+      let componentDisposed = false;
+      let pendingValue;
+      let hasPendingValue = false;
+      const disposeComponent = () => {
+        if (!component || componentDisposed) return;
+        componentDisposed = true;
+        try {
+          component.dispose?.();
+        } catch {
+        }
+      };
+      const unmount = () => {
+        let cleanupError;
+        try {
+          if (overlay) overlay.hide();
+          else if (mounted && layoutMounted) fullscreen.setLayoutRoot(void 0);
+          else if (mounted && component) fullscreen.removeChild(component);
+        } catch (error) {
+          cleanupError = error;
+        }
+        if (overlay || mounted) {
+          try {
+            fullscreen.setFocus(null);
+            fullscreen.requestRender();
+          } catch (error) {
+            cleanupError ??= error;
+          }
+        }
+        disposeComponent();
+        if (cleanupError !== void 0) throw cleanupError;
+      };
+      const complete = () => {
+        if (promiseSettled || !hasPendingValue) return;
+        promiseSettled = true;
+        this.cancelActiveCustom = void 0;
+        if (!factorySettled) {
+          resolve(pendingValue);
+          return;
+        }
+        try {
+          unmount();
+          resolve(pendingValue);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      const close = (value) => {
+        if (closed || promiseSettled) return;
+        closed = true;
+        pendingValue = value;
+        hasPendingValue = true;
+        complete();
+      };
+      const fail = (error) => {
+        if (promiseSettled) return;
+        closed = true;
+        promiseSettled = true;
+        this.cancelActiveCustom = void 0;
+        try {
+          unmount();
+          reject(error);
+        } catch (cleanupError) {
+          reject(cleanupError);
+        }
+      };
+      this.cancelActiveCustom = () => {
+        if (promiseSettled) return;
+        disposeComponent();
+        if (!promiseSettled) fail(new FullscreenUiDisposedError());
+      };
+      let created;
+      try {
+        created = factory(fullscreen, this.theme, this.keybindings, close);
+      } catch (error) {
+        factorySettled = true;
+        fail(error);
+        return;
+      }
+      Promise.resolve(created).then((value) => {
+        component = value;
+        factorySettled = true;
+        if (promiseSettled) {
+          disposeComponent();
+          return;
+        }
+        if (closed) {
+          complete();
+          return;
+        }
+        if (options?.overlay) {
+          const overlayOptions = typeof options.overlayOptions === "function" ? options.overlayOptions() : options.overlayOptions;
+          overlay = fullscreen.showOverlay(component, overlayOptions);
+          options.onHandle?.(overlay);
+        } else {
+          fullscreen.clear();
+          mounted = true;
+          if (isFullscreenLayoutComponent(component)) {
+            layoutMounted = true;
+            fullscreen.setLayoutRoot(component.getFullscreenLayout());
+          } else {
+            fullscreen.addChild(component);
+          }
+          fullscreen.setFocus(component);
+          fullscreen.requestRender();
+        }
+      }).catch(fail);
+    });
+  }
+};
+function isFullscreenLayoutComponent(component) {
+  return "getFullscreenLayout" in component && typeof component.getFullscreenLayout === "function";
+}
+
+// src/main-tree-picker.ts
+import {
+  copyToClipboard,
+  TreeSelectorComponent
+} from "@earendil-works/pi-coding-agent";
+import { Key as Key2, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+
+// src/settings.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+// src/side-thread.ts
+var BTW_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function createSideThread(conversationContext) {
+  return { conversationContext, turns: [] };
+}
+function buildSideThreadMessages(thread, question) {
+  const answeredTurns = thread.turns.filter(
+    (turn) => turn.kind === "answered"
+  );
+  const messages = [];
+  if (answeredTurns.length === 0) {
+    messages.push(createUserMessage(buildUserPrompt(question, thread.conversationContext)));
+    return messages;
+  }
+  const [first, ...rest] = answeredTurns;
+  messages.push(
+    createUserMessage(buildUserPrompt(first.question, thread.conversationContext)),
+    first.response
+  );
+  for (const turn of rest) {
+    messages.push(createUserMessage(buildFollowUpPrompt(turn.question)), turn.response);
+  }
+  messages.push(createUserMessage(buildFollowUpPrompt(question)));
+  return messages;
+}
+async function completeSideThreadTurn({
+  thread,
+  model,
+  question,
+  thinkingLevel,
+  auth,
+  signal,
+  completeSimple
+}) {
+  if (signal?.aborted) return { kind: "aborted" };
+  try {
+    const response = await completeSimple(
+      model,
+      { systemPrompt: SYSTEM_PROMPT, messages: buildSideThreadMessages(thread, question) },
+      buildStreamOptions(auth, thinkingLevel, signal)
+    );
+    if (signal?.aborted || response?.stopReason === "aborted") return { kind: "aborted" };
+    if (!isAssistantMessage(response)) {
+      return { kind: "error", message: "The side model returned a malformed response." };
+    }
+    if (response.stopReason === "error") {
+      return {
+        kind: "error",
+        message: response.errorMessage ?? "The side model returned an error."
+      };
+    }
+    const answer = extractAssistantText(response) || "No response received.";
+    thread.turns.push({ kind: "answered", question, answer, response });
+    return { kind: "answered", response, answer };
+  } catch (error) {
+    if (signal?.aborted) return { kind: "aborted" };
+    return { kind: "error", message: formatError(error) };
+  }
+}
+function extractAssistantText(response) {
+  return response.content.filter(
+    (content) => content !== null && typeof content === "object" && content.type === "text" && typeof content.text === "string"
+  ).map((content) => content.text).join("\n").trim();
+}
+function isAssistantMessage(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.role === "assistant" && Array.isArray(candidate.content) && typeof candidate.stopReason === "string";
+}
+function buildUserPrompt(question, conversationContext) {
+  return [
+    "Answer this side question without modifying the main conversation.",
+    "",
+    "<side_question>",
+    question,
+    "</side_question>",
+    "",
+    "<conversation_context>",
+    conversationContext || "No prior conversation context was available.",
+    "</conversation_context>"
+  ].join("\n");
+}
+function buildFollowUpPrompt(question) {
+  return [
+    "Continue the same side conversation.",
+    "",
+    "<side_question>",
+    question,
+    "</side_question>"
+  ].join("\n");
+}
+function createUserMessage(text) {
+  return {
+    role: "user",
+    content: [{ type: "text", text }],
+    timestamp: Date.now()
+  };
+}
+function buildStreamOptions(auth, thinkingLevel, signal) {
+  const options = {
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    env: auth.env,
+    signal
+  };
+  if (thinkingLevel !== "off") options.reasoning = thinkingLevel;
+  return options;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var SYSTEM_PROMPT = `You answer quick side questions for a coding-agent user.
+
+Use the provided conversation context only as background. Answer the user's side question directly and concisely. Do not claim to have changed files, run tools, or affected the main task. If the context is insufficient, say what is unknown and give the best next step.`;
+
+// src/settings.ts
+var BTW_SETTINGS_FILE = "pi-btw.json";
+var DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES = true;
+var MAX_SETTINGS_BYTES = 64 * 1024;
+var mutationQueues = /* @__PURE__ */ new Map();
+function btwSettingsPath() {
+  return join(getAgentDir(), BTW_SETTINGS_FILE);
+}
+function normalizeBtwSettings(value) {
+  if (!isSettingsDocument(value)) return void 0;
+  const settings = {};
+  if (Object.hasOwn(value, "model")) {
+    const model = Reflect.get(value, "model");
+    if (typeof model !== "string" || !parseBtwModelReference(model)) return void 0;
+    settings.model = model;
+  }
+  if (Object.hasOwn(value, "thinkingLevel")) {
+    const thinkingLevel = Reflect.get(value, "thinkingLevel");
+    if (!isBtwThinkingLevel(thinkingLevel)) return void 0;
+    settings.thinkingLevel = thinkingLevel;
+  }
+  if (Object.hasOwn(value, "rememberThinkingLevelChanges")) {
+    const remember = Reflect.get(value, "rememberThinkingLevelChanges");
+    if (typeof remember !== "boolean") return void 0;
+    settings.rememberThinkingLevelChanges = remember;
+  }
+  return settings;
+}
+function parseBtwModelReference(reference) {
+  if (/[\s\p{Cc}]/u.test(reference)) return void 0;
+  const separator = reference.indexOf("/");
+  if (separator <= 0 || separator === reference.length - 1) return void 0;
+  return { provider: reference.slice(0, separator), modelId: reference.slice(separator + 1) };
+}
+function effectiveRememberThinkingLevelChanges(settings) {
+  return settings.rememberThinkingLevelChanges ?? DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES;
+}
+async function readBtwSettings(settingsPath = btwSettingsPath()) {
+  await awaitBtwSettingsWrites(settingsPath);
+  return readBtwSettingsUncoordinated(settingsPath);
+}
+function updateBtwSettings(patch, options = {}) {
+  const settingsPath = options.settingsPath ?? btwSettingsPath();
+  return enqueueMutation(settingsPath, async () => {
+    options.signal?.throwIfAborted();
+    const current = await readSettingsDocumentForUpdate(settingsPath);
+    const updated = applyBtwSettingsPatch(current, patch);
+    const settings = normalizeBtwSettings(updated);
+    if (!settings) throw invalidSettingsError(settingsPath, "invalid settings shape");
+    await publishSettings(settingsPath, updated, options.signal, options.beforeRename);
+    return settings;
+  });
+}
+async function awaitBtwSettingsWrites(settingsPath = btwSettingsPath()) {
+  await mutationQueues.get(settingsPath);
+}
+function enqueueMutation(settingsPath, mutation) {
+  const previous = mutationQueues.get(settingsPath) ?? Promise.resolve();
+  const result = previous.then(mutation, mutation);
+  const settled = result.then(
+    () => void 0,
+    () => void 0
+  );
+  mutationQueues.set(settingsPath, settled);
+  void settled.finally(() => {
+    if (mutationQueues.get(settingsPath) === settled) mutationQueues.delete(settingsPath);
+  });
+  return result;
+}
+async function readBtwSettingsUncoordinated(settingsPath) {
+  let contents;
+  try {
+    contents = await readSettingsContents(settingsPath);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return { kind: "missing" };
+    return { kind: "invalid", reason: `${settingsPath}: ${formatError2(error)}` };
+  }
+  try {
+    const settings = normalizeBtwSettings(JSON.parse(contents));
+    return settings ? { kind: "loaded", settings } : { kind: "invalid", reason: `${settingsPath}: invalid settings shape` };
+  } catch {
+    return { kind: "invalid", reason: `${settingsPath}: invalid JSON` };
+  }
+}
+async function readSettingsDocumentForUpdate(settingsPath) {
+  let contents;
+  try {
+    contents = await readSettingsContents(settingsPath);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return {};
+    throw invalidSettingsError(settingsPath, formatError2(error));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch {
+    throw invalidSettingsError(settingsPath, "invalid JSON");
+  }
+  if (!isSettingsDocument(parsed) || !normalizeBtwSettings(parsed)) {
+    throw invalidSettingsError(settingsPath, "invalid settings shape");
+  }
+  return parsed;
+}
+async function readSettingsContents(settingsPath) {
+  const flags = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+  const handle = await open(settingsPath, flags);
+  try {
+    const descriptorStats = await handle.stat();
+    if (!descriptorStats.isFile()) throw new Error("settings path is not a regular file");
+    if (descriptorStats.size > MAX_SETTINGS_BYTES) {
+      throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
+    }
+    const buffer = Buffer.alloc(MAX_SETTINGS_BYTES + 1);
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+      const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    if (offset > MAX_SETTINGS_BYTES) {
+      throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+        buffer.subarray(0, offset)
+      );
+    } catch {
+      throw new Error("settings file is not valid UTF-8");
+    }
+  } finally {
+    await handle.close();
+  }
+}
+async function publishSettings(settingsPath, document, signal, beforeRename) {
+  signal?.throwIfAborted();
+  const contents = `${JSON.stringify(document, null, 2)}
+`;
+  if (Buffer.byteLength(contents, "utf8") > MAX_SETTINGS_BYTES) {
+    throw new Error(`settings document exceeds ${MAX_SETTINGS_BYTES} bytes`);
+  }
+  const directory = dirname(settingsPath);
+  await mkdir(directory, { recursive: true });
+  signal?.throwIfAborted();
+  const temporaryPath = join(
+    directory,
+    `.${basename(settingsPath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(temporaryPath, contents, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384,
+      signal
+    });
+    await beforeRename?.(temporaryPath, settingsPath);
+    signal?.throwIfAborted();
+    await rename(temporaryPath, settingsPath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function applyBtwSettingsPatch(current, patch) {
+  const updated = { ...current };
+  if (Object.hasOwn(patch, "thinkingLevel")) {
+    if (patch.thinkingLevel === void 0) delete updated.thinkingLevel;
+    else updated.thinkingLevel = patch.thinkingLevel;
+  }
+  if (Object.hasOwn(patch, "rememberThinkingLevelChanges")) {
+    updated.rememberThinkingLevelChanges = patch.rememberThinkingLevelChanges;
+  }
+  return updated;
+}
+function isSettingsDocument(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBtwThinkingLevel(value) {
+  return BTW_THINKING_LEVELS.includes(value);
+}
+function invalidSettingsError(settingsPath, reason) {
+  return new Error(`pi-btw settings at ${settingsPath} are invalid: ${reason}`);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/menu.ts
+var SAME_AS_MAIN_THREAD = "Same as main thread";
+async function showBtwCommandMenu(ctx, options) {
+  if (ctx.mode !== "tui") return "closed";
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (ctx.signal?.aborted) return "closed";
+  const settingsPath = options.settingsPath ?? btwSettingsPath();
+  const readSettings = options.readSettings ?? readBtwSettings;
+  const updateSettings = options.updateSettings ?? updateBtwSettings;
+  const levels = options.availableThinkingLevels.length > 0 ? [...options.availableThinkingLevels] : ["off"];
+  const displaySettingsPath = sanitizeSingleLine(settingsPath);
+  const resumeThreads = options.resumeThreads ?? [];
+  let startSelected = false;
+  let treeSelected = false;
+  let resumedThreadId;
+  const loadState = async () => {
+    const loaded = await readSettings(settingsPath);
+    if (loaded.kind === "invalid") {
+      return { kind: "invalid", settings: {}, reason: loaded.reason };
+    }
+    return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
+  };
+  const currentMainThinkingLevel = clampToAvailableThinkingLevel(
+    options.currentThinkingLevel,
+    levels
+  );
+  const displayThinkingLevel = (settings) => settings.thinkingLevel === void 0 ? SAME_AS_MAIN_THREAD : clampToAvailableThinkingLevel(settings.thinkingLevel, levels);
+  const displayThinkingSummary = (settings) => settings.thinkingLevel === void 0 ? `${SAME_AS_MAIN_THREAD} (currently ${currentMainThinkingLevel})` : displayThinkingLevel(settings);
+  const displayRememberSummary = (settings) => {
+    const value = effectiveRememberThinkingLevelChanges(settings) ? "On" : "Off";
+    return settings.thinkingLevel === void 0 ? `${value} (fixed levels only)` : value;
+  };
+  const menu = defineMenu({
+    start: "main",
+    screens: {
+      main: ({ state }) => ({
+        kind: "actions",
+        title: "Pi BTW",
+        lines: [
+          `Thinking: ${displayThinkingSummary(state.settings)} \xB7 Remember changes: ${displayRememberSummary(state.settings)}`
+        ],
+        items: [
+          {
+            id: "start",
+            label: "Start side thread",
+            description: "Open an empty side thread",
+            action: "start"
+          },
+          {
+            id: "start-tree",
+            label: "Start from main thread tree\u2026",
+            description: "Choose context without switching the main branch",
+            action: "start-tree"
+          },
+          ...resumeThreads.length > 0 ? [
+            {
+              id: "resume",
+              label: "Resume side thread",
+              description: "Continue an in-memory side thread",
+              to: "resume"
+            }
+          ] : [],
+          {
+            id: "settings",
+            label: "Settings",
+            description: "Choose pi-btw thinking level and fixed-level shortcut memory",
+            to: state.kind === "invalid" ? "invalid" : "settings"
+          }
+        ],
+        hint: "close"
+      }),
+      resume: () => ({
+        kind: "choice",
+        title: "Resume BTW side thread",
+        enableSearch: true,
+        items: resumeThreads.map((thread) => ({
+          id: thread.id,
+          label: thread.title,
+          description: `${thread.questionCount} ${thread.questionCount === 1 ? "question" : "questions"}`
+        })),
+        action: "resume",
+        viewportSize: 10,
+        hint: "back"
+      }),
+      settings: ({ state }) => ({
+        kind: "settings",
+        title: "Pi BTW Settings",
+        lines: [`User settings \xB7 ${displaySettingsPath}`],
+        items: [
+          {
+            id: "thinkingLevel",
+            label: "Thinking level",
+            description: `Set the starting level for future pi-btw side threads. Currently ${currentMainThinkingLevel}.`,
+            currentValue: displayThinkingLevel(state.settings),
+            values: [SAME_AS_MAIN_THREAD, ...levels],
+            action: "set-thinking"
+          },
+          {
+            id: "rememberThinkingLevelChanges",
+            label: "Remember thinking level changes",
+            description: "Save shortcut changes for fixed thinking levels to pi-btw.json.",
+            currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "set-remember"
+          }
+        ]
+      }),
+      invalid: ({ state }) => ({
+        kind: "detail",
+        title: "Pi BTW Settings \xB7 Read only",
+        lines: [
+          `Invalid settings file. Fix ${displaySettingsPath} before saving.`,
+          sanitizeSingleLine(state.reason ?? "The settings file is invalid.")
+        ],
+        hint: "back"
+      })
+    },
+    actions: {
+      start: async () => {
+        startSelected = true;
+        return { kind: "close" };
+      },
+      "start-tree": async () => {
+        treeSelected = true;
+        return { kind: "close" };
+      },
+      resume: async ({ itemId }) => {
+        if (!resumeThreads.some((thread) => thread.id === itemId)) {
+          return { kind: "rejected" };
+        }
+        resumedThreadId = itemId;
+        return { kind: "close" };
+      },
+      "set-thinking": async ({ value, signal }) => {
+        if (!value) return { kind: "rejected" };
+        const patch = value === SAME_AS_MAIN_THREAD ? { thinkingLevel: void 0 } : levels.includes(value) ? { thinkingLevel: value } : void 0;
+        if (!patch) return { kind: "rejected" };
+        try {
+          await updateSettings(patch, { settingsPath, signal });
+          if (signal.aborted) return { kind: "rejected" };
+          notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
+          return { kind: "stay" };
+        } catch (error) {
+          if (!signal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      },
+      "set-remember": async ({ value, signal }) => {
+        if (value !== "On" && value !== "Off") return { kind: "rejected" };
+        try {
+          await updateSettings(
+            { rememberThinkingLevelChanges: value === "On" },
+            { settingsPath, signal }
+          );
+          if (signal.aborted) return { kind: "rejected" };
+          notifySafely(ctx, `Remember thinking level changes: ${value}.`, "info");
+          return { kind: "stay" };
+        } catch (error) {
+          if (!signal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      }
+    }
+  });
+  const result = await runBtwMenuPreservingEditor(
+    ctx,
+    (menuContext) => runMenu(menuContext, menu, { getState: loadState })
+  );
+  if (result.kind !== "closed" || result.reason !== "close") return "closed";
+  if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
+  if (treeSelected) return "tree";
+  return startSelected ? "start" : "closed";
+}
+async function showBtwCustomPreservingEditor(ctx, factory) {
+  let liveEditorText = ctx.ui.getEditorText();
+  let completed = false;
+  const result = await ctx.ui.custom(
+    (tui, theme, keybindings, done) => factory(tui, theme, keybindings, (value) => {
+      try {
+        liveEditorText = ctx.ui.getEditorText();
+      } catch {
+      }
+      completed = true;
+      done(value);
+    })
+  );
+  if (completed) {
+    try {
+      if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+    } catch {
+    }
+  }
+  return result;
+}
+async function runBtwMenuPreservingEditor(ctx, run) {
+  let liveEditorText = ctx.ui.getEditorText();
+  let completed = false;
+  const ui = new Proxy(ctx.ui, {
+    get(target, property) {
+      if (property === "custom") {
+        return (factory, customOptions) => target.custom(
+          (tui, theme, keybindings, done) => factory(tui, theme, keybindings, (value2) => {
+            try {
+              liveEditorText = target.getEditorText();
+            } catch {
+            }
+            completed = true;
+            done(value2);
+          }),
+          customOptions
+        );
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  const result = await run({ mode: ctx.mode, hasUI: ctx.hasUI, ui });
+  if (result.kind !== "stale" && completed) {
+    try {
+      if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+    } catch {
+    }
+  }
+  return result;
+}
+function clampToAvailableThinkingLevel(requested, available) {
+  if (available.includes(requested)) return requested;
+  const requestedIndex = BTW_THINKING_LEVELS.indexOf(requested);
+  for (let index = requestedIndex; index < BTW_THINKING_LEVELS.length; index += 1) {
+    const candidate = BTW_THINKING_LEVELS[index];
+    if (candidate && available.includes(candidate)) return candidate;
+  }
+  for (let index = requestedIndex - 1; index >= 0; index -= 1) {
+    const candidate = BTW_THINKING_LEVELS[index];
+    if (candidate && available.includes(candidate)) return candidate;
+  }
+  return available[0] ?? "off";
+}
+function notifySaveFailure(ctx, error) {
+  notifySafely(
+    ctx,
+    `Pi BTW settings were not saved; the previous value remains active: ${formatError3(error)}`,
+    "error"
+  );
+}
+function notifySafely(ctx, message, level) {
+  try {
+    ctx.ui.notify(sanitizeSingleLine(message), level);
+  } catch {
+  }
+}
+function formatError3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/main-tree-picker.ts
+var MainThreadTreePickerComponent = class {
+  constructor(selector, onClose) {
+    this.selector = selector;
+    this.onClose = onClose;
+  }
+  selector;
+  onClose;
+  get focused() {
+    return this.selector.focused;
+  }
+  set focused(value) {
+    this.selector.focused = value;
+  }
+  get wantsKeyRelease() {
+    return this.selector.wantsKeyRelease;
+  }
+  render(width) {
+    return this.selector.render(width);
+  }
+  handleInput(data) {
+    if (matchesKey2(data, Key2.ctrl("c"))) {
+      this.onClose();
+      return;
+    }
+    this.selector.handleInput?.(data);
+  }
+  invalidate() {
+    this.selector.invalidate();
+  }
+  dispose() {
+    this.selector.dispose?.();
+    this.onClose();
+  }
+};
+async function pickMainEntry(pi, ctx, dependencies = {}) {
+  let rawTree;
+  let currentLeafId;
+  try {
+    rawTree = ctx.sessionManager.getTree();
+    currentLeafId = ctx.sessionManager.getLeafId();
+  } catch {
+    return { kind: "closed" };
+  }
+  if (rawTree.length === 0) {
+    notifySafely2(ctx, "No main-thread entries are available", "warning");
+    return { kind: "back" };
+  }
+  const tree = sanitizeTreeForDisplay(rawTree);
+  const rawCopyText = collectRawCopyText(rawTree);
+  const savedLabels = collectSavedLabels(rawTree);
+  const createSelector = dependencies.createSelector ?? createNativeTreeSelector;
+  const copy = dependencies.copyToClipboard ?? copyText;
+  const copyControllers = /* @__PURE__ */ new Set();
+  const copyTasks = /* @__PURE__ */ new Set();
+  const abortCopies = () => {
+    for (const controller of copyControllers) {
+      controller.abort(new Error("The main-thread tree picker closed"));
+    }
+  };
+  const result = await showBtwCustomPreservingEditor(
+    ctx,
+    (tui, _theme, _keybindings, done) => {
+      let settled = false;
+      let selector;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        abortCopies();
+        done(value);
+      };
+      const onCopy = (entryId, displayText) => {
+        if (settled) return;
+        const text = entryId ? rawCopyText.get(entryId) : displayText;
+        if (!text) {
+          notifySafely2(ctx, "Selected entry has no text to copy", "warning");
+          return;
+        }
+        const controller = new AbortController();
+        copyControllers.add(controller);
+        let operation;
+        try {
+          operation = copy(text, controller.signal);
+        } catch (error) {
+          operation = Promise.reject(error);
+        }
+        let task;
+        task = operation.then(() => {
+          if (!settled) notifySafely2(ctx, "Copied selected message", "info");
+        }).catch((error) => {
+          if (!settled && !controller.signal.aborted) {
+            notifySafely2(ctx, `Could not copy selected message: ${formatError4(error)}`, "error");
+          }
+        }).finally(() => {
+          copyControllers.delete(controller);
+          copyTasks.delete(task);
+        });
+        copyTasks.add(task);
+      };
+      const restoreLabel = (entryId) => {
+        const previous = savedLabels.get(entryId);
+        selector?.setViewLabel?.(entryId, previous?.label, previous?.labelTimestamp);
+        tui.requestRender();
+      };
+      const onLabelChange = (entryId, label) => {
+        if (settled) return;
+        try {
+          if (!ctx.sessionManager.getEntry(entryId)) {
+            restoreLabel(entryId);
+            notifySafely2(ctx, "The selected main-thread entry is no longer available", "warning");
+            return;
+          }
+          const persistedLabel = label === void 0 ? void 0 : sanitizeSingleLine(label);
+          pi.setLabel(entryId, persistedLabel);
+          savedLabels.set(entryId, { label: persistedLabel });
+          selector?.setViewLabel?.(entryId, persistedLabel);
+          tui.requestRender();
+        } catch (error) {
+          restoreLabel(entryId);
+          notifySafely2(ctx, `Could not update tree label: ${formatError4(error)}`, "error");
+        }
+      };
+      selector = createSelector({
+        tree,
+        currentLeafId,
+        terminalRows: tui.terminal.rows,
+        onSelect: (entryId) => finish({ kind: "selected", entryId }),
+        onCancel: () => finish({ kind: "back" }),
+        onCopy,
+        onLabelChange
+      });
+      return new MainThreadTreePickerComponent(selector, () => finish({ kind: "closed" }));
+    }
+  );
+  abortCopies();
+  await Promise.allSettled([...copyTasks]);
+  return result ?? { kind: "closed" };
+}
+function createNativeTreeSelector(options) {
+  const selector = new TreeSelectorComponent(
+    options.tree,
+    options.currentLeafId,
+    options.terminalRows,
+    options.onSelect,
+    options.onCancel,
+    options.onLabelChange
+  );
+  selector.onCopy = (displayText) => options.onCopy(selector.getTreeList().getSelectedNode()?.entry.id, displayText);
+  const result = selector;
+  result.setViewLabel = (entryId, label, labelTimestamp) => selector.getTreeList().updateNodeLabel(entryId, label, labelTimestamp);
+  return result;
+}
+function sanitizeTreeForDisplay(tree) {
+  return tree.map((node) => {
+    const result = {
+      entry: sanitizeEntryForDisplay(node.entry),
+      children: sanitizeTreeForDisplay(node.children)
+    };
+    if (node.label !== void 0) result.label = sanitizeSingleLine(node.label);
+    if (node.labelTimestamp !== void 0) {
+      result.labelTimestamp = sanitizeSingleLine(node.labelTimestamp);
+    }
+    return result;
+  });
+}
+function sanitizeEntryForDisplay(entry) {
+  switch (entry.type) {
+    case "message": {
+      const message = { ...entry.message };
+      if ("content" in entry.message)
+        message.content = sanitizeDisplayContent(entry.message.content);
+      for (const key of ["role", "errorMessage", "command", "toolName"]) {
+        const value = message[key];
+        if (typeof value === "string") message[key] = sanitizeSingleLine(value);
+      }
+      return { ...entry, message };
+    }
+    case "custom_message":
+      return {
+        ...entry,
+        customType: sanitizeSingleLine(entry.customType),
+        content: sanitizeDisplayContent(entry.content)
+      };
+    case "compaction":
+      return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+    case "branch_summary":
+      return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+    case "model_change":
+      return {
+        ...entry,
+        provider: sanitizeSingleLine(entry.provider),
+        modelId: sanitizeSingleLine(entry.modelId)
+      };
+    case "thinking_level_change":
+      return { ...entry, thinkingLevel: sanitizeSingleLine(entry.thinkingLevel) };
+    case "custom":
+      return { ...entry, customType: sanitizeSingleLine(entry.customType) };
+    case "label":
+      return {
+        ...entry,
+        label: entry.label === void 0 ? void 0 : sanitizeSingleLine(entry.label)
+      };
+    case "session_info":
+      return {
+        ...entry,
+        name: entry.name === void 0 ? void 0 : sanitizeSingleLine(entry.name)
+      };
+  }
+}
+function sanitizeDisplayContent(content) {
+  if (typeof content === "string") return sanitizeSingleLine(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => {
+    if (block === null || typeof block !== "object" || !("type" in block)) return block;
+    if (block.type === "text" && "text" in block && typeof block.text === "string") {
+      return { ...block, text: sanitizeSingleLine(block.text) };
+    }
+    if (block.type === "toolCall") {
+      const copy = { ...block };
+      if (typeof copy.name === "string") copy.name = sanitizeSingleLine(copy.name);
+      copy.arguments = sanitizeToolArguments(copy.arguments, /* @__PURE__ */ new WeakMap());
+      return copy;
+    }
+    return block;
+  });
+}
+function sanitizeToolArguments(value, seen) {
+  if (typeof value === "string") return sanitizeSingleLine(value);
+  if (value === null || typeof value !== "object") return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const result2 = [];
+    seen.set(value, result2);
+    for (const item of value) result2.push(sanitizeToolArguments(item, seen));
+    return result2;
+  }
+  const result = {};
+  seen.set(value, result);
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = sanitizeToolArguments(item, seen);
+  }
+  return result;
+}
+function collectRawCopyText(tree) {
+  const result = /* @__PURE__ */ new Map();
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      const text = getRawCopyText(node.entry);
+      if (text !== void 0) result.set(node.entry.id, text);
+      visit(node.children);
+    }
+  };
+  visit(tree);
+  return result;
+}
+function getRawCopyText(entry) {
+  let text;
+  if (entry.type === "message") {
+    if (entry.message.role === "bashExecution") text = entry.message.command;
+    else if ("content" in entry.message) {
+      text = extractRawText(entry.message.content);
+      if (!text && entry.message.role === "assistant") text = entry.message.errorMessage;
+    }
+  } else if (entry.type === "custom_message") text = extractRawText(entry.content);
+  else if (entry.type === "compaction" || entry.type === "branch_summary") text = entry.summary;
+  return text?.trim() ? text : void 0;
+}
+function extractRawText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (block) => block !== null && typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string"
+  ).map((block) => block.text).join("");
+}
+function collectSavedLabels(tree) {
+  const result = /* @__PURE__ */ new Map();
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      result.set(node.entry.id, {
+        label: node.label === void 0 ? void 0 : sanitizeSingleLine(node.label),
+        labelTimestamp: node.labelTimestamp === void 0 ? void 0 : sanitizeSingleLine(node.labelTimestamp)
+      });
+      visit(node.children);
+    }
+  };
+  visit(tree);
+  return result;
+}
+async function copyText(text, signal) {
+  signal.throwIfAborted();
+  await copyToClipboard(text);
+  signal.throwIfAborted();
+}
+function notifySafely2(ctx, message, level) {
+  try {
+    ctx.ui.notify(sanitizeSingleLine(message), level);
+  } catch {
+  }
+}
+function formatError4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/transcript-pager.ts
+import {
+  AssistantMessageComponent,
+  getMarkdownTheme,
+  UserMessageComponent
+} from "@earendil-works/pi-coding-agent";
+import {
+  CURSOR_MARKER,
+  Editor,
+  Key as Key3,
+  Loader,
+  Markdown,
+  matchesKey as matchesKey3,
+  ScrollView,
+  truncateToWidth as truncateToWidth3,
+  VStack,
+  visibleWidth as visibleWidth2
+} from "@earendil-works/pi-tui";
+var TRANSCRIPT_CHROME_LINES = 2;
+var MAX_STEERING_DISPLAY_LINES = 3;
+var OSC133_MARKERS = ["\x1B]133;A\x07", "\x1B]133;B\x07", "\x1B]133;C\x07"];
+var RESERVED_APP_LINES = 3;
+var PreservingScrollView = class extends ScrollView {
+  updateLayout(contentHeight, viewportHeight, requestRender) {
+    const preserveManualPosition = !this.isFollowingEnd;
+    super.updateLayout(contentHeight, viewportHeight, requestRender);
+    if (preserveManualPosition && this.isFollowingEnd) {
+      this.scrollTo(this.scrollTop, { disableFollow: true });
+    }
+  }
+};
+var BtwTranscriptPager = class {
+  constructor(tui, theme, turns, onAction, options = {}) {
+    this.tui = tui;
+    this.theme = theme;
+    this.onAction = onAction;
+    this.options = options;
+    this.transcriptComponents = buildTranscriptComponents(turns, this.theme);
+    this.canBringToMain = turns.some((turn) => turn.kind === "answered");
+    this.thinkingLevel = options.thinking?.level;
+    const editorTheme = {
+      borderColor: (text) => this.theme.fg("accent", text),
+      selectList: {
+        selectedPrefix: (text) => this.theme.fg("accent", text),
+        selectedText: (text) => this.theme.fg("accent", text),
+        description: (text) => this.theme.fg("muted", text),
+        scrollInfo: (text) => this.theme.fg("dim", text),
+        noMatch: (text) => this.theme.fg("warning", text)
+      }
+    };
+    this.editor = new Editor(this.tui, editorTheme);
+    if (options.initialQuestion) this.editor.setText(options.initialQuestion);
+    this.editor.onChange = () => {
+      this.warning = void 0;
+    };
+    this.editor.onSubmit = (text) => {
+      const question = text.trim();
+      if (!question) {
+        this.warning = "Question cannot be empty";
+        return;
+      }
+      this.finished = true;
+      this.onAction({ kind: "submit", question });
+    };
+    const transcript = this.createTranscriptComponent();
+    this.scrollView = new PreservingScrollView(transcript, {
+      follow: options.startAtBottom ? "end" : "none",
+      primary: true
+    });
+    this.layoutRoot = new VStack([
+      { component: this.createHeaderComponent(), basis: 1, shrink: 0, minSize: 1 },
+      { component: this.scrollView, basis: 0, grow: 1, minSize: 0 },
+      { component: this.createFooterComponent(), basis: 1, shrink: 0, minSize: 1 },
+      { component: this.editor, basis: "auto", shrink: 1, minSize: 0 }
+    ]);
+  }
+  tui;
+  theme;
+  onAction;
+  options;
+  transcriptComponents;
+  editor;
+  canBringToMain;
+  scrollView;
+  layoutRoot;
+  lastContentLineCount = 0;
+  warning;
+  finished = false;
+  isFocused = false;
+  thinkingLevel;
+  get focused() {
+    return this.isFocused;
+  }
+  set focused(value) {
+    this.isFocused = value;
+    this.editor.focused = value;
+  }
+  getFullscreenLayout() {
+    return this.layoutRoot;
+  }
+  render(width) {
+    const safeWidth = Math.max(1, width);
+    const editorLines = this.editor.render(safeWidth);
+    const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
+    const viewportHeight = Math.max(
+      0,
+      availableRows - editorLines.length - TRANSCRIPT_CHROME_LINES
+    );
+    const contentLines = renderTranscriptLines(this.transcriptComponents, safeWidth);
+    this.lastContentLineCount = contentLines.length;
+    this.scrollView.updateLayout(
+      contentLines.length,
+      viewportHeight,
+      () => this.tui.requestRender()
+    );
+    return fitComposerLayout(
+      renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
+      contentLines.slice(this.scrollView.scrollTop, this.scrollView.scrollTop + viewportHeight),
+      this.renderFooter(safeWidth),
+      editorLines,
+      availableRows
+    );
+  }
+  handleInput(data) {
+    if (this.finished) return;
+    if (matchesKey3(data, Key3.ctrl("c"))) {
+      this.finished = true;
+      this.onAction({ kind: "close" });
+      return;
+    }
+    if (this.canBringToMain && matchesKey3(data, Key3.ctrl("r"))) {
+      this.finished = true;
+      this.onAction({ kind: "bringToMain", questionDraft: this.editor.getExpandedText() });
+      return;
+    }
+    const thinking = this.options.thinking;
+    if (thinking && thinking.levels.length > 1 && thinking.keybindings.matches(data, "app.thinking.cycle")) {
+      const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
+      const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
+      if (nextLevel) {
+        this.thinkingLevel = nextLevel;
+        thinking.onChange(nextLevel);
+        this.warning = void 0;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesKey3(data, Key3.pageUp)) {
+      this.scrollView.scrollBy(-Math.max(1, this.scrollView.viewportHeight));
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey3(data, Key3.pageDown)) {
+      this.scrollView.scrollBy(Math.max(1, this.scrollView.viewportHeight));
+      this.tui.requestRender();
+      return;
+    }
+    this.editor.handleInput(data);
+    if (!this.finished) this.tui.requestRender();
+  }
+  invalidate() {
+    this.layoutRoot.invalidate();
+  }
+  dispose() {
+    if (this.finished) return;
+    this.finished = true;
+    this.onAction({ kind: "close" });
+  }
+  renderFooter(width) {
+    if (this.warning) {
+      const warning = width < 32 ? "Empty \u2022 Ctrl+C" : `${this.warning} \u2022 Ctrl+C exit`;
+      return truncateToWidth3(this.theme.fg("warning", warning), width);
+    }
+    const scrollable = this.getMaxScrollOffset() > 0;
+    const thinking = this.options.thinking;
+    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${thinkingKeyLabel(thinking.keybindings)} cycle` : "";
+    const base = this.canBringToMain ? "btw \u2022 Enter send \u2022 Ctrl+R bring to main \u2022 Ctrl+C exit" : "btw \u2022 Enter send \u2022 Ctrl+C exit";
+    const fullBase = `${base}${cycleHint}`;
+    const fallbackBase = "btw \u2022 Enter \u2022 Ctrl+C";
+    const compactBase = this.canBringToMain ? "btw \u2022 Enter \u2022 Ctrl+R \u2022 Ctrl+C" : fallbackBase;
+    const compactWithThinking = `${compactBase}${cycleHint}`;
+    let hints = visibleWidth2(fullBase) <= width ? fullBase : visibleWidth2(compactWithThinking) <= width ? compactWithThinking : visibleWidth2(compactBase) <= width ? compactBase : fallbackBase;
+    if (scrollable) {
+      const history = ` \u2022 ${this.scrollView.scrollTop > 0 ? "\u2191 older" : "\u2193 newer"} \u2022 PgUp/PgDn history`;
+      const compactHistory = " \u2022 PgUp/PgDn";
+      const compactScrollable = this.canBringToMain ? "Enter \u2022 Ctrl+R \u2022 Ctrl+C \u2022 PgUp/PgDn" : `${fallbackBase}${compactHistory}`;
+      if (visibleWidth2(`${hints}${history}`) <= width) {
+        hints += history;
+      } else if (visibleWidth2(`${compactBase}${history}`) <= width) {
+        hints = `${compactBase}${history}`;
+      } else if (visibleWidth2(`${hints}${compactHistory}`) <= width) {
+        hints += compactHistory;
+      } else if (visibleWidth2(`${compactBase}${compactHistory}`) <= width) {
+        hints = `${compactBase}${compactHistory}`;
+      } else if (visibleWidth2(compactScrollable) <= width) {
+        hints = compactScrollable;
+      }
+    }
+    return truncateToWidth3(this.theme.fg("muted", hints), width);
+  }
+  createHeaderComponent() {
+    return {
+      render: (width) => [renderSideThreadHeader(width, this.theme, this.thinkingLevel)],
+      invalidate() {
+      }
+    };
+  }
+  createTranscriptComponent() {
+    return {
+      render: (width) => {
+        const lines = renderTranscriptLines(this.transcriptComponents, width);
+        this.lastContentLineCount = lines.length;
+        return lines;
+      },
+      invalidate: () => {
+        for (const component of this.transcriptComponents) component.invalidate();
+      }
+    };
+  }
+  createFooterComponent() {
+    return {
+      render: (width) => [this.renderFooter(width)],
+      invalidate() {
+      }
+    };
+  }
+  getMaxScrollOffset() {
+    return Math.max(0, this.lastContentLineCount - this.scrollView.viewportHeight);
+  }
+};
+var BtwAnsweringView = class {
+  constructor(tui, theme, turns, pendingQuestion, onCancel, thinkingLevel, options = {}) {
+    this.tui = tui;
+    this.theme = theme;
+    this.onCancel = onCancel;
+    this.options = options;
+    this.transcriptComponents = buildTranscriptComponents(turns, this.theme, pendingQuestion);
+    this.thinkingLevel = options.steering?.thinking?.level ?? thinkingLevel;
+    this.loader = new Loader(
+      this.tui,
+      (text) => this.theme.fg("accent", text),
+      (text) => this.theme.fg("muted", text),
+      "Answering\u2026"
+    );
+    if (options.steering) {
+      const editorTheme = {
+        borderColor: (text) => this.theme.fg("accent", text),
+        selectList: {
+          selectedPrefix: (text) => this.theme.fg("accent", text),
+          selectedText: (text) => this.theme.fg("accent", text),
+          description: (text) => this.theme.fg("muted", text),
+          scrollInfo: (text) => this.theme.fg("dim", text),
+          noMatch: (text) => this.theme.fg("warning", text)
+        }
+      };
+      this.editor = new Editor(this.tui, editorTheme);
+      this.editor.onChange = () => {
+        this.warning = void 0;
+      };
+      this.editor.onSubmit = (text) => {
+        const question = text.trim();
+        if (!question) {
+          this.warning = "Question cannot be empty";
+          return;
+        }
+        options.steering?.onSubmit(question);
+        this.warning = void 0;
+      };
+    }
+    const transcript = this.createTranscriptComponent();
+    this.scrollView = new PreservingScrollView(transcript, { follow: "end", primary: true });
+    this.layoutRoot = new VStack([
+      { component: this.createHeaderComponent(), basis: 1, shrink: 0, minSize: 1 },
+      { component: this.scrollView, basis: 0, grow: 1, minSize: 0 },
+      {
+        component: this.createSteeringComponent(),
+        basis: "auto",
+        shrink: 1,
+        minSize: 0,
+        maxSize: MAX_STEERING_DISPLAY_LINES
+      },
+      { component: this.createFooterComponent(), basis: 1, shrink: 0, minSize: 1 },
+      ...this.editor ? [{ component: this.editor, basis: "auto", shrink: 1, minSize: 0 }] : []
+    ]);
+  }
+  tui;
+  theme;
+  onCancel;
+  options;
+  transcriptComponents;
+  loader;
+  editor;
+  controller = new AbortController();
+  scrollView;
+  layoutRoot;
+  lastContentLineCount = 0;
+  warning;
+  finished = false;
+  isFocused = false;
+  thinkingLevel;
+  get focused() {
+    return this.isFocused;
+  }
+  set focused(value) {
+    this.isFocused = value;
+    if (this.editor) this.editor.focused = value;
+  }
+  get signal() {
+    return this.controller.signal;
+  }
+  getFullscreenLayout() {
+    return this.layoutRoot;
+  }
+  render(width) {
+    const safeWidth = Math.max(1, width);
+    const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
+    const editorLines = this.editor?.render(safeWidth) ?? [];
+    const steeringCapacity = Math.max(
+      0,
+      availableRows - editorLines.length - TRANSCRIPT_CHROME_LINES
+    );
+    const steeringLines = renderSteeringLines(
+      this.options.steering?.questions ?? [],
+      safeWidth,
+      this.theme,
+      Math.min(MAX_STEERING_DISPLAY_LINES, steeringCapacity)
+    );
+    const viewportHeight = Math.max(
+      0,
+      availableRows - editorLines.length - TRANSCRIPT_CHROME_LINES - steeringLines.length
+    );
+    const contentLines = renderTranscriptLines(this.transcriptComponents, safeWidth);
+    this.lastContentLineCount = contentLines.length;
+    this.scrollView.updateLayout(
+      contentLines.length,
+      viewportHeight,
+      () => this.tui.requestRender()
+    );
+    return fitComposerLayout(
+      renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
+      contentLines.slice(this.scrollView.scrollTop, this.scrollView.scrollTop + viewportHeight),
+      this.renderFooter(safeWidth),
+      editorLines,
+      availableRows,
+      steeringLines
+    );
+  }
+  handleInput(data) {
+    if (this.finished) return;
+    if (matchesKey3(data, Key3.ctrl("c"))) {
+      this.finished = true;
+      this.loader.stop();
+      this.controller.abort();
+      this.onCancel();
+      return;
+    }
+    const thinking = this.options.steering?.thinking;
+    if (thinking && thinking.levels.length > 1 && thinking.keybindings.matches(data, "app.thinking.cycle")) {
+      const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
+      const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
+      if (nextLevel) {
+        this.thinkingLevel = nextLevel;
+        thinking.onChange(nextLevel);
+        this.warning = void 0;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesKey3(data, Key3.pageUp)) {
+      this.scrollView.scrollBy(-Math.max(1, this.scrollView.viewportHeight));
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey3(data, Key3.pageDown)) {
+      this.scrollView.scrollBy(Math.max(1, this.scrollView.viewportHeight));
+      this.tui.requestRender();
+      return;
+    }
+    this.editor?.handleInput(data);
+    this.tui.requestRender();
+  }
+  invalidate() {
+    this.layoutRoot.invalidate();
+  }
+  finish() {
+    this.finished = true;
+    this.loader.stop();
+  }
+  dispose() {
+    if (this.finished) {
+      this.loader.stop();
+      this.controller.abort();
+      return;
+    }
+    this.finished = true;
+    this.loader.stop();
+    this.controller.abort();
+    this.onCancel();
+  }
+  renderFooter(width) {
+    if (this.warning) {
+      const warning = width < 32 ? "Empty \u2022 Ctrl+C" : `${this.warning} \u2022 Ctrl+C cancel`;
+      return truncateToWidth3(this.theme.fg("warning", warning), width);
+    }
+    const baseHint = this.editor ? "Enter steer \u2022 Ctrl+C cancel" : "Ctrl+C cancel";
+    const thinking = this.options.steering?.thinking;
+    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${thinkingKeyLabel(thinking.keybindings)} cycle` : "";
+    const scrollHint = this.getMaxScrollOffset() > 0 ? " \u2022 PgUp/PgDn history" : "";
+    const hints = `${baseHint}${cycleHint}${scrollHint}`;
+    const compactHints = this.editor ? "Enter \u2022 Ctrl+C" : "Ctrl+C";
+    const selectedHints = visibleWidth2(hints) <= width ? hints : compactHints;
+    const loaderWidth = Math.max(1, width - visibleWidth2(selectedHints) - 3);
+    const loaderLine = this.loader.render(loaderWidth).at(-1) ?? "Answering\u2026";
+    return truncateToWidth3(`${loaderLine} \u2022 ${this.theme.fg("muted", selectedHints)}`, width);
+  }
+  createHeaderComponent() {
+    return {
+      render: (width) => [renderSideThreadHeader(width, this.theme, this.thinkingLevel)],
+      invalidate() {
+      }
+    };
+  }
+  createTranscriptComponent() {
+    return {
+      render: (width) => {
+        const lines = renderTranscriptLines(this.transcriptComponents, width);
+        this.lastContentLineCount = lines.length;
+        return lines;
+      },
+      invalidate: () => {
+        for (const component of this.transcriptComponents) component.invalidate();
+      }
+    };
+  }
+  createSteeringComponent() {
+    return {
+      render: (width) => renderSteeringLines(
+        this.options.steering?.questions ?? [],
+        width,
+        this.theme,
+        MAX_STEERING_DISPLAY_LINES
+      ),
+      invalidate() {
+      }
+    };
+  }
+  createFooterComponent() {
+    return {
+      render: (width) => [this.renderFooter(width)],
+      invalidate: () => this.loader.invalidate()
+    };
+  }
+  getMaxScrollOffset() {
+    return Math.max(0, this.lastContentLineCount - this.scrollView.viewportHeight);
+  }
+};
+function buildTranscriptComponents(turns, theme, pendingQuestion) {
+  const components = turns.flatMap((turn) => {
+    const question = new UserMessageComponent(
+      escapeTerminalControls2(turn.question),
+      getMarkdownTheme(),
+      1
+    );
+    if (turn.kind === "error") {
+      const error = new Markdown(
+        `Error: ${escapeTerminalControls2(turn.answer)}`,
+        1,
+        1,
+        getMarkdownTheme(),
+        { color: (text) => theme.fg("error", text) }
+      );
+      return [question, error];
+    }
+    const response = {
+      ...turn.response,
+      content: [{ type: "text", text: escapeTerminalControls2(turn.answer) }],
+      stopReason: "stop",
+      errorMessage: void 0
+    };
+    return [question, new AssistantMessageComponent(response, true, getMarkdownTheme(), "", 1)];
+  });
+  if (pendingQuestion) {
+    components.push(
+      new UserMessageComponent(escapeTerminalControls2(pendingQuestion), getMarkdownTheme(), 1)
+    );
+  }
+  return components;
+}
+function renderTranscriptLines(components, width) {
+  return components.flatMap((component) => component.render(width)).map(stripShellIntegrationMarkers);
+}
+function renderSideThreadHeader(width, theme, thinkingLevel) {
+  const thinking = thinkingLevel ? ` \xB7 thinking ${thinkingLevel}` : "";
+  const title = truncateToWidth3(`\u2500 btw \xB7 side thread${thinking} `, width);
+  const ruleWidth = Math.max(0, width - visibleWidth2(title));
+  return theme.fg("muted", `${title}${"\u2500".repeat(ruleWidth)}`);
+}
+function thinkingKeyLabel(keybindings) {
+  const key = sanitizeSingleLine(String(keybindings.getKeys("app.thinking.cycle")[0] ?? "shift+tab")) || "Shift+Tab";
+  return key.split("+").map((part) => {
+    const lower = part.toLowerCase();
+    if (lower === "shift") return "Shift";
+    if (lower === "ctrl") return "Ctrl";
+    if (lower === "alt") return "Alt";
+    return part.length === 1 ? part.toUpperCase() : `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`;
+  }).join("+");
+}
+function fitComposerLayout(header, contentLines, footer, editorLines, availableRows, statusLines = []) {
+  const lines = [header, ...contentLines, ...statusLines, footer, ...editorLines];
+  if (lines.length <= availableRows) return lines;
+  if (availableRows <= 1) return [header];
+  const editorBudget = Math.max(0, availableRows - 2);
+  return [header, footer, ...fitEditorLines(editorLines, editorBudget)];
+}
+function fitEditorLines(editorLines, budget) {
+  if (budget <= 0) return [];
+  if (editorLines.length <= budget) return editorLines;
+  const cursorIndex = editorLines.findIndex((line) => line.includes(CURSOR_MARKER));
+  if (cursorIndex < 0) return editorLines.slice(-budget);
+  const start = Math.min(cursorIndex, editorLines.length - budget);
+  return editorLines.slice(start, start + budget);
+}
+function renderSteeringLines(questions, width, theme, maxLines) {
+  if (questions.length === 0 || maxLines <= 0) return [];
+  const formatQuestion = (question) => sanitizeSingleLine(question) || "(non-printing message)";
+  if (maxLines === 1 && questions.length > 1) {
+    return [
+      truncateToWidth3(
+        theme.fg(
+          "dim",
+          `Steering (+${questions.length - 1} more): ${formatQuestion(questions[0] ?? "")}`
+        ),
+        width
+      )
+    ];
+  }
+  const hasOverflow = questions.length > maxLines;
+  const questionLimit = hasOverflow ? Math.max(1, maxLines - 1) : maxLines;
+  const lines = questions.slice(0, questionLimit).map(
+    (question) => truncateToWidth3(theme.fg("dim", `Steering: ${formatQuestion(question)}`), width)
+  );
+  if (hasOverflow) {
+    lines.push(
+      truncateToWidth3(
+        theme.fg("dim", `Steering: \u2026 +${questions.length - questionLimit} more`),
+        width
+      )
+    );
+  }
+  return lines;
+}
+function stripShellIntegrationMarkers(line) {
+  return OSC133_MARKERS.reduce((result, marker) => result.replaceAll(marker, ""), line);
+}
+function escapeTerminalControls2(text) {
+  return [...text].map((character) => {
+    if (character === "\n") return character;
+    if (character === "	") return "    ";
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code >= 127 && code <= 159) {
+      return `\\x${code.toString(16).padStart(2, "0")}`;
+    }
+    return character;
+  }).join("");
+}
+
+// src/btw.ts
+var MAX_CONTEXT_CHARS = 4e4;
+function createModelRegistryCompleteSimple(modelRegistry) {
+  return async (model, context, options) => {
+    const provider = modelRegistry.getProvider(model.provider);
+    if (!provider) throw new Error(`No provider registered for model provider: ${model.provider}`);
+    return provider.streamSimple(model, context, options).result();
+  };
+}
+async function resolveBtwModel({
+  settings,
+  currentModel,
+  modelRegistry,
+  warn
+}) {
+  const reportWarning = (message) => warn?.(sanitizeSingleLine(message));
+  if (settings.model) {
+    const fallback = currentModel ? `${currentModel.provider}/${currentModel.id}` : "the current model";
+    const reference = parseBtwModelReference(settings.model);
+    if (!reference) {
+      reportWarning(`pi-btw model ${settings.model} is invalid; falling back to ${fallback}.`);
+      return resolveBtwModel({ settings: {}, currentModel, modelRegistry, warn: reportWarning });
+    }
+    const configuredModel = modelRegistry.find(reference.provider, reference.modelId);
+    if (!configuredModel) {
+      reportWarning(`pi-btw model ${settings.model} was not found; falling back to ${fallback}.`);
+    } else {
+      const sameAsCurrent = configuredModel === currentModel || configuredModel.provider === currentModel?.provider && configuredModel.id === currentModel.id;
+      const fallbackAction = sameAsCurrent ? "no distinct current model is available" : `falling back to ${fallback}`;
+      try {
+        const auth = await modelRegistry.getApiKeyAndHeaders(configuredModel);
+        if (auth.ok && hasRequestAuth(auth)) return { model: configuredModel, auth };
+        const reason = auth.ok ? "has no request credentials" : auth.error;
+        reportWarning(
+          `pi-btw model ${settings.model} is unavailable (${reason}); ${fallbackAction}.`
+        );
+      } catch (error) {
+        reportWarning(
+          `pi-btw model ${settings.model} credentials failed (${formatError5(error)}); ${fallbackAction}.`
+        );
+      }
+      if (sameAsCurrent) return void 0;
+    }
+  }
+  if (!currentModel) return void 0;
+  try {
+    const auth = await modelRegistry.getApiKeyAndHeaders(currentModel);
+    if (auth.ok && hasRequestAuth(auth)) return { model: currentModel, auth };
+  } catch {
+  }
+  return void 0;
+}
+function hasRequestAuth(auth) {
+  return Boolean(
+    auth.apiKey || providerHeadersHaveValue(auth.headers) || auth.env && Object.keys(auth.env).length > 0
+  );
+}
+function providerHeadersHaveValue(headers) {
+  return headers !== void 0 && Object.values(headers).some((value) => value !== null);
+}
+function formatError5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function notifySafely3(ctx, message, level) {
+  try {
+    ctx.ui.notify(sanitizeSingleLine(message), level);
+  } catch {
+  }
+}
+function btw(pi, dependencies = {}) {
+  const showCommandMenu = dependencies.showCommandMenu ?? showCommandMenuForBtw;
+  const pickEntry = dependencies.pickMainEntry ?? pickMainEntry;
+  const loadSettings = dependencies.loadSettings ?? loadSettingsForCommand;
+  const resolveModel = dependencies.resolveModel ?? resolveBtwModelWithLoader;
+  const runThread = dependencies.runThread ?? runBtwThread;
+  const runFullscreen = dependencies.runFullscreen ?? runBtwFullscreen;
+  const resumableThreads = /* @__PURE__ */ new Map();
+  let nextThreadNumber = 1;
+  const listResumeThreads = () => [...resumableThreads.values()].reverse().filter((state) => state.thread.turns.length > 0 && state.title).sort(
+    (first, second) => second.updatedAt - first.updatedAt || second.createdAt - first.createdAt
+  ).map((state) => ({
+    id: state.id,
+    title: state.title ?? "Untitled side thread",
+    questionCount: state.thread.turns.length
+  }));
+  pi.registerCommand("btw", {
+    description: "Ask a quick side question without adding it to the main conversation",
+    handler: async (args, ctx) => {
+      const question = args.trim();
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/btw requires interactive TUI mode", "error");
+        return;
+      }
+      let menuResult = "start";
+      let selectedConversationContext;
+      if (!question) {
+        while (true) {
+          menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
+          if (menuResult === "closed") return;
+          if (menuResult !== "tree") break;
+          const treeResult = await pickEntry(pi, ctx);
+          if (treeResult.kind === "closed") return;
+          if (treeResult.kind === "back") continue;
+          try {
+            if (!ctx.sessionManager.getEntry(treeResult.entryId)) {
+              notifySafely3(ctx, "The selected main-thread entry is no longer available", "warning");
+              continue;
+            }
+            const branch = ctx.sessionManager.getBranch(treeResult.entryId);
+            if (branch.at(-1)?.id !== treeResult.entryId) {
+              notifySafely3(
+                ctx,
+                "The selected main-thread branch is no longer available",
+                "warning"
+              );
+              continue;
+            }
+            selectedConversationContext = buildConversationContext(branch);
+            menuResult = "start";
+            break;
+          } catch {
+            return;
+          }
+        }
+      }
+      const settings = await loadSettings(ctx);
+      const sameAsMainThinkingLevel = settings.thinkingLevel === void 0;
+      const resolution = await resolveModel(settings, ctx);
+      if (resolution.kind === "cancelled") {
+        notifySafely3(ctx, "Cancelled", "info");
+        return;
+      }
+      if (resolution.kind === "unavailable") {
+        notifySafely3(ctx, "No available model for /btw", "error");
+        return;
+      }
+      let state = typeof menuResult === "object" ? resumableThreads.get(menuResult.threadId) : void 0;
+      if (typeof menuResult === "object" && !state) {
+        notifySafely3(ctx, "The selected /btw side thread is no longer available", "warning");
+        return;
+      }
+      const startingTurnCount = state?.thread.turns.length ?? 0;
+      try {
+        await runFullscreen(ctx, (fullscreenCtx) => {
+          if (!state) {
+            const createdAt = Date.now();
+            state = {
+              id: `btw-${nextThreadNumber}`,
+              thread: createSideThread(
+                selectedConversationContext ?? buildConversationContext(fullscreenCtx.sessionManager.getBranch())
+              ),
+              thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
+              createdAt,
+              updatedAt: createdAt
+            };
+            nextThreadNumber += 1;
+          }
+          return runThread({
+            initialQuestion: question || void 0,
+            selected: resolution.selected,
+            thinkingLevel: state.thinkingLevel,
+            rememberThinkingLevelChanges: !sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
+            state,
+            ctx: fullscreenCtx
+          });
+        });
+      } finally {
+        if (state?.title && state.thread.turns.length > 0) {
+          if (state.thread.turns.length > startingTurnCount) {
+            resumableThreads.delete(state.id);
+          }
+          resumableThreads.set(state.id, state);
+        }
+      }
+    }
+  });
+}
+async function showCommandMenuForBtw(pi, ctx, resumeThreads) {
+  const currentModel = ctx.model;
+  const availableModels = ctx.modelRegistry.getAll();
+  const currentThinkingLevel = pi.getThinkingLevel();
+  const loaded = await readBtwSettings();
+  const settings = loaded.kind === "loaded" ? loaded.settings : {};
+  const configured = settings.model ? parseBtwModelReference(settings.model) : void 0;
+  const configuredModel = configured ? availableModels.find(
+    (model2) => model2.provider === configured.provider && model2.id === configured.modelId
+  ) : void 0;
+  const model = configuredModel ?? currentModel;
+  return showBtwCommandMenu(ctx, {
+    currentThinkingLevel,
+    availableThinkingLevels: model ? getSupportedThinkingLevels(model) : BTW_THINKING_LEVELS,
+    resumeThreads
+  });
+}
+async function loadSettingsForCommand(ctx) {
+  const settingsResult = await readBtwSettings();
+  if (settingsResult.kind === "loaded") return settingsResult.settings;
+  if (settingsResult.kind === "invalid") {
+    notifySafely3(ctx, `pi-btw settings ignored: ${settingsResult.reason}`, "warning");
+  }
+  return {};
+}
+async function resolveBtwModelWithLoader(settings, ctx) {
+  return ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const loader = new BorderedLoader(tui, theme, "Resolving /btw model credentials...");
+    let settled = false;
+    loader.onAbort = () => {
+      if (settled) return;
+      settled = true;
+      done({ kind: "cancelled" });
+    };
+    resolveBtwModel({
+      settings,
+      currentModel: ctx.model,
+      modelRegistry: ctx.modelRegistry,
+      warn: (message) => {
+        if (!settled) notifySafely3(ctx, message, "warning");
+      }
+    }).then((selected) => {
+      if (settled) return;
+      settled = true;
+      done(selected ? { kind: "selected", selected } : { kind: "unavailable" });
+    }).catch(() => {
+      if (settled) return;
+      settled = true;
+      done({ kind: "unavailable" });
+    });
+    return loader;
+  });
+}
+async function runBtwThread({
+  initialQuestion,
+  selected,
+  thinkingLevel,
+  rememberThinkingLevelChanges = false,
+  settingsPath,
+  state,
+  ctx,
+  dependencies = {}
+}) {
+  const ask = dependencies.ask ?? askThreadQuestion;
+  const interact = dependencies.interact ?? showThreadComposer;
+  const chooseBringToMainAction = dependencies.chooseBringToMain ?? chooseBringToMain;
+  const deliverBringToMainDraft = dependencies.deliverBringToMain ?? loadBringToMainDraft;
+  const persistThinkingLevel = dependencies.persistThinkingLevel ?? ((level) => updateBtwSettings({ thinkingLevel: level }, { settingsPath }));
+  const now = dependencies.now ?? Date.now;
+  const thread = state?.thread ?? createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
+  const thinkingLevels = getSupportedThinkingLevels(selected.model);
+  const pendingWrites = /* @__PURE__ */ new Set();
+  const steeringQuestions = [];
+  let activeThinkingLevel = clampThinkingLevel(
+    selected.model,
+    state?.thinkingLevel ?? thinkingLevel
+  );
+  if (state) state.thinkingLevel = activeThinkingLevel;
+  let pendingQuestion = initialQuestion;
+  let composerDraft;
+  const createThinkingControl = () => ({
+    level: activeThinkingLevel,
+    levels: thinkingLevels,
+    onChange: (level) => {
+      if (!thinkingLevels.includes(level)) return;
+      activeThinkingLevel = level;
+      if (state) state.thinkingLevel = level;
+      if (!rememberThinkingLevelChanges) return;
+      let write;
+      write = Promise.resolve().then(() => persistThinkingLevel(level)).then(() => void 0).catch((error) => {
+        notifySafely3(
+          ctx,
+          `Thinking level changed to ${level}, but could not be remembered in pi-btw.json: ${formatError5(error)}`,
+          "warning"
+        );
+      }).finally(() => pendingWrites.delete(write));
+      pendingWrites.add(write);
+    }
+  });
+  try {
+    while (true) {
+      if (!pendingQuestion) {
+        const action = await interact(
+          thread,
+          thread.turns.length > 0,
+          ctx,
+          composerDraft,
+          createThinkingControl()
+        );
+        if (action.kind === "close") return { kind: "closed" };
+        if (action.kind === "bringToMain") {
+          const choice = await chooseBringToMainAction(thread, ctx);
+          if (choice.kind === "closed") return choice;
+          if (choice.kind === "back") {
+            composerDraft = action.questionDraft;
+            continue;
+          }
+          const delivery = await deliverBringToMainDraft(choice.draft, ctx, choice.summary);
+          if (delivery === "loaded" || delivery === "closed") return { kind: "closed" };
+          composerDraft = action.questionDraft;
+          continue;
+        }
+        composerDraft = void 0;
+        pendingQuestion = action.question;
+      }
+      const result = await ask(thread, pendingQuestion, selected, activeThinkingLevel, ctx, {
+        questions: steeringQuestions,
+        submit: (question) => steeringQuestions.push(question),
+        thinking: createThinkingControl()
+      });
+      if (result.kind === "aborted") {
+        notifySafely3(ctx, "Cancelled", "info");
+        return { kind: "closed" };
+      }
+      if (result.kind === "error") {
+        thread.turns.push({
+          kind: "error",
+          question: pendingQuestion,
+          answer: result.message
+        });
+      }
+      if (state) {
+        state.title ||= sanitizeSingleLine(pendingQuestion) || "Untitled side thread";
+        state.updatedAt = now();
+      }
+      pendingQuestion = steeringQuestions.shift();
+    }
+  } finally {
+    await Promise.allSettled([...pendingWrites]);
+  }
+}
+async function chooseBringToMain(thread, ctx, dependencies = {}) {
+  const answered = getAnsweredTurns(thread.turns);
+  if (answered.length === 0) return { kind: "back" };
+  const showMenu = dependencies.showMenu ?? showBtwMenu;
+  const showPreview = dependencies.showPreview ?? showBringToMainPreview;
+  const makeChoice = (segments) => ({
+    kind: "bringToMain",
+    draft: formatBtwBringToMain(segments),
+    summary: summarizeBringToMain(segments)
+  });
+  const latestSegments = buildQuickBringToMainSegments(thread.turns, { kind: "latest" });
+  const entireSegments = buildQuickBringToMainSegments(thread.turns, { kind: "entire" });
+  const latestOption = `Latest question and answer  1 Q&A \xB7 ~${estimateBringToMainTokens(latestSegments)} tokens`;
+  const fromOption = "From a question onward\u2026  Choose a starting question";
+  const exactOption = "Select exact text\u2026  Lines or characters";
+  const entireOption = `Entire side thread  ${answered.length} Q&A \xB7 ~${estimateBringToMainTokens(entireSegments)} tokens`;
+  const cancelOption = "Cancel  Return to the side thread";
+  let selectedScope;
+  while (true) {
+    const scopeResult = await showMenu(
+      ctx,
+      "Bring what back to the main thread?",
+      [latestOption, fromOption, exactOption, entireOption, cancelOption],
+      selectedScope
+    );
+    if (scopeResult.kind === "close") return { kind: "closed" };
+    if (scopeResult.kind === "back" || scopeResult.value === cancelOption) return { kind: "back" };
+    const scope = scopeResult.value;
+    selectedScope = scope;
+    if (scope === latestOption) return makeChoice(latestSegments);
+    if (scope === entireOption) {
+      const choice = makeChoice(entireSegments);
+      const preview = await showPreview(ctx, choice.draft, choice.summary);
+      if (preview.kind === "close") return { kind: "closed" };
+      if (preview.kind === "back") continue;
+      return choice;
+    }
+    if (scope === fromOption) {
+      const questions = answered.map(
+        (turn, index) => `${index + 1}. ${truncatePreview(sanitizeSingleLine(turn.question))}`
+      );
+      let selectedQuestion;
+      while (true) {
+        const questionResult = await showMenu(
+          ctx,
+          "Start from which question?",
+          questions,
+          selectedQuestion
+        );
+        if (questionResult.kind === "close") return { kind: "closed" };
+        if (questionResult.kind === "back") break;
+        const answeredTurnIndex = questions.indexOf(questionResult.value);
+        if (answeredTurnIndex < 0) continue;
+        selectedQuestion = questionResult.value;
+        const choice = makeChoice(
+          buildQuickBringToMainSegments(thread.turns, { kind: "from", answeredTurnIndex })
+        );
+        const preview = await showPreview(ctx, choice.draft, choice.summary);
+        if (preview.kind === "close") return { kind: "closed" };
+        if (preview.kind === "back") continue;
+        return choice;
+      }
+      continue;
+    }
+    if (scope !== exactOption) continue;
+    let selectionState;
+    while (true) {
+      const selectedRange = await showBtwCustomPreservingEditor(
+        ctx,
+        (tui, theme, keybindings, done) => {
+          let selector;
+          selector = new BtwTextRangeSelector(
+            tui,
+            theme,
+            keybindings,
+            thread.turns,
+            (action) => {
+              if (action.kind === "back") done({ kind: "back" });
+              else if (action.kind === "close") done({ kind: "closed" });
+              else done({ ...makeChoice(action.segments), selectionState: selector.getState() });
+            },
+            selectionState
+          );
+          return selector;
+        }
+      );
+      if (!selectedRange) return { kind: "closed" };
+      if (selectedRange.kind === "closed") return selectedRange;
+      if (selectedRange.kind === "back") break;
+      const preview = await showPreview(ctx, selectedRange.draft, selectedRange.summary);
+      if (preview.kind === "close") return { kind: "closed" };
+      if (preview.kind === "back") {
+        selectionState = selectedRange.selectionState;
+        continue;
+      }
+      return {
+        kind: "bringToMain",
+        draft: selectedRange.draft,
+        summary: selectedRange.summary
+      };
+    }
+  }
+}
+async function showBringToMainPreview(ctx, draft, summary) {
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (ctx.signal?.aborted) return { kind: "close" };
+  let confirmed = false;
+  const count = summary.messages === 1 ? "1 message" : `${summary.messages} messages`;
+  const lineCount = summary.lines === 1 ? "1 line" : `${summary.lines} lines`;
+  const menu = defineMenu({
+    start: "preview",
+    screens: {
+      preview: () => ({
+        kind: "review",
+        title: `Preview \xB7 ${count} \xB7 ${lineCount} \xB7 ~${summary.tokens} tokens`,
+        content: draft,
+        viewportSize: "adaptive",
+        hint: "back",
+        confirm: { id: "bring", label: "Bring", action: "bring" }
+      })
+    },
+    actions: {
+      bring: async () => {
+        confirmed = true;
+        return { kind: "close" };
+      }
+    }
+  });
+  const result = await runBtwMenuPreservingEditor(
+    ctx,
+    (menuContext) => runMenu(menuContext, menu, { getState: () => void 0 })
+  );
+  if (confirmed && result.kind === "closed" && result.reason === "close") {
+    return { kind: "bring" };
+  }
+  return terminalBtwMenuAction(result);
+}
+async function showBtwMenu(ctx, title, options, initialValue) {
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (ctx.signal?.aborted) return { kind: "close" };
+  const items = options.map((label, index) => ({ id: `option-${index}`, label }));
+  const initialIndex = initialValue === void 0 ? -1 : options.indexOf(initialValue);
+  let selectedValue;
+  const menu = defineMenu({
+    start: "choices",
+    screens: {
+      choices: () => ({
+        kind: "choice",
+        title,
+        items,
+        action: "select",
+        initialItemId: initialIndex >= 0 ? `option-${initialIndex}` : void 0,
+        hint: "back"
+      })
+    },
+    actions: {
+      select: async ({ itemId }) => {
+        const index = Number.parseInt(itemId.slice("option-".length), 10);
+        selectedValue = options[index];
+        return selectedValue === void 0 ? { kind: "stay" } : { kind: "close" };
+      }
+    }
+  });
+  const result = await runBtwMenuPreservingEditor(
+    ctx,
+    (menuContext) => runMenu(menuContext, menu, { getState: () => void 0 })
+  );
+  return selectedValue !== void 0 && result.kind === "closed" && result.reason === "close" ? { kind: "select", value: selectedValue } : terminalBtwMenuAction(result);
+}
+function terminalBtwMenuAction(result) {
+  if (result.kind === "closed") return { kind: result.reason };
+  if (result.kind === "error") throw result.error;
+  return { kind: "close" };
+}
+async function loadBringToMainDraft(draft, ctx, summary) {
+  const describeContent = () => `${summary.messages} ${summary.messages === 1 ? "message" : "messages"} (~${summary.tokens} ${summary.tokens === 1 ? "token" : "tokens"})`;
+  const existing = ctx.ui.getEditorText();
+  if (!existing.trim()) {
+    ctx.ui.setEditorText(draft);
+    ctx.ui.notify(
+      `Brought ${describeContent()} to the main editor. Review and submit when ready.`,
+      "info"
+    );
+    return "loaded";
+  }
+  const appendOption = "Append after current draft  Recommended";
+  const replaceOption = "\u26A0 Replace current draft  Discards current editor text";
+  const cancelOption = "Cancel  Return to the side thread";
+  while (true) {
+    const action = await showBtwMenu(ctx, "The main editor already has a draft", [
+      appendOption,
+      replaceOption,
+      cancelOption
+    ]);
+    if (action.kind === "close") return "closed";
+    if (action.kind === "back" || action.value === cancelOption) return "back";
+    if (action.value === appendOption) {
+      ctx.ui.setEditorText(`${ctx.ui.getEditorText()}
+
+${draft}`);
+      ctx.ui.notify(
+        `Appended ${describeContent()} to the existing main-editor draft. Review and submit when ready.`,
+        "info"
+      );
+      return "loaded";
+    }
+    if (action.value !== replaceOption) continue;
+    const current = ctx.ui.getEditorText();
+    const characters = [...current].length;
+    const confirmed = await showBtwMenu(
+      ctx,
+      `Replace the current ${characters}-character editor draft?`,
+      ["Back  Keep current editor text", "\u26A0 Replace current draft  Cannot be undone"]
+    );
+    if (confirmed.kind === "close") return "closed";
+    if (confirmed.kind === "back" || confirmed.value === "Back  Keep current editor text") continue;
+    if (confirmed.value !== "\u26A0 Replace current draft  Cannot be undone") continue;
+    if (ctx.ui.getEditorText() !== current) {
+      ctx.ui.notify(
+        "The main editor changed during confirmation. Review the updated draft and choose again.",
+        "warning"
+      );
+      continue;
+    }
+    ctx.ui.setEditorText(draft);
+    ctx.ui.notify(
+      `Replaced the main-editor draft with ${describeContent()}. Review and submit when ready.`,
+      "info"
+    );
+    return "loaded";
+  }
+}
+function truncatePreview(text) {
+  return text.length <= 72 ? text : `${text.slice(0, 69)}\u2026`;
+}
+async function askThreadQuestion(thread, question, selected, thinkingLevel, ctx, steering) {
+  return ctx.ui.custom(
+    (tui, theme, keybindings, done) => {
+      let settled = false;
+      const view = new BtwAnsweringView(
+        tui,
+        theme,
+        thread.turns,
+        question,
+        () => {
+          if (settled) return;
+          settled = true;
+          done({ kind: "aborted" });
+        },
+        thinkingLevel,
+        {
+          steering: {
+            questions: steering.questions,
+            onSubmit: steering.submit,
+            thinking: { ...steering.thinking, keybindings }
+          }
+        }
+      );
+      completeSideThreadTurn({
+        thread,
+        question,
+        model: selected.model,
+        thinkingLevel,
+        auth: selected.auth,
+        signal: view.signal,
+        completeSimple: createModelRegistryCompleteSimple(ctx.modelRegistry)
+      }).then((result) => {
+        if (settled) return;
+        settled = true;
+        view.finish();
+        done(result);
+      });
+      return view;
+    }
+  );
+}
+async function showThreadComposer(thread, startAtBottom, ctx, initialQuestion, thinking) {
+  return ctx.ui.custom(
+    (tui, theme, keybindings, done) => new BtwTranscriptPager(tui, theme, thread.turns, done, {
+      startAtBottom,
+      initialQuestion,
+      thinking: { ...thinking, keybindings }
+    })
+  );
+}
+function buildConversationContext(entries) {
+  const sections = [];
+  for (const entry of entries) {
+    if (entry.type !== "message" || !entry.message?.role) continue;
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const contentLines = extractContentLines(entry.message.content);
+    if (contentLines.length === 0) continue;
+    const label = role === "user" ? "User" : "Assistant";
+    const status = entry.message.stopReason && entry.message.stopReason !== "stop" ? ` (${entry.message.stopReason})` : "";
+    sections.push(`${label}${status}: ${contentLines.join("\n")}`);
+  }
+  return truncateFromStart(sections.join("\n\n"), MAX_CONTEXT_CHARS);
+}
+function extractContentLines(content) {
+  if (typeof content === "string") return [content.trim()].filter(Boolean);
+  if (!Array.isArray(content)) return [];
+  const lines = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const block = part;
+    if (block.type === "text" && typeof block.text === "string") {
+      lines.push(block.text.trim());
+    } else if (block.type === "toolCall" && typeof block.name === "string") {
+      lines.push(`Tool call: ${block.name}(${formatJson(block.arguments)})`);
+    } else if (block.type === "toolResult" && typeof block.name === "string") {
+      lines.push(`Tool result from ${block.name}: ${formatJson(block.result)}`);
+    }
+  }
+  return lines.filter(Boolean);
+}
+function formatJson(value) {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncateFromStart(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `[Earlier context omitted; showing the last ${maxChars} characters.]
+${text.slice(-maxChars)}`;
+}
+export {
+  btw as default
+};
+//# sourceMappingURL=index.ts.map