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

package/src/lobby/view.ts

@@ -9,7 +9,8 @@
  * pane toggles, paging) work in both. Everything bot-lobby-specific arrives
  * through `LobbyHost`, so the view renders and reacts the same in tests.
  */
-import { decodeKittyPrintable, Editor, Input, Key, matchesKey, visibleWidth, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, Editor, Input, Key, matchesKey, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { textWidth } from "../width.ts";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { PlannedTask } from "../state/backlog.ts";
@@ -22,8 +23,8 @@ import type { QuickFixQueue } from "./quickfix.ts";
 import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } from "./planner.ts";
 import { issueText, type IssuesState } from "./issues.ts";
 import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, type KeyMap, type LobbyAction } from "./keys.ts";
-import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "./layout.ts";
-import { chatLines, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
+import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
+import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
 import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
 import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
 import { filterJobs, newestFirst, renderQuickFix } from "./tabs/quickfix.ts";
@@ -113,6 +114,9 @@ function sameView(a: SessionView, b: SessionView): boolean {
   return true;
 }
 
+/** Tops a conversation whose earlier messages are not in memory. */
+export const OLDER_NOTE = "↑ earlier messages load as you scroll up";
+
 const SECTION_OF: Record<SessionWhere, string> = { "this window": "THIS WINDOW", background: "BACKGROUND", "other terminal": "OTHER TERMINALS", "not running": "NOT RUNNING" };
 const WHERE_MARKS: Record<SessionWhere, string> = { "this window": "●", background: "◆", "other terminal": "◇", "not running": "○" };
 
@@ -189,8 +193,12 @@ export interface LobbyHost {
   archiveTask(taskId: string): string;
   restoreTask(taskId: string): string;
   deleteTask(taskId: string, where: "list" | "archive"): string;
-  /** Another session's conversation, read from its saved session file. */
+  /** Another session's conversation, read from its saved session file (its newest messages). */
   sessionChat(sessionId: string): ChatEntry[];
+  /** Whether another session has messages earlier than `sessionChat` returns. */
+  hasOlderChat(sessionId: string): boolean;
+  /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
+  chatHistory(sessionId?: string): readonly ChatEntry[];
   /** A task's status without animations, for a session other than this window's. */
   taskScene(task: Task, width: number, height: number): string[];
   profileLabel(kind: LobbyAgentKind): string;
@@ -216,7 +224,7 @@ class LobbyEditor extends Editor {
     if (!this.label) return super.renderTopBorder(width, hiddenLineCount);
     const label = ` ${this.label} `;
     const more = hiddenLineCount > 0 ? ` ↑${hiddenLineCount} ` : "";
-    const rest = width - 2 - visibleWidth(label) - visibleWidth(more);
+    const rest = width - 2 - textWidth(label) - textWidth(more);
     if (rest < 1) return super.renderTopBorder(width, hiddenLineCount);
     return `${this.borderColor("──")}${this.paintLabel(label)}${this.borderColor("─".repeat(rest))}${more ? this.borderColor(more) : ""}`;
   }
@@ -312,6 +320,8 @@ export class LobbyView implements Component, Focusable {
   homeFocus: HomePane = "conversation";
   /** How many lines each pane held last frame, so a pane scrolled back stays on what you are reading as lines arrive. */
   private readonly seenTotals = new Map<string, number>();
+  /** Each Lobby pane's newest entry last frame: those panes measure what arrived below it, as their totals are estimates. */
+  private readonly marks = new Map<string, PaneMark>();
   /** Where the current tab's scrollable panes landed in the last frame. */
   private readonly panes: PaneLayout = new Map();
   private tasksSelected = 0;
@@ -430,6 +440,7 @@ export class LobbyView implements Component, Focusable {
   refreshData(force: boolean): void {
     const now = this.now();
     if (!force && now - this.data.at < DATA_REFRESH_MS) return;
+    this.dataVersion += 1;
     this.data = {
       tasks: this.host.tasks(),
       plans: this.host.plans(),
@@ -838,6 +849,7 @@ export class LobbyView implements Component, Focusable {
         break;
     }
     this.clampScroll();
+    if (pane === "conversation") this.followHistory();
   }
 
   /** Home and End: the oldest or first line of the focused pane, or back to its newest or last. */
@@ -861,6 +873,8 @@ export class LobbyView implements Component, Focusable {
       return;
     }
     this.scrollPane(pane, far);
+    // Home loads earlier messages at the top; go on to the very first of them.
+    if (start && pane === "conversation" && this.history) this.homeOffsets.conversation = Number.MAX_SAFE_INTEGER;
   }
 
   /** The wheel over the draft scrolls it; the cursor follows only when it would leave the screen. */
@@ -882,11 +896,10 @@ export class LobbyView implements Component, Focusable {
     const limit = (name: string, offset: number, anchored: boolean): number => {
       const pane = this.panes.get(name);
       if (!pane) return offset;
-      const seen = this.seenTotals.get(name);
-      this.seenTotals.set(name, pane.total);
+      const grew = this.grewBelow(name, pane);
       let next = offset;
-      if (anchored && next > 0 && seen !== undefined && pane.total > seen) {
-        next += pane.total - seen;
+      if (anchored && next > 0 && grew > 0) {
+        next += grew;
         moved = true;
       }
       return Math.min(next, Math.max(0, pane.total - pane.rows));
@@ -910,6 +923,25 @@ export class LobbyView implements Component, Focusable {
     return moved;
   }
 
+  /**
+   * Lines that arrived below a pane since it was last looked at, counted once.
+   * A pane that measures them from its newest entry says so; for the others
+   * (their totals exact) the total's growth stands in. An estimated total also
+   * moves as scrolling draws more or fewer of the entries it estimates, and
+   * following that pinned a pane scrolled to its top there.
+   */
+  private grewBelow(name: string, pane: PaneBox): number {
+    const seen = this.seenTotals.get(name);
+    this.seenTotals.set(name, pane.total);
+    const follow = pane.follow;
+    if (!follow) return seen === undefined ? 0 : pane.total - seen;
+    if (follow.mark) this.marks.set(name, follow.mark);
+    else this.marks.delete(name);
+    const grew = follow.grew;
+    follow.grew = 0;
+    return grew;
+  }
+
   /** Move the draft cursor by `delta` lines, skipping blank ones, and keep it on screen. */
   private moveCursor(delta: number): void {
     const lines = this.planLayout.draftText;
@@ -954,7 +986,9 @@ export class LobbyView implements Component, Focusable {
     const rows = this.taskRowList();
     this.tasksSelected = Math.max(0, Math.min(rows.length - 1, index));
     this.tasksDetailOffset = 0;
-    this.refreshData(true);
+    // Only the newly selected task's comments: moving through the list must not reread every task from disk.
+    const row = rows[this.tasksSelected];
+    if (row?.kind === "task" && !this.data.comments.has(row.id)) this.data.comments.set(row.id, this.host.comments(row.id));
   }
 
   private async loadIssueDetail(): Promise<void> {
@@ -1205,6 +1239,50 @@ export class LobbyView implements Component, Focusable {
     void this.host.answerDialog(session).then(() => this.host.requestRender());
   }
 
+  /* -------------------------------------------------------------- history */
+
+  /**
+   * The whole conversation of the session in view, loaded when the
+   * conversation pane is scrolled back past the messages kept in memory, and
+   * let go once it is back at the newest.
+   */
+  private history?: { view: SessionView; entries: readonly ChatEntry[] };
+
+  /** The conversation to draw for the session in view, and whether earlier messages wait to be loaded. */
+  private conversationFor(entry: SessionEntry): { chat: readonly ChatEntry[]; older: boolean } {
+    if (this.history && sameView(this.history.view, entry.view)) return { chat: this.history.entries, older: false };
+    if (entry.view.kind === "here") return { chat: this.host.feed.chat, older: this.host.feed.chatOlder };
+    if (entry.view.kind === "background") {
+      const session = this.viewedSessionFor(entry.view.key);
+      return { chat: session?.feed.chat ?? [], older: Boolean(session?.feed.chatOlder && session.sessionId) };
+    }
+    return entry.sessionId ? { chat: this.host.sessionChat(entry.sessionId), older: this.host.hasOlderChat(entry.sessionId) } : { chat: [], older: false };
+  }
+
+  /**
+   * After the conversation pane scrolls: at its top, with earlier messages
+   * waiting, load the whole conversation; back at its newest, let it go.
+   * True when history was loaded now.
+   */
+  private followHistory(): boolean {
+    if (this.tab !== "lobby") return false;
+    if (this.homeOffsets.conversation === 0) {
+      this.history = undefined;
+      return false;
+    }
+    if (this.history && sameView(this.history.view, this.viewing)) return false;
+    const pane = this.panes.get("conversation");
+    if (!pane || this.homeOffsets.conversation < pane.total - pane.rows) return false;
+    const entry = this.viewedEntry();
+    if (!this.conversationFor(entry).older) return false;
+    const sessionId = entry.view.kind === "here" ? undefined : entry.view.kind === "background" ? this.viewedSessionFor(entry.view.key)?.sessionId : entry.sessionId;
+    if (entry.view.kind !== "here" && !sessionId) return false;
+    const entries = this.host.chatHistory(sessionId);
+    if (entries.length === 0) return false;
+    this.history = { view: entry.view, entries };
+    return true;
+  }
+
   /* ------------------------------------------------------------ sessions */
 
   /** Every session the lobby can show: this window, the background sessions it started, then tasks other terminals drive. */
@@ -1270,6 +1348,7 @@ export class LobbyView implements Component, Focusable {
     this.viewing = target;
     this.picking = false;
     this.newSession = false;
+    this.history = undefined;
     for (const pane of HOME_PANES) this.homeOffsets[pane] = 0;
     if (this.tab !== "lobby") this.setTab("lobby");
     this.setMode("type");
@@ -1657,8 +1736,41 @@ export class LobbyView implements Component, Focusable {
 
   /* -------------------------------------------------------------- render */
 
+  /** Bumped each time the data is reread. */
+  private dataVersion = 0;
+  /** Task rows as last built: several parts of a frame ask, and they only change with the data, the search or the clock. */
+  private rowsMemo?: { key: string; rows: TaskRow[] };
+
+  /** The Metrics tab's figures as last computed: they change only with the data, the grouping, the order or the search. */
+  private metricsMemo?: { key: string; figures: ReturnType<LobbyView["computeMetrics"]> };
+
+  private metricsFigures(query: string | undefined) {
+    const key = `${this.dataVersion}|${this.metricsBy}|${this.metricsSort}|${query ?? ""}`;
+    if (this.metricsMemo?.key !== key) this.metricsMemo = { key, figures: this.computeMetrics(query) };
+    return this.metricsMemo.figures;
+  }
+
+  private computeMetrics(query: string | undefined) {
+    const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
+    return {
+      records,
+      groups: sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort),
+      taskTimes: taskTimesByModel(this.data.tasks, records),
+      stats: taskStats(this.data.tasks),
+      jev: summarizeClassifier(this.data.classifierMetrics, records),
+    };
+  }
+
   /** Task rows, narrowed by the Tasks tab's search. */
   private taskRowList(): TaskRow[] {
+    const key = `${this.dataVersion}|${this.tick}|${this.showArchived}|${this.queries.tasks ?? ""}`;
+    if (this.rowsMemo?.key === key) return this.rowsMemo.rows;
+    const rows = this.buildTaskRows();
+    this.rowsMemo = { key, rows };
+    return rows;
+  }
+
+  private buildTaskRows(): TaskRow[] {
     const names = new Map<string, string>();
     for (const session of this.host.sessions()) if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
     const auto = new Set(this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && this.host.isAuto(task.id)).map((task) => task.id));
@@ -1691,12 +1803,12 @@ export class LobbyView implements Component, Focusable {
       const badge = badges[tab] ? ` ${paint(theme, tab === "plan" && session?.awaitingAnswers ? "warning" : "accent", badges[tab]!)}` : "";
       let cell = ` ${number} ${name}${badge} `;
       if (tab === this.tab) cell = theme.bg ? theme.bg("selectedBg", cell) : `[${cell}]`;
-      const from = visibleWidth(left);
+      const from = textWidth(left);
       left += cell;
-      spans.push({ tab, from, to: visibleWidth(left) });
+      spans.push({ tab, from, to: textWidth(left) });
     }
     this.tabSpans = spans;
-    const room = width - visibleWidth(left) - 1;
+    const room = width - textWidth(left) - 1;
     const entry = this.viewedEntry();
     const help = paint(theme, "dim", `${keyLabel(this.keys.help)} keys `);
     const auto = entry.auto ? ` ${bold(theme, paint(theme, "success", "⟳ AUTO"))}` : "";
@@ -1717,8 +1829,8 @@ export class LobbyView implements Component, Focusable {
         ? [`${dot} ${zen.task.id} ${state}${auto}${asking}  ${help}`, `${dot} ${zen.task.id} ${state}${auto}${asking} `, `${dot} ${state}${auto} `, `${dot}${auto} `]
         : [`${paint(theme, "dim", "no task in this session")}${asking}  ${help}`, `${paint(theme, "dim", "no task in this session")}${asking} `, help, ""];
     }
-    const status = choices.find((choice) => visibleWidth(choice) <= room) ?? "";
-    const gap = width - visibleWidth(left) - visibleWidth(status);
+    const status = choices.find((choice) => textWidth(choice) <= room) ?? "";
+    const gap = width - textWidth(left) - textWidth(status);
     return gap >= 1 ? `${left}${" ".repeat(gap)}${status}` : fit(left, width);
   }
 
@@ -1780,7 +1892,7 @@ export class LobbyView implements Component, Focusable {
     const tail = this.searching
       ? paint(theme, "dim", " enter keep · esc clear · ↑↓ browse results ")
       : paint(theme, "dim", ` ${keyLabel(this.keys.search)} or / edits · esc clears `);
-    const room = Math.max(4, width - visibleWidth(lead) - visibleWidth(tail));
+    const room = Math.max(4, width - textWidth(lead) - textWidth(tail));
     const field = this.searching ? this.search.render(room)[0] ?? "" : bold(theme, fit(query ?? "", room));
     return [fit(`${lead}${fit(field, room)}${tail}`, width)];
   }
@@ -2018,12 +2130,9 @@ export class LobbyView implements Component, Focusable {
         }, width, height, theme);
       }
       case "metrics": {
-        const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
-        const groups = sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort);
+        const { records, groups, taskTimes, stats, jev } = this.metricsFigures(query);
         this.metricsSelected = Math.min(this.metricsSelected, Math.max(0, groups.length - 1));
-        const taskTimes = taskTimesByModel(this.data.tasks, records);
-        const jev = summarizeClassifier(this.data.classifierMetrics, records);
-        return renderMetrics({ groups, taskTimes, records, stats: taskStats(this.data.tasks), by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
+        return renderMetrics({ groups, taskTimes, records, stats, by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
       }
     }
   }
@@ -2150,7 +2259,7 @@ export class LobbyView implements Component, Focusable {
     const room = height - lines.length - 2;
     if (room > 2) {
       lines.push("", rule(width, "Conversation", theme));
-      const talk = chat.length > 0 ? chatLines(chat, width, theme) : [paint(theme, "dim", "Nothing said yet.")];
+      const talk = chat.length > 0 ? chatTail(chat, width, theme, room - 1).lines : [paint(theme, "dim", "Nothing said yet.")];
       lines.push(...talk.slice(-(room - 1)));
     }
     return lines;
@@ -2175,9 +2284,11 @@ export class LobbyView implements Component, Focusable {
     const query = this.query();
     const entry = this.viewedEntry();
     if (entry.view.kind !== "here") return this.otherSessionBody(entry, width, height, theme, now);
+    const talk = this.conversationFor(entry);
     return renderHome({
       ...(zen.task ? { task: zen.task, scene: (w: number, h: number, animated: boolean) => this.host.scene(w, h, animated) } : {}),
-      chat: feed.chat,
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       ...(feed.reply ? { liveReply: feed.reply } : {}),
       activity: feed.activity,
       thoughts: feed.thoughts,
@@ -2185,6 +2296,7 @@ export class LobbyView implements Component, Focusable {
       others,
       pending: this.data.plans.filter((plan) => plan.status === "pending").length,
       offsets: this.homeOffsets,
+      anchors: this.marks,
       ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
       panes: this.panes,
       tick: this.tick,
@@ -2207,6 +2319,7 @@ export class LobbyView implements Component, Focusable {
    */
   private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
     const session = this.viewedSession();
+    const talk = this.conversationFor(entry);
     const task = entry.task;
     const query = this.query();
     const common = {
@@ -2214,6 +2327,7 @@ export class LobbyView implements Component, Focusable {
       others: 0,
       pending: 0,
       offsets: this.homeOffsets,
+      anchors: this.marks,
       ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
       panes: this.panes,
       tick: this.tick,
@@ -2232,7 +2346,8 @@ export class LobbyView implements Component, Focusable {
       const emptyNote = session.status === "starting" ? `starting ${session.name}…` : !session.alive ? `${session.name} has ended.` : `${session.name} has not said anything yet.`;
       return renderHome({
         ...common,
-        chat: session.feed.chat,
+        chat: talk.chat,
+        ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
         ...(session.feed.reply ? { liveReply: session.feed.reply } : {}),
         activity: session.feed.activity,
         thoughts: session.feed.thoughts,
@@ -2243,7 +2358,8 @@ export class LobbyView implements Component, Focusable {
     const running = entry.where === "other terminal";
     return renderHome({
       ...common,
-      chat: entry.sessionId ? this.host.sessionChat(entry.sessionId) : [],
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       activity: [],
       thoughts: [],
       busy: false,

package/src/master/decisions.ts

@@ -7,7 +7,7 @@ import { detectGaps, domainsInvolved } from "./synthesis.ts";
 export function completionBlockers(task: Task, pendingCount: number): string[] {
   const blockers: string[] = [];
   if (!task.plan) blockers.push("no approved plan is recorded");
-  if (task.qaVerdict !== "pass") blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
   if (pendingCount > 0) blockers.push(`${pendingCount} unresolved approval request(s)`);
   if (task.blockers.length > 0) blockers.push(`${task.blockers.length} unresolved blocker(s)`);
   return blockers;

package/src/master/master.ts

@@ -4,8 +4,8 @@ import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schema
 import type { Domain } from "../schemas/agent.ts";
 import type { AgentRun, ReviewResult, ScoutResult, WorkerResult } from "../schemas/findings.ts";
 import { domainSpec } from "../agents/registry.ts";
-import { runAgent, runParallel, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
-import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
+import { runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
+import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
 import { summarizeOutcomes } from "./synthesis.ts";
@@ -24,6 +24,8 @@ export interface ScoutOutcome {
 }
 
 export interface ScoutRequest {
+  /** Under a task time budget: the batch's time (every scout runs within it). */
+  time?: AgentTime;
   taskId: string;
   /** Requirements/objective text used for context selection. */
   taskText: string;
@@ -65,7 +67,7 @@ function scoutContext(request: ScoutRequest, domain: Domain, likely = ""): Agent
     task: request.taskText,
     ...selectKnowledge(`${request.taskText} ${domainSpec(domain).scoutFocus}`, slices),
     instructions: request.config.agents[domain].instructions,
-    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, likely].filter(Boolean).join("\n\n"),
+    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, likely, request.time?.note ?? ""].filter(Boolean).join("\n\n"),
   };
 }
 
@@ -120,6 +122,7 @@ export async function runScouts(request: ScoutRequest, run: ProcessRunner = spaw
     context: scoutContext(request, domain, likely[index]),
     ...(extraTools.length > 0 ? { extraTools } : {}),
     ...profileFields(request.config, request.profile, domain, "scout"),
+    ...(request.time ? { time: { ...request.time } } : {}),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
@@ -203,6 +206,21 @@ export interface WorkerRequest {
   hints?: FileHinter;
   /** Lowers thinking (or the model) for a step the classifier judges simple or trivial. */
   effort?: EffortRouter;
+  /** Under a task time budget: the step's time, and who decides on more when it runs out. */
+  time?: AgentTime;
+  /** The worker may ask the user (the designer): its questions are relayed, and its images saved in `previews`. */
+  ask?: { onAsk: RelayAsk; previews: string };
+}
+
+/** What a worker that may ask the user is told about it. */
+function askGuidance(previews: string): string {
+  return [
+    "You can ask the user with ask_user_question: the oracle relays it, and your clock stops while they answer.",
+    "Ask when a design decision is genuinely theirs (a visual direction, a layout, a style), once, with all such questions together, before you build it; decide everything else yourself.",
+    "Show each option. Give it a `preview`: a Markdown wireframe (a fenced block drawn with box characters) or a short snippet of the component.",
+    `When you can render an option (a screenshot from the project's own tooling, a rendered mockup), save it as a PNG under ${previews} (never in the repository) and give its path as the option's \`image\`.`,
+    "Put the option you recommend first. The answers are recorded as the task's decisions: build what the user chose.",
+  ].join(" ");
 }
 
 function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
@@ -218,6 +236,8 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
       ? `Scout findings for your domain:\n${summarizeOutcomes(own, 1500)}`
       : "No scout findings were collected for your domain; verify the repository yourself.",
     likely,
+    request.time?.note ?? "",
+    request.ask ? askGuidance(request.ask.previews) : "",
   ].filter(Boolean).join("\n\n");
 }
 
@@ -253,11 +273,18 @@ export async function runWorker(
     ...watchdogOptions(request.config.workflow),
     ...request.agent,
     ...(extraTools.length > 0 ? { extraTools } : {}),
+    // One allotment for the step: a routed attempt that falls short re-runs on what is left of it.
+    ...(request.time ? { time: request.time } : {}),
+    ...(request.ask ? { onAsk: request.ask.onAsk } : {}),
   };
   let outcome = workerOutcome(request.domain, await runAgent(route ? { ...base, ...routedFields(route) } : base, run));
   // A routed step that fell short runs again at the configured model and thinking.
   if (route && fellShort(outcome.run, outcome.issues) && !request.signal?.aborted) {
+    const routed = outcome.run.edited ?? [];
     outcome = workerOutcome(request.domain, await runAgent(base, run));
+    // The step owns what the routed attempt edited too.
+    const edited = [...new Set([...routed, ...(outcome.run.edited ?? [])])];
+    if (edited.length > 0) outcome = { ...outcome, run: { ...outcome.run, edited } };
   }
   return outcome;
 }
@@ -284,6 +311,12 @@ export interface ReviewerRequest {
   workerSummary: string;
   scoutOutcomes: ScoutOutcome[];
   diff: string;
+  /** Who changed each changed file (planned, quick fix, pre-existing, …), one line each. */
+  provenance?: string;
+  /** What the previous QA round asked for, when there was one: this round verifies it. */
+  previousRound?: string;
+  /** Under a task time budget: the gate's time. */
+  time?: AgentTime;
   instruction?: string;
   cwd: string;
   dataRoots: readonly string[];
@@ -301,8 +334,11 @@ function reviewerContext(request: ReviewerRequest): string {
   return [
     `Task state: reviewing. Domain: ${request.domain}.`,
     "You may not modify implementation. Report required changes instead.",
-    request.workerSummary ? `Worker summary:\n${truncate(request.workerSummary, 2000)}` : "No worker summary available.",
+    request.previousRound ?? "",
+    request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
     owns.length > 0 ? `Scout findings:\n${summarizeOutcomes(owns, 1200)}` : "",
+    request.provenance ? `Who changed each file (bot-lobby's record of every agent's edit and write calls; judge each as your role's Change provenance says):\n${request.provenance}` : "",
+    request.time?.note ?? "",
     `Repository changes:\n${request.diff}`,
   ]
     .filter((line) => line.length > 0)
@@ -334,6 +370,7 @@ function reviewerAgentRequest(request: ReviewerRequest, selected: KnowledgeSelec
       workflowContext: reviewerContext(request),
     },
     ...profileFields(request.config, request.profile, request.domain, "reviewer"),
+    ...(request.time ? { time: request.time } : {}),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,

package/src/master/research.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
 import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, ResearchResult } from "../schemas/findings.ts";
-import { runAgent, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
+import { runAgent, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
 import { writeFileEnsured } from "../knowledge/store.ts";
 import { isResearchResultUsable, parseResearchResult, validateResearchResult } from "../roles/researcher.ts";
@@ -27,6 +27,8 @@ export interface ResearchRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Under a task time budget: the researcher's time. */
+  time?: AgentTime;
 }
 
 export function researchResultPath(taskDir: string, domain: Domain): string {
@@ -56,7 +58,7 @@ function researchContext(request: ResearchRequest): AgentRequest["context"] {
   return {
     task: request.instruction,
     instructions: request.config.agents[request.domain].instructions,
-    workflowContext: `Task state: research requested by the Master. Domain: ${request.domain}. Read-only; report cited findings only.`,
+    workflowContext: [`Task state: research requested by the Master. Domain: ${request.domain}. Read-only; report cited findings only.`, request.time?.note ?? ""].filter(Boolean).join("\n\n"),
   };
 }
 
@@ -86,6 +88,7 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       model: profile.model,
       thinking: profile.thinking,
       timeoutMs: profile.timeoutMs,
+      ...(request.time ? { time: request.time } : {}),
       cwd: request.cwd,
       signal: request.signal,
       onUpdate: request.onUpdate,