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

package/README.md

@@ -96,6 +96,7 @@ for the Master (see [The lobby](#the-lobby)).
 /bot-lobby claim <taskId>      Take ownership of an orphaned task
 /bot-lobby auto [on|off]        Auto mode: the oracle drives this session's task to completion (alt+g)
 /bot-lobby start-plan PLAN-… [auto]   Start a saved plan here; its agreed plan needs no approval
+/bot-lobby switch <session.jsonl>     Run a saved session in this window (the session browser's s)
 /bot-lobby lobby | help         Open the lobby, or show this list
 ```
 
@@ -113,8 +114,8 @@ or without a task.
                     (the task's status: state, what the agents are doing, the plan checklist)
 ╭ Conversation ──────────────────────────────── Alt+C ╮ ╭ Activity ──────────────────────────────── Alt+A ╮
 │ ──────── task started · add login · 12:04 ───────── │ │ 12:04 MASTER    ✓ scouting designer, backend    │
-│ ● You                                         12:04 │ │ 12:06 DEV       ⠋ reading auth.ts…              │
-│   ▌ add a login page with email + password          │ │ 12:06 DESIGN    ⠋ editing LoginForm.tsx…        │
+│                                        12:04  You ● │ │ 12:06 DEV       ⠋ reading auth.ts…              │
+│        add a login page with email + password ▐     │ │ 12:06 DESIGN    ⠋ editing LoginForm.tsx…        │
 │ ◆ Oracle                                      12:06 │ │ 12:06 QUICK FIX ✓ done: rename getUser          │
 │   Proposal                                          │ │                                                 │
 │   • LoginForm component                             │ │                                                 │
@@ -130,10 +131,12 @@ or without a task.
 
 - **1 Lobby** — the task's status (its state box, what the agents are
   doing and the plan checklist), then the conversation with the oracle
-  (its text only: no tool rows, no thinking; each turn under a `● You` or
-  `◆ Oracle` line with its time, your words in pi's user-message band, the
-  oracle's replies as Markdown, and events such as a task starting as a
-  rule), an activity log that narrates
+  laid out like a chat (its text only: no tool rows, no thinking): your
+  messages on the right as bubbles in the accent colour on pi's
+  user-message background, each only as wide as its text (at most about
+  three quarters of the pane), under `12:04  You ●`; the oracle's replies on
+  the left as Markdown under `◆ Oracle  12:06`; and events such as a task
+  starting as a centred rule), an activity log that narrates
   every tool call in plain words (`reading index.html…`, `searching for
   "router" in src`, `running npm test`, `delegating to backend: Step 2 …`) from
   the Master and every subagent, and a single **Thinking** pane — the one place
@@ -165,8 +168,16 @@ or without a task.
   twice discards one. `n` types a new task that starts in its own session, `o`
   shows the session driving the selected task, `x` twice stops a background
   session, and `alt+g` switches auto mode for the selected task. Rows say who
-  drives each task (`this session`, `background`, another session's id) and
-  mark auto mode `⟳ auto`.
+  drives each task (`this session`, `background`, another running session, or
+  `not running` once its session has ended) and mark auto mode `⟳ auto`.
+  **Cleaning up:** every finished task is listed, and `a` archives the
+  selected one — it leaves every list and moves, folder and all, to
+  `.pi/bot-lobby/archive/tasks/` (a task still under way is abandoned first,
+  so `a` asks twice). `A` twice archives every finished task at once. `v`
+  shows the archive as an ARCHIVED section, where `a` restores a task as it
+  was. `d` twice deletes a task, on the list or in the archive, for good. A
+  task a running session drives (this window's, a background one, or another
+  terminal's) is left alone until that session stops or cancels it.
 - **3 Plan** — task planning mode with a planning panel. Describe what you
   want and every seat grills you from its own domain, on the model and
   thinking level its settings name: **DEV** (APIs, data, errors, security,
@@ -240,7 +251,7 @@ typing). These work in both modes:
 | `alt+s` | bot-lobby settings: every agent's model, thinking and time limit, and the lobby's switches |
 | `ctrl+f` (or `/` while browsing) | search the current tab |
 | `ctrl+s` | save the plan from the Plan tab to the pending tasks — while typing too, from any tab |
-| `alt+o` | the session switcher: this window, its background sessions, and tasks other terminals drive |
+| `alt+o` | the session browser: view, message or switch to any session in the project |
 | `alt+n` | type a new task that starts in its own session, named after it |
 | `alt+g` | auto mode on or off for the task in view (the selected one on Tasks) |
 | `tab` / `shift+tab`, `alt+1`…`alt+5` | switch tabs |
@@ -320,14 +331,35 @@ between sessions from the lobby.
   empty prompt puts the question to you in this window with pi's own dialog
   (`esc` there cancels it, as it would in that session). With the lobby
   hidden, a notice says who is waiting.
-- **Switch.** `alt+o` opens the switcher: this window, every background
-  session it started (working, idle, ended; `⟳ auto`; questions waiting), and
-  tasks that sessions in other terminals drive. `enter` shows one in the Lobby
-  tab, `n` starts a new one, `x` twice stops a background session. For a task
-  another terminal drives, the Lobby shows its conversation from its session
-  file, and your messages go to its task inbox (`inbox.jsonl`) — its own
-  session passes them to its oracle within a few seconds — while its live
-  activity stays in that terminal.
+- **Browse.** `alt+o` opens the session browser: every session in the
+  project, grouped by where it runs — **this window**, the **background**
+  sessions it started (working, idle or ended, `⟳` auto mode, `●` questions
+  waiting), sessions running in **other terminals** (with or without a task),
+  and tasks whose session is **not running** (it ended, or none ever took
+  the task). Beside the list, a preview of the one picked: where it runs, its
+  task and progress, what `enter` and `s` do with it, and the end of its
+  conversation. Every running session keeps a heartbeat in
+  `.pi/bot-lobby/sessions/` so the others can see it; one that goes quiet or
+  whose process ends drops off.
+- **View.** `enter` shows the picked session in the Lobby tab. A background
+  session streams live; for another terminal's session or a task that is not
+  running, the conversation comes from its saved session file. What you type
+  goes to its oracle: a background session is steered directly, another
+  terminal's session gets it through its inbox within a few seconds, and a
+  task that is not running keeps it in its task inbox (`inbox.jsonl`) until a
+  session picks the task up.
+- **Switch.** `s` — in the browser, or while browsing a session shown in the
+  Lobby tab — runs that session in this window with pi's own session switch
+  (through `/bot-lobby switch`), and the lobby comes back on it. A background
+  session's process is stopped first, so only this window writes its
+  session; a task that is not running resumes its session here (one that no
+  session ever owned is taken over instead, like `/bot-lobby claim`). A
+  session running in another terminal stays there: switch in that terminal,
+  or close it and resume it here. Not while this window's oracle is working.
+  The session this window leaves keeps its task, which then shows as not
+  running until you switch back.
+- **Stop or start.** `x` twice stops a background session; `n` starts a new
+  task in a new session.
 
 Background sessions belong to the window that started them: they keep running
 while you switch pi sessions there, and stop when that pi exits. Their tasks
@@ -726,6 +758,9 @@ and the output contract — and an empty layer is dropped.
 ├── Backend/knowledge/          knowledge.md, engineering-standards.md, decisions.md, completed-tasks.md
 ├── QA/knowledge/               knowledge.md, testing-standards.md, decisions.md, completed-tasks.md
 ├── archive/<Agent>/            previous knowledge versions (outside all retrieval paths)
+├── archive/tasks/TASK-…/       archived tasks, whole, out of every list until restored
+├── sessions/<id>.json          heartbeats of the pi sessions running in the project
+├── sessions/<id>.inbox.jsonl   messages for a running session's oracle, and their delivery
 ├── backlog/PLAN-<slug>.json    pending tasks saved from the planner (optionally linked to an issue)
 ├── metrics.jsonl               one line per finished run of any agent, for the Metrics tab
 └── tasks/TASK-<stamp>/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/lobby/keys.ts

@@ -12,7 +12,7 @@ export const LOBBY_ACTIONS = {
   settings: { key: "alt+s", help: "bot-lobby settings: each agent's model and thinking, the lobby" },
   search: { key: "ctrl+f", help: "search the current tab" },
   savePlan: { key: "ctrl+s", help: "save the plan being made in the Plan tab to the pending tasks" },
-  sessions: { key: "alt+o", help: "switch session: this window, background sessions, other terminals" },
+  sessions: { key: "alt+o", help: "browse sessions: view one, message it, or switch this window to it" },
   newSession: { key: "alt+n", help: "start a task in a new session, named after it" },
   toggleAuto: { key: "alt+g", help: "auto mode: the oracle drives the task to completion without asking" },
   nextTab: { key: "tab", help: "next tab" },

package/src/lobby/runtime.ts

@@ -14,7 +14,9 @@ import { listTasks, loadTask } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig, saveConfig } from "../state/project.ts";
 import { addPlanComment, readPlanComments } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
-import { sendToInbox } from "../state/inbox.ts";
+import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
+import { livePresence } from "../state/presence.ts";
+import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
 import { appendMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
@@ -33,7 +35,7 @@ import { answerMessage, dialogAsker, loadAskTool, questionnaires, toolAsker, typ
 import { QuickFixQueue } from "./quickfix.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
-import { LobbyView, type LobbyHost, type TabId } from "./view.ts";
+import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
 import type { LobbyTheme } from "./layout.ts";
 import { createMarkdownRenderer } from "./markdown.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
@@ -282,6 +284,113 @@ function switchAuto(state: Runtime, taskId: string, on: boolean): void {
   autoSeen.set(taskId, { at: Date.now(), on });
 }
 
+/** Heartbeats of the other sessions running in this project, reread at most once a second (every frame asks). */
+let liveSeen: { at: number; root: string; sessions: LiveSession[] } | undefined;
+const LIVE_READ_MS = 1000;
+
+function liveSessions(state: Runtime): LiveSession[] {
+  const now = Date.now();
+  if (liveSeen && liveSeen.root === state.root && now - liveSeen.at < LIVE_READ_MS) return liveSeen.sessions;
+  const me = state.ctx.sessionManager.getSessionId();
+  let sessions: LiveSession[] = [];
+  try {
+    sessions = livePresence(state.root, state.configDir, now).filter((presence) => presence.sessionId !== me);
+  } catch {
+    // An unreadable folder only means no other sessions are listed.
+  }
+  liveSeen = { at: now, root: state.root, sessions };
+  return sessions;
+}
+
+/** Leave a message for a session running in another terminal. */
+function sendToSession(state: Runtime, sessionId: string, text: string): string {
+  try {
+    leaveForSession(state.root, state.configDir, sessionId, text, state.ctx.sessionManager.getSessionId());
+  } catch (error) {
+    return (error as Error).message;
+  }
+  lobbyFeed.log("LOBBY", "message for another session's oracle saved", "info");
+  return "sent — that session passes it to its oracle within a few seconds";
+}
+
+/** The lobby reopens on the session this window switches to (set just before asking pi to switch). */
+let reopenAfterSwitch = false;
+
+/**
+ * Run another session in this window through `/bot-lobby switch`, which pi
+ * runs with a command context (the only one that may replace the session).
+ * A background session is stopped first, so one process writes its file; a
+ * task no session owns is claimed instead.
+ */
+async function switchTo(state: Runtime, target: SwitchTarget): Promise<string> {
+  if (!state.ctx.isIdle()) return "this window's oracle is working — esc stops it, then switch";
+  if (target.claimTaskId) {
+    reopenAfterSwitch = false;
+    state.pi.sendUserMessage(`/bot-lobby claim ${target.claimTaskId}`, { expandPromptTemplates: true });
+    return `taking ${target.claimTaskId} over in this window`;
+  }
+  let file = target.background?.sessionFile;
+  if (target.background) {
+    target.background.stop();
+    await target.background.whenExited();
+  }
+  file ??= target.sessionId ? await chats.locate(target.sessionId) : undefined;
+  if (!file) return `could not find ${target.name}'s session file — /resume lists every saved session`;
+  reopenAfterSwitch = true;
+  state.pi.sendUserMessage(`/bot-lobby switch ${file}`, { expandPromptTemplates: true });
+  return `switching this window to ${target.name}…`;
+}
+
+/** Why a task cannot be archived or deleted now: a running session drives it. */
+function drivenElsewhere(state: Runtime, task: Task): string | undefined {
+  if (TERMINAL_STATES.includes(task.state) || !task.ownerSessionId) return undefined;
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) return `this window drives ${task.id} — cancel it first (/bot-lobby cancel ${task.id})`;
+  const background = backgroundSessions().find((session) => session.alive && session.sessionId === task.ownerSessionId);
+  if (background) return `${background.name} is driving ${task.id} in the background — stop it first (x x)`;
+  if (liveSessions(state).some((session) => session.sessionId === task.ownerSessionId)) return `a session in another terminal is driving ${task.id} — finish or cancel it there first`;
+  return undefined;
+}
+
+function archiveTask(state: Runtime, taskId: string): string {
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) return `no task ${taskId}`;
+  const busy = drivenElsewhere(state, task);
+  if (busy) return busy;
+  try {
+    archiveTaskOnDisk(state.root, state.configDir, taskId);
+  } catch (error) {
+    return (error as Error).message;
+  }
+  lobbyFeed.log("LOBBY", `archived ${taskId}`, "info");
+  return `archived ${taskId}${TERMINAL_STATES.includes(task.state) ? "" : " (abandoned first)"} — v shows archived tasks, a restores one`;
+}
+
+function restoreTask(state: Runtime, taskId: string): string {
+  try {
+    restoreTaskOnDisk(state.root, state.configDir, taskId);
+  } catch (error) {
+    return (error as Error).message;
+  }
+  lobbyFeed.log("LOBBY", `restored ${taskId}`, "info");
+  return `restored ${taskId} to the task list`;
+}
+
+function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"): string {
+  if (where === "list") {
+    const task = loadTask(state.root, state.configDir, taskId);
+    if (!task) return `no task ${taskId}`;
+    const busy = drivenElsewhere(state, task);
+    if (busy) return busy;
+  }
+  try {
+    deleteTaskOnDisk(state.root, state.configDir, taskId, where);
+  } catch (error) {
+    return (error as Error).message;
+  }
+  lobbyFeed.log("LOBBY", `deleted ${taskId}`, "warning");
+  return `deleted ${taskId} for good`;
+}
+
 /** A task's status box without animations, for a session other than this window's. */
 function taskScene(state: Runtime, task: Task, width: number, height: number): string[] {
   return panelLines(task, persistedRuns(task), Date.now(), false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme });
@@ -436,6 +545,13 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     isAuto: (taskId) => autoFor(state, taskId),
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
+    sendToSession: (sessionId, text) => sendToSession(state, sessionId, text),
+    liveSessions: () => liveSessions(state),
+    switchTo: (target) => switchTo(state, target),
+    archivedTasks: () => listArchivedTasks(state.root, state.configDir),
+    archiveTask: (taskId) => archiveTask(state, taskId),
+    restoreTask: (taskId) => restoreTask(state, taskId),
+    deleteTask: (taskId, where) => deleteTask(state, taskId, where),
     sessionChat: (sessionId) => chats.chat(sessionId),
     taskScene: (task, width, height) => taskScene(state, task, width, height),
     requestRender: () => tui.requestRender(),
@@ -630,7 +746,7 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   // The owner's clock (pi/owner.ts) delivers comments and messages and drives auto mode; the lobby logs what it did.
   onOwnerEvent((event) => {
     if (event.kind === "comments") lobbyFeed.log("LOBBY", `passed ${event.count} plan comment${event.count === 1 ? "" : "s"} on ${event.taskId} to the oracle`, "info");
-    else if (event.kind === "inbox") lobbyFeed.log("LOBBY", `passed ${event.count} message${event.count === 1 ? "" : "s"} from another session to the oracle`, "info");
+    else if (event.kind === "inbox" || event.kind === "messages") lobbyFeed.log("LOBBY", `passed ${event.count} message${event.count === 1 ? "" : "s"} from another session to the oracle`, "info");
     else if (event.kind === "auto") lobbyFeed.log("LOBBY", `auto mode ${event.on ? "on" : "off"} for ${event.taskId}`, event.on ? "success" : "info");
     else if (event.kind === "nudge") lobbyFeed.log("LOBBY", `auto mode: keeping the oracle going on ${event.taskId}`, "info");
     else lobbyFeed.log("LOBBY", `auto mode: no progress on ${event.taskId} — it needs you`, "warning");
@@ -673,7 +789,11 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
   });
   pi.on("session_start", (_event, ctx) => {
     initLobby(pi, ctx, configDir);
-    autoOpenLobby();
+    // A switch asked for from the lobby lands back in the lobby, on the session it switched to.
+    if (reopenAfterSwitch) {
+      reopenAfterSwitch = false;
+      showLobby("lobby");
+    } else autoOpenLobby();
   });
   pi.on("session_shutdown", () => shutdown());
   pi.on("ui_prompt_start", () => promptStarted());

package/src/lobby/session-files.ts

@@ -78,6 +78,18 @@ export class SessionChats {
     this.now = now;
   }
 
+  /** A session's file, asking pi's list at once when it is not known yet. */
+  async locate(sessionId: string): Promise<string | undefined> {
+    const known = this.paths.get(sessionId);
+    if (known) return known;
+    try {
+      for (const session of await this.list()) this.paths.set(session.id, session.path);
+    } catch {
+      return undefined;
+    }
+    return this.paths.get(sessionId);
+  }
+
   /** Tell the cache where a session's file is (a background session reports it). */
   remember(sessionId: string, path: string): void {
     this.paths.set(sessionId, path);

package/src/lobby/sessions.ts

@@ -49,6 +49,9 @@ export interface SessionStart {
 
 let counter = 0;
 
+/** How long a stopped session gets to end before it is killed. */
+export const STOP_GRACE_MS = 5000;
+
 export class BackgroundSession {
   readonly key: string;
   readonly name: string;
@@ -69,6 +72,8 @@ export class BackgroundSession {
   private stderr = "";
   private nextId = 0;
   private readonly onChange: () => void;
+  private readonly exitWaiters: Array<() => void> = [];
+  private killTimer?: ReturnType<typeof setTimeout>;
 
   constructor(proc: SessionProcess, start: SessionStart, onChange: () => void = () => {}) {
     counter += 1;
@@ -98,10 +103,18 @@ export class BackgroundSession {
     this.status = "exited";
     this.exitCode = code;
     this.dialogs.length = 0;
+    if (this.killTimer) clearTimeout(this.killTimer);
     this.feed.say("note", reason);
+    for (const resolve of this.exitWaiters.splice(0)) resolve();
     this.onChange();
   }
 
+  /** Resolves once the process has ended (at once if it already has). */
+  whenExited(): Promise<void> {
+    if (!this.alive) return Promise.resolve();
+    return new Promise((resolve) => this.exitWaiters.push(resolve));
+  }
+
   get alive(): boolean {
     return this.status !== "exited";
   }
@@ -147,8 +160,11 @@ export class BackgroundSession {
     this.onChange();
   }
 
-  /** Stop the session: its process ends (its task keeps its state and can be resumed or claimed later). */
-  stop(): void {
+  /**
+   * Stop the session: its process ends (its task keeps its state and can be
+   * resumed or claimed later). One that does not end within `graceMs` is killed.
+   */
+  stop(graceMs = STOP_GRACE_MS): void {
     if (!this.alive) return;
     try {
       this.proc.stdin?.end();
@@ -160,6 +176,16 @@ export class BackgroundSession {
     } catch {
       // Already gone.
     }
+    if (this.killTimer || graceMs <= 0) return;
+    this.killTimer = setTimeout(() => {
+      if (!this.alive) return;
+      try {
+        this.proc.kill("SIGKILL");
+      } catch {
+        // Already gone.
+      }
+    }, graceMs);
+    this.killTimer.unref?.();
   }
 
   /** Split stdout into JSON lines (LF only, as pi's RPC framing requires) and handle each. */

package/src/lobby/tabs/home.ts

@@ -94,45 +94,72 @@ export function activityLine(entry: ActivityEntry, width: number, tick: number,
   return `${paint(theme, "dim", clock(entry.at))} ${who} ${mark} ${body}`;
 }
 
-/** How each speaker is shown: a mark and a name in its colour. */
+/**
+ * How each speaker is shown: a mark and a name in its colour, and the side of
+ * the conversation it speaks from — you on the right, the oracle on the left.
+ */
 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 }>;
+  you: { mark: "●", name: "You", color: "accent", side: "right" },
+  oracle: { mark: "◆", name: "Oracle", color: "toolTitle", side: "left" },
+  panel: { mark: "◆", name: "Panel", color: "toolTitle", side: "left" },
+} as const satisfies Record<string, { mark: string; name: string; color: LobbyColor; side: "left" | "right" }>;
 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. */
+/** The oracle's replies sit under its name, past its mark. */
 const BODY_INDENT = 2;
+/** Your messages take at most this share of the pane, the oracle's this much, so the two sides read apart. */
+const YOU_SHARE = 0.72;
+const ORACLE_SHARE = 0.86;
+/** Narrower panes give every message (nearly) the full width. */
+const NARROW = 48;
+
+/** The widest a message from one side may be in a pane `width` wide. */
+function messageWidth(width: number, share: number, margin: number): number {
+  return Math.max(1, width < NARROW ? width - margin : Math.floor(width * share));
+}
 
-/** `◆ 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;
+/**
+ * Who speaks and when: `◆ Oracle ········ 12:04` on the left for the oracle,
+ * `12:04  You ●` on the right for you. `note` is the time, or what the
+ * speaker is doing (`⠋ writing`).
+ */
+export function speakerLine(speaker: Speaker, width: number, theme?: LobbyTheme, note = ""): string {
+  const { mark, name, color, side } = SPEAKERS[speaker];
+  const who = paint(theme, color, mark);
+  const label = bold(theme, paint(theme, color, name));
+  const dimmed = note ? paint(theme, "dim", note) : "";
+  if (side === "right") {
+    const head = dimmed ? `${dimmed}  ${label} ${who}` : `${label} ${who}`;
+    return `${" ".repeat(Math.max(0, width - visibleWidth(head)))}${head}`;
+  }
+  const left = `${who} ${label}`;
+  const gap = width - visibleWidth(left) - visibleWidth(dimmed);
+  return gap >= 1 && dimmed ? `${left}${" ".repeat(gap)}${dimmed}` : 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).
+ * What you wrote: a bubble on the right, only as wide as its longest line (up
+ * to `YOU_SHARE` of the pane), your words in the accent colour on pi's
+ * user-message background — or, where the theme has no background, closed
+ * by a bar in that colour.
  */
 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)}`);
+  const most = Math.max(1, messageWidth(width, YOU_SHARE, 4) - 2);
+  const lines = wrap(text, most);
+  const inner = Math.max(1, ...lines.map((line) => visibleWidth(line)));
+  const pad = " ".repeat(Math.max(0, width - inner - 2));
+  const bubble = theme?.bg
+    ? (line: string) => theme.bg!("userMessageBg", ` ${fit(paint(theme, "accent", line), inner)} `)
+    : (line: string) => `${fit(paint(theme, "accent", line), inner)} ${paint(theme, "accent", "▐")}`;
+  return lines.map((line) => `${pad}${bubble(line)}`);
 }
 
-/** The oracle's reply as Markdown, under its name. */
+/** The oracle's reply as Markdown on the left, 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}` : ""));
+  return markdownLines(text, Math.max(1, messageWidth(width, ORACLE_SHARE, 0) - 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. */
@@ -146,9 +173,10 @@ export function eventLines(text: string, at: number, width: number, theme?: Lobb
 }
 
 /**
- * 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).
+ * The conversation, oldest first, like a chat: your messages as bubbles on
+ * the right, the oracle's replies in Markdown on the left, each turn under a
+ * line naming its speaker and time, events as centred 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[] = [];

package/src/lobby/tabs/tasks.ts

@@ -13,13 +13,14 @@ import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
 import { ago, beside, bold, box, detailWindow, fill, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
 
-export type TaskSection = "mine" | "others" | "pending" | "recent";
+export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
 /** How a row is ticked off: still to do (a plan, or a task under way), completed, or abandoned. */
 export type CheckState = "open" | "done" | "dropped";
 
 export interface TaskRow {
-  kind: "task" | "plan";
+  /** A task on the list, a saved plan, or a task in the archive. */
+  kind: "task" | "plan" | "archived";
   id: string;
   title: string;
   section: TaskSection;
@@ -31,7 +32,7 @@ export interface TaskRow {
   progress?: { done: number; total: number };
   /** Who drives it, for tasks other sessions own. */
   owner?: string;
-  /** How long ago it finished (finished tasks) or was saved (plans), as `3h`. */
+  /** How long ago it finished (finished tasks), was saved (plans) or was archived, as `3h`. */
   age?: string;
   /** The GitHub issue a plan came from. */
   issue?: number;
@@ -45,6 +46,10 @@ export interface RowContext {
   names?: ReadonlyMap<string, string>;
   /** Tasks with auto mode on. */
   auto?: ReadonlySet<string>;
+  /** Sessions running now (from their heartbeats); a task whose owner is not among them says so. */
+  live?: ReadonlySet<string>;
+  /** Archived tasks, listed last when shown. */
+  archived?: readonly Task[];
 }
 
 export const SECTION_TITLES: Record<TaskSection, string> = {
@@ -52,6 +57,7 @@ export const SECTION_TITLES: Record<TaskSection, string> = {
   others: "OTHER SESSIONS",
   pending: "PENDING",
   recent: "FINISHED",
+  archived: "ARCHIVED",
 };
 
 /** The box each row wears: empty while there is work to do, ticked when completed, crossed when abandoned. */
@@ -63,9 +69,6 @@ export function checkState(task: Task): CheckState {
   return "open";
 }
 
-/** Finished tasks listed under RECENT. */
-export const RECENT_LIMIT = 8;
-
 /** Checklist progress as `3/7`, or undefined before a plan exists. */
 export function taskProgress(task: Task): { done: number; total: number } | undefined {
   if (!task.plan) return undefined;
@@ -74,13 +77,14 @@ export function taskProgress(task: Task): { done: number; total: number } | unde
   return { done: steps.filter((step) => step.status === "done").length, total: steps.length };
 }
 
-function ownerLabel(task: Task, sessionId: string | undefined, names?: ReadonlyMap<string, string>): string {
-  if (!task.ownerSessionId) return "no owner";
+function ownerLabel(task: Task, sessionId: string | undefined, names?: ReadonlyMap<string, string>, live?: ReadonlySet<string>): string {
+  if (!task.ownerSessionId) return "not running";
   if (task.ownerSessionId === sessionId) return "this session";
   const name = names?.get(task.ownerSessionId);
   // A background session is named after its task, so the row's title already says which one.
   if (name) return name === task.title ? "background" : `background · ${name}`;
-  return `session ${task.ownerSessionId.slice(0, 8)}`;
+  // An ended session's id tells nobody anything: say that nothing runs the task.
+  return live && !live.has(task.ownerSessionId) ? "not running" : `session ${task.ownerSessionId.slice(0, 8)}`;
 }
 
 /** Rows in display order: this session's task, other sessions', pending plans, then recent finished tasks. */
@@ -98,7 +102,7 @@ export function taskRows(tasks: readonly Task[], plans: readonly PlannedTask[],
       ...(task.paused && section !== "recent" ? { paused: true } : {}),
       check: checkState(task),
       ...(progress ? { progress } : {}),
-      ...(section === "others" ? { owner: ownerLabel(task, sessionId, context.names) } : {}),
+      ...(section === "others" ? { owner: ownerLabel(task, sessionId, context.names, context.live) } : {}),
       ...(section === "recent" ? { age: ago(now - Date.parse(task.updatedAt)) } : {}),
       ...(auto ? { auto: true } : {}),
     };
@@ -116,7 +120,16 @@ export function taskRows(tasks: readonly Task[], plans: readonly PlannedTask[],
       ...(plan.createdAt ? { age: ago(now - Date.parse(plan.createdAt)) } : {}),
       ...(plan.issue ? { issue: plan.issue.number } : {}),
     })),
-    ...tasks.filter((task) => TERMINAL_STATES.includes(task.state)).slice(0, RECENT_LIMIT).map((task) => row(task, "recent")),
+    ...tasks.filter((task) => TERMINAL_STATES.includes(task.state)).map((task) => row(task, "recent")),
+    ...(context.archived ?? []).map((task): TaskRow => ({
+      kind: "archived",
+      id: task.id,
+      title: task.title,
+      section: "archived",
+      status: task.state,
+      check: checkState(task),
+      age: ago(now - Date.parse(task.archivedAt ?? task.updatedAt)),
+    })),
   ];
 }
 
@@ -151,6 +164,7 @@ export function checkMark(row: Pick<TaskRow, "check" | "status" | "paused">, the
 /** A title as its box says: struck through and dim once abandoned, bold while selected. */
 function rowTitle(row: TaskRow, selected: boolean, theme?: LobbyTheme): string {
   if (row.check === "dropped") return paint(theme, "dim", strike(theme, row.title));
+  if (row.kind === "archived") return selected ? bold(theme, row.title) : paint(theme, "dim", row.title);
   if (row.check === "done") return selected ? bold(theme, row.title) : paint(theme, "muted", row.title);
   return selected ? bold(theme, row.title) : row.title;
 }
@@ -216,9 +230,11 @@ export function listLines(rows: readonly TaskRow[], selected: number, width: num
 /** The list pane's right-hand count: what is open and what is finished, or how many rows match a search. */
 export function listCount(rows: readonly TaskRow[], query?: string): string {
   if (query) return `${rows.length} match${rows.length === 1 ? "" : "es"}`;
-  const open = rows.filter((row) => row.check === "open").length;
-  const finished = rows.length - open;
-  return [open ? `${open} open` : "", finished ? `${finished} finished` : ""].filter(Boolean).join(" · ") || "0";
+  const listed = rows.filter((row) => row.kind !== "archived");
+  const open = listed.filter((row) => row.check === "open").length;
+  const finished = listed.length - open;
+  const archived = rows.length - listed.length;
+  return [open ? `${open} open` : "", finished ? `${finished} finished` : "", archived ? `${archived} archived` : ""].filter(Boolean).join(" · ") || "0";
 }
 
 const COMMENT_MARKS: Record<PlanComment["status"], string> = { open: "○", delivered: "◐", addressed: "✓" };