@thedevlabs-io/labd 0.3.1 → 0.6.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;
 }
@@ -433,6 +433,36 @@ var EXEC_TOOLS = ["run_command"];
 function isExecTool(name) {
   return EXEC_TOOLS.includes(name);
 }
+var AGENT_TOOLS = ["spawn_agent"];
+function isAgentTool(name) {
+  return AGENT_TOOLS.includes(name);
+}
+var MAX_SUBAGENTS = 3;
+var SUBAGENT_REPORT_CHARS = 8e3;
+function subAgentCapabilities(parent) {
+  return parent.filter((c) => !isAgentTool(c));
+}
+function subAgentConversationId(parentId, callId) {
+  return parentId ? `${parentId}~helper~${callId}` : void 0;
+}
+function subAgentBrief(task) {
+  return `You are working as a helper for labd, the assistant the learner is talking to. It has handed you one piece of a larger job and is waiting on your report. The learner is the same person, in the same project, under the same rules: the same tools, the same approvals, and the same things you will not do.
+
+Your task:
+
+${task.trim()}
+
+How to work:
+- You start with none of the parent conversation, so the task above is all you know about it. If it is not enough to act on, say what is missing in your report rather than guessing at the intent.
+- Do the task, and only the task. The parent decides what happens next, so do not widen the job, and do not ask the learner questions - your report goes to the parent, not to them.
+- If a write or command you need is declined, do not look for another way round it. Stop and say so.
+- End with a report the parent can act on without redoing your work: what you found or changed, file by file and with line numbers where they matter, and anything you could not finish and why. Keep it tight. Leave out how you went about it.`;
+}
+function subAgentReport(text) {
+  const clean = text.trim() || "The helper finished without a report.";
+  return clean.length <= SUBAGENT_REPORT_CHARS ? clean : `${clean.slice(0, SUBAGENT_REPORT_CHARS)}
+... the helper's report was longer than this and was trimmed.`;
+}
 var AGENT_MODES = ["ask", "auto", "agent"];
 var DEFAULT_AGENT_MODE = "auto";
 function toAgentMode(raw) {
@@ -454,8 +484,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 +708,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 +784,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 +799,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 +846,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();
   }
@@ -1305,6 +1349,154 @@ function trim(output) {
   ].join("");
 }
 
+// packages/core/src/calls.ts
+var TOOL_OUTPUT_KEPT = 8e3;
+function keepOutput(text) {
+  const clean = text.replace(/\s+$/, "");
+  return clean.length <= TOOL_OUTPUT_KEPT ? clean : `${clean.slice(0, TOOL_OUTPUT_KEPT)}
+\u2026 trimmed here.`;
+}
+async function executeCall(call, env) {
+  let preview;
+  if (isWriteTool(call.name) || isExecTool(call.name)) {
+    try {
+      preview = previewTool(call, env.toolCtx);
+      env.step({ status: "running", preview });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      env.step({ status: "error", detail: message });
+      return { id: call.id, content: message, isError: true };
+    }
+  } else {
+    env.step({ status: "running" });
+  }
+  if (needsApproval(env.mode, call)) {
+    env.step({ status: "awaiting", preview });
+    const ok = env.approve ? await env.approve(call, preview) : false;
+    if (env.signal.aborted) return "aborted";
+    if (!ok) {
+      env.step({ status: "skipped", preview });
+      return {
+        id: call.id,
+        content: env.approve ? "The learner declined this, so nothing was done. Do not retry it. Explain what you would have done and why, and let them decide what to do next." : "This needed the learner to approve it and labd is running unattended, so nothing was done. Say what you would have done; do not try another way round it."
+      };
+    }
+  }
+  if (env.signal.aborted) return "aborted";
+  try {
+    const content = await runTool(call, env.toolCtx);
+    if (isWriteTool(call.name)) {
+      const input = call.input;
+      env.wrote(String(input.path ?? input.from ?? ""));
+    }
+    if (isExecTool(call.name)) env.ran(String(call.input.command ?? ""));
+    env.step({ status: isWriteTool(call.name) ? "applied" : "done", preview, output: keepOutput(content) });
+    return { id: call.id, content };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    env.step({ status: "error", preview, detail: message });
+    return { id: call.id, content: message, isError: true };
+  }
+}
+
+// packages/core/src/helper.ts
+var STALL_ROUNDS = 3;
+var LABEL_MAX = 80;
+function helperLabel(call) {
+  const description = call.input.description;
+  const text = typeof description === "string" ? description.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim() : "";
+  return text ? text.length > LABEL_MAX ? `${text.slice(0, LABEL_MAX - 1)}\u2026` : text : "helper";
+}
+async function runHelper(call, env) {
+  const task = call.input.task;
+  if (typeof task !== "string" || !task.trim()) {
+    return { id: call.id, content: "spawn_agent needs a `task`: the complete brief for the helper.", isError: true };
+  }
+  const label2 = helperLabel(call);
+  const helper = { id: call.id, label: label2 };
+  const ask = env.approve;
+  const capabilities = subAgentCapabilities(env.capabilities);
+  const conversationId = subAgentConversationId(env.sessionId, call.id);
+  let wire = [{ role: "user", text: subAgentBrief(task) }];
+  let report = "";
+  const asked = /* @__PURE__ */ new Set();
+  let stalled = 0;
+  for (; ; ) {
+    let text = "";
+    const calls = [];
+    let needTools = false;
+    let failure = null;
+    const stream = env.client.stream(
+      {
+        protocol: PROTOCOL_VERSION,
+        messages: wire,
+        context: buildContext(env.root),
+        capabilities,
+        ...conversationId ? { conversationId } : {},
+        ...env.effort ? { effort: env.effort } : {}
+      },
+      env.signal
+    );
+    for await (const event of stream) {
+      if (env.signal.aborted) break;
+      if (event.type === "text") text += event.text;
+      else if (event.type === "tool_call") calls.push(event.call);
+      else if (event.type === "need_tools") needTools = true;
+      else if (event.type === "error") failure = event.message;
+    }
+    if (env.signal.aborted) return "aborted";
+    if (failure) {
+      const sofar = report ? `
+
+What it had reported before that:
+${subAgentReport(report)}` : "";
+      return { id: call.id, content: `The helper stopped: ${failure}${sofar}`, isError: true };
+    }
+    wire = [...wire, { role: "assistant", text, ...calls.length ? { toolCalls: calls } : {} }];
+    if (text.trim()) report = text;
+    if (!needTools || !calls.length) break;
+    const fresh = calls.some((c) => {
+      if (isWriteTool(c.name) || isExecTool(c.name)) return true;
+      const key = `${c.name}:${JSON.stringify(c.input)}`;
+      if (asked.has(key)) return false;
+      asked.add(key);
+      return true;
+    });
+    stalled = fresh ? 0 : stalled + 1;
+    if (stalled >= STALL_ROUNDS) {
+      report = `${report}
+
+(The helper kept asking for what it had already read, so it was stopped.)`.trim();
+      break;
+    }
+    const results = [];
+    for (const c of calls) {
+      if (env.signal.aborted) return "aborted";
+      if (isAgentTool(c.name)) {
+        results.push({ id: c.id, content: "A helper cannot start helpers of its own. Do this part yourself.", isError: true });
+        continue;
+      }
+      const outcome = await executeCall(c, {
+        mode: env.mode(),
+        // Routed to this call's row: two helpers can run commands at once.
+        toolCtx: { ...env.toolCtx, onCommandOutput: (line) => env.toolCtx.onCommandOutput?.(line, `${call.id}/${c.id}`) },
+        signal: env.signal,
+        approve: ask ? (pending, preview) => ask(pending, preview, label2) : void 0,
+        step: (s) => env.step({ ...s, call: c, helper }),
+        wrote: env.wrote,
+        ran: env.ran
+      });
+      if (outcome === "aborted") {
+        env.step({ call: c, helper, status: "skipped", detail: "Stopped." });
+        return "aborted";
+      }
+      results.push(outcome);
+    }
+    wire = [...wire, { role: "tool", results }];
+  }
+  return { id: call.id, content: subAgentReport(report) };
+}
+
 // packages/core/src/agent.ts
 var CLI_CAPABILITIES = [
   "read_file",
@@ -1314,18 +1506,15 @@ var CLI_CAPABILITIES = [
   "create_file",
   "move_file",
   "delete_file",
-  "run_command"
+  "run_command",
+  // Helpers run here, in this process, on the same rules - see helper.ts.
+  "spawn_agent"
 ];
-var TOOL_OUTPUT_KEPT = 8e3;
-function keepOutput(text) {
-  const clean = text.replace(/\s+$/, "");
-  return clean.length <= TOOL_OUTPUT_KEPT ? clean : `${clean.slice(0, TOOL_OUTPUT_KEPT)}
-\u2026 trimmed here.`;
-}
-var STALL_ROUNDS = 3;
+var STALL_ROUNDS2 = 3;
 var COMPACT_AT = 75;
 async function runTurn(question, opts) {
-  const { session, client, ui, mode } = opts;
+  const { session, client, ui } = opts;
+  const modeNow = () => opts.currentMode?.() ?? opts.mode;
   const turnId = randomUUID2();
   const controller = new AbortController();
   opts.signal?.addEventListener("abort", () => controller.abort(), { once: true });
@@ -1334,10 +1523,17 @@ async function runTurn(question, opts) {
     checkpoints: opts.checkpoints,
     turn: { sessionId: session.id, turnId },
     commandTimeoutMs: opts.commandTimeoutMs ?? 12e4,
-    onCommandOutput: (line) => ui.commandOutput?.(line)
+    onCommandOutput: (line2, key) => ui.commandOutput?.(line2, key)
   };
   session.add({ kind: "user", text: question, ...opts.attachments?.length ? { attachments: opts.attachments.map((a) => ({ path: a.path })) } : {} }, turnId);
   const result = { text: "", turnId, wrote: [], ran: [], aborted: false };
+  const ask = ui.approve;
+  let line = Promise.resolve();
+  const approve = ask ? (call, preview, helper) => {
+    const answer = line.then(() => controller.signal.aborted ? false : ask(call, preview, helper));
+    line = answer.catch(() => void 0);
+    return answer;
+  } : void 0;
   const asked = /* @__PURE__ */ new Set();
   let stalled = 0;
   for (let round = 0; ; round++) {
@@ -1416,20 +1612,79 @@ async function runTurn(question, opts) {
       return true;
     });
     stalled = fresh ? 0 : stalled + 1;
-    if (stalled >= STALL_ROUNDS) {
+    if (stalled >= STALL_ROUNDS2) {
       ui.error(
         `labd asked for the same things ${stalled} rounds running, so it stopped rather than keep going round. Tell it which file to start in, or ask for a narrower piece of this.`
       );
       session.add({ kind: "tool", results: calls.map((c) => stopped(c, "error", "Stopped: labd was repeating itself.")) }, turnId);
       return result;
     }
-    const results = [];
-    for (const call of calls) {
-      if (controller.signal.aborted) {
-        results.push(stopped(call));
-        continue;
+    const results = new Array(calls.length);
+    const working = [];
+    try {
+      let helpers = 0;
+      calls.forEach((call, at2) => {
+        if (!isAgentTool(call.name)) return;
+        const label2 = helperLabel(call);
+        if (helpers++ >= MAX_SUBAGENTS) {
+          const why = `Only ${MAX_SUBAGENTS} helpers can run at once, so this one was not started. Do it yourself, or start it once the others have reported.`;
+          ui.tool({ call, status: "error", detail: why });
+          results[at2] = { id: call.id, content: why, isError: true };
+          return;
+        }
+        ui.tool({ call, status: "running", detail: label2 });
+        working.push(
+          runHelper(call, {
+            client,
+            root: opts.root,
+            mode: modeNow,
+            effort: opts.effort,
+            capabilities: CLI_CAPABILITIES,
+            sessionId: session.id,
+            toolCtx,
+            signal: controller.signal,
+            approve,
+            step: (step) => ui.tool(step),
+            wrote: (path) => result.wrote.push(path),
+            ran: (command) => result.ran.push(command)
+          }).catch((err) => ({
+            id: call.id,
+            content: `The helper failed: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          })).then((outcome) => {
+            if (outcome === "aborted") {
+              results[at2] = stopped(call);
+              return;
+            }
+            results[at2] = outcome;
+            ui.tool({ call, status: outcome.isError ? "error" : "done", detail: label2, output: keepOutput(outcome.content) });
+          })
+        );
+      });
+      for (const [at2, call] of calls.entries()) {
+        if (isAgentTool(call.name)) continue;
+        if (controller.signal.aborted) {
+          results[at2] = stopped(call);
+          continue;
+        }
+        const outcome = await executeCall(call, {
+          mode: modeNow(),
+          // Output names its row, so it cannot land in a helper's command
+          // running at the same moment.
+          toolCtx: { ...toolCtx, onCommandOutput: (line2) => ui.commandOutput?.(line2, call.id) },
+          signal: controller.signal,
+          approve,
+          step: (step) => ui.tool({ ...step, call }),
+          wrote: (path) => result.wrote.push(path),
+          ran: (command) => result.ran.push(command)
+        });
+        results[at2] = outcome === "aborted" ? stopped(call) : outcome;
       }
-      results.push(await runOne(call));
+      await Promise.all(working);
+    } catch (err) {
+      controller.abort();
+      await Promise.allSettled(working);
+      throw err;
     }
     session.add({ kind: "tool", results }, turnId);
     if (controller.signal.aborted) {
@@ -1441,52 +1696,6 @@ async function runTurn(question, opts) {
     ui.tool({ call, status, detail: why });
     return { id: call.id, content: why, isError: true };
   }
-  async function runOne(call) {
-    let preview;
-    if (isWriteTool(call.name) || isExecTool(call.name)) {
-      try {
-        preview = previewTool(call, toolCtx);
-        ui.tool({ call, status: "running", preview });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        ui.tool({ call, status: "error", detail: message });
-        return { id: call.id, content: message, isError: true };
-      }
-    } else {
-      ui.tool({ call, status: "running" });
-    }
-    if (needsApproval(mode, call)) {
-      ui.tool({ call, status: "awaiting", preview });
-      const ok = ui.approve ? await ui.approve(call, preview) : false;
-      if (controller.signal.aborted) return stopped(call);
-      if (!ok) {
-        ui.tool({ call, status: "skipped", preview });
-        return {
-          id: call.id,
-          content: ui.approve ? "The learner declined this, so nothing was done. Do not retry it. Explain what you would have done and why, and let them decide what to do next." : "This needed the learner to approve it and labd is running unattended, so nothing was done. Say what you would have done; do not try another way round it."
-        };
-      }
-    }
-    try {
-      const content = await runTool(call, toolCtx);
-      if (isWriteTool(call.name)) {
-        const input = call.input;
-        result.wrote.push(String(input.path ?? input.from ?? ""));
-      }
-      if (isExecTool(call.name)) result.ran.push(String(call.input.command ?? ""));
-      ui.tool({
-        call,
-        status: isWriteTool(call.name) ? "applied" : "done",
-        preview,
-        output: keepOutput(content)
-      });
-      return { id: call.id, content };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      ui.tool({ call, status: "error", preview, detail: message });
-      return { id: call.id, content: message, isError: true };
-    }
-  }
 }
 async function compact(opts) {
   const controller = new AbortController();
@@ -1884,9 +2093,16 @@ function setColor(value) {
   on = value;
 }
 var wrap = (open, close = "0") => (text) => on ? `${ESC}[${open}m${text}${ESC}[${close}m` : text;
+function lightBackground() {
+  const bg = Number(process.env.COLORFGBG?.split(";").at(-1));
+  return bg === 7 || bg === 15;
+}
 var paint = {
-  /** labd's accent. 214 is the nearest xterm cube entry to the brand orange. */
-  accent: wrap("38;5;214"),
+  /**
+   * labd's accent. 214 is the nearest xterm cube entry to the brand orange.
+   * Closes the foreground only, so it can sit inside a `band` without ending it.
+   */
+  accent: wrap("38;5;214", "39"),
   bold: wrap("1", "22"),
   dim: wrap("2", "22"),
   muted: wrap("90"),
@@ -1898,6 +2114,11 @@ var paint = {
   /** For the one place a background is worth it: the cursor cell in the box. */
   invert: wrap("7", "27")
 };
+function band(text, visible, width) {
+  if (!on) return text;
+  const bg = lightBackground() ? "48;5;254" : "48;5;236";
+  return `${ESC}[${bg}m${text}${" ".repeat(Math.max(0, width - visible))}${ESC}[49m`;
+}
 function stripColor(text) {
   return text.replace(new RegExp(`${ESC}\\[[0-9;]*m`, "g"), "");
 }
@@ -2059,7 +2280,8 @@ var LABELS = {
   create_file: "Create",
   move_file: "Move",
   delete_file: "Delete",
-  run_command: "Run"
+  run_command: "Run",
+  spawn_agent: "Helper"
 };
 function approvalCard(preview, call, mode, width) {
   const out = [""];
@@ -2147,21 +2369,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 +2420,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 +2472,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 +2552,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,148 +2621,1056 @@ 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)];
-}
-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("")
-        )
-      )
-    );
+// 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");
   }
-  frames.push(faceLines());
-  return frames;
-}
-
-// packages/tui/src/markdown.ts
-function renderMarkdown(text, opts) {
-  const lines = text.replace(/\r\n/g, "\n").split("\n");
-  const pad2 = opts.indent ?? "";
-  const out = [];
-  let inFence = false;
-  let fenceLang = "";
-  for (const line of lines) {
-    const fence = /^\s*```(\w*)/.exec(line);
-    if (fence) {
-      if (!inFence) {
-        inFence = true;
-        fenceLang = fence[1] ?? "";
-        out.push(paint.dim(`${pad2}${fenceLang || "code"}`));
-      } else {
-        inFence = false;
-        fenceLang = "";
-        out.push("");
+  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();
       }
-      continue;
+      return "unhandled";
     }
-    if (inFence) {
-      out.push(`${paint.dim(`${pad2}|`)} ${line}`);
-      continue;
+    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);
     }
-    out.push(...prose(line, opts.width, pad2));
+    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";
   }
-  return out.join("\n");
-}
-function prose(line, width, pad2) {
-  const heading = /^(#{1,6})\s+(.*)$/.exec(line);
-  if (heading) return [`${pad2}${paint.bold(paint.accent(heading[2]))}`];
-  if (/^\s*([-*_])\s*\1\s*\1[\s-*_]*$/.test(line)) {
-    return [`${pad2}${paint.dim("-".repeat(Math.min(width, 40)))}`];
+  /**
+   * 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 } };
   }
-  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]}  `);
+  moveTo(next) {
+    if (next === this.col) return "same";
+    this.col = next;
+    return "cursor";
   }
-  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]}   `);
+  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";
   }
-  const quote = /^\s*>\s?(.*)$/.exec(line);
-  if (quote) {
-    const gutter = `${pad2}${paint.dim("|")} `;
-    return wrap2(paint.muted(inline(quote[1])), width, gutter, gutter);
+  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";
   }
-  if (!line.trim()) return [""];
-  return wrap2(inline(line), width, pad2, pad2);
-}
-var HOLD = "\0";
-function inline(text) {
-  const code = [];
-  let held = text.replace(/`([^`]+)`/g, (_, body2) => {
-    code.push(body2);
-    return `${HOLD}${code.length - 1}${HOLD}`;
-  });
-  held = held.replace(/\*\*([^*]+)\*\*/g, (_, body2) => paint.bold(body2)).replace(/(^|[\s(])\*([^*]+)\*/g, (_, pre, body2) => `${pre}${paint.bold(body2)}`).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label2, href) => `${label2} ${paint.dim(`(${href})`)}`);
-  return held.replace(
-    new RegExp(`${HOLD}(\\d+)${HOLD}`, "g"),
-    (_, n) => paint.cyan(code[Number(n)] ?? "")
-  );
-}
-function wrap2(text, width, first, rest) {
-  const limit = Math.max(20, width - visibleWidth(first));
-  if (visibleWidth(text) <= limit) return [`${first}${text}`];
-  const out = [];
-  let line = "";
-  for (const word of text.split(" ")) {
-    if (line && visibleWidth(line) + 1 + visibleWidth(word) > limit) {
-      out.push(`${out.length === 0 ? first : rest}${line}`);
-      line = word;
-    } else {
-      line = line ? `${line} ${word}` : word;
-    }
+  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";
   }
-  if (line) out.push(`${out.length === 0 ? first : rest}${line}`);
-  return out;
-}
+};
 
-// packages/tui/src/prompt.ts
-import { emitKeypressEvents } from "node:readline";
+// packages/tui/src/keys.ts
 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;
+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 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 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;
+  }
+  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 pad4 = opts.indent ?? "";
+  const out = [];
+  let inFence = false;
+  let fenceLang = "";
+  for (const line of lines) {
+    const fence = /^\s*```(\w*)/.exec(line);
+    if (fence) {
+      if (!inFence) {
+        inFence = true;
+        fenceLang = fence[1] ?? "";
+        out.push(paint.dim(`${pad4}${fenceLang || "code"}`));
+      } else {
+        inFence = false;
+        fenceLang = "";
+        out.push("");
+      }
+      continue;
+    }
+    if (inFence) {
+      out.push(`${paint.dim(`${pad4}|`)} ${line}`);
+      continue;
+    }
+    out.push(...prose(line, opts.width, pad4));
+  }
+  return out.join("\n");
+}
+function prose(line, width, pad4) {
+  const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+  if (heading) return [`${pad4}${paint.bold(paint.accent(heading[2]))}`];
+  if (/^\s*([-*_])\s*\1\s*\1[\s-*_]*$/.test(line)) {
+    return [`${pad4}${paint.dim("-".repeat(Math.min(width, 40)))}`];
+  }
+  const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+  if (bullet) {
+    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 = `${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 = `${pad4}${paint.dim("|")} `;
+    return wrap2(paint.muted(inline(quote[1])), width, gutter, gutter);
+  }
+  if (!line.trim()) return [""];
+  return wrap2(inline(line), width, pad4, pad4);
+}
+var HOLD = "\0";
+function inline(text) {
+  const code = [];
+  let held = text.replace(/`([^`]+)`/g, (_, body2) => {
+    code.push(body2);
+    return `${HOLD}${code.length - 1}${HOLD}`;
+  });
+  held = held.replace(/\*\*([^*]+)\*\*/g, (_, body2) => paint.bold(body2)).replace(/(^|[\s(])\*([^*]+)\*/g, (_, pre, body2) => `${pre}${paint.bold(body2)}`).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label2, href) => `${label2} ${paint.dim(`(${href})`)}`);
+  return held.replace(
+    new RegExp(`${HOLD}(\\d+)${HOLD}`, "g"),
+    (_, n) => paint.cyan(code[Number(n)] ?? "")
+  );
+}
+function wrap2(text, width, first, rest) {
+  const limit = Math.max(20, width - visibleWidth(first));
+  if (visibleWidth(text) <= limit) return [`${first}${text}`];
+  const out = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    if (line && visibleWidth(line) + 1 + visibleWidth(word) > limit) {
+      out.push(`${out.length === 0 ? first : rest}${line}`);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line) out.push(`${out.length === 0 ? first : rest}${line}`);
+  return out;
+}
+
+// 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;
+  }
+  /**
+   * Move a block to the bottom. For an approval card, which must stay the last
+   * thing on screen while it waits: a helper that keeps working adds rows below
+   * it, and a card pushed up past the fold is one approved without being read.
+   */
+  toEnd(entry) {
+    const at2 = this.entries.indexOf(entry);
+    if (at2 === -1 || at2 === this.entries.length - 1) return;
+    this.entries.splice(at2, 1);
+    this.entries.push(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;
+  }
+  /**
+   * An answer, streaming or finished.
+   *
+   * 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.
+   */
+  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) => {
+          const text = i === 0 && j === 0 ? `${paint.accent(">")} ${piece}` : `  ${piece}`;
+          return band(text, visibleWidth(text), inner);
+        })
+      );
+    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 = [
+        ...block.helper ? [`  ${paint.accent("from a helper:")} ${paint.muted(block.helper)}`] : [],
+        ...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_ON);
+    if (this.renderer.isTty) process.stdout.write(PASTE_ON2);
     this.renderer.hideCursor();
     process.stdout.on("resize", this.onResize);
     process.once("exit", this.restore);
@@ -2613,7 +3744,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 +3757,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 +3907,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 +3934,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 +4029,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 +4050,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 +4088,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 +4129,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 +4323,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 +4347,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 +4389,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 +4489,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 +4588,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 +4648,88 @@ 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) {
+  if (step.call.name === "spawn_agent") return `working with a helper: ${detail(step)}`;
+  const own = `${step.call.name.replace(/_/g, " ")} ${detail(step)}`;
+  return step.helper ? `${step.helper.label}: ${own}` : own;
+}
+function stepKey(step) {
+  return step.helper ? `${step.helper.id}/${step.call.id}` : step.call.id;
+}
+function detail(step) {
+  const input = step.call.input;
+  if (step.call.name === "spawn_agent") return String(input.description ?? "helper");
+  const own = String(input.why ?? input.path ?? input.from ?? input.query ?? "");
+  return step.helper ? `\u21B3 ${step.helper.label} \xB7 ${own}` : own;
+}
+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") || "/";
+    // The whole brief: what the helper was actually told is what a learner
+    // wants when its report surprises them.
+    case "spawn_agent":
+      return str("task");
+    default:
+      return str("path");
+  }
+}
+
 // packages/cli/src/modes/interactive.ts
 async function runInteractive(runtime) {
   const renderer = new Renderer();
@@ -3524,98 +4784,936 @@ async function runInteractive(runtime) {
         renderer.print(paint.dim("  bye."));
         break;
       }
-      const input = result.text;
-      if (!input) continue;
-      renderer.print(`${paint.accent(">")} ${input}`);
-      if (input.startsWith("/") || input === "?") {
-        const outcome = await handleCommand(input, {
-          runtime,
-          mode: state.mode,
-          effort: state.effort,
-          print: (text) => renderer.print(text)
-        });
-        if (outcome.exit) break;
-        if (outcome.mode) state.mode = outcome.mode;
-        if (outcome.effort !== void 0) state.effort = outcome.effort;
-        continue;
+      const input = result.text;
+      if (!input) continue;
+      renderer.print(`${paint.accent(">")} ${input}`);
+      if (input.startsWith("/") || input === "?") {
+        const outcome = await handleCommand(input, {
+          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;
+        continue;
+      }
+      const tags = taggedPaths(input);
+      const attachments = tags.length ? attachTagged(runtime.root, tags) : void 0;
+      for (const refused of attachments?.filter((a) => a.omitted) ?? []) {
+        renderer.print(`  ${paint.yellow("!")} ${paint.muted(`${refused.path}: ${refused.omitted}`)}`);
+      }
+      for (const handler of runtime.extensions.onTurn) {
+        try {
+          handler({ question: input });
+        } catch {
+        }
+      }
+      abort = new AbortController();
+      const markdown = new MarkdownStream(renderer.contentWidth);
+      let opened = false;
+      let held = null;
+      const say = (line) => held ? held.push(line) : renderer.print(line);
+      const ui = {
+        text(chunk) {
+          const ready = markdown.push(chunk);
+          if (!ready) return;
+          if (!opened) {
+            renderer.print("");
+            opened = true;
+          }
+          renderer.print(ready.replace(/\n$/, ""));
+        },
+        status(what) {
+          startSpinner(what);
+        },
+        tool(step) {
+          for (const handler of runtime.extensions.onTool) {
+            try {
+              handler(step);
+            } catch {
+            }
+          }
+          if (step.status === "running" || step.status === "awaiting") {
+            if (!held) startSpinner(label(step));
+            return;
+          }
+          for (const line of toolBlock(
+            step.call.name,
+            detail(step),
+            step.status,
+            { input: verbatim(step.call), output: step.output ?? step.detail },
+            renderer.contentWidth
+          )) {
+            say(line);
+          }
+        },
+        async approve(call, preview, helper) {
+          stopSpinner();
+          if (helper) renderer.print(`  ${paint.accent("from a helper:")} ${paint.muted(helper)}`);
+          for (const line of approvalCard(preview, call, state.mode, renderer.contentWidth)) {
+            renderer.print(line);
+          }
+          const verb = call.name === "run_command" ? "run this command" : "apply this change";
+          held = [];
+          try {
+            const answer = await prompt.read(`${verb}? [y/N]`);
+            const ok = answer.kind === "line" && /^y(es)?$/i.test(answer.text.trim());
+            renderer.print(`  ${ok ? paint.green("allowed") : paint.muted("declined")}`);
+            return ok;
+          } finally {
+            const waiting = held;
+            held = null;
+            for (const line of waiting) renderer.print(line);
+          }
+        },
+        error(message) {
+          stopSpinner();
+          renderer.print(`${paint.red("  labd:")} ${message}`);
+        },
+        done(info2) {
+          if (info2.context) state.context = info2.context;
+          if (info2.credits) state.credits = info2.credits;
+        },
+        commandOutput(line) {
+          say(paint.dim(`  | ${line.replace(/\n/g, "\n  | ")}`));
+        }
+      };
+      startSpinner("thinking");
+      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
+      });
+      abort = null;
+      stopSpinner();
+      const tail = markdown.flush();
+      if (tail) {
+        if (!opened) renderer.print("");
+        renderer.print(tail.replace(/\n$/, ""));
+      }
+      if (turn.wrote.length && runtime.checkpoints) {
+        renderer.print(
+          paint.dim(
+            `  ${turn.wrote.length} file${turn.wrote.length === 1 ? "" : "s"} changed. /undo puts this answer back.`
+          )
+        );
+      }
+      answered++;
+      if (state.context && state.context.percentUsed >= COMPACT_AT) {
+        startSpinner("summarising, to make room");
+        const ok = await compact({ session: runtime.session, client: runtime.client, root: runtime.root });
+        stopSpinner();
+        renderer.print(paint.dim(ok ? "  summarised the conversation so far." : "  (could not summarise; carrying on)"));
+      }
+    }
+  } finally {
+    stopSpinner();
+    prompt.close();
+  }
+  if (answered) {
+    process.stderr.write(paint.dim(`
+${FACE} session saved. Continue it with: labd --resume ${runtime.session.id.slice(0, 8)}
+`));
+    await closeConversation(runtime);
+  }
+  return 0;
+}
+async function banner(renderer, runtime, mode) {
+  const where = basename4(runtime.root);
+  renderer.print("");
+  const still = !renderer.isTty || Boolean(process.env.LABD_NO_MOTION);
+  if (still) {
+    for (const line of faceLines()) renderer.print(line);
+  } else {
+    renderer.hideCursor();
+    for (const frame of decodeFrames()) {
+      renderer.draw(frame);
+      await sleep2(FACE_FRAME_MS);
+    }
+    renderer.clear();
+    for (const line of faceLines()) renderer.print(line);
+  }
+  renderer.print("");
+  renderer.print(`${paint.accent(FACE)} ${paint.bold("labd")} ${paint.dim(`in ${where}${runtime.branch ? ` on ${runtime.branch}` : ""}`)}`);
+  renderer.print(`  ${paint.dim(MODE_CAPTION[mode])}`);
+  if (runtime.settings.ignoredProjectServerUrl) {
+    renderer.print(
+      `  ${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) {
+    renderer.print(`  ${paint.yellow("!")} ${paint.muted(`extensions: ${skipped.why}`)}`);
+  }
+  renderer.print("");
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// 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;
+  }
+  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,
+    /**
+     * The mode the running turn is held to, when shift+tab has moved `mode` up
+     * to `agent` mid-answer. Going up does not apply until the next question -
+     * a habit keypress must not let the very next command run unasked - while
+     * going down applies at once, being the safe direction. Null when the turn
+     * simply follows `mode`.
+     */
+    heldMode: null,
+    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 shown = state.mode === "agent" ? paint.red(paint.bold("agent")) : state.mode === "auto" ? paint.accent("auto") : paint.muted("ask");
+    const mode = state.heldMode ? `${shown}${paint.dim(" (next question)")}` : shown;
+    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+tab mode \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.name === "tab" && key.shift) return cycleMode();
+    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 effectiveMode() {
+    return state.heldMode ?? state.mode;
+  }
+  function cycleMode() {
+    const previous = effectiveMode();
+    const next = AGENT_MODES[(AGENT_MODES.indexOf(state.mode) + 1) % AGENT_MODES.length];
+    state.mode = next;
+    const running = state.abort !== null;
+    state.heldMode = next === "agent" && running ? previous : null;
+    notice(`${next}: ${MODE_CAPTION[next]}`, 4e3);
+    if (next === "agent") {
+      note(
+        `  ${paint.red(paint.bold("agent"))} ${paint.muted(
+          running ? `- from your next question. This answer stays on ${previous}.` : "- commands now run without asking, and cannot be put back."
+        )}
+  ${paint.muted("For this session only. shift+tab again to leave it.")}`
+      );
+    }
+  }
+  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;
+      state.heldMode = null;
+    }
+    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"],
+      ["shift+tab", "next mode: ask, auto, agent"],
+      ["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);
       }
-      const tags = taggedPaths(input);
-      const attachments = tags.length ? attachTagged(runtime.root, tags) : void 0;
-      for (const refused of attachments?.filter((a) => a.omitted) ?? []) {
-        renderer.print(`  ${paint.yellow("!")} ${paint.muted(`${refused.path}: ${refused.omitted}`)}`);
+    );
+    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) {
+    state.heldMode = null;
+    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 {
       }
-      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 });
         }
-      }
-      abort = new AbortController();
-      const markdown = new MarkdownStream(renderer.contentWidth);
-      let opened = false;
-      const ui = {
-        text(chunk) {
-          const ready = markdown.push(chunk);
-          if (!ready) return;
-          if (!opened) {
-            renderer.print("");
-            opened = true;
-          }
-          renderer.print(ready.replace(/\n$/, ""));
-        },
-        status(what) {
-          startSpinner(what);
-        },
-        tool(step) {
-          for (const handler of runtime.extensions.onTool) {
-            try {
-              handler(step);
-            } catch {
-            }
-          }
-          if (step.status === "running" || step.status === "awaiting") {
-            startSpinner(label(step));
-            return;
-          }
-          for (const line of toolBlock(
-            step.call.name,
-            detail(step),
-            step.status,
-            { input: verbatim(step.call), output: step.output ?? step.detail },
-            renderer.contentWidth
-          )) {
-            renderer.print(line);
+        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 {
           }
-        },
-        async approve(call, preview) {
-          stopSpinner();
-          for (const line of approvalCard(preview, call, state.mode, renderer.contentWidth)) {
-            renderer.print(line);
+        }
+        closeAnswer();
+        const key = stepKey(step);
+        let entry = state.toolBlocks.get(key);
+        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(key, entry);
+          if (state.approval) {
+            transcript.toEnd(state.approval.entry);
+            if (viewport.follow) viewport.end();
           }
-          const verb = call.name === "run_command" ? "run this command" : "apply this change";
-          const answer = await prompt.read(`${verb}? [y/N]`);
-          const ok = answer.kind === "line" && /^y(es)?$/i.test(answer.text.trim());
-          renderer.print(`  ${ok ? paint.green("allowed") : paint.muted("declined")}`);
-          return ok;
-        },
-        error(message) {
-          stopSpinner();
-          renderer.print(`${paint.red("  labd:")} ${message}`);
-        },
-        done(info) {
-          if (info.context) state.context = info.context;
-          if (info.credits) state.credits = info.credits;
-        },
-        commandOutput(line) {
-          renderer.print(paint.dim(`  | ${line.replace(/\n/g, "\n  | ")}`));
         }
-      };
-      startSpinner("thinking");
+        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, helper) {
+        setBusy(null);
+        closeAnswer();
+        const entry = transcript.add({ kind: "approval", call, preview, helper, mode: effectiveMode(), 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, key) {
+        const target = key ? state.toolBlocks.get(key) : void 0;
+        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,
+        currentMode: effectiveMode,
         checkpoints: runtime.checkpoints,
         effort: state.effort,
         attachments,
@@ -3623,126 +5721,171 @@ async function runInteractive(runtime) {
         ui,
         signal: abort.signal
       });
-      abort = null;
-      stopSpinner();
-      const tail = markdown.flush();
-      if (tail) {
-        if (!opened) renderer.print("");
-        renderer.print(tail.replace(/\n$/, ""));
-      }
+      closeAnswer();
       if (turn.wrote.length && runtime.checkpoints) {
-        renderer.print(
-          paint.dim(
-            `  ${turn.wrote.length} file${turn.wrote.length === 1 ? "" : "s"} changed. /undo puts this answer back.`
-          )
-        );
+        note(paint.dim(`  ${turn.wrote.length} file${turn.wrote.length === 1 ? "" : "s"} changed. /undo puts this answer back.`));
       }
-      answered++;
-      if (state.context && state.context.percentUsed >= COMPACT_AT) {
-        startSpinner("summarising, to make room");
+      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 });
-        stopSpinner();
-        renderer.print(paint.dim(ok ? "  summarised the conversation so far." : "  (could not summarise; carrying on)"));
+        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;
+      state.heldMode = null;
+      if (state.approval) answerApproval(false);
+      setBusy(null);
     }
-  } finally {
-    stopSpinner();
-    prompt.close();
   }
-  if (answered) {
+  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 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) };
+function borderColour2(s) {
+  switch (s) {
+    case "ok":
+      return paint.green;
+    case "unknown":
+      return paint.red;
+    case "partial":
+      return paint.cyan;
+    default:
+      return paint.dim;
   }
-  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 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 detail(step) {
-  const input = step.call.input;
-  return String(input.why ?? input.path ?? input.from ?? input.query ?? "");
+function centre(line, width) {
+  const pad4 = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
+  return `${" ".repeat(pad4)}${line}`;
 }
-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");
-  }
+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);
 }
-async function banner(renderer, runtime, mode) {
-  const where = basename4(runtime.root);
-  renderer.print("");
-  const still = !renderer.isTty || Boolean(process.env.LABD_NO_MOTION);
-  if (still) {
-    for (const line of faceLines()) renderer.print(line);
-  } else {
-    renderer.hideCursor();
-    for (const frame of decodeFrames()) {
-      renderer.draw(frame);
-      await sleep2(FACE_FRAME_MS);
+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;
     }
-    renderer.clear();
-    for (const line of faceLines()) renderer.print(line);
-  }
-  renderer.print("");
-  renderer.print(`${paint.accent(FACE)} ${paint.bold("labd")} ${paint.dim(`in ${where}${runtime.branch ? ` on ${runtime.branch}` : ""}`)}`);
-  renderer.print(`  ${paint.dim(MODE_CAPTION[mode])}`);
-  if (runtime.settings.ignoredProjectServerUrl) {
-    renderer.print(
-      `  ${paint.yellow("!")} ${paint.muted(
-        `ignoring serverUrl in .labd/settings.json (${runtime.settings.ignoredProjectServerUrl}) - this project isn't trusted; \`labd trust\` if you meant it`
-      )}`
-    );
+    if (visible >= from) out += line[i];
+    visible++;
+    i++;
   }
-  for (const skipped of runtime.extensions.skipped) {
-    renderer.print(`  ${paint.yellow("!")} ${paint.muted(`extensions: ${skipped.why}`)}`);
+  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)`;
   }
-  renderer.print("");
+  return text.replace(/\s+/g, " ").slice(0, 60);
 }
-function sleep2(ms) {
+function sleep3(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;
-  }
-  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;
-}
 
 // packages/cli/src/modes/print.ts
 function toStderr(text) {
@@ -3778,6 +5921,7 @@ async function runPrint(runtime, opts) {
         emit({
           type: "tool",
           name: step.call.name,
+          ...step.helper ? { helper: step.helper } : {},
           status: step.status,
           input: step.call.input,
           detail: step.detail,
@@ -3785,7 +5929,8 @@ async function runPrint(runtime, opts) {
           output: step.output
         });
       } else if (step.status !== "running") {
-        toStderr(`${paint.dim(`${step.call.name}: ${step.status}${step.detail ? ` - ${step.detail}` : ""}`)}
+        const who = step.helper ? `${step.helper.label} > ` : "";
+        toStderr(`${paint.dim(`${who}${step.call.name}: ${step.status}${step.detail ? ` - ${step.detail}` : ""}`)}
 `);
       }
       if (step.status === "skipped") declined = true;
@@ -3796,8 +5941,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 +5999,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);
     }
   });
@@ -3944,6 +6089,8 @@ async function runRpc(runtime) {
       tool(step) {
         notify("labd/tool", {
           name: step.call.name,
+          // Which helper made the call, when one did: its spawn_agent call id and name.
+          ...step.helper ? { helper: step.helper } : {},
           status: step.status,
           input: step.call.input,
           detail: step.detail,
@@ -3954,11 +6101,11 @@ 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 });
+      commandOutput(line, key) {
+        notify("labd/command_output", { line, ...key ? { key } : {} });
       },
       /**
        * Ask the host. A host that never answers gets a refusal after a timeout
@@ -3966,7 +6113,7 @@ async function runRpc(runtime) {
        * alternative is writing to someone's files because their integration was
        * asleep.
        */
-      approve(call, preview) {
+      approve(call, preview, helper) {
         return new Promise((resolve2) => {
           if (closed) return resolve2(false);
           const id = nextId++;
@@ -3977,7 +6124,7 @@ async function runRpc(runtime) {
             clearTimeout(timer);
             resolve2(approved);
           });
-          out({ jsonrpc: "2.0", id, method: "labd/approve", params: { call, preview } });
+          out({ jsonrpc: "2.0", id, method: "labd/approve", params: { call, preview, ...helper ? { helper } : {} } });
         });
       }
     };
@@ -4007,7 +6154,7 @@ async function runRpc(runtime) {
 }
 
 // packages/cli/src/index.ts
-var VERSION = true ? "0.3.1" : "0.0.0-dev";
+var VERSION = true ? "0.6.0" : "0.0.0-dev";
 async function main(argv) {
   const args = parse(argv);
   if (args.color !== void 0) setColor(args.color);
@@ -4033,11 +6180,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 +6210,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 +6246,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 +6263,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 +6295,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 +6327,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 +6364,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 +6394,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 +6416,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 +6432,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")}