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

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,26 +17,33 @@ 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";
-import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
+import { kickoff, startPlannedTask } from "./start-task.ts";
+import { startRequest } from "./route.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 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";
+import { qaStillDue } from "../workflow/track.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 <request>        Start a request: a quick fix when one agent can do it alone (the oracle confirms), else a task",
+  "/bot-lobby --task [--auto] <request>   Always a task (also 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 --fast|--full <request>   Start a task on the fast track (straight to the agents it needs) or the full workflow, whatever it reads as",
+  "/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 +57,54 @@ 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`, `--fast`, `--full`, `--budget <time>` (or `--budget=<time>`). */
+const START_FLAG = /^--(task|auto|fast|full)(?=\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;
+  /** `--fast` or `--full`: the task's path, whatever its request reads as. */
+  track?: "fast" | "full";
+  /** `--task`: a task, never routed to the quick-fix agent. */
+  task?: boolean;
+}
+
+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" | "track" | "task"> = {};
+  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[1] === "task") extras.task = true;
+    else if (match[1] === "fast" || match[1] === "full") extras.track = match[1];
+    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 +127,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, !qaStillDue(task)))}` : "";
+  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 +217,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, !qaStillDue(task)))}` : `${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, !qaStillDue(task)))}` : `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 +324,16 @@ 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, track, task } = 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();
+        // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
+        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}) });
+        if (started === "task") autoOpenLobby();
         return;
       }
       switch (sub) {
@@ -269,6 +360,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":

package/src/pi/events.ts

@@ -9,20 +9,38 @@ import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity } from "./ui.ts";
 import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
-import { isSubagentProcess, visibleTools } from "./quiet.ts";
+import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
+import { qaStillDue } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
+import { budgetLine, budgetState, pauseClocks, readBudget, resumeClocks, startClock, stopClocks } from "../state/budget.ts";
+
+/** Tools that wait on the user: the task's clock waits with them. */
+const ASKING_TOOLS: ReadonlySet<string> = new Set(["ask_user_question"]);
 
 /** States in which the triage still helps the Master shape the task; once it is planned, the hints are noise. */
 const SHAPING_STATES: ReadonlySet<TaskState> = new Set(["created", "clarifying", "scouting", "synthesizing", "awaiting_approval"]);
 
-/** The Master's workflow context: the task's state, plus the classifier's triage while the task is being shaped. */
-export function masterWorkflowContext(task: Task): string {
-  return [describeTask(task), SHAPING_STATES.has(task.state) ? triageContext(task.triage) : ""].filter(Boolean).join("\n\n");
+/** The Master's workflow context: the task's state, where its time budget stands, and the classifier's triage while the task is being shaped. */
+export function masterWorkflowContext(task: Task, time = ""): string {
+  return [describeTask(task), time, SHAPING_STATES.has(task.state) ? triageContext(task.triage) : ""].filter(Boolean).join("\n\n");
+}
+
+/** The oracle's view of the task's time budget: where it stands and how to spend it; "" without one. */
+export function budgetContext(root: string, configDir: string, task: Task): string {
+  const budget = readBudget(root, configDir, task.id);
+  if (!budget) return "";
+  const state = budgetState(task.id, budget, !qaStillDue(task));
+  const running = budget.allotments.filter((entry) => !entry.endedAt).map((entry) => `${entry.who} (${entry.minutes}m)`);
+  return [
+    budgetLine(budget, state),
+    running.length > 0 ? `Running now: ${running.join(", ")}.` : "",
+    "Divide what is left by scope: pass `minutes` on each implement (per assignment in a parallel batch), keeping the QA gate's reserve. Every agent is told its minutes; one that runs out reports where it left off and the user decides on more.",
+  ].filter(Boolean).join(" ");
 }
 
 export function masterTaskContext(task: Task, comments: readonly PlanComment[] = [], auto = false): string {
@@ -47,12 +65,11 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
  * section rather than replacing the whole prompt.
  */
 export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
+  // Web tools the oracle put away for the task in hand, given back when it ends.
+  let hiddenWeb: string[] = [];
   pi.on("session_start", (_event, ctx) => {
     // Master-only: subagents keep their own --tools allowlist (see quiet.ts).
-    if (!isSubagentProcess()) {
-      registerQuietTools(pi);
-      pi.setActiveTools(visibleTools(pi.getActiveTools()));
-    }
+    if (!isSubagentProcess()) registerQuietTools(pi);
     const root = detectProjectRoot(ctx.cwd, configDir);
     setMinimized(false);
     applyStatus(ctx, root, configDir);
@@ -65,25 +82,38 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   // Parallel tool calls: the newest still-running call keeps the word.
   const inFlight = new Map<string, string>();
   const showOracle = () => setOracleActivity([...inFlight.values()].at(-1) ?? ORACLE_THINKING);
-  pi.on("agent_start", () => {
+  // A task's time budget counts while the oracle works on it, not while it waits on the user.
+  const asking = new Set<string>();
+  pi.on("agent_start", (_event, ctx) => {
     if (isSubagentProcess()) return;
     inFlight.clear();
     showOracle();
+    const root = detectProjectRoot(ctx.cwd, configDir);
+    const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
+    if (task) startClock(root, configDir, task.id);
   });
   pi.on("tool_execution_start", (event) => {
     if (isSubagentProcess()) return;
     inFlight.set(event.toolCallId, oracleActivityWord(event.toolName, event.args));
     showOracle();
+    if (ASKING_TOOLS.has(event.toolName) && !asking.has(event.toolCallId)) {
+      asking.add(event.toolCallId);
+      pauseClocks();
+    }
   });
   pi.on("tool_execution_end", (event) => {
     if (isSubagentProcess()) return;
     inFlight.delete(event.toolCallId);
     showOracle();
+    if (asking.delete(event.toolCallId)) resumeClocks();
   });
   pi.on("agent_end", () => {
     if (isSubagentProcess()) return;
     inFlight.clear();
     setOracleActivity(undefined);
+    for (const _call of asking) resumeClocks();
+    asking.clear();
+    stopClocks();
   });
   pi.on("session_shutdown", (_event, ctx) => {
     cancelAllRuns();
@@ -95,6 +125,14 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
     const sessionId = ctx.sessionManager.getSessionId();
     const hidden = isSubagentProcess() || isMinimized();
     const task = hidden ? undefined : activeTask(root, configDir, sessionId);
+    if (!isSubagentProcess()) {
+      // The researcher is the task's only web path; without a task pi keeps them.
+      const tools = webToolsFor(pi.getActiveTools(), Boolean(task), hiddenWeb);
+      if (tools) {
+        hiddenWeb = tools.hidden;
+        pi.setActiveTools(tools.active);
+      }
+    }
     if (!task) {
       // After a task ended and cleared the context, a line on where its record is, in case the user refers back to it.
       const previous = hidden ? undefined : previousTaskNote(ctx, configDir);
@@ -110,7 +148,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,
-      workflowContext: masterWorkflowContext(task),
+      workflowContext: masterWorkflowContext(task, budgetContext(root, configDir, task)),
       instructions: loadConfig().master.instructions,
     });
   });

package/src/pi/quiet.ts

@@ -1,8 +1,9 @@
 /**
  * Quiet mode for the master transcript: built-in tool rows render zero lines
- * by default and `alt+t` reveals a compact one-line summary per call. The web
- * tools are removed from the master's active set so the researcher subagent,
- * running in its own process, stays the only web path.
+ * by default and `alt+t` reveals a compact one-line summary per call. While a
+ * task runs, the web tools are removed from the master's active set so the
+ * researcher subagent, running in its own process, stays the task's only web
+ * path; without a task, pi has them like any other tool.
  *
  * bot-lobby's extension also loads inside the subagent processes it spawns
  * (see `spawnPiProcess`). Those children receive their tools from an explicit
@@ -10,7 +11,7 @@
  * never run there or research silently degrades to repository-only.
  */
 
-/** Web tools owned by pi-web-access; the researcher gets them, the master does not. */
+/** bot-lobby's web tools (src/web/tools.ts): the researcher's, and pi's outside a task, never the oracle's. */
 export const WEB_TOOL_NAMES: readonly string[] = [
   "web_search",
   "fetch_content",
@@ -40,6 +41,23 @@ export function visibleTools(active: string[]): string[] {
   return active.filter((name) => !WEB_TOOL_NAMES.includes(name));
 }
 
+/**
+ * The master's active tools for a turn: without the web tools while a task
+ * is active, and with those it took away given back once none is. Only tools
+ * it hid itself come back, so a tool the user turned off stays off. Returns
+ * undefined when nothing changes.
+ */
+export function webToolsFor(active: string[], taskActive: boolean, hidden: readonly string[]): { active: string[]; hidden: string[] } | undefined {
+  if (taskActive) {
+    const taken = active.filter((name) => WEB_TOOL_NAMES.includes(name));
+    if (taken.length === 0) return undefined;
+    return { active: visibleTools(active), hidden: [...new Set([...hidden, ...taken])] };
+  }
+  const back = hidden.filter((name) => !active.includes(name));
+  if (hidden.length === 0) return undefined;
+  return { active: [...active, ...back], hidden: [] };
+}
+
 /** True inside a bot-lobby subagent process (marked in `spawnPiProcess`). */
 export function isSubagentProcess(): boolean {
   return process.env.BOT_LOBBY_SUBAGENT === "1";