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

package/src/lobby/quickfix.ts

@@ -10,13 +10,18 @@ import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } fr
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import type { LobbyFeed } from "./feed.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import type { Classifier } from "../classifier/classifier.ts";
+import { quickFixSize } from "../classifier/triage.ts";
+import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
 export const QUICK_FIX_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 
 export const QUICK_FIX_SOURCE = "QUICK FIX";
 
-export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout";
+/** `held`: the classifier judged the request a task, not a quick fix; it waits for you (r runs it anyway, t makes it a task). */
+export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout" | "held";
 
 export interface QuickFixStep {
   at: number;
@@ -39,6 +44,13 @@ export interface QuickFixJob {
   report?: string;
   error?: string;
   usage?: { input: number; output: number; cost: number; turns: number };
+  /** Why the job was held, or what became of it. */
+  note?: string;
+  /** Run even if the classifier judges it large (r on a held job). */
+  force?: boolean;
+  /** The classifier routed it down (`trivial 0.88: p/big · low → p/cheap · low`); cleared when it re-ran on the configured profile. */
+  route?: string;
+  routedFrom?: string;
 }
 
 export interface QuickFixProfile {
@@ -61,6 +73,12 @@ export interface QuickFixDeps {
   /** Called after every change so the lobby can repaint. */
   onChange?: () => void;
   notify?: (message: string, level: "info" | "warning" | "error") => void;
+  /** Likely files for the prompt, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Holds a request it judges large (a task, not a quick fix) instead of spending a run on it. */
+  classifier?: Classifier;
+  /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
 export const MAX_JOBS = 30;
@@ -120,6 +138,30 @@ export class QuickFixQueue {
     return true;
   }
 
+  /** Run a held job anyway: it goes back in the queue and is not sized again. */
+  runAnyway(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "queued";
+    job.force = true;
+    delete job.note;
+    delete job.startedAt;
+    delete job.finishedAt;
+    this.changed();
+    this.pump();
+    return true;
+  }
+
+  /** A held job that became a task: it leaves the queue with a note. */
+  movedToTask(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "cancelled";
+    job.note = "started as a task in a new session";
+    this.changed();
+    return true;
+  }
+
   /** Abort everything (session shutdown). */
   cancelAll(): void {
     for (const job of this.jobs) if (job.status === "queued") job.status = "cancelled";
@@ -162,17 +204,23 @@ export class QuickFixQueue {
     job.startedAt = Date.now();
     job.thinking = profile.thinking;
     if (profile.model) job.model = profile.model;
-    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     this.changed();
+    const held = job.force ? undefined : await this.tooLarge(job, controller.signal);
+    if (held) {
+      this.controllers.delete(job.id);
+      return this.hold(job, held);
+    }
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     try {
-      const result = await runPiAgent(
+      const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
+      const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
-          task: job.prompt,
+          task: likely ? `${job.prompt}\n\n${likely}` : job.prompt,
           systemPrompt: quickFixPrompt(profile.instructions),
-          tools: QUICK_FIX_TOOLS,
-          model: profile.model,
-          thinking: profile.thinking,
+          tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
+          model,
+          thinking,
           timeoutMs: profile.timeoutMs,
           signal: controller.signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
@@ -181,6 +229,27 @@ export class QuickFixQueue {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
+      let result;
+      if (route) {
+        job.route = routeLabel(route);
+        job.routedFrom = profileLabel(route.from);
+        job.thinking = route.thinking;
+        if (route.model) job.model = route.model;
+        this.changed();
+        result = await attempt(route.model, route.thinking);
+        if (fellShort(result) && !controller.signal.aborted) {
+          // The routed attempt counts in the metrics on its own; the job re-runs on the configured profile.
+          appendMetrics(this.deps.root, this.deps.configDir, [{ ...quickFixMetric({ ...job, status: result.status, finishedAt: Date.now(), usage: result.usage, ...(result.model ? { model: result.model } : {}) }), id: `${job.id}-routed-${job.startedAt}` }]);
+          this.addStep(job, "the routed attempt fell short; running again on the configured model and thinking", Date.now());
+          delete job.route;
+          delete job.routedFrom;
+          job.thinking = profile.thinking;
+          if (profile.model) job.model = profile.model;
+          result = await attempt(profile.model, profile.thinking);
+        }
+      } else {
+        result = await attempt(profile.model, profile.thinking);
+      }
       job.status = result.status;
       job.report = result.output.trim() || undefined;
       job.error = result.error;
@@ -195,6 +264,48 @@ export class QuickFixQueue {
     }
   }
 
+  /** Where the classifier routes this request, or undefined. */
+  private async route(prompt: string, profile: QuickFixProfile, signal: AbortSignal): Promise<EffortRoute | undefined> {
+    try {
+      return await this.deps.effort?.route(prompt, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }, { signal });
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Why a request is too large for a quick fix, when the classifier is sure; undefined runs it. */
+  private async tooLarge(job: QuickFixJob, signal: AbortSignal): Promise<string | undefined> {
+    const jev = this.deps.classifier;
+    if (!jev?.enabled("triage")) return undefined;
+    try {
+      const sized = await quickFixSize(jev, job.prompt, signal);
+      if (!sized || sized.size !== "large" || sized.confidence < jev.config.thresholds.quickFixLargeAt) return undefined;
+      return `looks like a task (large, ${sized.confidence.toFixed(2)})`;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Hold a job instead of running it; nothing ran, so nothing lands in the metrics. */
+  private hold(job: QuickFixJob, note: string): void {
+    job.status = "held";
+    job.note = note;
+    job.finishedAt = Date.now();
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `held: ${jobTitle(job)} — ${note}; r runs it anyway, t makes it a task`, "warning", job.finishedAt);
+    this.deps.notify?.(`bot-lobby quick fix held: ${jobTitle(job)} ${note}`, "warning");
+    this.changed();
+    this.pump();
+  }
+
+  /** The Likely files block for a prompt, or "" (no hints, nothing stands out, out of time). */
+  private async likely(prompt: string, signal: AbortSignal): Promise<string> {
+    try {
+      return (await this.deps.hints?.block(prompt, signal)) ?? "";
+    } catch {
+      return "";
+    }
+  }
+
   private finish(job: QuickFixJob): void {
     job.finishedAt = Date.now();
     for (const step of job.steps) step.pending = false;
@@ -217,11 +328,12 @@ export function quickFixMetric(job: QuickFixJob): MetricRecord {
     agent: QUICK_FIX_SOURCE,
     ...(job.model ? { model: job.model } : {}),
     ...(job.thinking ? { thinking: job.thinking } : {}),
-    status: job.status === "queued" || job.status === "running" ? "failed" : job.status,
+    status: job.status === "queued" || job.status === "running" ? "failed" : job.status === "held" ? "cancelled" : job.status,
     startedAt: new Date(started).toISOString(),
     durationMs: Math.max(0, (job.finishedAt ?? started) - started),
     turns: job.usage?.turns || job.turns || undefined,
     tools: job.tools,
     ...(job.usage ? { input: job.usage.input, output: job.usage.output, cost: job.usage.cost } : {}),
+    ...(job.routedFrom ? { routedFrom: job.routedFrom } : {}),
   };
 }

package/src/lobby/runtime.ts

@@ -14,9 +14,11 @@ 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 { appendMetrics, readClassifierMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, persistedRuns, setMinimized, setWidgetSuppressor, ZenScene, zenSnapshot } from "../pi/ui.ts";
 import { panelLines } from "../pi/zen.ts";
@@ -27,13 +29,15 @@ import { modelLookup } from "../pi/tools.ts";
 import { startPlannedTask, startTask } from "../pi/start-task.ts";
 import type { LobbyAgentKind, LobbyPanel, PanelMember } from "../schemas/configuration.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
+import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
+import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, dialogAsker, loadAskTool, questionnaires, toolAsker, type Asker } from "./ask.ts";
 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 +286,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 });
@@ -306,6 +417,10 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
     profile: () => lobbyProfile(state, "planner"),
     memberProfile: (member) => seatProfile(state, member),
     panel: seats ?? config.lobby.planningPanel,
+    maxRounds: () => loadConfig().lobby.maxPlanningRounds,
+    classifier: classifier(),
+    hints: hintsFor({ cwd: state.ctx.cwd, root: state.root, configDir: state.configDir }),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(state.ctx)(model), thinking).level),
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
@@ -404,6 +519,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     plans: () => listPlannedTasks(state.root, state.configDir),
     comments: (taskId) => readPlanComments(state.root, state.configDir, taskId),
     metrics: () => readMetrics(state.root, state.configDir),
+    classifierMetrics: () => readClassifierMetrics(state.root, state.configDir),
     toOracle: (text) => toOracle(state, text),
     comment: (taskId, text) => addComment(state, taskId, text),
     startPlanned: (plan) => startPlanned(state, plan),
@@ -415,6 +531,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
     answerPanel: () => answerPanel(state),
     defaultPanel: () => loadConfig().lobby.planningPanel,
+    planningRounds: () => loadConfig().lobby.maxPlanningRounds,
     issuesEnabled: () => loadConfig().lobby.issues,
     panels: () => loadConfig().lobby.panels,
     savePanels: (panels) => savePanels(panels),
@@ -436,6 +553,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(),
@@ -612,6 +736,9 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     notify: (message, level) => {
       if (!state.visible) ctx.ui.notify(message, level);
     },
+    hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    classifier: classifier(),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
   });
   runtime = state;
   lobbyFeed.clear();
@@ -630,7 +757,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 +800,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[] = [];