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

package/src/lobby/markdown.ts

@@ -5,10 +5,37 @@
  * text, since the lobby repaints many times a second.
  */
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Markdown, stripTerminalSequences, type MarkdownTheme } from "@earendil-works/pi-tui";
+import { Markdown, stripTerminalSequences, type DefaultTextStyle, type MarkdownOptions, type MarkdownTheme } from "@earendil-works/pi-tui";
+
+/**
+ * Whose words a piece of Markdown is, which sets how its plain text reads, as
+ * pi draws the same things: an agent's reply in the theme's text colour, your
+ * own words in yours (list markers and backslash escapes kept as typed), a
+ * thought dimmed and in italics.
+ */
+export type MarkdownStyle = "reply" | "you" | "thought";
+
+/** The plain-text look of each style but a reply; the lobby takes them from the session's theme. */
+export type MarkdownStyles = Partial<Record<Exclude<MarkdownStyle, "reply">, DefaultTextStyle>>;
 
 /** Markdown rendered to lines at a width; `keep: false` for text seen once (a reply still streaming), so it does not crowd the cache. */
-export type MarkdownRenderer = (text: string, width: number, keep?: boolean) => string[];
+export type MarkdownRenderer = (text: string, width: number, keep?: boolean, style?: MarkdownStyle) => string[];
+
+/** How pi renders what you write: your ordered-list markers and backslash escapes stay as you typed them. */
+const YOUR_WORDS: MarkdownOptions = { preserveOrderedListMarkers: true, preserveBackslashEscapes: true };
+
+/**
+ * Line breaks a model wrote out as `\n` (text escaped twice on its way here,
+ * so a whole plan arrives as one line): made real when the text has no real
+ * line break at all, outside inline code, where `\n` is usually meant.
+ */
+export function unescapeBreaks(text: string): string {
+  if (text.includes("\n") || !text.includes("\\n")) return text;
+  return text
+    .split(/(`[^`\n]*`)/)
+    .map((part, index) => (index % 2 === 1 ? part : part.replace(/(?:\\r)?\\n/g, "\n")))
+    .join("");
+}
 
 /** A heading line as pi renders it: optional styling, then `#`…`######` and a space. */
 const HEADING_HASHES = /^((?:\x1b\[[0-9;]*m)*)#{1,6} ((?:\x1b\[[0-9;]*m)*)/;
@@ -29,10 +56,10 @@ export const CACHE_LIMIT = 512;
  * theme object on every call, so the theme is taken once, here: a theme
  * switch makes a new renderer (the lobby keeps one per pi theme).
  */
-export function createMarkdownRenderer(theme: MarkdownTheme = getMarkdownTheme()): MarkdownRenderer {
+export function createMarkdownRenderer(theme: MarkdownTheme = getMarkdownTheme(), styles: MarkdownStyles = {}): MarkdownRenderer {
   const cache = new Map<string, string[]>();
-  return (text, width, keep = true) => {
-    const key = `${width}\0${text}`;
+  return (text, width, keep = true, style = "reply") => {
+    const key = `${style}\0${width}\0${text}`;
     const hit = cache.get(key);
     if (hit) {
       // Most recently used last, so the oldest is the one dropped.
@@ -40,7 +67,10 @@ export function createMarkdownRenderer(theme: MarkdownTheme = getMarkdownTheme()
       cache.set(key, hit);
       return hit;
     }
-    const lines = new Markdown(text, 0, 0, theme).render(Math.max(1, width)).map((line) => tidyHeading(line.trimEnd(), theme.bold));
+    const look = style === "reply" ? undefined : styles[style];
+    const lines = new Markdown(unescapeBreaks(text), 0, 0, theme, look, style === "you" ? YOUR_WORDS : undefined)
+      .render(Math.max(1, width))
+      .map((line) => tidyHeading(line.trimEnd(), theme.bold));
     // Drop the blank lines pi pads the render with at either end.
     while (lines.length > 0 && !lines[0]!.trim()) lines.shift();
     while (lines.length > 0 && !lines.at(-1)!.trim()) lines.pop();

package/src/lobby/planner.ts

@@ -37,7 +37,7 @@ import { fellShort, profileLabel, type EffortRouter, type EffortScore } from "..
 
 /** Seats and the oracle read the repository to ask informed questions; they never edit. */
 export const PLANNER_TOOLS: readonly string[] = ["read", "grep", "find", "ls"];
-/** RESEARCH also gets the web tools (from pi-web-access; pi ignores them when it is not installed). */
+/** RESEARCH also gets bot-lobby's web tools (src/web/tools.ts). */
 export const RESEARCH_PANEL_TOOLS: readonly string[] = [...PLANNER_TOOLS, "web_search", "fetch_content", "source_check", "get_search_content"];
 
 /** The chair of the panel, as the Plan tab, the feed and the metrics name it. */

package/src/lobby/quickfix.ts

@@ -9,6 +9,7 @@ import { loadPrompt } from "../prompts/loader.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
+import { appendChange, EditLog } from "../state/changes.ts";
 import type { LobbyFeed } from "./feed.ts";
 import type { FileHinter } from "../classifier/files.ts";
 import type { Classifier } from "../classifier/classifier.ts";
@@ -51,6 +52,21 @@ export interface QuickFixJob {
   /** 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;
+  /** Files it changed with `edit`/`write`, as shown (relative to the project); the change ledger lets a running task's QA gate tell them from its own. */
+  files?: string[];
+  /** Runs on this profile instead of the quick-fix settings: a quick feature the oracle routed here gets its builder's model, thinking and time. */
+  profile?: QuickFixProfile;
+  /** The oracle sent it here from a request typed to the lobby. */
+  routed?: boolean;
+}
+
+/** How a job enters the queue besides its prompt. */
+export interface SubmitOptions {
+  /** Skip the classifier's "looks like a task" hold (the oracle already routed it here). */
+  force?: boolean;
+  profile?: QuickFixProfile;
+  /** Shown with the job: where it came from. */
+  note?: string;
 }
 
 export interface QuickFixProfile {
@@ -103,6 +119,7 @@ export class QuickFixQueue {
   jobs: QuickFixJob[] = [];
   private readonly deps: QuickFixDeps;
   private readonly controllers = new Map<string, AbortController>();
+  private readonly edits = new Map<string, EditLog>();
   private counter = 0;
 
   constructor(deps: QuickFixDeps) {
@@ -114,10 +131,21 @@ export class QuickFixQueue {
   }
 
   /** Queue a quick fix; it starts at once when nothing else is running. */
-  submit(prompt: string, now = Date.now()): QuickFixJob {
+  submit(prompt: string, now = Date.now(), options: SubmitOptions = {}): QuickFixJob {
     const text = prompt.trim();
     if (!text) throw new Error("a quick fix needs a prompt");
-    const job: QuickFixJob = { id: `QF-${++this.counter}`, prompt: text, status: "queued", createdAt: now, steps: [], tools: 0, turns: 0 };
+    const job: QuickFixJob = {
+      id: `QF-${++this.counter}`,
+      prompt: text,
+      status: "queued",
+      createdAt: now,
+      steps: [],
+      tools: 0,
+      turns: 0,
+      ...(options.force ? { force: true, routed: true } : {}),
+      ...(options.profile ? { profile: options.profile } : {}),
+      ...(options.note ? { note: options.note } : {}),
+    };
     this.jobs = [...this.jobs, job].filter((entry, index, all) => isActive(entry) || index >= all.length - MAX_JOBS);
     this.changed();
     this.pump();
@@ -188,6 +216,8 @@ export class QuickFixQueue {
     const now = Date.now();
     if (event.type === "tool_execution_start") {
       job.tools += 1;
+      const edits = this.edits.get(job.id);
+      if (edits?.note(event.toolName, event.args)) job.files = edits.shown();
       this.addStep(job, describeToolCall(event.toolName, event.args), now);
     } else if (event.type === "turn_start") job.turns += 1;
     else if (event.type === "thought") this.deps.feed?.thought(QUICK_FIX_SOURCE, event.text, now);
@@ -197,7 +227,7 @@ export class QuickFixQueue {
   }
 
   private async run(job: QuickFixJob): Promise<void> {
-    const profile = this.deps.profile();
+    const profile = job.profile ?? this.deps.profile();
     const controller = new AbortController();
     this.controllers.set(job.id, controller);
     job.status = "running";
@@ -211,6 +241,7 @@ export class QuickFixQueue {
       return this.hold(job, held);
     }
     this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
+    this.edits.set(job.id, new EditLog(this.deps.cwd));
     try {
       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(
@@ -280,6 +311,8 @@ export class QuickFixQueue {
     try {
       const sized = await quickFixSize(jev, job.prompt, signal);
       if (!sized || sized.size !== "large" || sized.confidence < jev.config.thresholds.quickFixLargeAt) return undefined;
+      // Large but still one engineer's work (a rich page in one file): it runs.
+      if ((sized.solo ?? 0) >= jev.config.thresholds.quickFixAt) return undefined;
       return `looks like a task (large, ${sized.confidence.toFixed(2)})`;
     } catch {
       return undefined;
@@ -309,6 +342,20 @@ export class QuickFixQueue {
   private finish(job: QuickFixJob): void {
     job.finishedAt = Date.now();
     for (const step of job.steps) step.pending = false;
+    const edited = this.edits.get(job.id)?.list() ?? [];
+    this.edits.delete(job.id);
+    // Whatever it edited, even when it failed, is on record for a task's QA gate as the user's own request.
+    if (edited.length > 0) {
+      appendChange(this.deps.root, this.deps.configDir, {
+        source: "quickfix",
+        id: job.id,
+        what: jobTitle(job),
+        files: edited,
+        startedAt: new Date(job.startedAt ?? job.createdAt).toISOString(),
+        finishedAt: new Date(job.finishedAt).toISOString(),
+        status: job.status,
+      });
+    }
     this.deps.feed?.end(job.id, job.status !== "success");
     const ok = job.status === "success";
     const outcome = ok ? "done" : `${job.status}${job.error ? ` — ${job.error.split("\n")[0]}` : ""}`;

package/src/lobby/runtime.ts

@@ -6,8 +6,8 @@
  * turn into the feed, passes plan comments to the Master that owns a task and
  * records each Master turn in the metrics log.
  */
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { getMarkdownTheme, getSelectListTheme, SessionManager } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSelectListTheme, SessionManager } from "@earendil-works/pi-coding-agent";
 import { Key, type OverlayHandle, type TUI } from "@earendil-works/pi-tui";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { loadTask, peekTasks } from "../state/persistence.ts";
@@ -26,22 +26,24 @@ import { shortTitle } from "../text.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { modelRef, resolveLobbyProfile, resolvePanelProfile } from "../pi/model-support.ts";
 import { modelLookup } from "../pi/tools.ts";
-import { startPlannedTask, startTask } from "../pi/start-task.ts";
+import { startPlannedTask } from "../pi/start-task.ts";
+import { pendingRequest, setQuickFixHandoff, startRequest } from "../pi/route.ts";
+import type { Domain } from "../schemas/agent.ts";
 import type { LobbyAgentKind, LobbyPanel, PanelMember } from "../schemas/configuration.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike, type ChatEntry } 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 { answerMessage, askUser, questionnaires, 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 LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
-import type { LobbyTheme } from "./layout.ts";
-import { createMarkdownRenderer } from "./markdown.ts";
+import { lobbyTheme } from "./theme.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
 import { openEntrySettings, openSettings } from "../pi/settings-ui.ts";
+import { budgetClock } from "../state/budget.ts";
 
 export const ANCHOR_KEY = "bot-lobby-anchor";
 export { deliverComments };
@@ -62,8 +64,8 @@ interface Runtime {
   planner?: PlanningSession;
   issues: IssuesState;
   unsubscribeFeed?: () => void;
-  /** The ask-user-question tool (or pi's dialogs), loaded once on first use. */
-  asker?: Promise<Asker>;
+  /** Puts the panel's questions to the user: the questionnaire unless a test sets another. */
+  asker?: Asker;
   /** A questionnaire is on screen. */
   asking: boolean;
   /** The lobby turned the terminal's mouse reporting on (pi's regular screen only). */
@@ -149,9 +151,10 @@ function toOracle(state: Runtime, text: string): string | undefined {
     state.pi.sendUserMessage(text, { expandPromptTemplates: true, ...(busy ? { deliverAs: "followUp" as const } : {}) });
     return `sent ${text.split(/\s+/)[0]} to pi (built-in commands need the lobby hidden: alt+l)`;
   }
-  if (!currentZenTask()) {
-    startTask(state.pi, state.ctx, state.configDir, text).catch((error: Error) => failed(state, "could not start the task", error));
-    return "starting a task — the oracle takes it from here";
+  // While the oracle decides where a request goes, what the user types joins that conversation.
+  if (!currentZenTask() && !pendingRequest()) {
+    startRequest(state.pi, state.ctx, state.configDir, text).catch((error: Error) => failed(state, "could not start the task", error));
+    return "reading your request — a quick fix or a task, the oracle takes it from here";
   }
   state.pi.sendUserMessage(text, busy ? { deliverAs: "steer" } : undefined);
   return undefined;
@@ -425,7 +428,9 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
 
 /** 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 });
+  const now = Date.now();
+  const time = budgetClock(state.root, state.configDir, task.id, now);
+  return panelLines(task, persistedRuns(task), now, false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme, ...(time ? { time } : {}) });
 }
 
 function seatProfile(state: Runtime, member: PanelMember) {
@@ -463,10 +468,9 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
   return state.planner;
 }
 
-/** The library's questionnaire when it loads, pi's own dialogs otherwise. */
-function panelAsker(state: Runtime): Promise<Asker> {
-  state.asker ??= loadAskTool(state.pi).then((tool) => (tool ? toolAsker(tool) : dialogAsker()));
-  return state.asker;
+/** The questionnaire (pi's own dialogs where it cannot be drawn); tests swap it. */
+function panelAsker(state: Runtime): Asker {
+  return state.asker ?? askUser;
 }
 
 /**
@@ -483,7 +487,7 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   if (state.asking) return "the questions are already open";
   state.asking = true;
   try {
-    const asker = await panelAsker(state);
+    const asker = panelAsker(state);
     const chunks = questionnaires(session.questions);
     for (let index = session.answered.length; index < chunks.length; index++) {
       const result = await asker(chunks[index]!, state.ctx);
@@ -508,29 +512,6 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   }
 }
 
-const lobbyThemes = new WeakMap<Theme, LobbyTheme>();
-
-/**
- * pi's theme as the lobby draws with it, plus Markdown rendering; one wrapper
- * (and one Markdown renderer with its cache) per theme, so caches stay warm
- * and a theme switch starts fresh.
- */
-function lobbyTheme(theme: Theme): LobbyTheme {
-  let wrapped = lobbyThemes.get(theme);
-  if (!wrapped) {
-    wrapped = {
-      fg: (color, text) => theme.fg(color, text),
-      bold: (text) => theme.bold(text),
-      italic: (text) => theme.italic(text),
-      bg: (color, text) => theme.bg(color, text),
-      markdown: createMarkdownRenderer(getMarkdownTheme()),
-      strike: (text) => theme.strikethrough(text),
-    };
-    lobbyThemes.set(theme, wrapped);
-  }
-  return wrapped;
-}
-
 function host(state: Runtime, tui: TUI): LobbyHost {
   return {
     rows: () => tui.terminal.rows,
@@ -728,6 +709,7 @@ function shutdown(): void {
   const state = runtime;
   if (!state) return;
   runtime = undefined;
+  setQuickFixHandoff(undefined);
   setMouse(state, false);
   state.unsubscribeFeed?.();
   state.quickfix.cancelAll();
@@ -739,6 +721,24 @@ function shutdown(): void {
   onMinimizeChange(undefined);
 }
 
+/**
+ * The oracle routed a request to the quick-fix agent: queue it (no "looks like
+ * a task" hold, the oracle already decided), on its builder's settings when it
+ * is a quick feature, and show it on the Quick fix tab.
+ */
+function handToQuickFix(state: Runtime, request: string, builder: Domain | undefined, reason: string): string {
+  const quick = lobbyProfile(state, "quickfix");
+  const profile = builder ? { ...seatProfile(state, builder), instructions: quick.instructions } : undefined;
+  const job = state.quickfix.submit(request, Date.now(), {
+    force: true,
+    ...(profile ? { profile } : {}),
+    note: `The oracle sent your request here: ${reason.replace(/[.\s]+$/, "")}.${builder ? ` A quick feature: it runs on ${builder === "designer" ? "DESIGN" : "DEV"}'s model, thinking and time limit.` : ""}`,
+  });
+  showLobby("quickfix");
+  state.view?.showQuickFix(job.id);
+  return job.id;
+}
+
 /** Create the session's lobby runtime (interactive master sessions only). */
 export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string): void {
   shutdown();
@@ -776,6 +776,7 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
   });
   runtime = state;
+  setQuickFixHandoff((request, builder, reason) => (runtime === state ? handToQuickFix(state, request, builder, reason) : undefined));
   lobbyFeed.clear();
   // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.
   lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY));