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

package/src/lobby/tabs/issues.ts

@@ -4,7 +4,7 @@
  * becomes a task.
  */
 import type { IssueDetail, IssueSummary } from "../issues.ts";
-import { bold, since, columns, fill, paint, rule, selectRow, spinner, split, windowStart, wrap, type LobbyTheme } from "../layout.ts";
+import { bold, since, columns, fill, markdownLines, paint, rule, selectRow, spinner, split, windowStart, wrap, type LobbyTheme } from "../layout.ts";
 
 export interface IssuesTabInput {
   issues: readonly IssueSummary[];
@@ -31,9 +31,10 @@ export function issueDetailLines(issue: IssueDetail, width: number, now: number,
   ].filter(Boolean);
   const lines = [...wrap(bold(theme, `#${issue.number} ${issue.title}`), width), facts.join(paint(theme, "dim", " · "))];
   if (issue.url) lines.push(paint(theme, "dim", issue.url));
-  lines.push("", paint(theme, "dim", "p plans it with the planning panel, then save it as a task"), "", ...wrap(issue.body.trim() || paint(theme, "dim", "(no description)"), width));
+  // Issues and their comments are GitHub Markdown.
+  lines.push("", paint(theme, "dim", "p plans it with the planning panel, then save it as a task"), "", ...(issue.body.trim() ? markdownLines(issue.body.trim(), width, theme) : [paint(theme, "dim", "(no description)")]));
   for (const comment of issue.comments) {
-    lines.push("", rule(width, comment.author ?? "comment", theme, comment.createdAt ? since(now - Date.parse(comment.createdAt)) : ""), ...wrap(comment.body.trim(), width));
+    lines.push("", rule(width, comment.author ?? "comment", theme, comment.createdAt ? since(now - Date.parse(comment.createdAt)) : ""), ...markdownLines(comment.body.trim(), width, theme));
   }
   return lines;
 }

package/src/lobby/tabs/plan.ts

@@ -9,7 +9,7 @@
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { ORACLE_LABEL, type LineComment, type PanelNote, type PanelQuestion, type PlannerMessage, type PlannerReply, type PlannerSeed, type RoundMode } from "../planner.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
-import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { beside, bold, box, clock, fill, fit, italic, markdownHanging, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
 import { sourceColor, speakerLine, tailWindow, youLines } from "./home.ts";
 
 export interface SeatView {
@@ -152,7 +152,7 @@ function questionLines(questions: ReadonlyArray<{ question: PanelQuestion; numbe
     const lead = `${paint(theme, "dim", `${String(number).padStart(2)}.`)} ${bold(theme, paint(theme, sourceColor(question.from), question.from.padEnd(LABEL_WIDTH)))} `;
     const indent = " ".repeat(4 + LABEL_WIDTH);
     const options = question.options.map((option) => wrapHanging(`${indent}${paint(theme, "dim", "○")} `, `${option.label}${option.description ? paint(theme, "dim", ` — ${option.description}`) : ""}`, width)).flat();
-    return [...wrapHanging(lead, question.text, width), ...options];
+    return [...markdownHanging(lead, question.text, width, theme), ...options];
   });
 }
 
@@ -178,7 +178,7 @@ export function conversationLines(view: PlanView, width: number, theme?: LobbyTh
       continue;
     }
     lines.push(speakerLine("panel", width, theme, time));
-    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : wrap(message.text, width).map((line) => (line ? `  ${line}` : ""))));
+    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : markdownLines(message.text, Math.max(1, width - 2), theme).map((line) => (line ? `  ${line}` : ""))));
     for (const entry of message.decided ?? []) {
       lines.push(...wrapHanging(`  ${paint(theme, "success", "✓")} `, `${paint(theme, sourceColor(entry.from), `[${entry.from}]`)} ${entry.question} → ${bold(theme, entry.answer)} ${paint(theme, "dim", `· decided by the classifier (${entry.probability.toFixed(2)}); comment on the plan to overrule`)}`, width));
     }
@@ -210,7 +210,7 @@ export function draftLines(view: PlanView, width: number, theme?: LobbyTheme): D
   }
   if (view.notes.length > 0) {
     lines.push(line(""), line(bold(theme, paint(theme, "mdHeading", "What each seat needs"))));
-    for (const note of view.notes) for (const wrapped of wrapHanging(`${paint(theme, sourceColor(note.from), note.from.padEnd(LABEL_WIDTH))} `, note.text, width)) lines.push(line(wrapped));
+    for (const note of view.notes) for (const wrapped of markdownHanging(`${paint(theme, sourceColor(note.from), note.from.padEnd(LABEL_WIDTH))} `, note.text, width, theme)) lines.push(line(wrapped));
   }
   return lines;
 }

package/src/lobby/tabs/quickfix.ts

@@ -61,7 +61,9 @@ export function jobDetailLines(job: QuickFixJob, width: number, tick: number, no
     job.tools ? `${job.tools} tool${job.tools === 1 ? "" : "s"}` : "",
     job.usage?.cost ? `$${job.usage.cost.toFixed(2)}` : "",
   ].filter(Boolean);
-  const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...wrap(bold(theme, job.prompt), width)];
+  // What you asked, in Markdown as your messages read in the conversation (a pasted snippet, a list of steps).
+  const asked = theme?.markdown ? markdownLines(job.prompt, width, theme, true, "you") : wrap(bold(theme, job.prompt), width);
+  const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...asked];
   if (job.route) lines.push("", ...wrap(paint(theme, "dim", `↓ routed ${job.route}`), width));
   if (job.note) lines.push("", ...wrap(paint(theme, "warning", job.status === "held" ? `‖ Held: ${job.note}. r runs it anyway · t starts it as a task in a new session.` : job.note), width));
   lines.push("", rule(width, "Steps", theme));
@@ -70,6 +72,10 @@ export function jobDetailLines(job: QuickFixJob, width: number, tick: number, no
     const lead = `${paint(theme, "dim", clock(step.at))} ${step.pending && job.status === "running" ? paint(theme, "accent", spinner(tick)) : paint(theme, "dim", "·")} `;
     lines.push(...wrapHanging(lead, step.pending && job.status === "running" ? `${step.text}…` : paint(theme, "muted", step.text), width));
   }
+  if (job.files?.length) {
+    lines.push("", rule(width, "Edited", theme));
+    for (const file of job.files) lines.push(...wrapHanging(paint(theme, "dim", "· "), paint(theme, "muted", file), width));
+  }
   if (job.error) lines.push("", ...wrap(paint(theme, "error", `✗ ${job.error}`), width));
   if (job.report) {
     lines.push("", rule(width, "Report", theme), ...markdownLines(job.report, width, theme));

package/src/lobby/tabs/tasks.ts

@@ -11,7 +11,8 @@ import { planChecklist } from "../../pi/zen.ts";
 import { persistedRuns } from "../../pi/ui.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
-import { ago, beside, bold, box, detailWindow, fill, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { textWidth } from "../../width.ts";
+import { ago, beside, bold, box, detailWindow, fill, markdownHanging, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
 
 export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
@@ -240,6 +241,13 @@ export function listCount(rows: readonly TaskRow[], query?: string): string {
 const COMMENT_MARKS: Record<PlanComment["status"], string> = { open: "○", delivered: "◐", addressed: "✓" };
 const COMMENT_WORDS: Record<PlanComment["status"], string> = { open: "waiting for the owning session", delivered: "sent to the oracle", addressed: "plan amended" };
 
+/** `note` at the end of the last line when it fits there, else on a line of its own under it. */
+function trailing(lines: string[], note: string, width: number): string[] {
+  const last = lines.at(-1) ?? "";
+  if (textWidth(last) + 1 + textWidth(note) <= width) return [...lines.slice(0, -1), `${last} ${note}`];
+  return [...lines, ...wrapHanging("  ", note, width)];
+}
+
 function section(title: string, width: number, theme?: LobbyTheme, right = ""): string[] {
   return ["", rule(width, title, theme, right)];
 }
@@ -268,7 +276,8 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
     lines.push("", `  ${pips(done, steps.length, cells, theme)} ${paint(theme, "muted", `${done} of ${steps.length} steps`)}`);
   }
   const request = taskRequest(task);
-  if (request && request !== task.title) lines.push(...section("Request", width, theme), ...wrap(paint(theme, "muted", request), width));
+  // Requests are often Markdown: a plan agreed in the planning panel, an issue, a pasted spec.
+  if (request && request !== task.title) lines.push(...section("Request", width, theme), ...markdownLines(request, width, theme));
   if (task.plan) {
     if (steps.length > 0) {
       lines.push(...section("Progress", width, theme, `${done}/${steps.length} steps`));
@@ -291,11 +300,12 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
   if (comments.length === 0) lines.push(paint(theme, "dim", TERMINAL_STATES.includes(task.state) ? "No comments." : "No comments yet — press c to comment on the plan; the oracle amends it."));
   for (const comment of comments) {
     const color = comment.status === "addressed" ? "success" : comment.status === "delivered" ? "accent" : "warning";
-    lines.push(...wrapHanging(`${paint(theme, color, COMMENT_MARKS[comment.status])} `, `${comment.text} ${paint(theme, "dim", `— ${COMMENT_WORDS[comment.status]}, ${since(now - Date.parse(comment.createdAt))}`)}`, width));
+    const said = markdownHanging(`${paint(theme, color, COMMENT_MARKS[comment.status])} `, comment.text, width, theme);
+    lines.push(...trailing(said, paint(theme, "dim", `— ${COMMENT_WORDS[comment.status]}, ${since(now - Date.parse(comment.createdAt))}`), width));
   }
   if (task.amendments.length > 0) {
     lines.push(...section("Amendments", width, theme));
-    for (const amendment of task.amendments) lines.push(...wrapHanging("- ", amendment, width));
+    for (const amendment of task.amendments) lines.push(...markdownHanging("- ", amendment, width, theme));
   }
   const approvals = pendingApprovals(task);
   if (approvals.length > 0 || task.blockers.length > 0) {

package/src/lobby/theme.ts

@@ -0,0 +1,30 @@
+/**
+ * pi's theme as bot-lobby draws with it (the lobby, the questionnaire), plus
+ * Markdown rendering; one wrapper (and one Markdown renderer with its cache)
+ * per theme, so caches stay warm and a theme switch starts fresh.
+ */
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import type { LobbyTheme } from "./layout.ts";
+import { createMarkdownRenderer } from "./markdown.ts";
+
+const lobbyThemes = new WeakMap<Theme, LobbyTheme>();
+
+export 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),
+      // The same looks pi gives your messages and the thinking it shows.
+      markdown: createMarkdownRenderer(getMarkdownTheme(), {
+        you: { color: (text) => theme.fg("accent", text) },
+        thought: { color: (text) => theme.fg("thinkingText", text), italic: true },
+      }),
+      strike: (text) => theme.strikethrough(text),
+    };
+    lobbyThemes.set(theme, wrapped);
+  }
+  return wrapped;
+}

package/src/lobby/view.ts

@@ -23,7 +23,7 @@ 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 { 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";
@@ -320,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;
@@ -894,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));
@@ -922,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;
@@ -2276,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,
@@ -2306,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,

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,

package/src/pi/commands.ts

@@ -17,7 +17,7 @@ import { transition } from "../state/task-state.ts";
 import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
 import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
-import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type ApprovalChoice } from "../workflow/workflow.ts";
+import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAsks, waiveQa, type ApprovalChoice } from "../workflow/workflow.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
 import { classifierSummary, openSettings } from "./settings-ui.ts";
 import { keyStatus } from "../classifier/instance.ts";
@@ -27,16 +27,20 @@ import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
 import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
+import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startClock } from "../state/budget.ts";
 
 const HELP = [
   "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
   "/bot-lobby <request>        Start a task through the workflow",
   "/bot-lobby --task [--auto] <request>   Start a task even when the request begins with a subcommand word",
+  "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
+  "/bot-lobby budget [90m|off]  Show or set this session's task time budget",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
   "/bot-lobby pause|resume     Pause or resume the active task",
   "/bot-lobby cancel [taskId]  Abandon a task",
   "/bot-lobby approve|amend <text>|decline   Answer the current proposal",
+  "/bot-lobby accept [taskId]  Accept a task's work as it is, without a QA pass; the oracle then completes it",
   "/bot-lobby knowledge        Show persistent knowledge files",
   "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
   "/bot-lobby settings         Edit per-agent model/thinking/instructions",
@@ -50,21 +54,48 @@ const HELP = [
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
 
 function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
 }
 
-export function parseCommand(args: string): { sub: string | undefined; rest: string[]; restText: string; auto?: boolean } {
-  const trimmed = args.trim();
-  // `--task [--auto] <request>` always starts a task (a background session started from the lobby sends this).
-  const forced = /^--task(\s+--auto)?(?:\s+([\s\S]*))?$/.exec(trimmed);
-  if (forced) return { sub: undefined, rest: [], restText: (forced[2] ?? "").trim(), ...(forced[1] ? { auto: true } : {}) };
+/** A task start's leading flags: `--task` (always a task), `--auto`, `--budget <time>` (or `--budget=<time>`). */
+const START_FLAG = /^--(task|auto)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+
+export interface ParsedCommand {
+  sub: string | undefined;
+  rest: string[];
+  restText: string;
+  auto?: boolean;
+  /** Minutes from `--budget`. */
+  budget?: number;
+  /** `--budget` with something that is not a time. */
+  budgetError?: string;
+}
+
+export function parseCommand(args: string): ParsedCommand {
+  let trimmed = args.trim();
+  // Leading flags start a task: what follows is its request, even when it begins with a subcommand word
+  // (a background session started from the lobby sends `--task [--auto] <request>`).
+  let flagged = false;
+  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError"> = {};
+  for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
+    flagged = true;
+    if (match[1] === "auto") extras.auto = true;
+    else if (match[2] !== undefined) {
+      const minutes = parseMinutes(match[2]);
+      if (minutes) extras.budget = minutes;
+      else extras.budgetError = `"${match[2]}" is not a time budget (try 90m, 1h or 1h30m)`;
+    }
+    trimmed = trimmed.slice(match[0].length);
+  }
+  if (flagged) return { sub: undefined, rest: [], restText: trimmed.trim(), ...extras };
   const [sub, ...rest] = trimmed.split(/\s+/).filter(Boolean);
   if (!sub || !SUBCOMMANDS.has(sub)) return { sub: undefined, rest: [], restText: trimmed };
   const takesArgs = sub === "amend" || sub === "claim"
     || (sub === "auto" && rest.length === 1 && /^(on|off)$/i.test(rest[0]!))
+    || (sub === "budget" && rest.length >= 1 && rest.length <= 2 && (/^off$/i.test(rest[0]!) || parseMinutes(rest.join("")) !== undefined))
     || (sub === "start-plan" && rest.length >= 1 && rest.length <= 2 && /^PLAN-/.test(rest[0]!) && (rest.length === 1 || rest[1] === "auto"))
     || (sub === "switch" && rest.length >= 1 && /\.jsonl$/.test(rest.join(" ")));
   if (!takesArgs && rest.length > 0 && !(rest.length === 1 && isTaskId(rest[0]))) {
@@ -87,7 +118,9 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
     broken.length > 0 ? `Unreadable task state: ${broken.join(", ")}` : "",
   ].filter(Boolean).join("\n");
   const footer = knowledge ? `\n${knowledge}` : "";
-  ctx.ui.notify(task ? `${describeTask(task)}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
+  const budget = task ? readBudget(root, configDir, task.id) : undefined;
+  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : "";
+  ctx.ui.notify(task ? `${describeTask(task)}${time}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
 /** Recent runs of the active (or named) task, newest last, so slow models are easy to spot. */
@@ -175,6 +208,52 @@ function answerProposal(
   }
 }
 
+/**
+ * `/bot-lobby accept [taskId]`: the user accepts a task's work as it stands,
+ * without a QA pass (QA keeps asking for more, and the user has seen enough).
+ * The gate is waived and blockers cleared; the oracle is asked to complete it.
+ */
+function acceptWork(pi: ExtensionAPI, ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const sessionId = ctx.sessionManager.getSessionId();
+  const task = selectTask(root, configDir, taskId, sessionId);
+  if (!task || TERMINAL_STATES.includes(task.state)) return ctx.ui.notify("bot-lobby: no active task to accept.", "warning");
+  if (task.ownerSessionId && task.ownerSessionId !== sessionId) {
+    return ctx.ui.notify(`${task.id} is owned by another pi session; accept it there, or /bot-lobby claim ${task.id} first.`, "warning");
+  }
+  if (!["implementing", "reviewing", "blocked"].includes(task.state)) {
+    return ctx.ui.notify(`bot-lobby: ${task.id} is still ${task.state}; there is no work to accept yet.`, "warning");
+  }
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, lastQaAsks(task), "with /bot-lobby accept");
+  saveTask(root, configDir, task);
+  applyStatus(ctx, root, configDir);
+  ctx.ui.notify(`bot-lobby: ${task.id} accepted as it is; the oracle will complete it.`, "info");
+  const message = `The user accepted ${task.id}'s work as it is (the QA gate is waived). Call orchestrate action=complete now with a short summary that names anything QA still asked for.`;
+  pi.sendUserMessage(message, ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+}
+
+/**
+ * `/bot-lobby budget [time|off]`: show, set or remove the time budget of this
+ * session's task. Time already spent is kept; the oracle sees the change on
+ * its next step.
+ */
+function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
+  if (!task) return ctx.ui.notify("bot-lobby: no active task in this session — a time budget applies to a task (start one with /bot-lobby --budget 90m <request>)", "warning");
+  if (!value) {
+    const budget = readBudget(root, configDir, task.id);
+    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
+  }
+  const minutes = /^off$/i.test(value) ? 0 : parseMinutes(value);
+  if (minutes === undefined) return ctx.ui.notify(`bot-lobby: "${value}" is not a time budget (try 90m, 1h or 1h30m)`, "warning");
+  const budget = setBudget(root, configDir, task.id, minutes);
+  // Set while the oracle works: its clock runs from now, not from its next turn.
+  if (budget && !ctx.isIdle()) startClock(root, configDir, task.id);
+  applyStatus(ctx, root, configDir);
+  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
+}
+
 function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const cfg = loadConfig();
@@ -236,13 +315,14 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, budget, budgetError } = parseCommand(args ?? "");
+      if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
         if (!restText) {
           if (!showLobby()) ctx.ui.notify(HELP, "info");
           return;
         }
-        if (await startTask(pi, ctx, configDir, restText, auto ? { auto } : {})) autoOpenLobby();
+        if (await startTask(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}) })) autoOpenLobby();
         return;
       }
       switch (sub) {
@@ -269,6 +349,10 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return answerProposal(ctx, configDir, "amend", restText);
         case "decline":
           return answerProposal(ctx, configDir, "decline");
+        case "accept":
+          return acceptWork(pi, ctx, configDir, rest[0]);
+        case "budget":
+          return budgetCommand(ctx, configDir, rest.join(""));
         case "knowledge":
           return showKnowledge(ctx, configDir);
         case "settings":