@a-t-h-i/bot-lobby 0.5.1 → 0.6.0

package/src/lobby/sessions.ts

@@ -0,0 +1,288 @@
+/**
+ * Background sessions: a task started "in a new session" from the lobby runs
+ * in its own headless pi process (`pi --mode rpc --name <task>`). It is an
+ * ordinary saved pi session, named after its task so `/resume` finds it, that
+ * this window drives over pi's RPC protocol: the lobby shows its conversation,
+ * activity and thoughts live (a feed per session, fed from its events), sends
+ * it your messages, and puts the questions it asks to you in this window.
+ */
+import { spawn, type ChildProcess } from "node:child_process";
+import { resolvePiInvocation } from "../execution/pi-runner.ts";
+import { describeToolCall } from "../pi/activity.ts";
+import { LobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
+
+/** A question a background session is waiting on, as its RPC request carries it. */
+export interface SessionDialog {
+  id: string;
+  method: "select" | "confirm" | "input" | "editor";
+  title: string;
+  message?: string;
+  options?: string[];
+  placeholder?: string;
+  prefill?: string;
+}
+
+/** An answer to a dialog: the value, a yes/no, or put away. */
+export type DialogAnswer = { value: string } | { confirmed: boolean } | { cancelled: true };
+
+/** The child process as the session needs it (a real ChildProcess in pi, a fake in tests). */
+export interface SessionProcess {
+  stdin: { write(text: string): unknown; end(): unknown; on?(event: "error", listener: (error: Error) => void): unknown } | null;
+  stdout: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
+  stderr: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
+  on(event: "exit", listener: (code: number | null) => void): unknown;
+  on(event: "error", listener: (error: Error) => void): unknown;
+  kill(signal?: NodeJS.Signals): unknown;
+  pid?: number;
+}
+
+export type SessionStatus = "starting" | "idle" | "working" | "exited";
+
+export interface SessionStart {
+  /** The display name: the task's title. */
+  name: string;
+  /** What to send once it is up: the request, or a planned task to start. */
+  request?: string;
+  planId?: string;
+  auto?: boolean;
+}
+
+let counter = 0;
+
+export class BackgroundSession {
+  readonly key: string;
+  readonly name: string;
+  /** The planned task it was started from. */
+  readonly planId?: string;
+  readonly feed = new LobbyFeed();
+  readonly startedAt = Date.now();
+  status: SessionStatus = "starting";
+  sessionId?: string;
+  sessionFile?: string;
+  /** The footer status the session sets (bot-lobby's task line), when it sets one. */
+  statusText?: string;
+  exitCode?: number | null;
+  /** Dialogs the session waits on, oldest first. */
+  readonly dialogs: SessionDialog[] = [];
+  private readonly proc: SessionProcess;
+  private buffer = "";
+  private stderr = "";
+  private nextId = 0;
+  private readonly onChange: () => void;
+
+  constructor(proc: SessionProcess, start: SessionStart, onChange: () => void = () => {}) {
+    counter += 1;
+    this.key = `S${counter}`;
+    this.name = start.name;
+    if (start.planId) this.planId = start.planId;
+    this.proc = proc;
+    this.onChange = onChange;
+    proc.stdout?.on("data", (chunk) => this.receive(String(chunk)));
+    proc.stderr?.on("data", (chunk) => {
+      this.stderr = `${this.stderr}${String(chunk)}`.slice(-4000);
+    });
+    // A write to a session that just ended must not take this pi down with it.
+    proc.stdin?.on?.("error", () => {});
+    proc.on("exit", (code) => this.ended(code, code === 0 || code === null ? "the session ended" : `the session exited (${code})${this.lastError() ? `: ${this.lastError()}` : ""}`));
+    proc.on("error", (error) => {
+      this.stderr = `${this.stderr}\n${error.message}`;
+      this.ended(1, `the session could not run: ${error.message}`);
+    });
+    this.write({ type: "get_state" });
+    if (start.planId) this.prompt(`/bot-lobby start-plan ${start.planId}${start.auto ? " auto" : ""}`);
+    else if (start.request) this.prompt(`/bot-lobby --task ${start.auto ? "--auto " : ""}${start.request}`);
+  }
+
+  private ended(code: number | null, reason: string): void {
+    if (this.status === "exited") return;
+    this.status = "exited";
+    this.exitCode = code;
+    this.dialogs.length = 0;
+    this.feed.say("note", reason);
+    this.onChange();
+  }
+
+  get alive(): boolean {
+    return this.status !== "exited";
+  }
+
+  get busy(): boolean {
+    return this.status === "working";
+  }
+
+  /** The last line the process wrote to stderr, for a failure message. */
+  lastError(): string {
+    // Attention pings (OSC 9) a session writes to stderr are not errors.
+    return this.stderr.replace(/\x1b\][^\x07]*\x07|\x07/g, "").trim().split("\n").at(-1)?.trim() ?? "";
+  }
+
+  private write(command: Record<string, unknown>): void {
+    if (!this.alive || !this.proc.stdin) return;
+    this.nextId += 1;
+    this.proc.stdin.write(`${JSON.stringify({ id: `${this.key}-${this.nextId}`, ...command })}\n`);
+  }
+
+  private prompt(message: string): void {
+    this.write({ type: "prompt", message, ...(this.busy ? { streamingBehavior: "steer" } : {}) });
+  }
+
+  /** Send the session's oracle a message, steering its running turn when it works. */
+  send(text: string): void {
+    const body = text.trim();
+    if (!body) return;
+    this.prompt(body);
+  }
+
+  /** Stop the oracle's running turn (the session stays up). */
+  abort(): void {
+    if (this.busy) this.write({ type: "abort" });
+  }
+
+  /** Answer the oldest dialog it waits on. */
+  answer(id: string, answer: DialogAnswer): void {
+    const index = this.dialogs.findIndex((dialog) => dialog.id === id);
+    if (index < 0) return;
+    this.dialogs.splice(index, 1);
+    if (this.alive && this.proc.stdin) this.proc.stdin.write(`${JSON.stringify({ type: "extension_ui_response", id, ...answer })}\n`);
+    this.onChange();
+  }
+
+  /** Stop the session: its process ends (its task keeps its state and can be resumed or claimed later). */
+  stop(): void {
+    if (!this.alive) return;
+    try {
+      this.proc.stdin?.end();
+    } catch {
+      // Already closed.
+    }
+    try {
+      this.proc.kill("SIGTERM");
+    } catch {
+      // Already gone.
+    }
+  }
+
+  /** Split stdout into JSON lines (LF only, as pi's RPC framing requires) and handle each. */
+  private receive(chunk: string): void {
+    this.buffer += chunk;
+    let newline = this.buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.trim()) this.handle(line);
+      newline = this.buffer.indexOf("\n");
+    }
+  }
+
+  private handle(line: string): void {
+    let event: Record<string, unknown>;
+    try {
+      event = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      return;
+    }
+    const type = event.type;
+    if (type === "response") {
+      const data = event.data as { sessionId?: string; sessionFile?: string } | undefined;
+      if (event.command === "get_state" && data) {
+        this.sessionId = data.sessionId;
+        this.sessionFile = data.sessionFile;
+        if (this.status === "starting") this.status = "idle";
+      } else if (event.success === false && typeof event.error === "string") {
+        this.feed.log("LOBBY", `the session refused a request: ${event.error}`, "warning");
+      }
+      this.onChange();
+      return;
+    }
+    if (type === "extension_ui_request") return this.uiRequest(event);
+    if (type === "agent_start") this.status = "working";
+    else if (type === "agent_end") this.status = "idle";
+    narrateEvent(this.feed, event as unknown as AgentEventLike, describeToolCall);
+    this.onChange();
+  }
+
+  private uiRequest(event: Record<string, unknown>): void {
+    const id = String(event.id ?? "");
+    const method = String(event.method ?? "");
+    if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
+      this.dialogs.push({
+        id,
+        method,
+        title: String(event.title ?? ""),
+        ...(typeof event.message === "string" ? { message: event.message } : {}),
+        ...(Array.isArray(event.options) ? { options: event.options.map(String) } : {}),
+        ...(typeof event.placeholder === "string" ? { placeholder: event.placeholder } : {}),
+        ...(typeof event.prefill === "string" ? { prefill: event.prefill } : {}),
+      });
+      this.feed.log("LOBBY", `waiting for you: ${String(event.title ?? "a question").split("\n")[0]}`, "warning");
+    } else if (method === "notify") {
+      const level = event.notifyType === "error" ? "error" : event.notifyType === "warning" ? "warning" : "info";
+      this.feed.log("LOBBY", String(event.message ?? "").split("\n")[0]!.replace(/^bot-lobby:?\s+/, ""), level);
+    } else if (method === "setStatus" && event.statusKey === "bot-lobby") {
+      this.statusText = typeof event.statusText === "string" ? event.statusText : undefined;
+    }
+    this.onChange();
+  }
+}
+
+/** Launch a headless pi for a new session: `pi --mode rpc --name <name>`, loading bot-lobby as this pi did. */
+export type SessionLauncher = (args: string[], cwd: string) => SessionProcess;
+
+/** `-e`/`--extension` arguments this pi was started with, so a session started from it loads the same extensions. */
+export function extensionArgs(argv: readonly string[] = process.argv): string[] {
+  const forwarded: string[] = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]!;
+    if ((arg === "-e" || arg === "--extension") && argv[index + 1]) forwarded.push(arg, argv[++index]!);
+    else if (arg.startsWith("--extension=")) forwarded.push(arg);
+  }
+  return forwarded;
+}
+
+export function sessionArgs(name: string, model?: string, argv: readonly string[] = process.argv): string[] {
+  return ["--mode", "rpc", "--name", name, ...(model ? ["--model", model] : []), ...extensionArgs(argv)];
+}
+
+const POSIX = process.platform !== "win32";
+
+/** The real launcher: the same pi build as this session, in its own process group, without subagent markers. */
+export const launchPi: SessionLauncher = (args, cwd) => {
+  const invocation = resolvePiInvocation(args);
+  const env: NodeJS.ProcessEnv = { ...process.env, PI_SKIP_VERSION_CHECK: "1" };
+  delete env.BOT_LOBBY_SUBAGENT;
+  const proc: ChildProcess = spawn(invocation.command, invocation.args, { cwd, env, shell: false, detached: POSIX, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+  return proc as unknown as SessionProcess;
+};
+
+/** Every background session this window started, oldest first. */
+export class SessionRegistry {
+  readonly sessions: BackgroundSession[] = [];
+  private readonly launcher: SessionLauncher;
+  private readonly onChange: () => void;
+
+  constructor(launcher: SessionLauncher = launchPi, onChange: () => void = () => {}) {
+    this.launcher = launcher;
+    this.onChange = onChange;
+  }
+
+  start(cwd: string, start: SessionStart, model?: string): BackgroundSession {
+    const proc = this.launcher(sessionArgs(start.name, model), cwd);
+    const session = new BackgroundSession(proc, start, this.onChange);
+    this.sessions.push(session);
+    this.onChange();
+    return session;
+  }
+
+  get(key: string): BackgroundSession | undefined {
+    return this.sessions.find((session) => session.key === key);
+  }
+
+  /** The background session running a pi session id, if this window started it. */
+  bySessionId(sessionId: string | undefined): BackgroundSession | undefined {
+    return sessionId ? this.sessions.find((session) => session.sessionId === sessionId) : undefined;
+  }
+
+  stopAll(): void {
+    for (const session of this.sessions) session.stop();
+  }
+}

package/src/lobby/tabs/home.ts

@@ -1,13 +1,15 @@
 /**
- * The Lobby tab: the zen scene of this session's task on top, then the
+ * The Lobby tab: the zen scene of this session's task on top (the oracle
+ * and agent animations, or just their status when animations are off), then the
  * conversation with the oracle (text only, no tool rows, no thinking), the
  * activity log of plain-words steps from every agent, and the one place where
  * thoughts show up. Pure: the scene arrives as a callback, the clock as `now`.
  */
+import { visibleWidth } from "@earendil-works/pi-tui";
 import type { Task } from "../../schemas/task.ts";
 import type { ActivityEntry, ChatEntry, ThoughtEntry } from "../feed.ts";
 import type { LobbyPanel } from "../../schemas/configuration.ts";
-import { beside, bold, box, clock, fill, italic, markdownHanging, notePane, paint, since, spinner, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, since, spinner, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
 
 /** The Lobby tab's scrollable panes. */
 export const HOME_PANES = ["conversation", "activity", "thinking"] as const;
@@ -15,8 +17,8 @@ export type HomePane = (typeof HOME_PANES)[number];
 
 export interface HomeInput {
   task?: Task;
-  /** Draws the zen scene into at most `height` lines; absent when no task is active. */
-  scene?: (width: number, height: number) => string[];
+  /** Draws the zen scene into at most `height` lines, animated or still; absent when no task is active. */
+  scene?: (width: number, height: number, animated: boolean) => string[];
   chat: readonly ChatEntry[];
   /** The oracle's reply while it streams. */
   liveReply?: string;
@@ -41,13 +43,22 @@ export interface HomeInput {
   query?: string;
   /** Key labels for the pane toggles, shown on the panes. */
   keys?: Record<LobbyPanel, string>;
+  /** Another session is shown: its name titles the conversation. */
+  title?: string;
+  /** The scene is another session's still status (no animations to toggle). */
+  stillScene?: boolean;
+  /** What the empty conversation says instead of the default (a session starting, say). */
+  emptyNote?: string;
+  /** What the empty activity log says instead of "No activity yet.". */
+  activityNote?: string;
 }
 
 /** Wide terminals put the conversation and the activity log side by side. */
 export const HOME_COLUMNS_MIN = 100;
-/** Most lines the scene may take, and its share of the body. */
+/** Most lines the scene may take, and its share of the body; the still status needs far fewer. */
 const SCENE_SHARE = 0.45;
 const MAX_SCENE = 36;
+const MAX_STILL = 10;
 
 const SOURCE_COLORS: Record<string, LobbyColor> = {
   MASTER: "accent",
@@ -83,34 +94,93 @@ export function activityLine(entry: ActivityEntry, width: number, tick: number,
   return `${paint(theme, "dim", clock(entry.at))} ${who} ${mark} ${body}`;
 }
 
-function chatLead(role: ChatEntry["role"], theme?: LobbyTheme): string {
-  if (role === "you") return `${bold(theme, paint(theme, "accent", "you"))} ${paint(theme, "dim", "▸")} `;
-  if (role === "oracle") return `${bold(theme, paint(theme, "toolTitle", "oracle"))} ${paint(theme, "dim", "▸")} `;
-  return `${paint(theme, "dim", "·")} `;
+/** How each speaker is shown: a mark and a name in its colour. */
+export const SPEAKERS = {
+  you: { mark: "●", name: "You", color: "accent" },
+  oracle: { mark: "◆", name: "Oracle", color: "toolTitle" },
+  panel: { mark: "◆", name: "Panel", color: "toolTitle" },
+} as const satisfies Record<string, { mark: string; name: string; color: LobbyColor }>;
+export type Speaker = keyof typeof SPEAKERS;
+
+/** Messages from one speaker within this long of each other share a header. */
+const GROUP_MS = 5 * 60_000;
+/** Message bodies sit under the speaker's name, past its mark. */
+const BODY_INDENT = 2;
+
+/** `◆ Oracle ············ 12:04`: who speaks on the left; when, or what they are doing, on the right. */
+export function speakerLine(speaker: Speaker, width: number, theme?: LobbyTheme, right = ""): string {
+  const { mark, name, color } = SPEAKERS[speaker];
+  const left = `${paint(theme, color, mark)} ${bold(theme, paint(theme, color, name))}`;
+  const note = right ? paint(theme, "dim", right) : "";
+  const gap = width - visibleWidth(left) - visibleWidth(note);
+  return gap >= 1 && note ? `${left}${" ".repeat(gap)}${note}` : left;
+}
+
+/**
+ * What you wrote, as pi shows it: a band in the user-message background with
+ * a column of padding (a bar in its colour where the theme has no background).
+ */
+export function youLines(text: string, width: number, theme?: LobbyTheme): string[] {
+  const inner = Math.max(1, width - BODY_INDENT - 2);
+  const indent = " ".repeat(BODY_INDENT);
+  const band = theme?.bg
+    ? (line: string) => theme.bg!("userMessageBg", ` ${fit(paint(theme, "userMessageText", line), inner)} `)
+    : (line: string) => `${paint(theme, "accent", "▌")} ${line}`;
+  return wrap(text, inner).map((line) => `${indent}${band(line)}`);
+}
+
+/** The oracle's reply as Markdown, under its name. */
+function oracleLines(text: string, width: number, theme?: LobbyTheme): string[] {
+  const indent = " ".repeat(BODY_INDENT);
+  return markdownLines(text, Math.max(1, width - BODY_INDENT), theme).map((line) => (line ? `${indent}${line}` : ""));
+}
+
+/** An event in the conversation (a task starting, a comment sent) as a centred rule; failures stand out instead. */
+export function eventLines(text: string, at: number, width: number, theme?: LobbyTheme): string[] {
+  if (text.startsWith("✗")) return wrap(paint(theme, "error", text), width);
+  const label = ` ${text}${at > 0 ? ` · ${clock(at)}` : ""} `;
+  const room = width - visibleWidth(label);
+  if (room < 6) return wrap(paint(theme, "dim", text), width);
+  const left = Math.floor(room / 2);
+  return [paint(theme, "dim", `${"─".repeat(left)}${label}${"─".repeat(room - left)}`)];
 }
 
-/** The conversation as wrapped lines, oldest first, a blank line between turns. */
+/**
+ * The conversation, oldest first: each turn under a speaker line with its
+ * time, your messages in a band, the oracle's in Markdown, events as rules,
+ * and while the oracle works its header says so (streaming the reply under it).
+ */
 export function chatLines(chat: readonly ChatEntry[], width: number, theme?: LobbyTheme, live?: string, busy = false, tick = 0): string[] {
   const lines: string[] = [];
-  const push = (role: ChatEntry["role"], text: string) => {
-    if (lines.length > 0) lines.push("");
-    // The oracle writes Markdown; what you typed and notes are shown as written.
-    if (role === "oracle") lines.push(...markdownHanging(chatLead(role, theme), text, width, theme));
-    else lines.push(...wrapHanging(chatLead(role, theme), role === "note" ? paint(theme, "dim", text) : text, width));
+  const gap = () => {
+    if (lines.length > 0 && lines.at(-1) !== "") lines.push("");
   };
-  for (const entry of chat) push(entry.role, entry.text);
+  let last: ChatEntry | undefined;
+  for (const entry of chat) {
+    gap();
+    if (entry.role === "note") {
+      lines.push(...eventLines(entry.text, entry.at, width, theme));
+      last = undefined;
+      continue;
+    }
+    const grouped = last?.role === entry.role && entry.at >= last.at && entry.at - last.at < GROUP_MS;
+    if (!grouped) lines.push(speakerLine(entry.role, width, theme, entry.at > 0 ? clock(entry.at) : ""));
+    lines.push(...(entry.role === "you" ? youLines(entry.text, width, theme) : oracleLines(entry.text, width, theme)));
+    last = entry;
+  }
   if (live?.trim()) {
-    push("oracle", live.trim());
-    lines[lines.length - 1] = `${lines.at(-1)!.trimEnd()} ${paint(theme, "accent", spinner(tick))}`;
+    gap();
+    lines.push(speakerLine("oracle", width, theme, `${spinner(tick)} writing`), ...oracleLines(live.trim(), width, theme));
   } else if (busy) {
-    if (lines.length > 0) lines.push("");
-    lines.push(...wrapHanging(chatLead("oracle", theme), paint(theme, "dim", `${spinner(tick)} working…`), width));
+    gap();
+    lines.push(speakerLine("oracle", width, theme, `${spinner(tick)} working…`));
   }
   return lines;
 }
 
 function emptyChat(input: HomeInput, width: number, theme?: LobbyTheme): string[] {
   if (input.query) return wrap(paint(theme, "dim", `Nothing in the conversation matches "${input.query}".`), width);
+  if (input.emptyNote) return wrap(paint(theme, "dim", input.emptyNote), width);
   const lines = input.task
     ? [paint(theme, "dim", "Nothing said yet. Type below to talk to the oracle about this task.")]
     : [
@@ -147,7 +217,7 @@ function conversation(input: HomeInput, chat: readonly ChatEntry[], width: numbe
 }
 
 function activity(input: HomeInput, entries: readonly ActivityEntry[], width: number, theme?: LobbyTheme): string[] {
-  if (entries.length === 0) return [paint(theme, "dim", input.query ? `No activity matches "${input.query}".` : "No activity yet.")];
+  if (entries.length === 0) return wrap(paint(theme, "dim", input.query ? `No activity matches "${input.query}".` : input.activityNote ?? "No activity yet."), width);
   return entries.map((entry) => activityLine(entry, width, input.tick, theme));
 }
 
@@ -177,17 +247,35 @@ function thinkingContent(input: HomeInput, thoughts: readonly ThoughtEntry[], wi
   return [paint(theme, "dim", input.query ? `No thought matches "${input.query}".` : "Thoughts from the oracle and every agent appear here, and only here.")];
 }
 
-function sceneLines(input: HomeInput, width: number, height: number): string[] {
-  if (!input.task || !input.scene || !input.panels.scene) return [];
-  const budget = Math.min(MAX_SCENE, Math.floor(height * SCENE_SHARE));
-  if (budget < 6) return [];
-  return input.scene(width, budget).slice(0, budget);
+/**
+ * The scene: with animations off (the `animations` panel, off by default)
+ * only the task's status box, what the agents are doing and the checklist;
+ * with them on, the animated oracle and agents too. Its first line names the
+ * key that toggles the animations.
+ */
+function sceneLines(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
+  if (!input.task || !input.scene) return [];
+  const animated = input.panels.animations && !input.stillScene;
+  const budget = Math.min(animated ? MAX_SCENE : MAX_STILL, Math.floor(height * SCENE_SHARE));
+  if (budget < (animated ? 6 : 4)) return [];
+  const lines = input.scene(width, budget, animated).slice(0, budget);
+  const note = input.keys && !input.stillScene ? `${input.keys.animations} ${animated ? "hides" : "shows"} animations` : undefined;
+  return keyNote(lines, width, note, theme);
+}
+
+/** `note` at the right end of the first line, dimmed, when it fits beside what is there. */
+function keyNote(lines: readonly string[], width: number, note: string | undefined, theme?: LobbyTheme): string[] {
+  const first = lines[0];
+  if (!note || first === undefined) return [...lines];
+  const gap = width - visibleWidth(first) - visibleWidth(note) - 1;
+  if (gap < 2) return [...lines];
+  return [`${first}${" ".repeat(gap)}${paint(theme, "dim", note)}`, ...lines.slice(1)];
 }
 
 function hiddenHint(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
   const keys = input.keys;
   const text = keys
-    ? `Every pane is hidden — ${keys.conversation} conversation · ${keys.activity} activity · ${keys.thinking} thinking${input.task ? ` · ${keys.scene} scene` : ""}`
+    ? `Every pane is hidden — ${keys.conversation} conversation · ${keys.activity} activity · ${keys.thinking} thinking`
     : "Every pane is hidden.";
   const lines = wrap(paint(theme, "dim", text), width);
   const top = Math.max(0, Math.floor((height - lines.length) / 2));
@@ -205,7 +293,7 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   if (height <= 0) return [];
   const { panels } = input;
   const feed = filterFeed(input);
-  const scene = sceneLines(input, width, height);
+  const scene = sceneLines(input, width, height, theme);
   const rest = height - scene.length;
   const showMain = panels.conversation || panels.activity;
   const thinkHeight = !panels.thinking ? 0 : !showMain ? rest : rest >= 18 ? Math.max(5, Math.floor(rest * 0.25)) : rest >= 10 ? 4 : 0;
@@ -220,7 +308,7 @@ export function renderHome(input: HomeInput, width: number, height: number, them
     const right = rightNote(view.offset, note);
     return box(w, h, view.shown, { title, ...(right ? { right } : {}), focused: input.focus === name, scroll: { total: all.length, start: view.start }, theme });
   };
-  const chatBox = pane("conversation", input.task ? `Conversation · ${input.task.id}` : "Conversation", input.query ? matches(feed.chat.length) : input.keys?.conversation, (inner) => conversation(input, feed.chat, inner, theme));
+  const chatBox = pane("conversation", input.title ? `Conversation · ${input.title}` : "Conversation", input.query ? matches(feed.chat.length) : input.keys?.conversation, (inner) => conversation(input, feed.chat, inner, theme));
   const activityBox = pane("activity", "Activity", input.query ? matches(feed.activity.length) : input.keys?.activity, (inner) => activity(input, feed.activity, inner, theme));
   const thought = currentThought(feed.thoughts);
   const thinkingNote = thought ? `${thought.source} · ${thought.live ? "thinking" : since(input.now - thought.at)}` : input.keys?.thinking;

package/src/lobby/tabs/plan.ts

@@ -9,8 +9,8 @@
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { ORACLE_LABEL, type LineComment, type PanelNote, type PanelQuestion, type PlannerMessage, type PlannerReply, type PlannerSeed } from "../planner.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
-import { beside, bold, box, fill, italic, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
-import { sourceColor, tailWindow } from "./home.ts";
+import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { sourceColor, speakerLine, tailWindow, youLines } from "./home.ts";
 
 export interface SeatView {
   label: string;
@@ -77,43 +77,34 @@ export interface PlanTabInput {
   layout?: PlanLayout;
   /** Filled with where the conversation (`talk`) and the draft landed, for scrolling. */
   panes?: PaneLayout;
+  /** The key that saves the plan, as the status line names it. */
+  saveKey?: string;
 }
 
 export const PLAN_COLUMNS_MIN = 100;
 const LABEL_WIDTH = 8;
 
+/** Before a session: one sentence, then who sits on the panel and the model each runs on. */
 function intro(input: PlanTabInput, width: number, theme?: LobbyTheme): string[] {
-  // The roster leads with the chair; the intro names it separately.
-  const members = input.seats.filter((seat) => seat.label !== ORACLE_LABEL);
-  const seats = members.filter((seat) => seat.seated).map((seat) => seat.label);
-  const text = [
-    bold(theme, "Plan a task with the whole team before anyone writes code."),
-    "",
-    `Describe what you want below. The planning panel — the oracle chairing${seats.length > 0 ? `, with ${seats.join(", ")}` : ""} — reads the codebase and questions you, each seat from its own domain: contracts and data, flows and states, acceptance criteria and tests, libraries and prior art.`,
-    "",
-    "After each round the oracle puts the panel's questions to you one at a time, each with options and room for your own answer, and folds every answer into the draft plan, so all the agents start from the same decisions.",
-    "",
-    "Comment on any line of the draft: enter moves to the draft, ↑↓ pick a line (or click it), c comments. When the panel agrees, s saves the plan to the pending tasks list. While browsing (esc), 1-4 seat or unseat DEV, DESIGN, QA and RESEARCH.",
-    "",
-    paint(theme, "dim", `oracle: ${input.profile} (m changes it; each seat uses its domain's settings, alt+s)`),
-    ...members.map((seat) => paint(theme, "dim", `${seat.label.toLowerCase()}: ${seat.seated ? seat.profile ?? "" : "not seated"}`)),
-  ];
-  return text.flatMap((line) => wrap(line, width));
+  const rows = input.seats.map((seat) => {
+    const name = paint(theme, seat.seated ? sourceColor(seat.label) : "dim", seat.label.padEnd(LABEL_WIDTH + 2));
+    const model = seat.label === ORACLE_LABEL ? input.profile : seat.seated ? seat.profile ?? "" : "not seated";
+    return fit(`${name}${paint(theme, seat.seated ? "muted" : "dim", model)}`, width);
+  });
+  return [...wrap(bold(theme, "Describe a task below and the panel questions you until the plan is clear."), width), "", ...rows];
 }
 
 function statusLine(view: PlanView, input: PlanTabInput, theme?: LobbyTheme): string {
   const parts: string[] = [];
+  const count = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
   if (view.busy) parts.push(`${paint(theme, "accent", spinner(input.tick))} round ${view.turns}`);
-  else if (view.error) parts.push(paint(theme, "error", `✗ ${view.error.split("\n")[0]} — esc, then r retries`));
-  else if (view.reply?.status === "ready") parts.push(paint(theme, "success", "✓ READY — the panel agrees; s saves it as a pending task"));
-  else if (view.awaitingAnswers) {
-    const left = view.answeredChunks > 0 ? " (some answered — enter resumes)" : " — enter answers them one at a time";
-    parts.push(paint(theme, "warning", `● ${view.questions.length} question${view.questions.length === 1 ? "" : "s"} for you${left}`));
-  }
-  if (view.lineComments.length > 0) parts.push(paint(theme, "accent", `◆ ${view.lineComments.length} line comment${view.lineComments.length === 1 ? "" : "s"} to send`));
+  else if (view.error) parts.push(paint(theme, "error", `✗ ${view.error.split("\n")[0]} — r retries`));
+  else if (view.reply?.status === "ready") parts.push(paint(theme, "success", `✓ ready — ${input.saveKey ?? "Ctrl+S"} saves it`));
+  else if (view.awaitingAnswers) parts.push(paint(theme, "warning", `● ${count(view.questions.length, "question")} — enter ${view.answeredChunks > 0 ? "resumes" : "answers them"}`));
+  if (view.lineComments.length > 0) parts.push(paint(theme, "accent", `◆ ${count(view.lineComments.length, "comment")} to send`));
   if (view.saved) parts.push(paint(theme, "success", `saved as ${view.saved.id}`));
   if (!view.busy && view.turns > 0) parts.push(paint(theme, "dim", `round ${view.turns}`));
-  return parts.join(paint(theme, "dim", " · ")) || paint(theme, "dim", "Answer below; enter sends.");
+  return parts.join(paint(theme, "dim", " · "));
 }
 
 /** One seat on the roster: a spinner and its step while it works, then ready, its question count or a failure. */
@@ -124,6 +115,8 @@ function seatCell(seat: SeatView, tick: number, theme?: LobbyTheme): string {
   if (seat.status === "failed") return `${name} ${paint(theme, "error", "✗ failed — r retries")}`;
   if (seat.status === "idle") return `${name} ${paint(theme, "dim", "·")}`;
   if (seat.ready) return `${name} ${paint(theme, "success", "✓ ready")}`;
+  // A seat whose questions the oracle settled itself has nothing waiting on you.
+  if (seat.questions === 0) return `${name} ${paint(theme, "dim", "done")}`;
   return `${name} ${paint(theme, "warning", `${seat.questions} question${seat.questions === 1 ? "" : "s"}`)}`;
 }
 
@@ -158,12 +151,14 @@ export function conversationLines(view: PlanView, width: number, theme?: LobbyTh
       .filter(({ question }) => matches(`${question.from} ${question.text} ${question.options.map((option) => option.label).join(" ")}`, query));
     if (message.role === "you" ? !matches(message.text, query) : message.questions?.length ? questions.length === 0 : !matches(message.text, query)) continue;
     if (lines.length > 0 && lines.at(-1) !== "") lines.push("");
+    // The same turns as the Lobby's conversation: who speaks and when, your words in a band.
+    const time = message.at > 0 ? clock(message.at) : "";
     if (message.role === "you") {
-      lines.push(...wrapHanging(`${bold(theme, paint(theme, "accent", "you"))} ${paint(theme, "dim", "▸")} `, message.text, width));
+      lines.push(speakerLine("you", width, theme, time), ...youLines(message.text, width, theme));
       continue;
     }
-    lines.push(`${bold(theme, paint(theme, "toolTitle", "panel"))} ${paint(theme, "dim", "▸")}`);
-    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : wrap(message.text, width)));
+    lines.push(speakerLine("panel", width, theme, time));
+    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : wrap(message.text, width).map((line) => (line ? `  ${line}` : ""))));
   }
   if (query && lines.length === 0) return wrap(paint(theme, "dim", `Nothing in the conversation matches "${query}".`), width);
   return lines;
@@ -201,7 +196,7 @@ export function renderPlan(input: PlanTabInput, width: number, height: number, t
   if (height <= 0) return [];
   const notice = input.notice ? [paint(theme, "accent", input.notice)] : [];
   const view = input.session;
-  if (!view) return fill([...notice, ...box(width, height - notice.length, intro(input, width - 4, theme), { title: "Plan", right: input.profile, theme })], height, width);
+  if (!view) return fill([...notice, ...box(width, height - notice.length, intro(input, width - 4, theme), { title: "Plan", theme })], height, width);
   const header = [
     ...notice,
     ...wrap(`${bold(theme, view.title ? `Planning · ${view.title}` : "Planning")}  ${statusLine(view, input, theme)}`, width),