@a-t-h-i/bot-lobby 0.6.3 → 0.6.5

package/src/execution/pi-runner.ts

@@ -4,12 +4,20 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { activityWord } from "../pi/activity.ts";
 import { shortDuration } from "../text.ts";
+import { readRelayRequest } from "../ask/relay.ts";
+import type { AskQuestion, AskResult } from "../ask/types.ts";
 
 /** Live control over one running subagent: queue a steering message for its next turn. */
 export interface RunHandle {
   steer(text: string): void;
 }
 
+/**
+ * Puts a subagent's relayed questions to the user (see ask/relay.ts). The
+ * signal aborts when the run ends first, so the questionnaire is put away.
+ */
+export type RelayAsk = (questions: AskQuestion[], signal: AbortSignal) => Promise<AskResult>;
+
 export interface PiRunOptions {
   cwd: string;
   task: string;
@@ -33,6 +41,28 @@ export interface PiRunOptions {
   wrapUpAtMs?: number;
   /** Receives the steering handle once the process is running. */
   onStart?: (handle: RunHandle) => void;
+  /** Under a task time budget: when the agent is warned, when its time is up, and who decides on more (see ProcessRunOptions). */
+  time?: TimeLimit;
+  /** Answers the agent's relayed questions; without it they are cancelled like any other dialog. */
+  onAsk?: RelayAsk;
+}
+
+/**
+ * A run's allotted time under a task budget. At `headsUpAtMs` the agent is
+ * told how much is left; at `upAtMs` it is steered to stop and report where it
+ * left off. Once that report is in (its turn ended), `onTimeUp` decides: more
+ * ms keeps the same process going with its context (a follow-up prompt), 0
+ * ends it. The hard deadline (`timeoutMs`) and the stall watchdog wait while
+ * the decision is pending, and move out with any time granted.
+ */
+export interface TimeLimit {
+  upAtMs: number;
+  headsUpAtMs?: number;
+  headsUpMessage?: string;
+  upMessage: string;
+  onTimeUp?: (report: string) => Promise<{ extraMs: number; message?: string }>;
+  /** Time the agent gets to write its report after `upAtMs` before it is stopped. */
+  graceMs: number;
 }
 
 export interface ProcessOutcome {
@@ -47,6 +77,10 @@ export interface ProcessOutcome {
   wrappedUp?: boolean;
   /** The RPC host rejected the prompt itself. */
   protocolError?: string;
+  /** Stopped at its allotted time and not given more: its report says where it left off. */
+  timeUp?: boolean;
+  /** Time granted past its allotment, in ms. */
+  extendedMs?: number;
 }
 
 /** Streaming agent events forwarded as they arrive on stdout. */
@@ -61,8 +95,16 @@ export type PiStreamEvent =
   | { type: "compaction" }
   | { type: "usage"; input: number; output: number; cost: number; model?: string }
   | { type: "wrap_up" }
+  /** Its allotted time is up: it was asked to stop and report where it left off. */
+  | { type: "time_up" }
+  /** It was given `ms` more and carries on. */
+  | { type: "extended"; ms: number }
   /** One finished thinking block, bounded to `MAX_THOUGHT_CHARS`. */
   | { type: "thought"; text: string }
+  /** It asked the user (relayed); its clocks wait until the answers are back. */
+  | { type: "asking"; questions: number }
+  /** The answers went back after `waitedMs` of waiting on the user. */
+  | { type: "answered"; waitedMs: number }
   | { type: "heartbeat" };
 
 /** Longest thought forwarded from a subagent stream. */
@@ -84,6 +126,8 @@ export interface ProcessRunOptions {
   onStart?: (handle: RunHandle) => void;
   /** Grace between the deadline abort and the hard kill. */
   graceMs?: number;
+  time?: TimeLimit;
+  onAsk?: RelayAsk;
 }
 
 export type ProcessRunner = (
@@ -99,6 +143,8 @@ export interface PiRunResult {
   model?: string;
   stalled?: boolean;
   wrappedUp?: boolean;
+  timeUp?: boolean;
+  extendedMs?: number;
 }
 
 export interface ParsedStream {
@@ -134,12 +180,17 @@ export interface ControlEvent {
   method?: string;
   willRetry?: boolean;
   delayMs?: number;
+  /** extension_ui_request: the dialog's title and (editor) prefilled text. */
+  title?: string;
+  prefill?: string;
 }
 
 /** Buffers one JSON-mode stream, keeping only lines parsePiStream consumes. */
 export interface StreamCollector {
   push(chunk: string): void;
   finish(): string;
+  /** What is kept so far, without ending the stream. */
+  peek(): string;
 }
 
 const INTERESTING = [
@@ -268,6 +319,9 @@ export function createStreamCollector(
       if (partial.length > 0) keep(partial.splice(0).join(""));
       return kept.join("\n");
     },
+    peek() {
+      return kept.join("\n");
+    },
   };
 }
 
@@ -422,6 +476,14 @@ interface RunState {
   wrappedUp: boolean;
   settled: boolean;
   protocolError?: string;
+  /** Told its time is up; its next turn end waits on the decision. */
+  timeUp: boolean;
+  headsUp: boolean;
+  /** Waiting on the decision: the agent is idle, so the deadline and the stall watchdog wait too. */
+  deciding: boolean;
+  /** Relayed questions waiting on the user: every clock and the watchdog wait. */
+  asking: number;
+  extendedMs: number;
 }
 
 /** Smallest positive limit, used to pick a watchdog cadence that can see it. */
@@ -452,9 +514,14 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
     });
-    const state: RunState = { killed: false, timedOut: false, stalled: false, wrappedUp: false, settled: false };
+    const state: RunState = { killed: false, timedOut: false, stalled: false, wrappedUp: false, settled: false, timeUp: false, headsUp: false, deciding: false, asking: 0, extendedMs: 0 };
     const input = rpcInput(proc);
     const started = Date.now();
+    const time = options.time;
+    // The allotted time counts from here; a grant restarts it.
+    let clockStart = started;
+    let upAtMs = time?.upAtMs ?? 0;
+    let headsUpAtMs = time?.headsUpAtMs ?? 0;
     let lastOutput = started;
     let quietGraceUntil = 0;
     let toolsInFlight = 0;
@@ -462,6 +529,11 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
     let exitCode: number | undefined;
     let settleTimer: ReturnType<typeof setTimeout> | undefined;
     let done = false;
+    // Time spent waiting on the user's answers is not the agent's: its limits move out by it.
+    let deadlineAt = started + options.timeoutMs;
+    let askStarted = 0;
+    let pausedMs = 0;
+    const asks = new AbortController();
 
     const onEvent = (event: PiStreamEvent) => {
       if (event.type === "tool_execution_start") toolsInFlight += 1;
@@ -469,18 +541,84 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       if (event.type === "retry") quietGraceUntil = Date.now() + event.delayMs;
       options.onEvent?.(event);
     };
+    // A turn that ended after the time ran out waits on the decision; any other ends the run.
+    let turnDone = false;
+    const turnOver = () => {
+      if (turnDone) return;
+      turnDone = true;
+      clearTimeout(settleTimer);
+      settleTimer = undefined;
+      if (state.timeUp && time?.onTimeUp && !done && !state.killed) decide(time.onTimeUp);
+      else input.close();
+    };
+    const decide = (onTimeUp: NonNullable<TimeLimit["onTimeUp"]>) => {
+      state.deciding = true;
+      clearTimeout(deadline);
+      const report = parsePiStream(collector.peek()).text;
+      onTimeUp(report).then(({ extraMs, message }) => {
+        if (done || state.killed) return;
+        state.deciding = false;
+        if (extraMs <= 0) return input.close();
+        // Granted: the same agent carries on where it stopped, its context intact.
+        state.timeUp = false;
+        state.headsUp = false;
+        state.settled = false;
+        state.extendedMs += extraMs;
+        turnDone = false;
+        clockStart = Date.now();
+        lastOutput = clockStart;
+        upAtMs = extraMs;
+        // The user just named the time it has: no heads-up quoting the old allotment.
+        headsUpAtMs = 0;
+        deadlineAt = Date.now() + extraMs + (time?.graceMs ?? 0);
+        deadline = setTimeout(onDeadline, extraMs + (time?.graceMs ?? 0));
+        input.send({ type: "prompt", message: message ?? "You have more time: carry on from where you left off and finish." });
+        options.onEvent?.({ type: "extended", ms: extraMs });
+      }, () => {
+        state.deciding = false;
+        input.close();
+      });
+    };
+    const relay = (id: string | undefined, questions: AskQuestion[], ask: RelayAsk) => {
+      state.asking += 1;
+      if (state.asking === 1) {
+        askStarted = Date.now();
+        clearTimeout(deadline);
+      }
+      options.onEvent?.({ type: "asking", questions: questions.length });
+      ask(questions, asks.signal)
+        .catch((): AskResult => ({ answers: [], cancelled: true }))
+        .then((result) => {
+          state.asking -= 1;
+          if (done || state.killed) return;
+          if (state.asking === 0) {
+            const now = Date.now();
+            const waited = now - askStarted;
+            pausedMs += waited;
+            deadlineAt += waited;
+            clockStart += waited;
+            lastOutput = now;
+            if (!state.deciding) deadline = setTimeout(onDeadline, Math.max(0, deadlineAt - now));
+            options.onEvent?.({ type: "answered", waitedMs: waited });
+          }
+          input.send({ type: "extension_ui_response", id, value: JSON.stringify(result) });
+        });
+    };
     const onControl = (event: ControlEvent) => {
+      const relayed = event.type === "extension_ui_request" && event.method === "editor" && options.onAsk ? readRelayRequest(event.title, event.prefill) : undefined;
       if (event.type === "response" && event.command === "prompt" && event.success === false) {
         state.protocolError = event.error ?? "the prompt was rejected";
         input.close();
+      } else if (relayed && options.onAsk) {
+        relay(event.id, relayed, options.onAsk);
       } else if (event.type === "extension_ui_request" && event.method && DIALOG_METHODS.has(event.method)) {
         // Nobody can answer a dialog inside a subagent; cancel it instead of blocking forever.
         input.send({ type: "extension_ui_response", id: event.id, cancelled: true });
       } else if (event.type === "agent_settled") {
         state.settled = true;
-        input.close();
-      } else if (event.type === "agent_end" && event.willRetry !== true && !settleTimer) {
-        settleTimer = setTimeout(() => input.close(), SETTLE_FALLBACK_MS);
+        turnOver();
+      } else if (event.type === "agent_end" && event.willRetry !== true && !settleTimer && !turnDone) {
+        settleTimer = setTimeout(turnOver, SETTLE_FALLBACK_MS);
       }
     };
     const collector = createStreamCollector(onEvent, onControl);
@@ -501,12 +639,15 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       clearTimeout(deadline);
       clearTimeout(settleTimer);
       clearInterval(watch);
+      // Questions still open when the run ends are put away.
+      asks.abort();
       options.signal?.removeEventListener("abort", onAbort);
       input.close();
       // Reap anything the agent left running in its group.
       if (POSIX) signalGroup(proc, "SIGTERM");
       const { killed, timedOut, stalled, wrappedUp, protocolError } = state;
-      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, timedOut, stalled, wrappedUp, protocolError });
+      const timeUp = state.timeUp && !killed;
+      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, timedOut, stalled, wrappedUp, protocolError, ...(timeUp ? { timeUp } : {}), ...(state.extendedMs > 0 ? { extendedMs: state.extendedMs } : {}) });
     };
     const onAbort = () => {
       state.killed = true;
@@ -514,21 +655,31 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       input.close();
       terminate(proc, 3000);
     };
-    const deadline = setTimeout(() => {
+    const onDeadline = () => {
       state.killed = true;
       state.timedOut = true;
       input.send({ type: "abort" });
       input.close();
       setTimeout(() => terminate(proc), options.graceMs ?? DEADLINE_GRACE_MS).unref();
-    }, options.timeoutMs);
+    };
+    let deadline = setTimeout(onDeadline, options.timeoutMs);
     const watch = setInterval(() => {
-      if (state.killed || done) return;
+      if (state.killed || done || state.deciding || state.asking > 0) return;
       const now = Date.now();
-      if (!state.wrappedUp && !state.settled && options.wrapUpAtMs && options.wrapUpAtMs > 0 && now - started >= options.wrapUpAtMs) {
+      if (!state.wrappedUp && !state.settled && options.wrapUpAtMs && options.wrapUpAtMs > 0 && now - started - pausedMs >= options.wrapUpAtMs) {
         state.wrappedUp = true;
         input.send({ type: "steer", message: options.wrapUpMessage ?? WRAP_UP_MESSAGE });
         options.onEvent?.({ type: "wrap_up" });
       }
+      if (time && !state.headsUp && !state.timeUp && !turnDone && headsUpAtMs > 0 && now - clockStart >= headsUpAtMs) {
+        state.headsUp = true;
+        if (time.headsUpMessage) input.send({ type: "steer", message: time.headsUpMessage });
+      }
+      if (time && !state.timeUp && !turnDone && upAtMs > 0 && now - clockStart >= upAtMs) {
+        state.timeUp = true;
+        input.send({ type: "steer", message: time.upMessage });
+        options.onEvent?.({ type: "time_up" });
+      }
       const limit = toolsInFlight > 0 ? options.toolStallTimeoutMs : options.stallTimeoutMs;
       if (limit && limit > 0 && now - Math.max(lastOutput, quietGraceUntil) >= limit) {
         state.killed = true;
@@ -536,7 +687,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
         input.close();
         terminate(proc, 3000);
       }
-    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs, options.wrapUpAtMs));
+    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs, options.wrapUpAtMs, time?.upAtMs, time?.headsUpAtMs));
     watch.unref();
 
     proc.on("exit", (code, signal) => {
@@ -557,7 +708,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
 }
 
 function toResult(parsed: ParsedStream, outcome: ProcessOutcome, aborted: boolean, options: PiRunOptions): PiRunResult {
-  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model, wrappedUp: outcome.wrappedUp === true };
+  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model, wrappedUp: outcome.wrappedUp === true, ...(outcome.timeUp ? { timeUp: true } : {}), ...(outcome.extendedMs ? { extendedMs: outcome.extendedMs } : {}) };
   if (outcome.stalled) {
     const quiet = shortDuration(options.stallTimeoutMs ?? 0);
     return { ...base, status: "timeout", stalled: true, error: `stalled: no output for ${quiet}` };
@@ -602,6 +753,8 @@ export async function runPiAgent(options: PiRunOptions, run: ProcessRunner = spa
       stallTimeoutMs: options.stallTimeoutMs,
       toolStallTimeoutMs: options.toolStallTimeoutMs,
       wrapUpAtMs: options.wrapUpAtMs,
+      ...(options.time ? { time: options.time } : {}),
+      ...(options.onAsk ? { onAsk: options.onAsk } : {}),
       onStart: options.onStart,
       onEvent: (event) => {
         if (event.type === "tool_execution_start") options.onActivity?.(activityWord(event.toolName));

package/src/index.ts

@@ -2,6 +2,7 @@ import { CONFIG_DIR_NAME, type ExtensionAPI } from "@earendil-works/pi-coding-ag
 import { registerCommands } from "./pi/commands.ts";
 import { registerLifecycle } from "./pi/events.ts";
 import { registerOrchestrateTool } from "./pi/tools.ts";
+import { registerRouteTool } from "./pi/route.ts";
 import { onTransition } from "./state/task-state.ts";
 import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
@@ -11,6 +12,8 @@ import { registerOwner } from "./pi/owner.ts";
 import { registerClassifier } from "./classifier/instance.ts";
 import { registerClassifierTools } from "./classifier/tools.ts";
 import { registerFreshContext } from "./pi/fresh-context.ts";
+import { registerAskTool } from "./ask/tool.ts";
+import { registerWebTools } from "./web/tools.ts";
 
 export default function (pi: ExtensionAPI): void {
   // First, so every session_start handler below finds the classifier bound to this session's keys.
@@ -24,6 +27,12 @@ export default function (pi: ExtensionAPI): void {
   onTransition((task) => pingTransition(task));
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
+  // A new request one agent can do alone: the oracle confirms, and the lobby hands it to the quick-fix agent.
+  registerRouteTool(pi, CONFIG_DIR_NAME);
+  // The questionnaire the oracle (and pi without a task) asks the user with; no other extension is needed for it.
+  registerAskTool(pi);
+  // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).
+  registerWebTools(pi);
   // Parallel workers share files through the master's file desk.
   if (isSubagentProcess()) registerDeskClient(pi);
   // Subagents look files up with the classifier (the engine allows the tool only while file hints are on).

package/src/lobby/ask.ts

@@ -1,59 +1,17 @@
 /**
- * The oracle puts the planning panel's questions to the user one at a time
- * through the ask-user-question library (`@juicesharp/rpiv-ask-user-question`):
- * a tabbed questionnaire with each seat's options, the recommended one first,
- * and a free-text row on every question. The library only publishes a pi
- * extension entry point, so its `ask_user_question` tool is captured by
- * calling that entry with a `pi` whose `registerTool` keeps the definition
- * instead of registering it; its `execute` then runs the real questionnaire.
- * Without the library, pi's own select and input dialogs ask the same
- * questions in the same order.
+ * The oracle puts the planning panel's questions to the user through the
+ * questionnaire (`../ask`): a tab per question with each seat's options, the
+ * recommended one first, and a row for an answer in the user's own words.
+ * The panel's questions become questionnaires of at most four, and the
+ * answers become the user's turn for the next round.
  */
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PanelQuestion } from "./planner.ts";
+import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult } from "../ask/types.ts";
+import type { Asker } from "../ask/dialog.ts";
 
-/** The library's limits: at most 4 questions per questionnaire, 2-4 options each. */
-export const MAX_QUESTIONS = 4;
-export const MIN_OPTIONS = 2;
-export const MAX_OPTIONS = 4;
-const MAX_HEADER = 16;
-const MAX_LABEL = 60;
-/** Labels the library reserves for its own rows. */
-const RESERVED = new Set(["other", "type something.", "next"]);
-
-export interface AskOption {
-  label: string;
-  description: string;
-}
-
-export interface AskQuestion {
-  question: string;
-  header: string;
-  options: AskOption[];
-  multiSelect?: boolean;
-}
-
-export interface AskAnswer {
-  questionIndex: number;
-  question: string;
-  kind: "option" | "custom" | "multi";
-  answer: string | null;
-  selected?: string[];
-  notes?: string;
-}
-
-export interface AskResult {
-  answers: AskAnswer[];
-  cancelled: boolean;
-  globalNote?: string;
-}
-
-/** Puts up to `MAX_QUESTIONS` questions to the user and returns what they chose. */
-export type Asker = (questions: readonly AskQuestion[], ctx: ExtensionContext) => Promise<AskResult>;
-
-interface ToolLike {
-  execute(toolCallId: string, params: unknown, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext): Promise<{ details?: unknown }>;
-}
+export { MAX_QUESTIONS, MIN_OPTIONS, MAX_OPTIONS, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type Asker };
+export { askUser, dialogAsker } from "../ask/dialog.ts";
 
 function clip(text: string, max: number): string {
   const flat = text.replace(/\s+/g, " ").trim();
@@ -143,74 +101,6 @@ export function answerMessage(questions: readonly PanelQuestion[], results: read
   ].join("\n");
 }
 
-/**
- * Capture the library's tool through its public extension entry: the entry
- * registers the tool on the `pi` it is given, so a `pi` whose `registerTool`
- * keeps the definition (and whose `on` ignores the library's own tool-list
- * reconciler) yields it without touching the session's tools. Undefined when
- * the library is missing or registers nothing.
- */
-/**
- * The library ships TypeScript sources; a non-literal specifier keeps them out
- * of this package's typecheck (they are compiled by pi's loader at runtime).
- */
-const ASK_LIBRARY: string = "@juicesharp/rpiv-ask-user-question";
-
-export async function loadAskTool(pi: ExtensionAPI, load: () => Promise<unknown> = () => import(ASK_LIBRARY)): Promise<ToolLike | undefined> {
-  try {
-    const module = (await load()) as { default?: (pi: ExtensionAPI) => void };
-    if (typeof module.default !== "function") return undefined;
-    let captured: ToolLike | undefined;
-    const capture = new Proxy(pi, {
-      get(target, property, receiver) {
-        if (property === "registerTool") return (tool: ToolLike & { name?: string }) => {
-          if (tool.name === "ask_user_question") captured = tool;
-        };
-        if (property === "on") return () => () => {};
-        return Reflect.get(target, property, receiver);
-      },
-    });
-    module.default(capture);
-    return captured;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Run one questionnaire through the captured tool. */
-export function toolAsker(tool: ToolLike): Asker {
-  return async (questions, ctx) => {
-    const result = await tool.execute(`bot-lobby-panel-${Date.now().toString(36)}`, { questions }, undefined, undefined, ctx);
-    const details = result.details as Partial<AskResult> | undefined;
-    return { answers: details?.answers ?? [], cancelled: details?.cancelled !== false, ...(details?.globalNote ? { globalNote: details.globalNote } : {}) };
-  };
-}
-
-const TYPE_ANSWER = "Type an answer…";
-const SKIP = "Skip";
-
-/** The same questions through pi's built-in dialogs: pick an option, type an answer, or skip; esc stops. */
-export function dialogAsker(): Asker {
-  return async (questions, ctx) => {
-    const answers: AskAnswer[] = [];
-    for (const [index, question] of questions.entries()) {
-      const choices = [...question.options.map((option) => option.label), TYPE_ANSWER, SKIP];
-      const title = `${question.header} · ${index + 1}/${questions.length}\n\n${question.question}`;
-      const choice = await ctx.ui.select(title, choices);
-      if (choice === undefined) return { answers, cancelled: true };
-      if (choice === SKIP) continue;
-      if (choice === TYPE_ANSWER) {
-        const typed = await ctx.ui.input(question.question, "your answer");
-        if (typed === undefined) return { answers, cancelled: true };
-        if (typed.trim()) answers.push({ questionIndex: index, question: question.question, kind: "custom", answer: typed.trim() });
-        continue;
-      }
-      answers.push({ questionIndex: index, question: question.question, kind: "option", answer: choice });
-    }
-    return { answers, cancelled: false };
-  };
-}
-
 /**
  * Put every question to the user, one questionnaire after another. Stopping
  * a questionnaire (esc) stops the rest; what was answered before it is kept.

package/src/lobby/feed.ts

@@ -284,8 +284,13 @@ export function chatText(role: "user" | "assistant", text: string): Array<{ role
   const kickoff = /^A bot-lobby task is active: (\S+)\nTitle: (.*)/.exec(body);
   if (kickoff) {
     const request = /\nRequest: ([\s\S]*?)(?:\nState: |$)/.exec(body)?.[1]?.trim();
-    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request ? [{ role: "you" as const, text: request }] : [])];
+    // A request the oracle routed to the team is already in the conversation, under the routing note.
+    const shown = /\nRouted: /.test(body);
+    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request && !shown ? [{ role: "you" as const, text: request }] : [])];
   }
+  // A new request the classifier read as a quick fix, before the oracle confirms where it goes.
+  const routing = /^bot-lobby: a new request, not a task yet\.\nRequest: ([\s\S]*?)\nRead: /.exec(body);
+  if (routing) return [{ role: "you", text: routing[1]!.trim() }, { role: "note", text: "reads as a quick fix · the oracle confirms where it goes" }];
   const comment = /^The user left (?:a comment|\d+ comments) on (the approved plan|the proposal) of (\S+) from the lobby:/.exec(body);
   if (comment) return [{ role: "note", text: `your comment on ${comment[1]} went to the oracle` }];
   return [{ role: "you", text: body }];

package/src/lobby/layout.ts

@@ -6,6 +6,7 @@
  */
 import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { textWidth } from "../width.ts";
+import type { MarkdownStyle } from "./markdown.ts";
 
 /** Colours the lobby uses; a subset of pi's theme so tests can pass a plain stub. */
 export type LobbyColor =
@@ -29,8 +30,8 @@ export interface LobbyTheme {
   bold(text: string): string;
   italic?(text: string): string;
   bg?(color: "selectedBg" | "searchMatchBg" | "userMessageBg", text: string): string;
-  /** Render Markdown to styled lines; plain wrapping without it (tests). */
-  markdown?(text: string, width: number, keep?: boolean): string[];
+  /** Render Markdown to styled lines, in the look of whose words they are; plain wrapping without it (tests). */
+  markdown?(text: string, width: number, keep?: boolean, style?: MarkdownStyle): string[];
   /** Strike text through (an abandoned task's title); plain without it (tests). */
   strike?(text: string): string;
 }
@@ -184,8 +185,8 @@ export function spinner(tick: number): string {
 }
 
 /** Markdown for plans, reports and replies: the theme's renderer, or headings bold without their `#` and the rest wrapped. */
-export function markdownLines(text: string, width: number, theme?: LobbyTheme, keep = true): string[] {
-  if (theme?.markdown) return theme.markdown(text, width, keep);
+export function markdownLines(text: string, width: number, theme?: LobbyTheme, keep = true, style: MarkdownStyle = "reply"): string[] {
+  if (theme?.markdown) return theme.markdown(text, width, keep, style);
   return text.split("\n").flatMap((line) => {
     const heading = /^#{1,6}\s+(.*)$/.exec(line);
     return wrap(heading ? bold(theme, paint(theme, "mdHeading", heading[1]!)) : line, width);
@@ -193,9 +194,9 @@ export function markdownLines(text: string, width: number, theme?: LobbyTheme, k
 }
 
 /** Markdown behind a hanging lead (`oracle ▸ `): the first line carries the lead, the rest align under it. */
-export function markdownHanging(lead: string, text: string, width: number, theme?: LobbyTheme): string[] {
+export function markdownHanging(lead: string, text: string, width: number, theme?: LobbyTheme, style: MarkdownStyle = "reply"): string[] {
   const indent = textWidth(lead);
-  const body = markdownLines(text, Math.max(1, width - indent), theme);
+  const body = markdownLines(text, Math.max(1, width - indent), theme, true, style);
   if (body.length === 0) return [lead];
   return body.map((line, index) => (index === 0 ? `${lead}${line}` : line ? `${" ".repeat(indent)}${line}` : ""));
 }
@@ -211,6 +212,18 @@ export interface BoxOptions {
   scroll?: { total: number; start: number };
 }
 
+/** An entry of a pane (a message, a thought, an activity line) and how many lines run from its first line to the pane's end. */
+export interface PaneMark {
+  entry: object;
+  below: number;
+}
+
+/** A pane that measures what arrives below: its newest entry now, and the lines that arrived below the one marked the frame before. */
+export interface PaneFollow {
+  mark?: PaneMark;
+  grew: number;
+}
+
 /** A scrollable pane as a render laid it out: its box in body cells, and its content against its rows. */
 export interface PaneBox {
   top: number;
@@ -220,14 +233,20 @@ export interface PaneBox {
   /** Lines of content, and rows showing them at once. */
   total: number;
   rows: number;
+  /**
+   * Set by panes whose total is estimated: lines that arrived below since the
+   * frame before, measured from an entry, not from the total (which moves as
+   * scrolling draws more or fewer of the entries it estimates).
+   */
+  follow?: PaneFollow;
 }
 
 /** Scrollable panes by name, filled in by a tab's render so the lobby can clamp offsets and route the wheel. */
 export type PaneLayout = Map<string, PaneBox>;
 
 /** Record a pane that sits at `top`/`left` in the body, `width` × `height`, showing `total` lines. */
-export function notePane(panes: PaneLayout | undefined, name: string, top: number, left: number, width: number, height: number, total: number): void {
-  panes?.set(name, { top, left, width, height, total, rows: Math.max(0, height - 2) });
+export function notePane(panes: PaneLayout | undefined, name: string, top: number, left: number, width: number, height: number, total: number, follow?: PaneFollow): void {
+  panes?.set(name, { top, left, width, height, total, rows: Math.max(0, height - 2), ...(follow ? { follow } : {}) });
 }
 
 /** First line of a top-anchored pane scrolled `offset` lines down, stopping when its last line shows. */