@thedevlabs-io/labd 0.3.1 → 0.5.0

package/dist/labd.js

@@ -43,12 +43,12 @@ function scorePath(query, path) {
 var FILENAME_BONUS = 20;
 function scan(q, text) {
   let score = 0;
-  let at = 0;
+  let at2 = 0;
   let run = 0;
   for (const ch of q) {
-    const found = text.indexOf(ch, at);
+    const found = text.indexOf(ch, at2);
     if (found === -1) return null;
-    if (found === at && at > 0) {
+    if (found === at2 && at2 > 0) {
       run += 1;
       score += 4 + run * 2;
     } else {
@@ -57,7 +57,7 @@ function scan(q, text) {
     }
     const prev = found === 0 ? "/" : text[found - 1];
     if (prev === "/" || prev === "." || prev === "-" || prev === "_") score += 6;
-    at = found + 1;
+    at2 = found + 1;
   }
   return score;
 }
@@ -454,8 +454,8 @@ function danglingToolCallAt(messages) {
   return null;
 }
 function sendableMessages(messages) {
-  const at = danglingToolCallAt(messages);
-  return at === null ? messages : messages.slice(0, at);
+  const at2 = danglingToolCallAt(messages);
+  return at2 === null ? messages : messages.slice(0, at2);
 }
 function forExtraction(messages) {
   return messages.map((m) => {
@@ -678,6 +678,11 @@ function attachOne(root, path, budget) {
 import { appendFileSync, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync3, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename as basename2, join as join2 } from "node:path";
+function sessionTitle(summary, width = 60) {
+  const text = (summary.name ?? summary.preview ?? "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!text) return "(no questions yet)";
+  return text.length > width ? `${text.slice(0, width - 1)}\u2026` : text;
+}
 function bucketFor(stateDir2, root) {
   const bucket = join2(stateDir2, "sessions", createHash("sha256").update(root).digest("hex").slice(0, 16));
   mkdirSync(bucket, { recursive: true });
@@ -749,6 +754,7 @@ var Session = class _Session {
         id: session.id,
         file: join2(bucket, f),
         name: session.name,
+        preview: session.firstQuestion(),
         at: statSync3(join2(bucket, f)).mtimeMs,
         messages: session.nodes.size
       };
@@ -763,6 +769,14 @@ var Session = class _Session {
   size() {
     return this.nodes.size;
   }
+  /** The earliest question in the file, on any branch. */
+  firstQuestion() {
+    let first;
+    for (const node of this.nodes.values()) {
+      if (node.body.kind === "user" && (!first || node.at < first.at)) first = node;
+    }
+    return first?.body.kind === "user" ? first.body.text : void 0;
+  }
   rename(name) {
     this.name = name;
     this.append({ t: "meta", name });
@@ -802,15 +816,15 @@ var Session = class _Session {
   /** Root-to-head, which is the conversation as the model will see it. */
   path(from = this.head) {
     const out = [];
-    let at = from;
+    let at2 = from;
     const seen = /* @__PURE__ */ new Set();
-    while (at) {
-      if (seen.has(at)) break;
-      seen.add(at);
-      const node = this.nodes.get(at);
+    while (at2) {
+      if (seen.has(at2)) break;
+      seen.add(at2);
+      const node = this.nodes.get(at2);
       if (!node) break;
       out.push(node);
-      at = node.parentId;
+      at2 = node.parentId;
     }
     return out.reverse();
   }
@@ -2147,21 +2161,21 @@ function wrapCommand(command, width) {
   for (let i = 0; i < command.length; i += width) out.push(command.slice(i, i + width));
   return out;
 }
-function statusLine(info) {
+function statusLine(info2) {
   const bits = [];
-  if (info.contextPercent !== null && info.contextPercent !== void 0) {
-    const crowded = info.contextPercent >= 75;
-    bits.push((crowded ? paint.yellow : paint.muted)(`${info.contextPercent}% full`));
+  if (info2.contextPercent !== null && info2.contextPercent !== void 0) {
+    const crowded = info2.contextPercent >= 75;
+    bits.push((crowded ? paint.yellow : paint.muted)(`${info2.contextPercent}% full`));
   }
-  bits.push(paint.muted(info.project));
-  if (info.branch) bits.push(paint.muted(info.branch));
-  if (info.creditsPercent !== null && info.creditsPercent !== void 0) {
-    bits.push(paint.muted(`${info.creditsPercent}% left`));
+  bits.push(paint.muted(info2.project));
+  if (info2.branch) bits.push(paint.muted(info2.branch));
+  if (info2.creditsPercent !== null && info2.creditsPercent !== void 0) {
+    bits.push(paint.muted(`${info2.creditsPercent}% left`));
   }
-  if (info.effort) bits.push(paint.muted(`think ${info.effort}`));
-  const mode = info.mode === "agent" ? paint.red(paint.bold("agent")) : info.mode === "auto" ? paint.accent("auto") : paint.muted("ask");
+  if (info2.effort) bits.push(paint.muted(`think ${info2.effort}`));
+  const mode = info2.mode === "agent" ? paint.red(paint.bold("agent")) : info2.mode === "auto" ? paint.accent("auto") : paint.muted("ask");
   bits.push(mode);
-  const left = info.busy ? `${paint.accent(FACE)} ${paint.dim(info.busy)}` : paint.dim(FACE);
+  const left = info2.busy ? `${paint.accent(FACE)} ${paint.dim(info2.busy)}` : paint.dim(FACE);
   return `${left}  ${paint.dim("|")} ${bits.join(paint.dim(" | "))}`;
 }
 function spinnerFrame(tick) {
@@ -2198,10 +2212,10 @@ function body(opts, inner) {
 function withCursor(view, room, hidden) {
   const text = view.text.slice(0, room);
   if (hidden) return text;
-  const at = Math.min(view.column, room - 1 < 0 ? 0 : room);
-  const before = text.slice(0, at);
-  const under = text.slice(at, at + 1) || " ";
-  const after = text.slice(at + 1);
+  const at2 = Math.min(view.column, room - 1 < 0 ? 0 : room);
+  const before = text.slice(0, at2);
+  const under = text.slice(at2, at2 + 1) || " ";
+  const after = text.slice(at2 + 1);
   return `${before}${paint.invert(under)}${after}`;
 }
 function suggestionLines(all, inner) {
@@ -2250,27 +2264,27 @@ function boundaries(text) {
   for (const { index, segment } of segmenter.segment(text)) out.push(index + segment.length);
   return out;
 }
-function prevBoundary(text, at) {
+function prevBoundary(text, at2) {
   const marks = boundaries(text);
   let last = 0;
   for (const mark of marks) {
-    if (mark >= at) return last;
+    if (mark >= at2) return last;
     last = mark;
   }
   return last;
 }
-function nextBoundary(text, at) {
-  for (const mark of boundaries(text)) if (mark > at) return mark;
+function nextBoundary(text, at2) {
+  for (const mark of boundaries(text)) if (mark > at2) return mark;
   return text.length;
 }
-function wordStart(text, at) {
-  let i = at;
+function wordStart(text, at2) {
+  let i = at2;
   while (i > 0 && /\s/.test(text[i - 1])) i--;
   while (i > 0 && !/\s/.test(text[i - 1])) i--;
   return i;
 }
-function wordEnd(text, at) {
-  let i = at;
+function wordEnd(text, at2) {
+  let i = at2;
   while (i < text.length && /\s/.test(text[i])) i++;
   while (i < text.length && !/\s/.test(text[i])) i++;
   return i;
@@ -2330,6 +2344,7 @@ var LineEditor = class {
     if (!ctrl && !meta && key.sequence && PRINTABLE.test(key.sequence)) {
       return this.insert(key.sequence);
     }
+    if (key.paste !== void 0) return this.insert(key.paste);
     return "unhandled";
   }
   moveTo(next) {
@@ -2398,51 +2413,696 @@ var History = class {
   }
 };
 
-// packages/tui/src/face.ts
-var FACE_ART = [
-  "  \u250F\u2501                      \u2501\u2513  ",
-  "  \u2503    \u2584\u2584\u2584\u2584\u2584      \u2584\u2584\u2584\u2584\u2584    \u2503  ",
-  "  \u2503    \u2588\u2588\u2588\u2588\u2588      \u2588\u2588\u2588\u2588\u2588    \u2503  ",
-  "  \u2503    \u2580\u2580\u2580\u2580\u2580      \u2580\u2580\u2580\u2580\u2580    \u2503  ",
-  "  \u2503                        \u2503  ",
-  "  \u2503       \u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584       \u2503  ",
-  "  \u2517\u2501                      \u2501\u251B  "
-];
-var NOISE = "$#@%&*+=-:.<>/\\|_01x?";
-var FACE_FRAME_MS = 34;
-function noiseChar() {
-  return NOISE[Math.floor(Math.random() * NOISE.length)];
+// packages/tui/src/editor.ts
+function sanitizeMultiline(text) {
+  return text.replace(/\r\n?/g, "\n").replace(/\t/g, "  ").replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+var TextEditor = class {
+  lines = [""];
+  row = 0;
+  col = 0;
+  /** First line shown in the last `view`, kept so the window scrolls rather than jumps. */
+  top = 0;
+  get text() {
+    return this.lines.join("\n");
+  }
+  get cursor() {
+    return { row: this.row, col: this.col };
+  }
+  get lineCount() {
+    return this.lines.length;
+  }
+  get isEmpty() {
+    return this.lines.length === 1 && this.lines[0] === "";
+  }
+  /** The line the caret is on. Used to work out whether a `/` or `@` is being typed. */
+  get currentLine() {
+    return this.lines[this.row];
+  }
+  /** Replace everything - from history, or a completion. The caret lands at the end. */
+  setText(text) {
+    this.lines = sanitizeMultiline(text).split("\n");
+    this.row = this.lines.length - 1;
+    this.col = this.lines[this.row].length;
+  }
+  /** Replace just the caret's line, keeping the rest. For a completion of `/cmd` or `@path`. */
+  setCurrentLine(text) {
+    this.lines[this.row] = sanitizeMultiline(text).replace(/\n/g, " ");
+    this.col = this.lines[this.row].length;
+  }
+  reset() {
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.top = 0;
+  }
+  /** Insert at the caret. Newlines in `text` become new lines. */
+  insert(text) {
+    const clean = sanitizeMultiline(text);
+    if (!clean) return "same";
+    const parts = clean.split("\n");
+    const line = this.lines[this.row];
+    const before = line.slice(0, this.col);
+    const after = line.slice(this.col);
+    if (parts.length === 1) {
+      this.lines[this.row] = before + parts[0] + after;
+      this.col += parts[0].length;
+      return "text";
+    }
+    const inserted = [before + parts[0], ...parts.slice(1, -1), parts[parts.length - 1] + after];
+    this.lines.splice(this.row, 1, ...inserted);
+    this.row += parts.length - 1;
+    this.col = parts[parts.length - 1].length;
+    return "text";
+  }
+  newline() {
+    return this.insert("\n");
+  }
+  /**
+   * Apply one key. `unhandled` for a plain Enter (the caller sends), for Up on
+   * the first line and Down on the last (the caller walks history), and for
+   * anything else the editor does not claim.
+   */
+  apply(key) {
+    const { name, ctrl, meta, shift } = key;
+    const line = this.lines[this.row];
+    if (key.paste !== void 0) return this.insert(key.paste);
+    if (name === "return") {
+      if (shift || ctrl || meta) return this.newline();
+      if (/(^|[^\\])\\$/.test(line)) {
+        this.lines[this.row] = line.slice(0, -1);
+        this.col = Math.min(this.col, this.lines[this.row].length);
+        return this.newline();
+      }
+      return "unhandled";
+    }
+    if (ctrl && name === "j") return this.newline();
+    if (name === "up" && !ctrl && !meta) {
+      if (this.row === 0) return "unhandled";
+      this.row--;
+      this.col = Math.min(this.col, this.lines[this.row].length);
+      return "cursor";
+    }
+    if (name === "down" && !ctrl && !meta) {
+      if (this.row === this.lines.length - 1) return "unhandled";
+      this.row++;
+      this.col = Math.min(this.col, this.lines[this.row].length);
+      return "cursor";
+    }
+    if (name === "left" && !ctrl && !meta) {
+      if (this.col === 0) {
+        if (this.row === 0) return "same";
+        this.row--;
+        this.col = this.lines[this.row].length;
+        return "cursor";
+      }
+      return this.moveTo(prevBoundary(line, this.col));
+    }
+    if (name === "right" && !ctrl && !meta) {
+      if (this.col >= line.length) {
+        if (this.row === this.lines.length - 1) return "same";
+        this.row++;
+        this.col = 0;
+        return "cursor";
+      }
+      return this.moveTo(nextBoundary(line, this.col));
+    }
+    if (name === "home" || ctrl && name === "a") return this.moveTo(0);
+    if (name === "end" || ctrl && name === "e") return this.moveTo(line.length);
+    if ((meta || ctrl) && (name === "left" || name === "b")) return this.moveTo(wordStart(line, this.col));
+    if ((meta || ctrl) && (name === "right" || name === "f")) return this.moveTo(wordEnd(line, this.col));
+    if (name === "backspace" && (meta || ctrl)) {
+      if (this.col === 0) return this.joinUp();
+      return this.cut(wordStart(line, this.col), this.col);
+    }
+    if (ctrl && name === "w") {
+      if (this.col === 0) return this.joinUp();
+      return this.cut(wordStart(line, this.col), this.col);
+    }
+    if (name === "backspace") {
+      if (this.col === 0) return this.joinUp();
+      return this.cut(prevBoundary(line, this.col), this.col);
+    }
+    if (name === "delete") {
+      if (this.col >= line.length) return this.joinDown();
+      return this.cut(this.col, nextBoundary(line, this.col));
+    }
+    if (ctrl && name === "u") return this.cut(0, this.col);
+    if (ctrl && name === "k") {
+      if (this.col >= line.length) return this.joinDown();
+      return this.cut(this.col, line.length);
+    }
+    if (!ctrl && !meta && key.sequence && PRINTABLE.test(key.sequence)) return this.insert(key.sequence);
+    return "unhandled";
+  }
+  /**
+   * The lines to draw and where the caret is among them.
+   *
+   * At most `maxLines` rows, chosen so the caret's row is always one of them;
+   * each row scrolls horizontally on its own so a long line never wraps into the
+   * row below and the caret never leaves the box.
+   */
+  view(width, maxLines) {
+    const rows = Math.max(1, maxLines);
+    if (this.row < this.top) this.top = this.row;
+    if (this.row >= this.top + rows) this.top = this.row - rows + 1;
+    this.top = Math.max(0, Math.min(this.top, this.lines.length - rows));
+    const shown = this.lines.slice(this.top, this.top + rows);
+    let cursorCol = this.col;
+    const lines = shown.map((line, i) => {
+      if (width <= 0) return "";
+      if (line.length <= width) return line;
+      if (this.top + i !== this.row) return line.slice(0, width);
+      const start = Math.max(0, this.col - width + 1);
+      cursorCol = this.col - start;
+      return line.slice(start, start + width);
+    });
+    return { lines, cursor: { row: this.row - this.top, col: cursorCol } };
+  }
+  moveTo(next) {
+    if (next === this.col) return "same";
+    this.col = next;
+    return "cursor";
+  }
+  cut(from, to) {
+    if (from >= to) return "same";
+    const line = this.lines[this.row];
+    this.lines[this.row] = line.slice(0, from) + line.slice(to);
+    this.col = from;
+    return "text";
+  }
+  joinUp() {
+    if (this.row === 0) return "same";
+    const above = this.lines[this.row - 1];
+    this.lines.splice(this.row - 1, 2, above + this.lines[this.row]);
+    this.row--;
+    this.col = above.length;
+    return "text";
+  }
+  joinDown() {
+    if (this.row >= this.lines.length - 1) return "same";
+    this.lines.splice(this.row, 2, this.lines[this.row] + this.lines[this.row + 1]);
+    return "text";
+  }
+};
+
+// packages/tui/src/keys.ts
+var ESC3 = "\x1B";
+var PASTE_START = `${ESC3}[200~`;
+var PASTE_END = `${ESC3}[201~`;
+var CSI_FINAL = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  H: "home",
+  F: "end",
+  Z: "tab"
+};
+var TILDE = {
+  "1": "home",
+  "2": "insert",
+  "3": "delete",
+  "4": "end",
+  "5": "pageup",
+  "6": "pagedown",
+  "7": "home",
+  "8": "end"
+};
+function modifiers(param) {
+  const n = (Number(param) || 1) - 1;
+  return {
+    ...n & 1 ? { shift: true } : {},
+    ...n & 2 ? { meta: true } : {},
+    ...n & 4 ? { ctrl: true } : {}
+  };
 }
-function faceLines() {
-  return FACE_ART.map((row) => paint.accent(row));
+function coded(code, mods, sequence) {
+  switch (code) {
+    case 13:
+      return { name: "return", ...mods, sequence };
+    case 9:
+      return { name: "tab", ...mods, sequence };
+    case 27:
+      return { name: "escape", ...mods, sequence };
+    case 127:
+    case 8:
+      return { name: "backspace", ...mods, sequence };
+    default:
+      if (code >= 32) {
+        const ch = String.fromCodePoint(code);
+        return { name: ch.toLowerCase(), ...mods, sequence: mods.ctrl || mods.meta ? sequence : ch };
+      }
+      return null;
+  }
 }
-function decodeFrames() {
-  const cells = FACE_ART.map((row) => [...row]);
-  const lockAt = cells.map(
-    (row, y) => row.map((_, x) => Math.round(x * 0.55 + y * 0.9 + Math.random() * 7))
-  );
-  const last = Math.max(...lockAt.flat());
-  const frames = [];
-  for (let f = 1; f <= last + 1; f++) {
-    frames.push(
-      cells.map(
-        (row, y) => paint.accent(
-          row.map((char, x) => {
-            if (char === " ") return " ";
-            return f >= lockAt[y][x] ? char : noiseChar();
-          }).join("")
-        )
-      )
-    );
+function isPrefix(text, whole) {
+  return text.length <= whole.length && whole.startsWith(text);
+}
+function partialMarker(buf, marker) {
+  for (let n = Math.min(marker.length - 1, buf.length); n > 0; n--) {
+    if (isPrefix(buf.slice(buf.length - n), marker)) return n;
   }
-  frames.push(faceLines());
-  return frames;
+  return 0;
+}
+var KeyDecoder = class {
+  /** Bytes that could still turn out to be the start of something. */
+  pending = "";
+  /** Inside a bracketed paste: the text so far. Null outside one. */
+  pasting = null;
+  /**
+   * Decode a chunk. Sequences split across two reads are held until the next
+   * one; a lone ESC at the END of a chunk is reported as Escape at once, because
+   * a terminal sends a whole sequence in one write and a person pressing the key
+   * should not have to press another to be heard.
+   */
+  feed(chunk) {
+    const out = [];
+    let buf = this.pending + chunk;
+    this.pending = "";
+    let i = 0;
+    while (i < buf.length) {
+      if (this.pasting !== null) {
+        const end = buf.indexOf(PASTE_END, i);
+        if (end === -1) {
+          const hold = partialMarker(buf, PASTE_END);
+          this.pasting += buf.slice(i, buf.length - hold);
+          this.pending = buf.slice(buf.length - hold);
+          return out;
+        }
+        this.pasting += buf.slice(i, end);
+        out.push({ name: "paste", paste: this.pasting.replace(/\r\n?/g, "\n") });
+        this.pasting = null;
+        i = end + PASTE_END.length;
+        continue;
+      }
+      const ch = buf[i];
+      if (ch !== ESC3) {
+        const code2 = ch.charCodeAt(0);
+        if (code2 === 13) out.push({ name: "return", sequence: ch });
+        else if (code2 === 10) out.push({ name: "j", ctrl: true, sequence: ch });
+        else if (code2 === 9) out.push({ name: "tab", sequence: ch });
+        else if (code2 === 127 || code2 === 8) out.push({ name: "backspace", sequence: ch });
+        else if (code2 < 32) {
+          if (code2 > 0) out.push({ name: String.fromCharCode(96 + code2), ctrl: true, sequence: ch });
+        } else {
+          let j = i + 1;
+          while (j < buf.length) {
+            const c = buf.charCodeAt(j);
+            if (c < 32 || c === 127 || buf[j] === ESC3) break;
+            j++;
+          }
+          out.push({ sequence: buf.slice(i, j) });
+          i = j;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (i === buf.length - 1) {
+        out.push({ name: "escape", sequence: ESC3 });
+        i++;
+        continue;
+      }
+      const next = buf[i + 1];
+      if (next === "[") {
+        let j = i + 2;
+        while (j < buf.length && !(buf.charCodeAt(j) >= 64 && buf.charCodeAt(j) <= 126)) j++;
+        if (j >= buf.length) {
+          this.pending = buf.slice(i);
+          return out;
+        }
+        const seq = buf.slice(i, j + 1);
+        const body2 = buf.slice(i + 2, j);
+        const final = buf[j];
+        i = j + 1;
+        if (seq === PASTE_START) {
+          this.pasting = "";
+          continue;
+        }
+        const key = decodeCsi(body2, final, seq);
+        if (key) out.push(key);
+        continue;
+      }
+      if (next === "O") {
+        const final = buf[i + 2];
+        if (final === void 0) {
+          this.pending = buf.slice(i);
+          return out;
+        }
+        const name = CSI_FINAL[final];
+        if (name) out.push({ name, sequence: buf.slice(i, i + 3) });
+        i += 3;
+        continue;
+      }
+      if (next === "\x7F" || next === "\b") {
+        out.push({ name: "backspace", meta: true, sequence: buf.slice(i, i + 2) });
+        i += 2;
+        continue;
+      }
+      if (next === ESC3) {
+        out.push({ name: "escape", sequence: ESC3 });
+        i++;
+        continue;
+      }
+      const code = next.charCodeAt(0);
+      if (code >= 32 && code !== 127) {
+        out.push({
+          name: next.toLowerCase(),
+          meta: true,
+          ...next !== next.toLowerCase() ? { shift: true } : {},
+          sequence: buf.slice(i, i + 2)
+        });
+        i += 2;
+        continue;
+      }
+      out.push({ name: "escape", sequence: ESC3 });
+      i++;
+    }
+    return out;
+  }
+  /** Anything still held back - the tail of a paste, an escape that never finished. */
+  flush() {
+    const out = [];
+    if (this.pasting !== null) {
+      out.push({ name: "paste", paste: this.pasting + this.pending });
+      this.pasting = null;
+    } else if (this.pending === ESC3) {
+      out.push({ name: "escape", sequence: ESC3 });
+    }
+    this.pending = "";
+    return out;
+  }
+};
+function decodeCsi(body2, final, sequence) {
+  if (body2.startsWith("<") && (final === "M" || final === "m")) {
+    const [b, x, y] = body2.slice(1).split(";").map(Number);
+    if (final === "m") return null;
+    if (b & 32) return null;
+    const button = b & 3;
+    if (b & 64) {
+      return { name: "mouse", sequence, mouse: { kind: button === 0 ? "wheel-up" : "wheel-down", button: b, x, y } };
+    }
+    return { name: "mouse", sequence, mouse: { kind: "click", button, x, y } };
+  }
+  const params = body2.split(";");
+  if (final === "~") {
+    if (params[0] === "27") return coded(Number(params[2]), modifiers(params[1]), sequence);
+    if (params[0] === "200" || params[0] === "201") return null;
+    const name2 = TILDE[params[0]];
+    return name2 ? { name: name2, ...modifiers(params[1]), sequence } : null;
+  }
+  if (final === "u") return coded(Number(params[0]), modifiers(params[1]), sequence);
+  const name = CSI_FINAL[final];
+  if (!name) return null;
+  const mods = final === "Z" ? { shift: true } : modifiers(params[1]);
+  return { name, ...mods, sequence };
+}
+
+// packages/tui/src/layout.ts
+var MAX_COMPOSER_ROWS = 8;
+var SIDEBAR_MIN_COLUMNS = 120;
+var SIDEBAR_WIDTH = 32;
+function layout(opts) {
+  const rows = Math.max(4, opts.rows);
+  const columns = Math.max(20, opts.columns);
+  const wanted = Math.min(MAX_COMPOSER_ROWS, Math.max(1, opts.editorLines) + 2);
+  const composerHeight = Math.max(3, Math.min(wanted, rows - 3));
+  const header = { top: 0, left: 0, width: columns, height: 1 };
+  const footer = { top: rows - 1, left: 0, width: columns, height: 1 };
+  const composer2 = { top: rows - 1 - composerHeight, left: 0, width: columns, height: composerHeight };
+  const transcriptHeight = Math.max(0, composer2.top - 1);
+  const withSidebar = Boolean(opts.sidebar) && columns >= SIDEBAR_MIN_COLUMNS;
+  const mainWidth = withSidebar ? columns - SIDEBAR_WIDTH - 1 : columns;
+  const out = {
+    header,
+    transcript: { top: 1, left: 0, width: mainWidth, height: transcriptHeight },
+    composer: { ...composer2, width: mainWidth },
+    footer
+  };
+  if (withSidebar) {
+    out.sidebar = { top: 1, left: mainWidth + 1, width: SIDEBAR_WIDTH, height: composer2.top + composerHeight - 1 };
+  }
+  return out;
+}
+
+// packages/tui/src/popup.ts
+var MAX_POPUP_ROWS = 8;
+var Popup = class {
+  constructor(kind, items) {
+    this.kind = kind;
+    this.items = items;
+  }
+  selected = 0;
+  get current() {
+    return this.items[this.selected] ?? null;
+  }
+  move(delta) {
+    if (!this.items.length) return;
+    this.selected = (this.selected + delta + this.items.length) % this.items.length;
+  }
+  /** Rows to draw, at most `MAX_POPUP_ROWS`, keeping the selection in view. */
+  render(width, max = MAX_POPUP_ROWS) {
+    if (!this.items.length) return [];
+    const rows = Math.max(1, max);
+    const start = Math.max(0, Math.min(this.selected - rows + 1, this.items.length - rows));
+    const shown = this.items.slice(start, start + rows);
+    const column = Math.min(Math.max(...shown.map((s) => s.label.length)), Math.max(10, Math.floor(width / 2)));
+    return shown.map((item, i) => {
+      const isSelected = start + i === this.selected;
+      const mark = isSelected ? paint.accent("\u25B8") : " ";
+      const label2 = item.label.padEnd(column);
+      const room = width - column - 6;
+      const what = item.what ? paint.muted(truncate(item.what, Math.max(0, room))) : "";
+      const line = `  ${mark} ${isSelected ? paint.bold(paint.accent(label2)) : paint.accent(label2)}  ${what}`;
+      return pad2(truncate(line, width), width);
+    });
+  }
+};
+function pad2(text, width) {
+  const short = width - visibleWidth(text);
+  return short > 0 ? `${text}${" ".repeat(short)}` : text;
+}
+
+// packages/tui/src/dialog.ts
+function pick(title, items, onSelect) {
+  return { kind: "pick", title, items, query: "", selected: 0, onSelect };
+}
+function info(title, lines) {
+  return { kind: "info", title, lines, scroll: 0 };
+}
+function filterItems(items, query) {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (!words.length) return items;
+  return items.filter((item) => {
+    const hay = `${item.label} ${item.hint ?? ""}`.toLowerCase();
+    return words.every((w) => hay.includes(w));
+  });
+}
+function dialogKey(dialog, key) {
+  if (key.name === "escape" || key.ctrl && (key.name === "c" || key.name === "g")) return "close";
+  if (dialog.kind === "info") {
+    if (key.name === "up" || key.name === "k") dialog.scroll = Math.max(0, dialog.scroll - 1);
+    else if (key.name === "down" || key.name === "j") dialog.scroll++;
+    else if (key.name === "pageup") dialog.scroll = Math.max(0, dialog.scroll - 10);
+    else if (key.name === "pagedown") dialog.scroll += 10;
+    else if (key.name === "home") dialog.scroll = 0;
+    else if (key.name === "return" || key.name === "q") return "close";
+    else if (key.mouse?.kind === "wheel-up") dialog.scroll = Math.max(0, dialog.scroll - 3);
+    else if (key.mouse?.kind === "wheel-down") dialog.scroll += 3;
+    else return "same";
+    return "changed";
+  }
+  const shown = filterItems(dialog.items, dialog.query);
+  if (key.name === "up" || key.mouse?.kind === "wheel-up") {
+    dialog.selected = shown.length ? (dialog.selected - 1 + shown.length) % shown.length : 0;
+    return "changed";
+  }
+  if (key.name === "down" || key.mouse?.kind === "wheel-down" || key.name === "tab") {
+    dialog.selected = shown.length ? (dialog.selected + 1) % shown.length : 0;
+    return "changed";
+  }
+  if (key.name === "return") {
+    const item = shown[dialog.selected];
+    if (!item) return "same";
+    dialog.onSelect(item);
+    return "select";
+  }
+  if (key.name === "backspace") {
+    if (!dialog.query) return "same";
+    dialog.query = dialog.query.slice(0, -1);
+    dialog.selected = 0;
+    return "changed";
+  }
+  if (!key.ctrl && !key.meta && key.sequence && /^[^\u0000-\u001f\u007f]+$/.test(key.sequence)) {
+    dialog.query += key.sequence;
+    dialog.selected = 0;
+    return "changed";
+  }
+  return "same";
+}
+var BOX = { tl: "\u256D", tr: "\u256E", bl: "\u2570", br: "\u256F", h: "\u2500", v: "\u2502" };
+function renderDialog(dialog, rows, columns) {
+  const width = Math.max(24, Math.min(columns - 4, 84));
+  const inner = width - 4;
+  const maxBody = Math.max(3, rows - 6);
+  const body2 = [];
+  if (dialog.kind === "pick") {
+    const shown = filterItems(dialog.items, dialog.query);
+    const listRows = Math.max(1, Math.min(shown.length, maxBody - 2));
+    const start = Math.max(0, Math.min(dialog.selected - listRows + 1, shown.length - listRows));
+    body2.push(`${paint.accent("search")} ${dialog.query}${paint.invert(" ")}`);
+    body2.push("");
+    if (!shown.length) body2.push(paint.muted("nothing matches"));
+    for (const [i, item] of shown.slice(start, start + listRows).entries()) {
+      const isSelected = start + i === dialog.selected;
+      const mark = isSelected ? paint.accent("\u25B8") : " ";
+      const label2 = isSelected ? paint.bold(item.label) : item.label;
+      body2.push(truncate(`${mark} ${label2}${item.hint ? `  ${paint.muted(item.hint)}` : ""}`, inner));
+    }
+    if (shown.length > listRows) body2.push(paint.dim(`\u2026 ${shown.length - listRows} more; type to narrow`));
+  } else {
+    const visible = Math.min(dialog.lines.length, maxBody);
+    dialog.scroll = Math.max(0, Math.min(dialog.scroll, dialog.lines.length - visible));
+    for (const line of dialog.lines.slice(dialog.scroll, dialog.scroll + visible)) body2.push(truncate(line, inner));
+    if (dialog.lines.length > visible) {
+      body2.push(paint.dim(`\u2026 ${dialog.scroll + visible} of ${dialog.lines.length} lines \xB7 \u2191\u2193 to scroll`));
+    }
+  }
+  const title = ` ${dialog.title} `;
+  const rule = BOX.h.repeat(Math.max(0, width - 2 - title.length - 1));
+  const lines = [
+    paint.dim(`${BOX.tl}${BOX.h}`) + paint.bold(title) + paint.dim(`${rule}${BOX.tr}`),
+    ...body2.map((line) => `${paint.dim(BOX.v)} ${pad3(truncate(line, inner), inner)} ${paint.dim(BOX.v)}`),
+    paint.dim(`${BOX.bl}${BOX.h.repeat(width - 2)}${BOX.br}`)
+  ];
+  const top = Math.max(0, Math.floor((rows - lines.length) / 2));
+  const left = Math.max(0, Math.floor((columns - width) / 2));
+  return { top, left, lines };
+}
+function pad3(text, width) {
+  const short = width - visibleWidth(text);
+  return short > 0 ? `${text}${" ".repeat(short)}` : text;
+}
+
+// packages/tui/src/screen.ts
+import { EventEmitter } from "node:events";
+var ESC4 = "\x1B";
+var ALT_SCREEN_ON = `${ESC4}[?1049h`;
+var ALT_SCREEN_OFF = `${ESC4}[?1049l`;
+var CURSOR_HIDE = `${ESC4}[?25l`;
+var CURSOR_SHOW = `${ESC4}[?25h`;
+var PASTE_ON = `${ESC4}[?2004h`;
+var PASTE_OFF = `${ESC4}[?2004l`;
+var MOUSE_ON = `${ESC4}[?1000h${ESC4}[?1006h`;
+var MOUSE_OFF = `${ESC4}[?1006l${ESC4}[?1000l`;
+var CLEAR = `${ESC4}[2J`;
+var RESET = `${ESC4}[0m`;
+var at = (row, col) => `${ESC4}[${row + 1};${col + 1}H`;
+var Screen = class extends EventEmitter {
+  constructor(out = process.stdout, input = process.stdin, opts = {}) {
+    super();
+    this.out = out;
+    this.input = input;
+    this.opts = opts;
+  }
+  last = null;
+  lastSize = "";
+  entered = false;
+  decoder = new KeyDecoder();
+  get rows() {
+    const n = this.opts.rows ?? this.out.rows;
+    return typeof n === "number" && n > 0 ? n : 24;
+  }
+  get columns() {
+    const n = this.opts.columns ?? this.out.columns;
+    return typeof n === "number" && n > 0 ? n : 80;
+  }
+  /** Take the terminal: alternate screen, raw keys, bracketed paste, the mouse if asked. */
+  enter() {
+    if (this.entered) return;
+    this.entered = true;
+    this.out.write(`${ALT_SCREEN_ON}${CURSOR_HIDE}${CLEAR}${PASTE_ON}${this.opts.mouse ? MOUSE_ON : ""}`);
+    try {
+      this.input.setRawMode?.(true);
+    } catch {
+    }
+    this.input.setEncoding?.("utf8");
+    this.input.on("data", this.onData);
+    this.input.on("end", this.onEnd);
+    this.input.resume();
+    this.out.on?.("resize", this.onResize);
+    process.once("exit", this.leave);
+  }
+  /** Give the terminal back, in the reverse order. Safe to call more than once. */
+  leave = () => {
+    if (!this.entered) return;
+    this.entered = false;
+    process.off("exit", this.leave);
+    this.out.off?.("resize", this.onResize);
+    this.input.off("data", this.onData);
+    this.input.off("end", this.onEnd);
+    try {
+      this.input.pause();
+      this.input.setRawMode?.(false);
+    } catch {
+    }
+    this.out.write(`${this.opts.mouse ? MOUSE_OFF : ""}${PASTE_OFF}${RESET}${CURSOR_SHOW}${ALT_SCREEN_OFF}`);
+    this.last = null;
+  };
+  /**
+   * Draw a whole frame, writing only the rows that changed.
+   *
+   * `frame` is read as `rows` lines; missing ones are blank, extra ones are
+   * dropped. A size change since the last paint clears and redraws everything,
+   * because a shorter line leaves the old one's tail where a diff cannot see it.
+   */
+  paint(frame, cursor = null) {
+    if (!this.entered) return;
+    const rows = this.rows;
+    const columns = this.columns;
+    const size = `${rows}x${columns}`;
+    let out = CURSOR_HIDE;
+    if (!this.last || this.lastSize !== size) {
+      out += CLEAR;
+      this.last = new Array(rows).fill(null);
+      this.lastSize = size;
+    }
+    for (let r = 0; r < rows; r++) {
+      const line = fit(frame[r] ?? "", columns);
+      if (this.last[r] === line) continue;
+      this.last[r] = line;
+      out += `${at(r, 0)}${line}${RESET}`;
+    }
+    if (cursor) out += `${at(Math.min(cursor.row, rows - 1), Math.min(cursor.col, columns - 1))}${CURSOR_SHOW}`;
+    this.out.write(out);
+  }
+  /** Forget the last frame, so the next paint redraws every row. For ctrl-l. */
+  invalidate() {
+    this.last = null;
+  }
+  onData = (chunk) => {
+    const keys = this.decoder.feed(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    if (keys.length) this.emit("keys", keys);
+  };
+  onEnd = () => {
+    this.emit("end");
+  };
+  onResize = () => {
+    this.last = null;
+    this.emit("resize");
+  };
+};
+function fit(line, width) {
+  const cut = truncate(line, width);
+  const short = width - visibleWidth(cut);
+  return short > 0 ? `${cut}${" ".repeat(short)}` : cut;
 }
 
 // packages/tui/src/markdown.ts
 function renderMarkdown(text, opts) {
   const lines = text.replace(/\r\n/g, "\n").split("\n");
-  const pad2 = opts.indent ?? "";
+  const pad4 = opts.indent ?? "";
   const out = [];
   let inFence = false;
   let fenceLang = "";
@@ -2452,7 +3112,7 @@ function renderMarkdown(text, opts) {
       if (!inFence) {
         inFence = true;
         fenceLang = fence[1] ?? "";
-        out.push(paint.dim(`${pad2}${fenceLang || "code"}`));
+        out.push(paint.dim(`${pad4}${fenceLang || "code"}`));
       } else {
         inFence = false;
         fenceLang = "";
@@ -2461,36 +3121,36 @@ function renderMarkdown(text, opts) {
       continue;
     }
     if (inFence) {
-      out.push(`${paint.dim(`${pad2}|`)} ${line}`);
+      out.push(`${paint.dim(`${pad4}|`)} ${line}`);
       continue;
     }
-    out.push(...prose(line, opts.width, pad2));
+    out.push(...prose(line, opts.width, pad4));
   }
   return out.join("\n");
 }
-function prose(line, width, pad2) {
+function prose(line, width, pad4) {
   const heading = /^(#{1,6})\s+(.*)$/.exec(line);
-  if (heading) return [`${pad2}${paint.bold(paint.accent(heading[2]))}`];
+  if (heading) return [`${pad4}${paint.bold(paint.accent(heading[2]))}`];
   if (/^\s*([-*_])\s*\1\s*\1[\s-*_]*$/.test(line)) {
-    return [`${pad2}${paint.dim("-".repeat(Math.min(width, 40)))}`];
+    return [`${pad4}${paint.dim("-".repeat(Math.min(width, 40)))}`];
   }
   const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(line);
   if (bullet) {
-    const indent2 = `${pad2}${bullet[1]}${paint.accent("-")} `;
-    return wrap2(inline(bullet[2]), width, indent2, `${pad2}${bullet[1]}  `);
+    const indent2 = `${pad4}${bullet[1]}${paint.accent("-")} `;
+    return wrap2(inline(bullet[2]), width, indent2, `${pad4}${bullet[1]}  `);
   }
   const numbered = /^(\s*)(\d+)\.\s+(.*)$/.exec(line);
   if (numbered) {
-    const indent2 = `${pad2}${numbered[1]}${paint.accent(`${numbered[2]}.`)} `;
-    return wrap2(inline(numbered[3]), width, indent2, `${pad2}${numbered[1]}   `);
+    const indent2 = `${pad4}${numbered[1]}${paint.accent(`${numbered[2]}.`)} `;
+    return wrap2(inline(numbered[3]), width, indent2, `${pad4}${numbered[1]}   `);
   }
   const quote = /^\s*>\s?(.*)$/.exec(line);
   if (quote) {
-    const gutter = `${pad2}${paint.dim("|")} `;
+    const gutter = `${pad4}${paint.dim("|")} `;
     return wrap2(paint.muted(inline(quote[1])), width, gutter, gutter);
   }
   if (!line.trim()) return [""];
-  return wrap2(inline(line), width, pad2, pad2);
+  return wrap2(inline(line), width, pad4, pad4);
 }
 var HOLD = "\0";
 function inline(text) {
@@ -2522,55 +3182,301 @@ function wrap2(text, width, first, rest) {
   return out;
 }
 
-// packages/tui/src/prompt.ts
-import { emitKeypressEvents } from "node:readline";
-var ESC3 = "\x1B";
-var PASTE_ON = `${ESC3}[?2004h`;
-var PASTE_OFF = `${ESC3}[?2004l`;
-var PASTE_START = `${ESC3}[200~`;
-var PASTE_END = `${ESC3}[201~`;
-var Prompt = class {
-  constructor(renderer, hooks, input = process.stdin) {
-    this.renderer = renderer;
-    this.hooks = hooks;
-    this.input = input;
-    emitKeypressEvents(this.input);
-    if (this.input.isTTY) this.input.setRawMode(true);
-    this.input.on("keypress", this.onKey);
-    this.input.on("end", this.onEnd);
-    this.input.resume();
-    if (this.renderer.isTty) process.stdout.write(PASTE_ON);
-    this.renderer.hideCursor();
-    process.stdout.on("resize", this.onResize);
-    process.once("exit", this.restore);
+// packages/tui/src/transcript.ts
+var MAX_PROSE_WIDTH = 100;
+var LIVE_LINES = 8;
+var Transcript = class {
+  entries = [];
+  nextId = 1;
+  cache = /* @__PURE__ */ new Map();
+  /** For a streaming answer: the rendered COMPLETE part, so only the tail is re-rendered per chunk. */
+  prose = /* @__PURE__ */ new Map();
+  get length() {
+    return this.entries.length;
+  }
+  get blocks() {
+    return this.entries;
+  }
+  /** Typed by kind rather than by the literal passed, so `done: false` stays a boolean the caller can flip. */
+  add(block) {
+    const entry = { id: this.nextId++, version: 0, block };
+    this.entries.push(entry);
+    return entry;
+  }
+  /** Say a block changed, so its cached lines are dropped on the next render. */
+  touch(entry) {
+    entry.version++;
+  }
+  /** Forget everything shown. The session file is untouched; this is the view. */
+  clear() {
+    this.entries = [];
+    this.cache.clear();
+    this.prose.clear();
+  }
+  /** Every line, top to bottom, with one blank line between blocks. */
+  render(width) {
+    const out = [];
+    const live = /* @__PURE__ */ new Set();
+    for (const entry of this.entries) {
+      live.add(entry.id);
+      const lines = this.lines(entry, width);
+      if (out.length && lines.length) out.push("");
+      out.push(...lines);
+    }
+    for (const id of this.cache.keys()) if (!live.has(id)) this.cache.delete(id);
+    for (const id of this.prose.keys()) if (!live.has(id)) this.prose.delete(id);
+    return out;
+  }
+  lines(entry, width) {
+    const hit = this.cache.get(entry.id);
+    if (hit && hit.version === entry.version && hit.width === width) return hit.lines;
+    const lines = entry.block.kind === "assistant" ? this.assistant(entry, width) : renderBlock(entry.block, width);
+    this.cache.set(entry.id, { version: entry.version, width, lines });
+    return lines;
   }
-  editor = new LineEditor();
-  history = new History();
-  resolve = null;
-  busyLabel = null;
-  label = null;
-  pasting = false;
-  /** stdin has closed. Every later `read` resolves `exit` at once. */
-  ended = false;
-  closed = false;
   /**
-   * Wait for a line.
+   * An answer, streaming or finished.
    *
-   * `label` replaces the placeholder and turns the border yellow - used for the
-   * approval question, which is a different kind of asking and should not look
-   * like the ordinary prompt.
+   * Complete markdown blocks are rendered; the unfinished tail - a line still
+   * arriving, a fence not yet closed - is shown raw and dimmed, so the reader
+   * sees the words land without a heading flickering between plain and bold.
    */
-  read(label2) {
-    if (this.ended) return Promise.resolve({ kind: "exit" });
-    this.label = label2 ?? null;
-    this.busyLabel = null;
-    this.editor.reset();
-    this.draw();
-    return new Promise((resolve2) => {
-      this.resolve = resolve2;
-    });
-  }
-  /** Put the box in its working state, or take it out of one. */
+  assistant(entry, width) {
+    const inner = proseWidth(width);
+    const { text, done } = entry.block;
+    if (done) return text.trim() ? renderMarkdown(text.replace(/\s+$/, ""), { width: inner, indent: "  " }).split("\n") : [];
+    const { complete: complete2, tail } = splitStreaming(text);
+    let head = this.prose.get(entry.id);
+    if (!head || head.length !== complete2.length || head.width !== width) {
+      head = {
+        length: complete2.length,
+        width,
+        lines: complete2 ? renderMarkdown(complete2, { width: inner, indent: "  " }).split("\n") : []
+      };
+      this.prose.set(entry.id, head);
+    }
+    const raw = tail ? tail.split("\n").flatMap((line) => wrapPlain(line, inner - 2)).map((line) => `  ${paint.dim(line)}`) : [];
+    return [...head.lines, ...raw];
+  }
+};
+function splitStreaming(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  let tail = lines.pop() ?? "";
+  let open = -1;
+  lines.forEach((line, i) => {
+    if (/^\s*```/.test(line)) open = open === -1 ? i : -1;
+  });
+  let complete2 = lines;
+  if (open !== -1) {
+    tail = [...lines.slice(open), tail].join("\n");
+    complete2 = lines.slice(0, open);
+  }
+  return { complete: complete2.join("\n"), tail };
+}
+function proseWidth(width) {
+  return Math.max(20, Math.min(width - 2, MAX_PROSE_WIDTH));
+}
+function renderBlock(block, width) {
+  const inner = proseWidth(width);
+  switch (block.kind) {
+    case "user":
+      return block.text.split("\n").flatMap(
+        (line, i) => wrapPlain(line, inner - 2).map((piece, j) => i === 0 && j === 0 ? `${paint.accent(">")} ${piece}` : `  ${piece}`)
+      );
+    case "assistant":
+      return [];
+    case "tool": {
+      const out = toolBlock(block.name, block.detail, block.status, { input: block.input, output: block.output }, inner);
+      if (block.live.length && !block.output) {
+        const shown = block.live.slice(-LIVE_LINES);
+        if (block.live.length > LIVE_LINES) out.push(`         ${paint.dim(`\u2026 ${block.live.length - LIVE_LINES} more lines`)}`);
+        for (const line of shown) out.push(`         ${paint.dim(line)}`);
+      }
+      return out;
+    }
+    case "approval": {
+      const out = approvalCard(block.preview, block.call, block.mode, inner);
+      out.push(
+        block.answer === null ? `  ${paint.yellow("y")} ${paint.muted("to allow  \xB7")} ${paint.yellow("n")} ${paint.muted("or esc to decline")}` : `  ${block.answer === "allowed" ? paint.green("allowed") : paint.muted("declined")}`
+      );
+      return out;
+    }
+    case "error":
+      return block.text.split("\n").map((line, i) => i === 0 ? `${paint.red("  labd:")} ${line}` : `        ${line}`);
+    case "note":
+      return block.text.replace(/\n$/, "").split("\n");
+    case "compaction": {
+      const label2 = " summarised the conversation so far ";
+      const room = Math.max(0, inner - label2.length);
+      return [paint.dim(`  ${"\u2500".repeat(Math.floor(room / 2))}${label2}${"\u2500".repeat(Math.ceil(room / 2))}`)];
+    }
+  }
+}
+function wrapPlain(text, width) {
+  const limit = Math.max(10, width);
+  if (visibleWidth(text) <= limit) return [text];
+  const out = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    if (line && line.length + 1 + word.length > limit) {
+      out.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+    while (line.length > limit) {
+      out.push(line.slice(0, limit));
+      line = line.slice(limit);
+    }
+  }
+  if (line || !out.length) out.push(line);
+  return out;
+}
+var Viewport = class {
+  constructor(height) {
+    this.height = height;
+  }
+  top = 0;
+  follow = true;
+  total = 0;
+  /** The line count when the reader stopped following, so `newLines` can be counted from it. */
+  anchor = 0;
+  /** Lines that arrived since the reader scrolled away. Zero while following. */
+  get newLines() {
+    return this.follow ? 0 : Math.max(0, this.total - this.anchor);
+  }
+  /** Tell the viewport how many lines there are now, and how tall it is. */
+  update(total, height = this.height) {
+    this.height = height;
+    this.total = total;
+    if (this.follow) this.top = Math.max(0, total - height);
+    else this.top = Math.max(0, Math.min(this.top, total - height));
+  }
+  scroll(delta) {
+    const max = Math.max(0, this.total - this.height);
+    const next = Math.max(0, Math.min(max, this.top + delta));
+    if (next === this.top && this.follow) return;
+    this.top = next;
+    if (next >= max) this.refollow();
+    else this.unfollow();
+  }
+  pageUp() {
+    this.scroll(-Math.max(1, this.height - 1));
+  }
+  pageDown() {
+    this.scroll(Math.max(1, this.height - 1));
+  }
+  home() {
+    this.top = 0;
+    if (this.total > this.height) this.unfollow();
+  }
+  end() {
+    this.refollow();
+    this.top = Math.max(0, this.total - this.height);
+  }
+  /** The slice of `lines` on screen. */
+  slice(lines) {
+    return lines.slice(this.top, this.top + this.height);
+  }
+  unfollow() {
+    if (this.follow) this.anchor = this.total;
+    this.follow = false;
+  }
+  refollow() {
+    this.follow = true;
+  }
+};
+
+// packages/tui/src/face.ts
+var FACE_ART = [
+  "  \u250F\u2501                      \u2501\u2513  ",
+  "  \u2503    \u2584\u2584\u2584\u2584\u2584      \u2584\u2584\u2584\u2584\u2584    \u2503  ",
+  "  \u2503    \u2588\u2588\u2588\u2588\u2588      \u2588\u2588\u2588\u2588\u2588    \u2503  ",
+  "  \u2503    \u2580\u2580\u2580\u2580\u2580      \u2580\u2580\u2580\u2580\u2580    \u2503  ",
+  "  \u2503                        \u2503  ",
+  "  \u2503       \u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584       \u2503  ",
+  "  \u2517\u2501                      \u2501\u251B  "
+];
+var NOISE = "$#@%&*+=-:.<>/\\|_01x?";
+var FACE_FRAME_MS = 34;
+function noiseChar() {
+  return NOISE[Math.floor(Math.random() * NOISE.length)];
+}
+function faceLines() {
+  return FACE_ART.map((row) => paint.accent(row));
+}
+function decodeFrames() {
+  const cells = FACE_ART.map((row) => [...row]);
+  const lockAt = cells.map(
+    (row, y) => row.map((_, x) => Math.round(x * 0.55 + y * 0.9 + Math.random() * 7))
+  );
+  const last = Math.max(...lockAt.flat());
+  const frames = [];
+  for (let f = 1; f <= last + 1; f++) {
+    frames.push(
+      cells.map(
+        (row, y) => paint.accent(
+          row.map((char, x) => {
+            if (char === " ") return " ";
+            return f >= lockAt[y][x] ? char : noiseChar();
+          }).join("")
+        )
+      )
+    );
+  }
+  frames.push(faceLines());
+  return frames;
+}
+
+// packages/tui/src/prompt.ts
+import { emitKeypressEvents } from "node:readline";
+var ESC5 = "\x1B";
+var PASTE_ON2 = `${ESC5}[?2004h`;
+var PASTE_OFF2 = `${ESC5}[?2004l`;
+var PASTE_START2 = `${ESC5}[200~`;
+var PASTE_END2 = `${ESC5}[201~`;
+var Prompt = class {
+  constructor(renderer, hooks, input = process.stdin) {
+    this.renderer = renderer;
+    this.hooks = hooks;
+    this.input = input;
+    emitKeypressEvents(this.input);
+    if (this.input.isTTY) this.input.setRawMode(true);
+    this.input.on("keypress", this.onKey);
+    this.input.on("end", this.onEnd);
+    this.input.resume();
+    if (this.renderer.isTty) process.stdout.write(PASTE_ON2);
+    this.renderer.hideCursor();
+    process.stdout.on("resize", this.onResize);
+    process.once("exit", this.restore);
+  }
+  editor = new LineEditor();
+  history = new History();
+  resolve = null;
+  busyLabel = null;
+  label = null;
+  pasting = false;
+  /** stdin has closed. Every later `read` resolves `exit` at once. */
+  ended = false;
+  closed = false;
+  /**
+   * Wait for a line.
+   *
+   * `label` replaces the placeholder and turns the border yellow - used for the
+   * approval question, which is a different kind of asking and should not look
+   * like the ordinary prompt.
+   */
+  read(label2) {
+    if (this.ended) return Promise.resolve({ kind: "exit" });
+    this.label = label2 ?? null;
+    this.busyLabel = null;
+    this.editor.reset();
+    this.draw();
+    return new Promise((resolve2) => {
+      this.resolve = resolve2;
+    });
+  }
+  /** Put the box in its working state, or take it out of one. */
   busy(what) {
     this.busyLabel = what;
     this.draw();
@@ -2613,7 +3519,7 @@ var Prompt = class {
       if (this.input.isTTY) this.input.setRawMode(false);
     } catch {
     }
-    if (this.renderer.isTty) process.stdout.write(PASTE_OFF);
+    if (this.renderer.isTty) process.stdout.write(PASTE_OFF2);
     this.renderer.showCursor();
   };
   onResize = () => {
@@ -2626,11 +3532,11 @@ var Prompt = class {
   };
   onKey = (str, key = {}) => {
     const sequence = key.sequence ?? str ?? "";
-    if (sequence.includes(PASTE_START)) {
+    if (sequence.includes(PASTE_START2)) {
       this.pasting = true;
       return;
     }
-    if (sequence.includes(PASTE_END)) {
+    if (sequence.includes(PASTE_END2)) {
       this.pasting = false;
       this.draw();
       return;
@@ -2776,6 +3682,7 @@ import { chmodSync, existsSync, mkdirSync as mkdirSync4, readFileSync as readFil
 import { hostname } from "node:os";
 import { join as join5 } from "node:path";
 var POLL_INTERVAL_MS = 2500;
+var REVOKE_TIMEOUT_MS = 3e3;
 var Auth = class {
   constructor(stateDir2, baseUrl) {
     this.baseUrl = baseUrl;
@@ -2802,18 +3709,21 @@ var Auth = class {
   isReady() {
     return Boolean(this.token());
   }
+  /** True when there was a stored token to sign out; `LABD_TOKEN` is never stored, so never revoked. */
   async signOut() {
     const token = this.read().token;
     if (token) {
       await fetch(`${this.baseUrl}/v1/auth/device/revoke`, {
         method: "POST",
-        headers: { Authorization: `Bearer ${token}` }
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(REVOKE_TIMEOUT_MS)
       }).catch(() => void 0);
     }
     try {
       rmSync3(this.file, { force: true });
     } catch {
     }
+    return Boolean(token);
   }
   /**
    * Pair this machine with the learner's account.
@@ -2894,6 +3804,17 @@ function sleep(ms, signal) {
     }, { once: true });
   });
 }
+function signedOutMessage(hadStored, envToken) {
+  const lines = [];
+  if (hadStored) lines.push("signed out, and the stored token is gone. `labd login` pairs this machine again.");
+  else if (!envToken) lines.push("this machine was not signed in.");
+  if (envToken) {
+    lines.push(
+      hadStored ? "LABD_TOKEN is still set in this shell, so the next labd will be signed in with it." : "labd is signed in with LABD_TOKEN from this shell, which is never stored - unset it to sign out."
+    );
+  }
+  return lines.join("\n");
+}
 
 // packages/cli/src/config.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync6 } from "node:fs";
@@ -2904,7 +3825,9 @@ var DEFAULTS = {
   modeChosen: false,
   serverUrl: "https://agent.thedevlabs.io",
   commandTimeoutSeconds: 120,
-  checkpoints: true
+  checkpoints: true,
+  mouse: true,
+  sidebar: false
 };
 function unattendedMode(settings) {
   return settings.modeChosen ? settings.mode : "ask";
@@ -2940,7 +3863,11 @@ function loadSettings(root, overrides = {}, opts = {}) {
     commandTimeoutSeconds: clampTimeout(
       overrides.commandTimeoutSeconds ?? asNumber(project.commandTimeoutSeconds) ?? asNumber(global.commandTimeoutSeconds) ?? DEFAULTS.commandTimeoutSeconds
     ),
-    checkpoints: overrides.checkpoints ?? asBoolean(project.checkpoints) ?? asBoolean(global.checkpoints) ?? DEFAULTS.checkpoints
+    checkpoints: overrides.checkpoints ?? asBoolean(project.checkpoints) ?? asBoolean(global.checkpoints) ?? DEFAULTS.checkpoints,
+    // Screen preferences. Harmless from either file: neither changes what labd
+    // may do, only how the session is drawn.
+    mouse: overrides.mouse ?? asBoolean(project.mouse) ?? asBoolean(global.mouse) ?? DEFAULTS.mouse,
+    sidebar: overrides.sidebar ?? asBoolean(project.sidebar) ?? asBoolean(global.sidebar) ?? DEFAULTS.sidebar
   };
 }
 function read(path) {
@@ -2977,10 +3904,14 @@ var BUILTIN_COMMANDS = [
   { name: "resume", args: "<id>", what: "continue from a point in /tree" },
   { name: "sessions", what: "earlier sessions in this project" },
   { name: "session", what: "where this one is stored" },
-  { name: "new", what: "how to start a fresh session" },
+  { name: "rename", args: "<name>", what: "name this session, so /sessions and --resume show it" },
+  { name: "new", what: "start a fresh session; this one stays saved" },
   { name: "usage", what: "what's left of this month's allowance" },
   { name: "trust", what: "let this project load its own extensions" },
+  { name: "logout", what: "sign this machine out and leave" },
   { name: "reload", what: "reload extensions and the file list" },
+  { name: "sidebar", what: "show or hide the side panel (full-screen session only)" },
+  { name: "clear", what: "clear the screen; the session itself is kept" },
   { name: "quit", what: "leave" }
 ];
 function classify(line, extra = []) {
@@ -3167,9 +4098,12 @@ function branchOf(root) {
   if (abbrev === null) return void 0;
   return describeBranch(abbrev, abbrev === "HEAD" ? git("rev-parse", "--short", "HEAD") : null);
 }
+var closedAt = /* @__PURE__ */ new WeakMap();
 async function closeConversation(runtime) {
   const messages = runtime.session.wire();
   if (!messages.some((m) => m.role === "user")) return;
+  if (closedAt.get(runtime.session) === messages.length) return;
+  closedAt.set(runtime.session, messages.length);
   try {
     await runtime.client.close({
       protocol: PROTOCOL_VERSION,
@@ -3188,6 +4122,9 @@ async function closeConversation(runtime) {
 // packages/cli/src/modes/interactive.ts
 import { basename as basename4 } from "node:path";
 
+// packages/cli/src/commands.ts
+import { dirname as dirname3 } from "node:path";
+
 // packages/cli/src/files.ts
 import { readdirSync as readdirSync6 } from "node:fs";
 import { join as join8, relative as relative4 } from "node:path";
@@ -3227,7 +4164,6 @@ function walk2(root, dir, out, budget) {
 }
 
 // packages/cli/src/commands.ts
-import { dirname as dirname3 } from "node:path";
 async function handleCommand(input, ctx) {
   const [rawName = "", ...rest] = input.replace(/^\//, "").split(/\s+/);
   const name = rawName === "?" || rawName === "" ? "help" : rawName.toLowerCase();
@@ -3328,9 +4264,9 @@ async function handleCommand(input, ctx) {
       for (const s of all) {
         const when = new Date(s.at).toLocaleString();
         const mark = s.id === runtime.session.id ? paint.accent(">") : " ";
-        print(`  ${mark} ${paint.dim(s.id.slice(0, 8))} ${paint.muted(`${when}  ${s.messages} nodes`)} ${s.name ?? ""}`);
+        print(`  ${mark} ${paint.dim(s.id.slice(0, 8))} ${paint.muted(`${when}  ${s.messages} nodes`)} ${sessionTitle(s)}`);
       }
-      print(`  ${paint.dim("labd --resume <id> opens one.")}`);
+      print(`  ${paint.dim("labd --resume <id> opens one; labd --resume on its own lists them to pick from.")}`);
       return {};
     }
     case "undo": {
@@ -3427,6 +4363,27 @@ async function handleCommand(input, ctx) {
       for (const skipped of next.skipped) print(`  ${paint.yellow("!")} ${paint.muted(skipped.why)}`);
       return {};
     }
+    case "sidebar":
+    case "clear":
+      print(`  ${paint.muted(`/${name} works in the full-screen session; this is the plain one (--plain).`)}`);
+      return {};
+    case "rename": {
+      const name2 = sessionName(args);
+      if (!name2) {
+        const current = sessionName(runtime.session.displayName ?? "");
+        print(`  ${current ? paint.bold(current) : paint.muted("this session has no name yet")} ${paint.dim("- /rename <name> sets one")}`);
+        return {};
+      }
+      runtime.session.rename(name2);
+      print(`  ${paint.muted("named")} ${paint.bold(name2)}`);
+      return {};
+    }
+    case "logout": {
+      if (ctx.asked) await closeConversation(runtime);
+      const hadStored = await runtime.auth.signOut();
+      const farewell = signedOutMessage(hadStored, Boolean(process.env.LABD_TOKEN)).split("\n").map((line) => `  ${paint.muted(line)}`).join("\n");
+      return { exit: true, farewell };
+    }
     case "session":
       print(`  ${paint.muted(runtime.session.file)}`);
       print(`  ${paint.muted(`${runtime.session.size()} nodes, head ${runtime.session.headId?.slice(0, 8) ?? "none"}`)}`);
@@ -3466,10 +4423,77 @@ function help(runtime) {
     `  ${paint.dim("@path tags a file into the question. ctrl-c stops an answer.")}`
   ].join("\n");
 }
+var MAX_SESSION_NAME = 80;
+function sessionName(raw) {
+  return raw.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_SESSION_NAME);
+}
 function indent(text) {
   return text.split("\n").map((line) => `  ${line}`).join("\n");
 }
 
+// packages/cli/src/modes/shared.ts
+function describe(line, runtime) {
+  const extras = runtime.extensions.commands.keys();
+  const what = classify(line, extras);
+  if (what.state === "none") return { state: "idle" };
+  if (what.state === "ok") {
+    return { state: "ok", hint: what.info ? paint.muted(what.info.what) : null };
+  }
+  if (what.state === "partial") {
+    return { state: "partial", suggestions: matching(line, extras) };
+  }
+  const typed = line.trimStart().slice(1).split(/\s+/)[0] ?? "";
+  const meant = didYouMean(typed, extras);
+  return {
+    state: "unknown",
+    hint: meant ? `${paint.red("!")} ${paint.muted(`no /${typed}.`)} ${paint.dim("did you mean")} ${paint.accent(`/${meant}`)}${paint.dim("?")}` : `${paint.red("!")} ${paint.muted(`no /${typed}.`)} ${paint.dim("/help lists them all.")}`
+  };
+}
+function complete(line, runtime) {
+  if (line.startsWith("/") && !/\s/.test(line)) {
+    const hits2 = matching(line, runtime.extensions.commands.keys());
+    return hits2.length === 1 ? `/${hits2[0].name} ` : null;
+  }
+  const at2 = line.lastIndexOf("@");
+  if (at2 === -1) return null;
+  const partial = line.slice(at2 + 1);
+  const hits = rankPaths(partial, listFiles(runtime.root));
+  return hits.length ? `${line.slice(0, at2)}@${hits[0]} ` : null;
+}
+function fileTag(line) {
+  const at2 = line.lastIndexOf("@");
+  if (at2 === -1) return null;
+  if (at2 > 0 && !/\s/.test(line[at2 - 1])) return null;
+  const partial = line.slice(at2 + 1);
+  if (/\s/.test(partial)) return null;
+  return { at: at2, partial };
+}
+function label(step) {
+  return `${step.call.name.replace(/_/g, " ")} ${detail(step)}`;
+}
+function detail(step) {
+  const input = step.call.input;
+  return String(input.why ?? input.path ?? input.from ?? input.query ?? "");
+}
+function verbatim(call) {
+  const i = call.input;
+  const str = (k) => typeof i[k] === "string" ? i[k] : "";
+  switch (call.name) {
+    case "run_command":
+      return str("command");
+    case "search_workspace": {
+      const include = str("include");
+      return include ? `${str("query")}   in ${include}` : str("query");
+    }
+    case "move_file":
+      return `${str("from")} \u2192 ${str("to")}`;
+    case "list_dir":
+      return str("path") || "/";
+    default:
+      return str("path");
+  }
+}
+
 // packages/cli/src/modes/interactive.ts
 async function runInteractive(runtime) {
   const renderer = new Renderer();
@@ -3532,8 +4556,11 @@ async function runInteractive(runtime) {
           runtime,
           mode: state.mode,
           effort: state.effort,
+          asked: answered > 0,
           print: (text) => renderer.print(text)
         });
+        if (outcome.farewell) process.stderr.write(`${outcome.farewell}
+`);
         if (outcome.exit) break;
         if (outcome.mode) state.mode = outcome.mode;
         if (outcome.effort !== void 0) state.effort = outcome.effort;
@@ -3602,9 +4629,9 @@ async function runInteractive(runtime) {
           stopSpinner();
           renderer.print(`${paint.red("  labd:")} ${message}`);
         },
-        done(info) {
-          if (info.context) state.context = info.context;
-          if (info.credits) state.credits = info.credits;
+        done(info2) {
+          if (info2.context) state.context = info2.context;
+          if (info2.credits) state.credits = info2.credits;
         },
         commandOutput(line) {
           renderer.print(paint.dim(`  | ${line.replace(/\n/g, "\n  | ")}`));
@@ -3657,48 +4684,6 @@ ${FACE} session saved. Continue it with: labd --resume ${runtime.session.id.slic
   }
   return 0;
 }
-function describe(line, runtime) {
-  const extras = runtime.extensions.commands.keys();
-  const what = classify(line, extras);
-  if (what.state === "none") return { state: "idle" };
-  if (what.state === "ok") {
-    return { state: "ok", hint: what.info ? paint.muted(what.info.what) : null };
-  }
-  if (what.state === "partial") {
-    return { state: "partial", suggestions: matching(line, extras) };
-  }
-  const typed = line.trimStart().slice(1).split(/\s+/)[0] ?? "";
-  const meant = didYouMean(typed, extras);
-  return {
-    state: "unknown",
-    hint: meant ? `${paint.red("!")} ${paint.muted(`no /${typed}.`)} ${paint.dim("did you mean")} ${paint.accent(`/${meant}`)}${paint.dim("?")}` : `${paint.red("!")} ${paint.muted(`no /${typed}.`)} ${paint.dim("/help lists them all.")}`
-  };
-}
-function label(step) {
-  return `${step.call.name.replace(/_/g, " ")} ${detail(step)}`;
-}
-function detail(step) {
-  const input = step.call.input;
-  return String(input.why ?? input.path ?? input.from ?? input.query ?? "");
-}
-function verbatim(call) {
-  const i = call.input;
-  const str = (k) => typeof i[k] === "string" ? i[k] : "";
-  switch (call.name) {
-    case "run_command":
-      return str("command");
-    case "search_workspace": {
-      const include = str("include");
-      return include ? `${str("query")}   in ${include}` : str("query");
-    }
-    case "move_file":
-      return `${str("from")} \u2192 ${str("to")}`;
-    case "list_dir":
-      return str("path") || "/";
-    default:
-      return str("path");
-  }
-}
 async function banner(renderer, runtime, mode) {
   const where = basename4(runtime.root);
   renderer.print("");
@@ -3732,16 +4717,890 @@ async function banner(renderer, runtime, mode) {
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function complete(line, runtime) {
-  if (line.startsWith("/") && !/\s/.test(line)) {
-    const hits2 = matching(line, runtime.extensions.commands.keys());
-    return hits2.length === 1 ? `/${hits2[0].name} ` : null;
+
+// packages/cli/src/modes/screen.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { basename as basename5, dirname as dirname4 } from "node:path";
+
+// packages/cli/src/modes/serial.ts
+var Serial = class {
+  constructor(opts) {
+    this.opts = opts;
   }
-  const at = line.lastIndexOf("@");
-  if (at === -1) return null;
-  const partial = line.slice(at + 1);
-  const hits = rankPaths(partial, listFiles(runtime.root));
-  return hits.length ? `${line.slice(0, at)}@${hits[0]} ` : null;
+  pending = [];
+  current = null;
+  get busy() {
+    return this.current !== null;
+  }
+  /** What is waiting, oldest first. */
+  get queued() {
+    return this.pending;
+  }
+  /** Where the running work can be awaited, for a clean exit. */
+  get running() {
+    return this.current;
+  }
+  /** Send now if nothing is running and nothing holds the line, else wait behind it. */
+  submit(text) {
+    if (this.current || this.opts.held() || this.pending.length) {
+      this.pending.push(text);
+      this.opts.changed();
+      return "queued";
+    }
+    this.start(() => this.opts.send(text));
+    return "sent";
+  }
+  /**
+   * Run something that is not a typed line - picking a session from a list, say
+   * - under the same rule. Refused rather than queued when busy: the choice was
+   * made against what was on screen, and by the time it ran that would be gone.
+   */
+  run(work) {
+    if (this.current) return false;
+    this.start(work);
+    return true;
+  }
+  /** Start the next line, if there is one and nothing holds it. Call when a hold lifts. */
+  drain() {
+    if (this.current || this.opts.held()) return;
+    const next = this.pending.shift();
+    if (next === void 0) return;
+    this.start(() => this.opts.send(next));
+  }
+  /**
+   * Stop waiting for what is running, without stopping it. For a command that
+   * never finishes - an extension's, say - which would otherwise hold the line
+   * for good. Whatever it does later lands late; nothing waits on it.
+   */
+  release() {
+    if (!this.current) return;
+    this.current = null;
+    this.opts.changed();
+    this.drain();
+  }
+  /** Empty the line and hand back what was in it, so a stop does not lose it. */
+  take() {
+    const out = this.pending;
+    this.pending = [];
+    if (out.length) this.opts.changed();
+    return out;
+  }
+  start(work) {
+    const done = (async () => {
+      try {
+        await work();
+      } catch (err) {
+        this.opts.failed(err);
+      }
+    })();
+    this.current = done;
+    this.opts.changed();
+    void done.then(() => {
+      if (this.current === done) this.current = null;
+      this.opts.changed();
+      this.drain();
+    });
+  }
+};
+
+// packages/cli/src/modes/screen.ts
+var FRAME_MS = 33;
+var QUIT_WINDOW_MS = 2e3;
+var WHEEL_LINES = 3;
+var MAX_QUEUED_SHOWN = 3;
+var ESC6 = "\x1B";
+async function runScreen(runtime, opts) {
+  const screen = new Screen(process.stdout, process.stdin, { mouse: opts.mouse });
+  const transcript = new Transcript();
+  const viewport = new Viewport(10);
+  const editor = new TextEditor();
+  const history = new History();
+  const state = {
+    mode: runtime.settings.mode,
+    effort: runtime.settings.effort,
+    context: null,
+    credits: null,
+    sidebar: opts.sidebar,
+    tick: 0,
+    /** What labd is doing right now, for the footer. Null when idle. */
+    busy: null,
+    abort: null,
+    popup: null,
+    /** The line the popup was dismissed on, so Esc is not undone by the next frame. */
+    popupDismissed: null,
+    dialog: null,
+    approval: null,
+    /** The assistant block a streaming answer is going into. */
+    answer: null,
+    toolBlocks: /* @__PURE__ */ new Map(),
+    lastSteps: [],
+    ctrlCAt: 0,
+    /** A one-line message in the footer, and when it expires. */
+    notice: null,
+    /** Printed to stderr once the screen is given back. */
+    farewell: null,
+    /** A question was asked in the CURRENT session, so leaving should say so and close it. */
+    asked: false,
+    quitting: false,
+    faceIndex: 0,
+    dirty: null,
+    conventions: 0,
+    skills: 0
+  };
+  const serial = new Serial({
+    send: (text) => text.startsWith("/") || text === "?" ? command(text) : ask(text),
+    held: () => state.dialog !== null || state.quitting,
+    failed: (err) => transcript.add({ kind: "error", text: err instanceof Error ? err.message : String(err) }),
+    changed: () => schedule()
+  });
+  const faceFrames = process.env.LABD_NO_MOTION ? [faceLines()] : decodeFrames();
+  let frameTimer = null;
+  const schedule = () => {
+    if (frameTimer) return;
+    frameTimer = setTimeout(() => {
+      frameTimer = null;
+      draw();
+    }, FRAME_MS);
+  };
+  let spinner = null;
+  const setBusy = (what) => {
+    state.busy = what;
+    if (what && !spinner) {
+      spinner = setInterval(() => {
+        state.tick++;
+        schedule();
+      }, 400);
+    }
+    if (!what && spinner) {
+      clearInterval(spinner);
+      spinner = null;
+    }
+    schedule();
+  };
+  let resolveExit = null;
+  const exited = new Promise((resolve2) => {
+    resolveExit = resolve2;
+  });
+  const quit = () => {
+    if (state.quitting) return;
+    state.quitting = true;
+    state.abort?.abort();
+    resolveExit?.();
+  };
+  const note = (text) => {
+    transcript.add({ kind: "note", text });
+    schedule();
+  };
+  const notice = (text, ms = QUIT_WINDOW_MS) => {
+    state.notice = { text, until: Date.now() + ms };
+    schedule();
+    setTimeout(schedule, ms + 10);
+  };
+  function draw() {
+    if (state.quitting) return;
+    const rows = screen.rows;
+    const columns = screen.columns;
+    const L = layout({ rows, columns, editorLines: editor.lineCount, sidebar: state.sidebar });
+    const frame = [];
+    let cursor = null;
+    frame.push(header(columns));
+    const width = L.transcript.width;
+    const lines = transcript.length ? transcript.render(width) : emptyState(width, L.transcript.height);
+    viewport.update(lines.length, L.transcript.height);
+    const visible = viewport.slice(lines);
+    while (visible.length < L.transcript.height) visible.push("");
+    if (!viewport.follow && viewport.newLines > 0 && visible.length) {
+      const n = viewport.newLines;
+      const tag = paint.accent(`\u2193 ${n} new line${n === 1 ? "" : "s"} \xB7 end to follow`);
+      visible[visible.length - 1] = fit(" ".repeat(Math.max(0, width - visibleWidth(tag) - 1)) + tag, width);
+    }
+    const overlays = [];
+    if (serial.queued.length && !state.approval) overlays.push(queuedLines(width));
+    if (state.popup && !state.dialog) overlays.push(state.popup.render(width));
+    for (const rowsOut of overlays) {
+      const start = visible.length - rowsOut.length;
+      rowsOut.forEach((line, i) => {
+        if (start + i >= 0) visible[start + i] = line;
+      });
+    }
+    const body2 = [...visible.map((l) => fit(l, width)), ...composer2(L.composer.width, L.composer.height)];
+    if (L.sidebar) {
+      const side = sidebar(L.sidebar.width);
+      body2.forEach((line, i) => {
+        body2[i] = `${line}${paint.dim("\u2502")}${fit(side[i] ?? "", L.sidebar.width)}`;
+      });
+    }
+    frame.push(...body2);
+    frame.push(footer(columns));
+    if (!state.dialog && !state.approval && !state.quitting) {
+      const view = editor.view(L.composer.width - 6, L.composer.height - 2);
+      cursor = { row: L.composer.top + 1 + view.cursor.row, col: 4 + view.cursor.col };
+    }
+    if (state.dialog) {
+      const placed = renderDialog(state.dialog, rows, columns);
+      placed.lines.forEach((line, i) => {
+        const row = placed.top + i;
+        if (row < frame.length) frame[row] = overlay(frame[row] ?? "", placed.left, line, columns);
+      });
+    }
+    screen.paint(frame, cursor);
+  }
+  function header(width) {
+    const session = runtime.session.id.slice(0, 8);
+    const left = [
+      `${paint.accent(FACE)} ${paint.bold("labd")}`,
+      `${paint.muted(basename5(runtime.root))}${runtime.branch ? `  ${paint.muted(runtime.branch)}` : ""}`,
+      paint.dim(`session ${session}`)
+    ].join(paint.dim("  \xB7  "));
+    const mode = state.mode === "agent" ? paint.red(paint.bold("agent")) : state.mode === "auto" ? paint.accent("auto") : paint.muted("ask");
+    const right = `${mode}${state.effort ? paint.dim(` \xB7 think ${state.effort}`) : ""} `;
+    return spread(` ${left}`, right, width);
+  }
+  function footer(width) {
+    const d = paint.dim;
+    let left;
+    if (state.notice && state.notice.until > Date.now()) left = paint.yellow(state.notice.text);
+    else if (state.dialog) left = d("\u2191\u2193 move \xB7 enter choose \xB7 type to search \xB7 esc close");
+    else if (state.approval) left = `${paint.yellow("y")} ${d("allow \xB7")} ${paint.yellow("n")} ${d("decline \xB7 ctrl+c stop")}`;
+    else if (state.busy) left = `${paint.accent(state.busy)}${spinnerFrame(state.tick)}  ${d("enter queues \xB7 ctrl+c stop \xB7 pgup/pgdn scroll")}`;
+    else if (state.popup) left = d("\u2191\u2193 move \xB7 tab/enter accept \xB7 esc close");
+    else {
+      const described = describe(editor.currentLine, runtime);
+      left = described.hint ? described.hint : d("enter send \xB7 shift+enter newline \xB7 / commands \xB7 @ files \xB7 pgup/pgdn scroll \xB7 ctrl+c stop \xB7 ctrl+d quit");
+    }
+    const bits = [];
+    if (state.context) {
+      const crowded = state.context.percentUsed >= 75;
+      bits.push((crowded ? paint.yellow : paint.muted)(`context ${state.context.percentUsed}%`));
+    }
+    if (state.credits) bits.push(paint.muted(`credits ${state.credits.percentLeft}%`));
+    return spread(` ${left}`, `${bits.join(paint.dim(" \xB7 "))} `, width);
+  }
+  function composer2(width, height) {
+    const inner = width - 4;
+    const textRows = Math.max(1, height - 2);
+    const colour = state.approval ? paint.yellow : state.busy ? paint.accent : borderColour2(describe(editor.currentLine, runtime).state);
+    const out = [];
+    out.push(colour(`\u256D${"\u2500".repeat(Math.max(0, width - 2))}\u256E`));
+    const view = editor.view(inner - 2, textRows);
+    const lines = [...view.lines];
+    while (lines.length < textRows) lines.push("");
+    lines.forEach((line, i) => {
+      const first = i === 0 && editor.cursor.row - view.cursor.row === 0;
+      const sigil = first ? state.busy ? paint.dim(">") : paint.accent(">") : " ";
+      let text = line;
+      if (editor.isEmpty && i === 0) {
+        text = state.approval ? paint.yellow("y to allow, n or esc to decline") : state.busy ? paint.dim("labd is working - type to queue a message, ctrl+c stops it") : paint.dim("ask labd something  -  / for commands  -  @ to tag a file");
+      }
+      out.push(`${colour("\u2502")} ${sigil} ${fit(text, inner - 2)} ${colour("\u2502")}`);
+    });
+    out.push(colour(`\u2570${"\u2500".repeat(Math.max(0, width - 2))}\u256F`));
+    return out;
+  }
+  function emptyState(width, height) {
+    const face = faceFrames[Math.min(state.faceIndex, faceFrames.length - 1)];
+    const hint = paint.dim("ask labd something  -  / for commands  -  @ to tag a file");
+    const caption = wrapPlain(MODE_CAPTION[state.mode], Math.max(20, width - 4)).map((l) => paint.dim(l));
+    const body2 = [...face, "", hint, "", ...caption];
+    const top = Math.max(0, Math.floor((height - body2.length) / 2));
+    return [...Array(top).fill(""), ...body2.map((line) => centre(line, width))];
+  }
+  function sidebar(width) {
+    const row = (k, v) => `${paint.muted(k.padEnd(12))}${v}`;
+    const lines = [
+      ` ${paint.bold("project")}`,
+      ` ${row("name", basename5(runtime.root))}`,
+      ` ${row("branch", runtime.branch ?? paint.dim("none"))}`,
+      ` ${row("changed", state.dirty === null ? paint.dim("-") : `${state.dirty} file${state.dirty === 1 ? "" : "s"}`)}`,
+      ` ${row("conventions", String(state.conventions))}`,
+      ` ${row("skills", String(state.skills))}`,
+      "",
+      ` ${paint.bold("session")}`,
+      ` ${row("mode", state.mode)}`,
+      ` ${row("think", state.effort ?? paint.dim("default"))}`,
+      ` ${row("context", state.context ? `${state.context.percentUsed}%` : paint.dim("-"))}`,
+      ` ${row("credits", state.credits ? `${state.credits.percentLeft}% left` : paint.dim("-"))}`,
+      "",
+      ` ${paint.bold("recent steps")}`,
+      ...state.lastSteps.length ? state.lastSteps.map((s) => ` ${paint.muted(s)}`) : [` ${paint.dim("none yet")}`]
+    ];
+    return lines.map((l) => fit(l, width));
+  }
+  function onKeys(keys) {
+    for (const key of keys) onKey(key);
+  }
+  function onKey(key) {
+    if (key.ctrl && key.name === "c") return interrupt();
+    if (state.dialog) {
+      const r = dialogKey(state.dialog, key);
+      if (r === "close" || r === "select") closeDialog();
+      return schedule();
+    }
+    if (key.mouse) {
+      if (key.mouse.kind === "wheel-up") viewport.scroll(-WHEEL_LINES);
+      else if (key.mouse.kind === "wheel-down") viewport.scroll(WHEEL_LINES);
+      return schedule();
+    }
+    if (key.name === "pageup") return viewport.pageUp(), schedule();
+    if (key.name === "pagedown") return viewport.pageDown(), schedule();
+    if (key.name === "home" && editor.isEmpty) return viewport.home(), schedule();
+    if (key.name === "end" && editor.isEmpty) return viewport.end(), schedule();
+    if (state.approval) {
+      if (key.sequence === "y" || key.sequence === "Y") return answerApproval(true);
+      if (key.sequence === "n" || key.sequence === "N" || key.name === "escape") return answerApproval(false);
+      return;
+    }
+    if (key.ctrl && key.name === "d") {
+      if (editor.isEmpty) quit();
+      return;
+    }
+    if (key.ctrl && key.name === "l") return screen.invalidate(), schedule();
+    if (key.ctrl && key.name === "n") return void serial.submit("/new");
+    if (key.ctrl && key.name === "o") return void serial.submit("/sessions");
+    if (key.name === "escape") {
+      if (state.popup) {
+        state.popup = null;
+        state.popupDismissed = editor.currentLine;
+      } else if (!viewport.follow) viewport.end();
+      return schedule();
+    }
+    if (state.popup) {
+      if (key.name === "up") return state.popup.move(-1), schedule();
+      if (key.name === "down") return state.popup.move(1), schedule();
+      if (key.name === "tab" || key.name === "return" && !key.shift && !key.ctrl) return acceptPopup();
+    }
+    if (key.name === "tab") {
+      const completed = complete(editor.currentLine, runtime);
+      if (completed !== null) editor.setCurrentLine(completed);
+      refreshPopup();
+      return schedule();
+    }
+    const outcome = editor.apply(key);
+    if (outcome === "unhandled") {
+      if (key.name === "return") return submit();
+      if (key.name === "up" || key.name === "down") {
+        const line = key.name === "up" ? history.up(editor.text) : history.down();
+        if (line !== null) {
+          editor.setText(line);
+          refreshPopup();
+          schedule();
+        }
+      }
+      return;
+    }
+    if (outcome === "text") refreshPopup();
+    if (outcome !== "same") schedule();
+  }
+  function interrupt() {
+    if (state.approval) {
+      answerApproval(false);
+    }
+    if (state.abort) {
+      state.abort.abort();
+      state.abort = null;
+      note(paint.dim("  stopped."));
+      unqueue();
+      return;
+    }
+    if (serial.busy && serial.queued.length) {
+      unqueue();
+      notice("the queue is back in the box; ctrl+c again stops waiting for the command", 2500);
+      return;
+    }
+    if (serial.busy) {
+      serial.release();
+      setBusy(null);
+      note(paint.dim("  stopped waiting. The command may still finish in the background."));
+      return;
+    }
+    if (state.dialog) {
+      closeDialog();
+      return schedule();
+    }
+    if (!editor.isEmpty) {
+      editor.reset();
+      state.popup = null;
+      return schedule();
+    }
+    const now = Date.now();
+    if (now - state.ctrlCAt < QUIT_WINDOW_MS) return quit();
+    state.ctrlCAt = now;
+    notice("press ctrl+c again to quit");
+  }
+  function answerApproval(ok) {
+    const approval = state.approval;
+    if (!approval) return;
+    state.approval = null;
+    approval.entry.block.answer = ok ? "allowed" : "declined";
+    transcript.touch(approval.entry);
+    approval.resolve(ok);
+    schedule();
+  }
+  function refreshPopup() {
+    const line = editor.currentLine;
+    if (state.popupDismissed !== null && state.popupDismissed === line) return;
+    state.popupDismissed = null;
+    if (line.startsWith("/") && !/\s/.test(line)) {
+      if (classify(line, runtime.extensions.commands.keys()).state !== "partial") {
+        state.popup = null;
+        return;
+      }
+      const items = matching(line, runtime.extensions.commands.keys()).map((c) => ({
+        label: `/${c.name}`,
+        what: c.what,
+        value: `/${c.name} `
+      }));
+      state.popup = items.length ? new Popup("command", items) : null;
+      return;
+    }
+    const tag = fileTag(line);
+    if (tag) {
+      const hits = rankPaths(tag.partial, listFiles(runtime.root), 8);
+      state.popup = hits.length ? new Popup(
+        "file",
+        hits.map((path) => ({ label: path, value: `${line.slice(0, tag.at)}@${path} ` }))
+      ) : null;
+      return;
+    }
+    state.popup = null;
+  }
+  function acceptPopup() {
+    const item = state.popup?.current;
+    state.popup = null;
+    if (item) editor.setCurrentLine(item.value);
+    schedule();
+  }
+  function submit() {
+    const text = editor.text.trim();
+    if (!text) return;
+    history.add(text);
+    editor.reset();
+    state.popup = null;
+    viewport.end();
+    serial.submit(text);
+    schedule();
+  }
+  async function command(text) {
+    setBusy(`running ${text.split(/\s+/)[0]}`);
+    try {
+      await runCommand2(text);
+    } finally {
+      setBusy(null);
+    }
+  }
+  function closeDialog() {
+    state.dialog = null;
+    serial.drain();
+  }
+  function unqueue() {
+    const queued = serial.take();
+    if (!queued.length) return;
+    editor.setText([...queued, editor.text].filter(Boolean).join("\n"));
+    state.popup = null;
+  }
+  function queuedLines(width) {
+    const shown = serial.queued.slice(0, MAX_QUEUED_SHOWN);
+    const lines = shown.map((text) => fit(`  ${paint.dim("queued")} ${paint.muted(text.split("\n")[0] ?? "")}`, width));
+    const more = serial.queued.length - shown.length;
+    if (more > 0) lines.push(paint.dim(`         and ${more} more`));
+    return lines;
+  }
+  async function runCommand2(input) {
+    transcript.add({ kind: "user", text: input });
+    const [rawName = ""] = input.replace(/^\//, "").split(/\s+/);
+    const name = rawName === "?" || rawName === "" ? "help" : rawName.toLowerCase();
+    switch (name) {
+      case "help":
+        state.dialog = info("help", helpLines());
+        return schedule();
+      case "sessions":
+        return openSessions();
+      case "tree":
+        return openTree();
+      case "sidebar":
+        state.sidebar = !state.sidebar;
+        if (state.sidebar) refreshProjectFacts();
+        note(paint.muted(state.sidebar ? "  side panel on. It needs 120 columns to show." : "  side panel off."));
+        return;
+      case "clear":
+        transcript.clear();
+        state.toolBlocks.clear();
+        state.answer = null;
+        return schedule();
+      case "new":
+        return newSession();
+      default:
+        break;
+    }
+    const outcome = await handleCommand(input, {
+      runtime,
+      mode: state.mode,
+      effort: state.effort,
+      asked: state.asked,
+      print: (text) => note(text)
+    });
+    if (outcome.farewell) state.farewell = outcome.farewell;
+    if (outcome.exit) return quit();
+    if (outcome.mode) state.mode = outcome.mode;
+    if (outcome.effort !== void 0) state.effort = outcome.effort;
+    schedule();
+  }
+  function helpLines() {
+    const rows = BUILTIN_COMMANDS.map((c) => [`/${c.name}${c.args ? ` ${c.args}` : ""}`, c.what]);
+    for (const [cmd, command2] of runtime.extensions.commands) rows.push([`/${cmd}`, `${command2.describe} ${paint.dim("(extension)")}`]);
+    const width = Math.max(...rows.map(([n]) => n.length));
+    const keys = [
+      ["enter", "send"],
+      ["shift+enter, ctrl+j, or a trailing \\", "new line"],
+      ["/ and @", "commands and files, with a list"],
+      ["tab", "complete"],
+      ["pgup / pgdn, wheel", "scroll the transcript"],
+      ["home / end", "top / bottom (with an empty box)"],
+      ["esc", "close a list or dialog; jump back to the bottom"],
+      ["ctrl+c", "stop the answer; clear the box; twice to quit"],
+      ["ctrl+d", "quit"],
+      ["ctrl+n / ctrl+o", "new session / earlier sessions"],
+      ["ctrl+l", "redraw"]
+    ];
+    const kwidth = Math.max(...keys.map(([k]) => k.length));
+    return [
+      paint.bold("commands"),
+      ...rows.map(([n, w]) => `${paint.accent(n.padEnd(width))}  ${paint.muted(w)}`),
+      "",
+      paint.bold("keys"),
+      ...keys.map(([k, w]) => `${paint.accent(k.padEnd(kwidth))}  ${paint.muted(w)}`),
+      "",
+      paint.dim("@path tags a file into the question. --plain runs the older print-style session.")
+    ];
+  }
+  function openSessions() {
+    const all = Session.list(dirname4(runtime.session.file));
+    if (!all.length) return note(paint.muted("  no earlier sessions in this project"));
+    state.dialog = pick(
+      "sessions - enter resumes one",
+      all.map((s) => ({
+        id: s.file,
+        label: `${s.id === runtime.session.id ? "> " : "  "}${sessionTitle(s)}`,
+        hint: `${s.id.slice(0, 8)}  ${new Date(s.at).toLocaleString()}  ${s.messages} nodes`
+      })),
+      (item) => {
+        if (!serial.run(() => switchSession(item.id))) notice("labd is still working - pick again when it is done", 2500);
+      }
+    );
+    schedule();
+  }
+  function openTree() {
+    const nodes = runtime.session.all();
+    if (!nodes.length) return note(paint.muted("  nothing in this session yet"));
+    const head = runtime.session.headId;
+    state.dialog = pick(
+      "this session - enter continues from a point",
+      nodes.map((n) => ({
+        id: n.id,
+        label: `${n.id === head ? "> " : "  "}${n.id.slice(0, 8)} ${n.body.kind.padEnd(9)}`,
+        hint: summarise2(n.body)
+      })),
+      (item) => {
+        if (!serial.run(() => runCommand2(`/resume ${item.id.slice(0, 8)}`))) notice("labd is still working - pick again when it is done", 2500);
+      }
+    );
+    schedule();
+  }
+  async function switchSession(file) {
+    const current = runtime.session;
+    if (Session.list(dirname4(current.file)).find((s) => s.file === file)?.id === current.id) {
+      return note(paint.muted("  that is this session."));
+    }
+    if (state.asked) await closeConversation(runtime);
+    runtime.session = Session.open(file);
+    state.asked = false;
+    transcript.clear();
+    state.toolBlocks.clear();
+    state.answer = null;
+    replay();
+    note(paint.muted(`  resumed ${runtime.session.id.slice(0, 8)}.`));
+  }
+  async function newSession() {
+    if (state.asked) await closeConversation(runtime);
+    runtime.session = Session.create(bucketFor(runtime.stateDir, runtime.root));
+    state.asked = false;
+    transcript.clear();
+    state.toolBlocks.clear();
+    state.answer = null;
+    note(paint.muted(`  new session ${runtime.session.id.slice(0, 8)}. The previous one is saved; /sessions lists it.`));
+  }
+  function replay() {
+    for (const m of runtime.session.wire()) {
+      if (m.role === "user" && m.text) transcript.add({ kind: "user", text: m.text });
+      else if (m.role === "assistant" && m.text) transcript.add({ kind: "assistant", text: m.text, done: true });
+    }
+  }
+  async function ask(input) {
+    transcript.add({ kind: "user", text: input });
+    state.asked = true;
+    state.answer = null;
+    const tags = taggedPaths(input);
+    const attachments = tags.length ? attachTagged(runtime.root, tags) : void 0;
+    for (const refused of attachments?.filter((a) => a.omitted) ?? []) {
+      note(`  ${paint.yellow("!")} ${paint.muted(`${refused.path}: ${refused.omitted}`)}`);
+    }
+    for (const handler of runtime.extensions.onTurn) {
+      try {
+        handler({ question: input });
+      } catch {
+      }
+    }
+    const abort = new AbortController();
+    state.abort = abort;
+    const ui = {
+      text(chunk) {
+        if (!state.answer || state.answer.block.done) {
+          state.answer = transcript.add({ kind: "assistant", text: "", done: false });
+        }
+        state.answer.block.text += chunk;
+        transcript.touch(state.answer);
+        schedule();
+      },
+      status(what) {
+        setBusy(what);
+      },
+      tool(step) {
+        for (const handler of runtime.extensions.onTool) {
+          try {
+            handler(step);
+          } catch {
+          }
+        }
+        closeAnswer();
+        let entry = state.toolBlocks.get(step.call.id);
+        if (!entry) {
+          entry = transcript.add({
+            kind: "tool",
+            name: step.call.name,
+            detail: detail(step),
+            status: step.status,
+            input: verbatim(step.call) || void 0,
+            live: []
+          });
+          state.toolBlocks.set(step.call.id, entry);
+        }
+        entry.block.status = step.status;
+        if (step.status !== "running" && step.status !== "awaiting") {
+          entry.block.output = step.output ?? step.detail;
+          remember(`${label(step)}`.trim());
+        }
+        transcript.touch(entry);
+        if (step.status === "running" || step.status === "awaiting") setBusy(label(step));
+        schedule();
+      },
+      approve(call, preview) {
+        setBusy(null);
+        closeAnswer();
+        const entry = transcript.add({ kind: "approval", call, preview, mode: state.mode, answer: null });
+        viewport.end();
+        return new Promise((resolve2) => {
+          state.approval = { entry, resolve: resolve2 };
+          schedule();
+        });
+      },
+      error(message) {
+        setBusy(null);
+        transcript.add({ kind: "error", text: message });
+        schedule();
+      },
+      done(info2) {
+        if (info2.context) state.context = info2.context;
+        if (info2.credits) state.credits = info2.credits;
+        schedule();
+      },
+      commandOutput(line) {
+        let target;
+        for (const entry of state.toolBlocks.values()) {
+          if (entry.block.name === "run_command" && entry.block.status === "running") target = entry;
+        }
+        if (!target) return;
+        target.block.live.push(...line.replace(/\n$/, "").split("\n"));
+        transcript.touch(target);
+        schedule();
+      }
+    };
+    setBusy("thinking");
+    try {
+      const turn = await runTurn(input, {
+        session: runtime.session,
+        client: runtime.client,
+        root: runtime.root,
+        mode: state.mode,
+        checkpoints: runtime.checkpoints,
+        effort: state.effort,
+        attachments,
+        commandTimeoutMs: runtime.settings.commandTimeoutSeconds * 1e3,
+        ui,
+        signal: abort.signal
+      });
+      closeAnswer();
+      if (turn.wrote.length && runtime.checkpoints) {
+        note(paint.dim(`  ${turn.wrote.length} file${turn.wrote.length === 1 ? "" : "s"} changed. /undo puts this answer back.`));
+      }
+      if (state.sidebar) refreshProjectFacts();
+      if (!abort.signal.aborted && state.context && state.context.percentUsed >= COMPACT_AT) {
+        setBusy("summarising, to make room");
+        const ok = await compact({ session: runtime.session, client: runtime.client, root: runtime.root });
+        if (ok) transcript.add({ kind: "compaction" });
+        else note(paint.dim("  (could not summarise; carrying on)"));
+      }
+    } catch (err) {
+      transcript.add({ kind: "error", text: err instanceof Error ? err.message : String(err) });
+    } finally {
+      if (state.abort === abort) state.abort = null;
+      if (state.approval) answerApproval(false);
+      setBusy(null);
+    }
+  }
+  function closeAnswer() {
+    const answer = state.answer;
+    if (!answer || answer.block.done) return;
+    answer.block.done = true;
+    transcript.touch(answer);
+  }
+  function remember(step) {
+    state.lastSteps.push(step);
+    if (state.lastSteps.length > 5) state.lastSteps.shift();
+  }
+  function refreshProjectFacts() {
+    try {
+      const out = execFileSync3("git", ["status", "--porcelain"], {
+        cwd: runtime.root,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2e3
+      });
+      state.dirty = out.split("\n").filter(Boolean).length;
+    } catch {
+      state.dirty = null;
+    }
+    try {
+      const ctx = buildContext(runtime.root).editor;
+      state.conventions = ctx?.instructions?.length ?? 0;
+      state.skills = ctx?.skills?.length ?? 0;
+    } catch {
+    }
+  }
+  screen.on("keys", onKeys);
+  screen.on("resize", schedule);
+  screen.on("end", quit);
+  const onSignal = (code) => () => {
+    screen.leave();
+    process.exit(code);
+  };
+  const onTerm = onSignal(143);
+  const onInt = onSignal(130);
+  const onHup = onSignal(129);
+  process.on("SIGTERM", onTerm);
+  process.on("SIGINT", onInt);
+  process.on("SIGHUP", onHup);
+  screen.enter();
+  if (state.sidebar) refreshProjectFacts();
+  if (runtime.settings.ignoredProjectServerUrl) {
+    note(
+      `  ${paint.yellow("!")} ${paint.muted(
+        `ignoring serverUrl in .labd/settings.json (${runtime.settings.ignoredProjectServerUrl}) - this project isn't trusted; \`labd trust\` if you meant it`
+      )}`
+    );
+  }
+  for (const skipped of runtime.extensions.skipped) note(`  ${paint.yellow("!")} ${paint.muted(`extensions: ${skipped.why}`)}`);
+  replay();
+  let faceTimer = null;
+  if (faceFrames.length > 1) {
+    faceTimer = setInterval(() => {
+      state.faceIndex++;
+      if (state.faceIndex >= faceFrames.length - 1 && faceTimer) {
+        clearInterval(faceTimer);
+        faceTimer = null;
+      }
+      if (!transcript.length) schedule();
+    }, FACE_FRAME_MS);
+  }
+  if (opts.pickSession) openSessions();
+  draw();
+  try {
+    await exited;
+    if (serial.running) await Promise.race([serial.running, sleep3(1500)]);
+  } finally {
+    if (faceTimer) clearInterval(faceTimer);
+    if (frameTimer) clearTimeout(frameTimer);
+    setBusy(null);
+    process.off("SIGTERM", onTerm);
+    process.off("SIGINT", onInt);
+    process.off("SIGHUP", onHup);
+    screen.leave();
+  }
+  if (state.asked) {
+    process.stderr.write(paint.dim(`
+${FACE} session saved. Continue it with: labd --resume ${runtime.session.id.slice(0, 8)}
+`));
+    await closeConversation(runtime);
+  }
+  if (state.farewell) process.stderr.write(`${state.farewell}
+`);
+  return 0;
+}
+function borderColour2(s) {
+  switch (s) {
+    case "ok":
+      return paint.green;
+    case "unknown":
+      return paint.red;
+    case "partial":
+      return paint.cyan;
+    default:
+      return paint.dim;
+  }
+}
+function spread(left, right, width) {
+  const gap = width - visibleWidth(left) - visibleWidth(right);
+  if (gap >= 1) return `${left}${" ".repeat(gap)}${right}`;
+  const room = width - visibleWidth(right) - 1;
+  if (room < 8) return fit(left, width);
+  return `${fit(left, room)} ${right}`;
+}
+function centre(line, width) {
+  const pad4 = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
+  return `${" ".repeat(pad4)}${line}`;
+}
+function overlay(base, left, piece, width) {
+  const before = fit(base, left);
+  const after = sliceVisible(base, left + visibleWidth(piece));
+  return fit(`${before}${ESC6}[0m${piece}${ESC6}[0m${after}`, width);
+}
+function sliceVisible(line, from) {
+  let visible = 0;
+  let out = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === ESC6) {
+      const end = line.indexOf("m", i);
+      if (end === -1) break;
+      out += line.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    if (visible >= from) out += line[i];
+    visible++;
+    i++;
+  }
+  return out;
+}
+function summarise2(body2) {
+  const text = typeof body2.text === "string" ? body2.text : "";
+  if (body2.kind === "tool") {
+    const results = Array.isArray(body2.results) ? body2.results.length : 0;
+    return `${results} result(s)`;
+  }
+  return text.replace(/\s+/g, " ").slice(0, 60);
+}
+function sleep3(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // packages/cli/src/modes/print.ts
@@ -3796,8 +5655,8 @@ async function runPrint(runtime, opts) {
       else toStderr(`${paint.red("labd:")} ${message}
 `);
     },
-    done(info) {
-      if (opts.json) emit({ type: "done", credits: info.credits, context: info.context });
+    done(info2) {
+      if (opts.json) emit({ type: "done", credits: info2.credits, context: info2.context });
     },
     commandOutput(line) {
       if (opts.json) emit({ type: "command_output", line });
@@ -3854,10 +5713,10 @@ async function runRpc(runtime) {
   process.stdin.setEncoding("utf8");
   process.stdin.on("data", (chunk) => {
     buffer += chunk;
-    let at;
-    while ((at = buffer.indexOf("\n")) !== -1) {
-      const line = buffer.slice(0, at);
-      buffer = buffer.slice(at + 1);
+    let at2;
+    while ((at2 = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, at2);
+      buffer = buffer.slice(at2 + 1);
       if (line.trim()) void handle(line);
     }
   });
@@ -3954,8 +5813,8 @@ async function runRpc(runtime) {
       error(message) {
         notify("labd/error", { message });
       },
-      done(info) {
-        notify("labd/done", info);
+      done(info2) {
+        notify("labd/done", info2);
       },
       commandOutput(line) {
         notify("labd/command_output", { line });
@@ -4007,7 +5866,7 @@ async function runRpc(runtime) {
 }
 
 // packages/cli/src/index.ts
-var VERSION = true ? "0.3.1" : "0.0.0-dev";
+var VERSION = true ? "0.5.0" : "0.0.0-dev";
 async function main(argv) {
   const args = parse(argv);
   if (args.color !== void 0) setColor(args.color);
@@ -4033,11 +5892,16 @@ async function main(argv) {
     default:
       break;
   }
+  const screenCapable = !args.rpc && !args.print && !args.question && !args.plain && process.stdin.isTTY && process.stdout.isTTY;
+  if (args.pickSession && !screenCapable) {
+    throw new UsageError("--resume with no id opens a list, which needs the full-screen session. `labd sessions` prints the ids for `labd --resume <id>`.");
+  }
   const runtime = await createRuntime({
     root,
     overrides: {
       ...args.mode ? { mode: args.mode } : {},
-      ...args.effort ? { effort: args.effort } : {}
+      ...args.effort ? { effort: args.effort } : {},
+      ...args.mouse !== void 0 ? { mouse: args.mouse } : {}
     },
     resume: args.resume ? resolveSession(args.resume, root) : args.continue ? latestSession(root) : void 0,
     extensions: { enabled: !args.noExtensions, extra: args.extensions }
@@ -4058,7 +5922,8 @@ async function main(argv) {
 `);
     return 1;
   }
-  return runInteractive(runtime);
+  if (args.plain) return runInteractive(runtime);
+  return runScreen(runtime, { mouse: runtime.settings.mouse, sidebar: runtime.settings.sidebar, pickSession: args.pickSession });
 }
 async function login(root) {
   const settings = loadSettings(root, {}, { trusted: isTrusted(stateDir(), root) });
@@ -4093,9 +5958,11 @@ ${paint.red("labd:")} ${result.reason ?? "that did not complete"}.
 }
 async function logout(root) {
   const settings = loadSettings(root, {}, { trusted: isTrusted(stateDir(), root) });
-  await new Auth(stateDir(), settings.serverUrl).signOut();
-  process.stderr.write(`  ${paint.muted("disconnected, and the stored token is gone")}
+  const hadStored = await new Auth(stateDir(), settings.serverUrl).signOut();
+  for (const line of signedOutMessage(hadStored, Boolean(process.env.LABD_TOKEN)).split("\n")) {
+    process.stderr.write(`  ${paint.muted(line)}
 `);
+  }
   return 0;
 }
 function listSessions(root) {
@@ -4108,7 +5975,7 @@ function listSessions(root) {
   }
   for (const s of all.slice(0, 25)) {
     process.stdout.write(
-      `  ${paint.dim(s.id.slice(0, 8))}  ${paint.muted(new Date(s.at).toLocaleString())}  ${paint.muted(`${s.messages} nodes`)} ${s.name ?? ""}
+      `  ${paint.dim(s.id.slice(0, 8))}  ${paint.muted(new Date(s.at).toLocaleString())}  ${paint.muted(`${s.messages} nodes`)} ${sessionTitle(s)}
 `
     );
   }
@@ -4140,11 +6007,13 @@ function parse(argv) {
     print: false,
     json: false,
     rpc: false,
+    pickSession: false,
     continue: false,
     noExtensions: false,
     extensions: [],
     help: false,
-    version: false
+    version: false,
+    plain: false
   };
   const words = [];
   for (let i = 0; i < argv.length; i++) {
@@ -4170,10 +6039,14 @@ function parse(argv) {
         out.effort = value;
         break;
       }
+      case "-r":
       case "--resume": {
-        const value = next();
-        if (!value) throw new UsageError("--resume needs a session id");
-        out.resume = value;
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) {
+          out.pickSession = true;
+          break;
+        }
+        out.resume = next();
         break;
       }
       case "-c":
@@ -4203,6 +6076,12 @@ function parse(argv) {
       case "--color":
         out.color = true;
         break;
+      case "--plain":
+        out.plain = true;
+        break;
+      case "--no-mouse":
+        out.mouse = false;
+        break;
       case "-h":
       case "--help":
         out.help = true;
@@ -4227,6 +6106,9 @@ function parse(argv) {
   } else {
     out.question = words.join(" ");
   }
+  if ((out.resume || out.pickSession) && out.continue) {
+    throw new UsageError("--resume and --continue both choose a session - pass one of them");
+  }
   return out;
 }
 function applyMode(out, value) {
@@ -4246,7 +6128,7 @@ function usage() {
 ${paint.accent(FACE)} ${paint.bold("labd")} - the Dev Labs assistant, in your terminal
 
 ${paint.bold("USAGE")}
-  labd                        start a session in this project
+  labd                        start a session in this project (full-screen)
   labd "why is this failing"  ask one question and exit
   labd -p "..." | pbcopy      print mode, for pipes and scripts
   cat log | labd -p "why?"    piped input is added to the question
@@ -4262,12 +6144,15 @@ ${paint.bold("OPTIONS")}
       --json                  emit newline-delimited JSON events
       --mode <m>              ${AGENT_MODES.join(" | ")}   (or rpc, for JSON-RPC over stdio)
       --think <low|medium|high>
-      --resume <id>           continue an earlier session
+  -r, --resume [id]           continue an earlier session; with no id, pick one from a list
   -c, --continue              continue the most recent session here
   -C, --cwd <dir>             run as though started in <dir>
   -e, --extension <path>      load an extension file (repeatable)
       --no-extensions         load none
       --no-color              plain text (also honours NO_COLOR)
+      --no-mouse              leave the mouse to the terminal: the session takes it for
+                              wheel scrolling, and native text selection needs it released
+      --plain                 the older print-style session (deprecated; removed in 0.5)
   -h, --help    -v, --version
 
 ${paint.bold("MODES")}