@a-t-h-i/bot-lobby 0.6.53 → 0.6.55

package/src/master/goal-check.ts

@@ -0,0 +1,114 @@
+/**
+ * The goal check: before a task is called done, one read-only agent with a
+ * clean context compares the change with what the user actually asked for
+ * (the request and its amendments, not the plan) and names any requirement
+ * the change does not meet. Plans drift and agents can finish every step and
+ * still miss the point; this catches it at the one moment it is cheap to fix.
+ */
+import type { AgentRun } from "../schemas/findings.ts";
+import type { BotLobbyConfig, ProfileResolver } from "../schemas/configuration.ts";
+import { profileFor } from "../schemas/configuration.ts";
+import { runAgent, watchdogOptions } from "../execution/agent-runner.ts";
+import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
+import { loadPrompt } from "../prompts/loader.ts";
+import { truncate } from "../text.ts";
+
+export type GoalVerdict = "met" | "not_met" | "unread";
+
+export interface GoalCheckResult {
+  verdict: GoalVerdict;
+  /** Requirements the change does not meet, one line each. */
+  gaps: string[];
+  run: AgentRun;
+}
+
+export interface GoalCheckRequest {
+  taskId: string;
+  /** The user's request as they wrote it. */
+  request: string;
+  amendments: readonly string[];
+  diff: string;
+  cwd: string;
+  config: BotLobbyConfig;
+  profile?: ProfileResolver;
+  signal?: AbortSignal;
+  onUpdate?: (run: AgentRun) => void;
+}
+
+/** Most of the change it reads; a longer diff is cut, and the check reads the files it needs. */
+export const GOAL_DIFF_CHARS = 60_000;
+
+function section(text: string, title: string): string {
+  const match = new RegExp(`^#{1,3}\\s+${title}\\s*:?\\s*$([\\s\\S]*?)(?=^#{1,3}\\s|(?![\\s\\S]))`, "im").exec(text);
+  return match?.[1]?.trim() ?? "";
+}
+
+/** The verdict as written: on the heading line (`## Verdict: MET`, `**Verdict:** MET`) or the first line under it. */
+function verdictLine(text: string): string {
+  const inline = /^\s*(?:#{1,3}\s*)?\**verdict\**\s*:\**\s*(\S.*)$/im.exec(text);
+  if (inline?.[1]) return inline[1];
+  return section(text, "Verdict").split("\n").find((line) => line.trim()) ?? "";
+}
+
+/** Words that make a verdict anything but a plain MET. */
+const QUALIFIED = /\b(NOT|UNMET|PARTIAL(LY)?|MOSTLY|LARGELY|EXCEPT|BUT|SOME|INCOMPLETE|FAIL(ED|S)?)\b/;
+
+/**
+ * The verdict and gaps from a goal check's report; `unread` when it has no
+ * verdict. Only a plain MET is met: a qualified one (`NOT MET`, `NOT-MET`,
+ * `PARTIALLY MET`, `MET except …`) is not, and neither is a MET with gaps listed.
+ */
+export function parseGoalCheck(output: string): { verdict: GoalVerdict; gaps: string[] } {
+  const said = verdictLine(output).toUpperCase().replace(/[*_`]/g, " ").replace(/\s+/g, " ").trim();
+  const gaps = section(output, "Gaps")
+    .split("\n")
+    .map((line) => line.replace(/^\s*[-*]\s*/, "").trim())
+    .filter((line) => line.length > 0 && !/^\(?none\b[^a-z]*$/i.test(line) && !/^no gaps\.?$/i.test(line));
+  // The format line copied back (`MET or NOT MET`) says nothing.
+  if (/\bOR\b/.test(said)) return { verdict: "unread", gaps: [] };
+  let verdict: GoalVerdict = QUALIFIED.test(said) || /NOT[-_ ]?MET|UNMET/.test(said) ? "not_met" : /^MET\b/.test(said) ? "met" : "unread";
+  if (verdict === "met" && gaps.length > 0) verdict = "not_met";
+  // A NOT MET without any gap named is still a gap: point at the requirements list.
+  if (verdict === "not_met" && gaps.length === 0) {
+    const unmet = section(output, "Requirements").split("\n").filter((line) => /—\s*(not|partly|partially) met\s*—/i.test(line)).map((line) => line.replace(/^\s*[-*]\s*/, "").trim());
+    return { verdict, gaps: unmet.length > 0 ? unmet : [`the goal check found the request not fully met (${truncate(said, 120)}) but named no gap`] };
+  }
+  return { verdict, gaps: verdict === "met" ? [] : gaps };
+}
+
+export function goalCheckInstruction(request: GoalCheckRequest): string {
+  return [
+    "Check this change against what the user asked for.",
+    `## The user's request\n\n${request.request.trim()}`,
+    request.amendments.length > 0 ? `## The user's amendments\n\n${request.amendments.map((entry) => `- ${entry}`).join("\n")}` : "",
+    `## The change\n\n${truncate(request.diff, GOAL_DIFF_CHARS)}`,
+  ].filter(Boolean).join("\n\n");
+}
+
+/** The goal check's prompt, with the QA settings' own instructions when the user gave any. */
+export function goalCheckPrompt(instructions?: string): string {
+  const custom = instructions?.trim();
+  return custom ? `${loadPrompt("goal-check.md")}\n\n## Custom Instructions\n\n${custom}` : loadPrompt("goal-check.md");
+}
+
+export async function runGoalCheck(request: GoalCheckRequest, run: ProcessRunner = spawnPiProcess): Promise<GoalCheckResult> {
+  // The QA settings' model reads the change: the same reader the gate trusts, on a much smaller job.
+  const profile = profileFor(request.config, request.profile, "qa", "reviewer");
+  const agentRun = await runAgent({
+    taskId: request.taskId,
+    domain: "qa",
+    role: "reviewer",
+    instruction: goalCheckInstruction(request),
+    context: { task: request.request },
+    systemPrompt: goalCheckPrompt(profile.instructions),
+    ...(profile.model ? { model: profile.model } : {}),
+    thinking: profile.thinking,
+    cwd: request.cwd,
+    ...(request.signal ? { signal: request.signal } : {}),
+    ...(request.onUpdate ? { onUpdate: (update: AgentRun) => request.onUpdate!({ ...update, note: update.note ?? "goal check" }) } : {}),
+    ...watchdogOptions(request.config.workflow),
+    retries: 0,
+  }, run);
+  if (agentRun.status !== "success") return { verdict: "unread", gaps: [], run: agentRun };
+  return { ...parseGoalCheck(agentRun.output), run: agentRun };
+}

package/src/master/master.ts

@@ -4,7 +4,7 @@ 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 { boundedAgentTime, runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
+import { runAgent, runParallel, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { knowledgeFilePath, readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
 import { taskDir } from "../knowledge/paths.ts";
@@ -19,6 +19,7 @@ import { treeState } from "../execution/git.ts";
 import { toolBudgetEnv, toolBudgetNote } from "../pi/tool-budget.ts";
 import { recordFileNotes } from "../knowledge/file-notes.ts";
 import { readCachedScout, scoutKey, writeCachedScout } from "./scout-cache.ts";
+import { BOARD_ENV, BOARD_TOOLS, boardContext } from "../desk/board.ts";
 import type { FileHinter } from "../classifier/files.ts";
 import type { KnowledgePaths, KnowledgePicker } from "../classifier/knowledge.ts";
 import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
@@ -33,8 +34,6 @@ 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;
@@ -45,7 +44,7 @@ export interface ScoutRequest {
   dataRoots: readonly string[];
   taskDir: string;
   config: BotLobbyConfig;
-  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  /** Settings-derived model/thinking/grants, clamped to the model; plain settings when absent. */
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
@@ -57,10 +56,10 @@ export interface ScoutRequest {
   effort?: EffortRouter;
 }
 
-/** Model, thinking and time limit for one run, from settings. */
+/** Model, thinking and grants for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.autoCompact === false ? { autoCompact: false } : {}), thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
+  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.skills ? { skills: profile.skills } : {}), ...(profile.autoCompact === false ? { autoCompact: false } : {}), thinking: profile.thinking };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {
@@ -103,7 +102,7 @@ function scoutContext(request: ScoutRequest, domain: Domain, selected: Knowledge
     task: request.taskText,
     ...selected,
     instructions: request.config.agents[domain].instructions,
-    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, toolBudgetNote(request.config.scout.maxToolCalls), likely, request.time?.note ?? ""].filter(Boolean).join("\n\n"),
+    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, toolBudgetNote(request.config.scout.maxToolCalls), likely].filter(Boolean).join("\n\n"),
   };
 }
 
@@ -194,7 +193,6 @@ async function scoutDomains(request: ScoutRequest, run: ProcessRunner): Promise<
     ...(extraTools.length > 0 ? { extraTools } : {}),
     env: toolBudgetEnv(request.config.scout.maxToolCalls),
     ...profileFields(request.config, request.profile, domain, "scout"),
-    ...(request.time ? { time: { ...request.time } } : {}),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
@@ -206,7 +204,7 @@ async function scoutDomains(request: ScoutRequest, run: ProcessRunner): Promise<
   const runs = await runParallel(first, request.config.workflow.maxParallelScouts, run);
   let outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
   // A routed scout that came back unusable runs again on its configured model.
-  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted && requests[index]!.time!.endsAt > Date.now() ? index : -1)).filter((index) => index >= 0);
+  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted ? index : -1)).filter((index) => index >= 0);
   if (again.length > 0) {
     const reruns = await runParallel(again.map((index) => requests[index]!), request.config.workflow.maxParallelScouts, run);
     outcomes = outcomes.map((outcome, index) => {
@@ -269,7 +267,7 @@ export interface WorkerRequest {
   cwd: string;
   dataRoots: readonly string[];
   config: BotLobbyConfig;
-  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  /** Settings-derived model/thinking/grants, clamped to the model; plain settings when absent. */
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
@@ -279,12 +277,43 @@ export interface WorkerRequest {
   knowledge?: KnowledgePicker;
   /** 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 };
   /** A QA step's verification budget: Jev's QA risk read of the change so far. */
   risk?: string;
+  /** The task board's file: the worker reads what its role follows and posts contracts, decisions and blockers. */
+  board?: string;
+  /** Domains working at the same time as this one, in a parallel batch. */
+  alongside?: readonly Domain[];
+  /** The worker has a worktree of its own for the batch; its change is applied back when the batch ends. */
+  ownCheckout?: boolean;
+  /** The model ask_expert consults on. */
+  expert?: { model?: string; thinking: string };
+}
+
+/** How a worker uses the task board, and what it already says for its role. */
+function boardGuidance(request: WorkerRequest): string {
+  if (!request.board) return "";
+  return [
+    "Task board: post with `post_board` whenever you settle something another agent builds against or must follow (`contract`: a route, payload, type, event or file location; `decision`), when you are blocked on someone else's part (`blocker`), and when a piece is finished and testable (`done`). Exact facts in a line or two; no progress chatter. `read_board` shows what the others posted.",
+    boardContext(request.board, request.domain),
+  ].filter(Boolean).join("\n\n");
+}
+
+/** What a worker in a parallel batch is told about the others, and QA about testing alongside the build. */
+function alongsideGuidance(request: WorkerRequest): string {
+  const others = (request.alongside ?? []).filter((domain) => domain !== request.domain);
+  if (others.length === 0) return "";
+  const names = others.map((domain) => ({ backend: "DEV", designer: "DESIGN", qa: "QA" })[domain]).join(" and ");
+  const peers = `You work at the same time as ${names}. When you need a fact about their part (a name, a shape, a route), ask them with \`ask_peer\` instead of guessing; answer their questions with \`answer_peer\`. Questions only: neither of you takes work from the other.`;
+  const checkout = request.ownCheckout
+    ? " You work in a checkout of your own (no file claims needed): edit only the files your brief names, because when the batch ends your change is applied onto the others', and overlapping lines will not apply."
+    : "";
+  if (request.domain !== "qa") return `${peers}${checkout}`;
+  return [
+    `${peers}${checkout}`,
+    "You write the tests while the others build, so nobody waits for the build to finish first: work from the approved plan's contracts and acceptance criteria and the board's `contract` posts, not from their code. Write and claim test files only. When a builder posts `done` for a piece (or before you report), run your tests against what is there; a failing test against finished work is a finding for its owner, never a production fix of yours.",
+  ].join(" ");
 }
 
 /** What a worker that may ask the user is told about it. */
@@ -312,9 +341,11 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
       : "No scout findings were collected for your domain; verify the repository yourself.",
     likely,
     request.risk ?? "",
-    request.time?.note ?? "",
+    alongsideGuidance(request),
+    boardGuidance(request),
     request.ask ? askGuidance(request.ask.previews) : "",
     request.dataRoots[0] ? `Scripts you draft for the shared library go in \`${join(taskDir(request.dataRoots[0], request.taskId), "scripts")}\`.` : "",
+    request.dataRoots[0] ? `Long findings (an investigation, a list of call sites, a log excerpt) go in a file under \`${join(taskDir(request.dataRoots[0], request.taskId), "notes")}\`: give its path under Notes instead of pasting them into your report, so whoever needs them reads them whole.` : "",
   ].filter(Boolean).join("\n\n");
 }
 
@@ -330,9 +361,11 @@ export async function runWorker(
     routeFor(request.effort, request.instruction, { ...(configured.model ? { model: configured.model } : {}), thinking: configured.thinking }, { context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) }),
   ]);
   const hintTools = request.hints?.tools() ?? [];
-  const extraTools = [...(request.agent?.extraTools ?? []), ...hintTools];
+  const extraTools = [...(request.agent?.extraTools ?? []), ...hintTools, ...(request.board ? BOARD_TOOLS : [])];
+  const env = request.board ? { ...request.agent?.env, [BOARD_ENV]: request.board, BOT_LOBBY_BOARD_FROM: request.domain } : request.agent?.env;
   const base: AgentRequest = {
     delegationQuota: { used: 0 },
+    ...(request.expert ? { expert: request.expert } : {}),
     effort: request.effort,
     effortProfile: configured,
     taskId: request.taskId,
@@ -351,14 +384,13 @@ export async function runWorker(
     onUpdate: request.onUpdate,
     ...watchdogOptions(request.config.workflow),
     ...request.agent,
+    ...(env ? { env } : {}),
     ...(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 && base.time!.endsAt > Date.now()) {
+  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.
@@ -399,13 +431,15 @@ export interface ReviewerRequest {
   lint?: string;
   /** Jev's QA risk read of the change: the gate's depth, test budget and focus. */
   risk?: string;
-  /** Under a task time budget: the gate's time. */
-  time?: AgentTime;
+  /** The task board's contracts, decisions, blockers and finished pieces, as posted by the task's agents. */
+  board?: string;
+  /** Review with a clean context: no worker summaries or scout findings, only the request, plan, board and diff. */
+  clean?: boolean;
   instruction?: string;
   cwd: string;
   dataRoots: readonly string[];
   config: BotLobbyConfig;
-  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  /** Settings-derived model/thinking/grants, clamped to the model; plain settings when absent. */
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
@@ -422,11 +456,14 @@ function reviewerContext(request: ReviewerRequest): string {
     "You may not modify implementation. Report required changes instead.",
     request.risk ?? "",
     request.previousRound ?? "",
-    request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
+    request.clean
+      ? "You review with a clean context: the request, the approved plan, the task board and the diff, not the workers' own accounts of what they did. Judge the change by what the code does, and verify any claim yourself before you rely on it."
+      : request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
+    // QA scouts planned these tests: their findings are the reviewer's own groundwork, not a worker's account.
     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.lint ?? "",
-    request.time?.note ?? "",
+    request.board ?? "",
     `Repository changes:\n${request.diff}`,
   ]
     .filter((line) => line.length > 0)
@@ -459,7 +496,6 @@ 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,
@@ -483,7 +519,7 @@ export async function runReviewer(
   const agentRequest = reviewerAgentRequest(request, selected);
   const attempts = Math.max(1, request.config.workflow.maxAgentRetries + 1);
   let agentRun = await runAgent(agentRequest, run);
-  for (let attempt = 2; attempt <= attempts && isRetryableReviewRun(agentRun) && agentRequest.time!.endsAt > Date.now(); attempt++) {
+  for (let attempt = 2; attempt <= attempts && isRetryableReviewRun(agentRun); attempt++) {
     agentRun = await runAgent(agentRequest, run);
   }
   const result = parseReviewResult(request.domain, agentRun.output);

package/src/master/research.ts

@@ -2,7 +2,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, type AgentTime } from "../execution/agent-runner.ts";
+import { runAgent, watchdogOptions, type AgentRequest } 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";
@@ -26,8 +26,6 @@ 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 {
@@ -42,7 +40,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.`, request.time?.note ?? ""].filter(Boolean).join("\n\n"),
+    workflowContext: [`Task state: research requested by the Master. Domain: ${request.domain}. Read-only; report cited findings only.`].join("\n\n"),
   };
 }
 
@@ -71,10 +69,9 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       context: researchContext(request),
       model: profile.model,
       mcpTools: profile.mcpTools,
+      ...(profile.skills ? { skills: profile.skills } : {}),
       ...(profile.autoCompact === false ? { autoCompact: false } : {}),
       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

@@ -30,7 +30,6 @@ import { registerWebServer, webCommand } from "../webui/command.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";
 import type { GitIsolation } from "../schemas/configuration.ts";
 import { START_FLAG } from "./start-flags.ts";
@@ -41,10 +40,8 @@ const HELP = [
   "/bot-lobby                  Open the web lobby in your browser: tasks, plan, quick fix, metrics",
   "/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 --branch|--worktree|--no-branch <request>   Give the task its own git branch, or its own worktree, named after it (or neither), whatever workflow.gitIsolation says",
-  "/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",
@@ -66,7 +63,7 @@ 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", "accept", "budget", "knowledge", "config", "settings", "on", "off", "minimize", "restore", "claim", "carry-on", "auto", "start-plan", "switch", "web"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "knowledge", "config", "settings", "on", "off", "minimize", "restore", "claim", "carry-on", "auto", "start-plan", "switch", "web"]);
 
 /** Subcommands that act on a task or open the lobby turn bot-lobby on first; the rest work while it is off. */
 const TURNS_ON = new Set(["lobby", "settings", "resume", "approve", "amend", "decline", "accept", "claim", "carry-on", "auto", "start-plan", "switch", "web"]);
@@ -81,10 +78,6 @@ export interface ParsedCommand {
   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. */
@@ -98,7 +91,7 @@ export function parseCommand(args: string): ParsedCommand {
   // 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" | "isolation"> = {};
+  const extras: Pick<ParsedCommand, "auto" | "track" | "task" | "isolation"> = {};
   for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
     flagged = true;
     if (match[1] === "auto") extras.auto = true;
@@ -106,11 +99,6 @@ export function parseCommand(args: string): ParsedCommand {
     else if (match[1] === "fast" || match[1] === "full") extras.track = match[1];
     else if (match[1] === "branch" || match[1] === "worktree") extras.isolation = match[1];
     else if (match[1] === "no-branch") extras.isolation = "off";
-    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 };
@@ -118,7 +106,6 @@ export function parseCommand(args: string): ParsedCommand {
   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(" ")))
     || (sub === "web" && rest.length === 1 && ["stop", "link", "reset"].includes(rest[0]!));
@@ -142,9 +129,7 @@ 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}` : "";
-  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");
+  ctx.ui.notify(task ? `${describeTask(task)}${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. */
@@ -288,28 +273,6 @@ function acceptWork(pi: ExtensionAPI, ctx: ExtensionCommandContext, configDir: s
   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();
@@ -373,14 +336,13 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto, budget, budgetError, track, task, isolation } = parseCommand(args ?? "");
-      if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
+      const { sub, rest, restText, auto, track, task, isolation } = parseCommand(args ?? "");
       // A request, the bare command or anything that drives a task needs bot-lobby on (`web stop` does not).
       if (!sub || (TURNS_ON.has(sub) && !(sub === "web" && rest[0] === "stop"))) turnOn(pi, ctx, configDir);
       if (!sub) {
         if (!restText) return webCommand(ctx, undefined);
         // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
-        await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
+        await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
         return;
       }
       switch (sub) {
@@ -408,8 +370,6 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           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/delegation.ts

@@ -1,14 +1,15 @@
+import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { createDeskClient } from "../desk/ipc.ts";
-import { AGENT_ENV, DELEGATION_ENV, DELEGATE_TOOL, MAX_CHILDREN, type AgentPolicy } from "../execution/delegation.ts";
+import { AGENT_ENV, DELEGATION_ENV, DELEGATE_TOOL, EXPERT_TOOL, MAX_CHILDREN, MAX_CONSULTS, type AgentPolicy } from "../execution/delegation.ts";
 import { loadConfig } from "../state/project.ts";
 import { isSubagentProcess } from "./quiet.ts";
 
 export function allowedAgentTool(policy: AgentPolicy, name: string, readOnlyHint?: boolean, hidden = false): boolean {
   if (hidden) return false;
   if (name.startsWith("mcp__")) return policy.mcpTools.includes(name) && (!policy.readOnly || readOnlyHint === true);
-  if (name === DELEGATE_TOOL && policy.depth > 1) return false;
+  if ((name === DELEGATE_TOOL || name === EXPERT_TOOL) && policy.depth > 1) return false;
   return policy.tools.includes(name);
 }
 
@@ -44,7 +45,7 @@ export function registerAgentPermissions(pi: ExtensionAPI): void {
 
 export function registerDelegation(pi: ExtensionAPI): void {
   if (!isSubagentProcess() || !process.env[DELEGATION_ENV]) return;
-  const target = JSON.parse(process.env[DELEGATION_ENV]!) as { address: string; token: string; timeoutMs: number };
+  const target = JSON.parse(process.env[DELEGATION_ENV]!) as { address: string; token: string };
   const client = createDeskClient(target.address, target.token);
   pi.on("session_shutdown", () => client.close());
   pi.registerTool({
@@ -58,11 +59,29 @@ export function registerDelegation(pi: ExtensionAPI): void {
       const cancel = () => { void client.request({ op: "cancel_delegate" }); };
       signal?.addEventListener("abort", cancel, { once: true });
       try {
-        const answer = await client.request({ op: "delegate", briefs: params.briefs }, target.timeoutMs + 10_000);
+        const answer = await client.request({ op: "delegate", briefs: params.briefs }, 0);
         if (!answer.ok) throw new Error(answer.text);
         const children = JSON.parse(answer.text) as Array<{ runId: string; status: string; report: string; reportPath?: string; error?: string }>;
         return { content: [{ type: "text", text: children.map((child) => `Child ${child.runId}: ${child.status}\n${child.report}${child.reportPath ? `\nFull report: ${child.reportPath}` : ""}${child.error ? `\nError: ${child.error}` : ""}`).join("\n\n") }], details: { children } };
       } finally { signal?.removeEventListener("abort", cancel); }
     },
   });
+  pi.registerTool({
+    name: EXPERT_TOOL,
+    label: "Ask an expert",
+    description: `Ask a stronger model for advice on a hard step: a bug you cannot find after a real attempt, a tricky algorithm, an unfamiliar API, or a choice you are unsure of. Say what you are trying to do, what you tried and what happened, and point to the files and lines. It reads the repository and answers; it does not change anything, and you still do the work. At most ${MAX_CONSULTS} per step.`,
+    parameters: Type.Object({ question: Type.String({ minLength: 1, maxLength: 6000, description: "The question, with what you tried and the files and lines involved" }) }),
+    executionMode: "sequential",
+    async execute(_id, params, signal) {
+      signal?.throwIfAborted();
+      const consultId = randomUUID();
+      const cancel = () => { void client.request({ op: "cancel_consult", consultId }); };
+      signal?.addEventListener("abort", cancel, { once: true });
+      try {
+        const answer = await client.request({ op: "consult", text: params.question, consultId }, 0);
+        if (!answer.ok) throw new Error(answer.text);
+        return { content: [{ type: "text", text: `Expert advice:\n${answer.text}` }], details: undefined };
+      } finally { signal?.removeEventListener("abort", cancel); }
+    },
+  });
 }

package/src/pi/events.ts

@@ -20,7 +20,7 @@ import { triageContext } from "../classifier/triage.ts";
 import { qaStillDue, rosterWords } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
 import { skippedStepsNote } from "./plan-checklist.ts";
-import { budgetLine, budgetState, clockTask, pauseClocks, readBudget, resumeClocks, startClock, stopClocks, turnStarted } from "../state/budget.ts";
+import { clockTask, pauseClocks, resumeClocks, startClock, stopClocks, turnStarted } from "../state/work-clock.ts";
 
 /** Tools that wait on the user: the task's clock waits with them. */
 const ASKING_TOOLS: ReadonlySet<string> = new Set(["ask_user_question"]);
@@ -28,22 +28,9 @@ 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, 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(" ");
+/** The Master's workflow context: the task's state, and 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");
 }
 
 export function masterTaskContext(task: Task, comments: readonly PlanComment[] = [], auto = false): string {
@@ -84,7 +71,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
 
 
-  // A task's work time (and its time budget) counts while the oracle works on it, not while it waits on the user.
+  // A task's work time 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;
@@ -150,7 +137,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       knowledge: selected.knowledge,
       decisions: selected.decisions,
       scripts: dataRoots[0] ? libraryBlock(dataRoots[0]) : "",
-      workflowContext: masterWorkflowContext(task, budgetContext(root, configDir, task)),
+      workflowContext: masterWorkflowContext(task),
       instructions: loadConfig().master.instructions,
     });
   });