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

package/src/workflow/workflow.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
-import type { AgentRun, Pushback, ResearchResult, ReviewResult, WorkerResult } from "../schemas/findings.ts";
+import type { BotLobbyConfig, ProfileResolver } from "../schemas/configuration.ts";
+import type { AgentRun, Pushback, ResearchResult, ReviewResult } from "../schemas/findings.ts";
 import {
   MAX_RUN_LOG,
   MAX_WORKER_RECORDS,
@@ -30,12 +30,11 @@ import type { AskQuestion, AskResult } from "../ask/types.ts";
 import { mapConcurrent } from "../execution/agent-runner.ts";
 import { taskExecution } from "../execution/task-cancellation.ts";
 import { parseWorkerResult } from "../roles/worker.ts";
-import { autoNote, DESK_TOOLS, DeskSession } from "../desk/session.ts";
+import { autoNote, DeskSession } from "../desk/session.ts";
+import { closeWorkerTrees, mapToTop, mergeWorkerTrees, openWorkerTrees, type MergeOutcome } from "../execution/worker-trees.ts";
 import type { Handover } from "../desk/desk.ts";
 import { changedFiles, commitBefore, commitFiles, commitMessage, headCommit, readRepositoryDiff, uncommitted } from "../execution/git.ts";
 import { appendChange, explainChanges, provenanceLines, provenanceSummary, readChanges, type FileProvenance } from "../state/changes.ts";
-import { budgetLine, budgetState, formatMinutes, MIN_READ_MS, parseMinutes, qaAllotment, readBudget, readerAllotment, updateBudget, workerAllotment, type Allotment, type BudgetState, type TaskBudget } from "../state/budget.ts";
-import type { AgentTime } from "../execution/agent-runner.ts";
 import {
   loadScoutResults,
   runReviewer,
@@ -49,6 +48,9 @@ import {
 import { researchResultPath, runResearch, type ResearchOutcome, type ResearchRequest } from "../master/research.ts";
 import { assessReconnaissance, completionBlockers, decideReviewLoop, recordDecision } from "../master/decisions.ts";
 import { detectSharedFiles, summarizeOutcomes } from "../master/synthesis.ts";
+import { boardContext, boardPath, filterPosts, formatPosts, readBoard } from "../desk/board.ts";
+import { runGoalCheck } from "../master/goal-check.ts";
+import { createHash } from "node:crypto";
 import { tail, truncate } from "../text.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { briefRejection } from "./brief.ts";
@@ -56,8 +58,7 @@ import { assertNoPendingApprovals, pendingApprovals, requestApproval, resolveApp
 import { withBlockingRequest } from "../state/blocking-requests.ts";
 import { pingApproval } from "../pi/notify.ts";
 import { describeRun, runLogEntry } from "../pi/run-summary.ts";
-import { planChecklist, planSteps, runSteps, skippedStepsNote } from "../pi/plan-checklist.ts";
-import { STEP_LIMIT_MS, grantStepTime, reserveStepTime, stepTimeLeft } from "../state/step-limits.ts";
+import { skippedStepsNote } from "../pi/plan-checklist.ts";
 import { noteWorkerRun } from "../state/work-time.ts";
 import { nextStates } from "./transitions.ts";
 import type { FileHinter } from "../classifier/files.ts";
@@ -67,7 +68,7 @@ import type { EffortRouter } from "../classifier/effort.ts";
 import { answerClarify } from "../classifier/triage.ts";
 import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { markCommentsAddressed, pendingComments, readPlanComments } from "../state/comments.ts";
-import { builtSomething, fastNext, onFastTrack, parseRoster, PLANNED_NEXT, qaRequired, qaStillDue, qaTookPart, readRequest, rosterWords, satOut, trackSummary } from "./track.ts";
+import { builtSomething, fastNext, onFastTrack, parseRoster, PLANNED_NEXT, qaRequired, qaTookPart, readRequest, rosterWords, satOut, trackSummary } from "./track.ts";
 import { requestBesidePlan } from "../state/backlog.ts";
 import { missingWorktree, taskCwd } from "../execution/workspace.ts";
 import { completionReview, deferReview, refreshReview } from "../delivery/review.ts";
@@ -96,7 +97,6 @@ export const ORCHESTRATE_ACTIONS = [
   "block",
   "resume",
   "decide",
-  "budget",
   "track",
   "status",
   "cancel",
@@ -122,9 +122,7 @@ export interface OrchestrateParams {
   /** implement: the concrete instruction for the worker. */
   task?: string;
   /** implement: several domains at once, run in parallel through the file desk. */
-  assignments?: Array<{ domain: string; task: string; minutes?: number }>;
-  /** implement: minutes the step may take under the task's time budget; budget: extra minutes to ask the user for. */
-  minutes?: number;
+  assignments?: Array<{ domain: string; task: string }>;
   /** knowledge: which persistent file the text belongs to. */
   kind?: KnowledgeKind;
   /** compact: the knowledge file being rewritten; script: a drafted script to take instead of `text`. */
@@ -157,6 +155,8 @@ export interface WorkflowDeps {
   config: BotLobbyConfig;
   /** Per-run model/thinking/time limit, clamped to each model; plain settings when absent. */
   profile?: ProfileResolver;
+  /** The model and thinking ask_expert consults on, resolved like the profiles; the settings' own when absent. */
+  expert?: { model?: string; thinking: string };
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
   ask: (question: string) => Promise<string | undefined>;
@@ -361,13 +361,11 @@ async function handleScout(task: Task, params: OrchestrateParams, deps: Workflow
   if (task.state === "clarifying") transition(task, "scouting");
   const verifying = task.state === "synthesizing";
   const instruction = params.instruction?.trim() || "Investigate this request and report findings the Master needs.";
-  const time = readerTime(task, deps, "SCOUTS", instruction, SCOUT_SHARE, deps.config.scout.timeoutMs, "scouting");
   const outcomes = await runScouts(
     {
       taskId: task.id,
       taskText: taskRequest(task),
       instruction,
-      ...(time ? { time } : {}),
       domains,
       cwd: deps.cwd,
       dataRoots: readDataRoots(deps.root, deps.configDir),
@@ -382,7 +380,6 @@ async function handleScout(task: Task, params: OrchestrateParams, deps: Workflow
     },
     deps.runProcess ?? spawnPiProcess,
   );
-  if (time) settleAllotment(task, deps, time.id, "finished");
   if (!verifying) transition(task, "synthesizing");
   const involved = outcomes.filter((outcome) => outcome.usable).map((outcome) => outcome.result.domain);
   task.domains = [...new Set([...task.domains, ...involved])];
@@ -466,13 +463,11 @@ function researchRequestFor(
   domain: Domain,
   instruction: string,
   taskDir: string,
-  time?: AgentTime,
 ): ResearchRequest {
   return {
     taskId: task.id,
     domain,
     instruction,
-    ...(time ? { time } : {}),
     config: deps.config,
     profile: deps.profile,
     cwd: deps.cwd,
@@ -490,9 +485,7 @@ async function handleResearch(task: Task, params: OrchestrateParams, deps: Workf
   const instruction = params.instruction?.trim();
   if (!instruction) throw new Error("research requires instruction (the question to investigate)");
   const taskDir = taskDirFor(deps.root, deps.configDir, task.id);
-  const time = readerTime(task, deps, "RESEARCH", instruction, RESEARCH_SHARE, deps.config.researcher.timeoutMs ?? deps.config.workflow.agentTimeoutMs, "research");
-  const outcome = await runResearch(researchRequestFor(deps, task, domain, instruction, taskDir, time), deps.runProcess ?? spawnPiProcess);
-  if (time) settleAllotment(task, deps, time.id, "finished");
+  const outcome = await runResearch(researchRequestFor(deps, task, domain, instruction, taskDir), deps.runProcess ?? spawnPiProcess);
   appendResearchLog(taskDir, domain, outcome);
   recordAdvisoryPushbacks(task, [{ pushback: outcome.result.pushback, who: domain }]);
   return researchReport(outcome, researchResultPath(taskDir, domain));
@@ -624,11 +617,12 @@ function recordAdvisoryPushbacks(task: Task, entries: Array<{ pushback?: Pushbac
 
 const FULL_NEXT = "Next: inspect the diff, then run action=qa once this domain's work is complete.";
 
-function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?: Approval, next = FULL_NEXT): string {
+function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?: Approval, next = FULL_NEXT, fullReport = ""): string {
   const { result, run, issues } = outcome;
   const objection = result.pushback;
   return [
     `Worker ${result.domain}: ${run.status}${run.error ? ` (${run.error})` : ""}`,
+    fullReport ? `Full report: ${fullReport} (read it for detail the lines below shorten)` : "",
     result.completed ? `Completed: ${truncate(result.completed, 1200)}` : "",
     result.filesChanged.length > 0
       ? `Files changed:\n${result.filesChanged.map((file) => `- ${file.path} — ${file.change}`).join("\n")}`
@@ -706,10 +700,22 @@ function workerTaskText(task: Task, planBudget = 6000): string {
     .join("\n\n");
 }
 
-function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instruction: string, time?: AgentTime): WorkerRequest {
+/** The task's board: one file in its directory that every agent of the task posts to and reads. */
+function taskBoard(deps: WorkflowDeps, task: Task): string {
+  return boardPath(taskDirFor(deps.root, deps.configDir, task.id));
+}
+
+/** What the agents posted to the board during this action, for the oracle. */
+function boardNews(deps: WorkflowDeps, task: Task, after: number): string {
+  const posts = filterPosts(readBoard(taskBoard(deps, task)), { after, limit: 40 });
+  return posts.length > 0 ? `Task board, new posts:\n${formatPosts(posts)}` : "";
+}
+
+function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instruction: string, alongside?: readonly Domain[]): WorkerRequest {
   const ask = askRelay(task, deps, domain);
   return {
-    ...(time ? { time } : {}),
+    board: taskBoard(deps, task),
+    ...(alongside && alongside.length > 1 ? { alongside } : {}),
     ...(ask ? { ask } : {}),
     // QA writing tests works to the same budget as the gate: the risk of what is built so far.
     ...(domain === "qa" && task.qaRisk ? { risk: qaRiskBrief(task.qaRisk) } : {}),
@@ -722,6 +728,7 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
     dataRoots: readDataRoots(deps.root, deps.configDir),
     config: deps.config,
     profile: deps.profile,
+    ...(deps.expert ? { expert: deps.expert } : {}),
     signal: deps.signal,
     onUpdate: deps.onUpdate,
     ...(deps.hints ? { hints: deps.hints } : {}),
@@ -799,8 +806,6 @@ function recordWorkerRun(task: Task, run: AgentRun): void {
 interface Assignment {
   domain: Domain;
   instruction: string;
-  /** Minutes the oracle gave the step, under a time budget. */
-  minutes?: number;
 }
 
 /** The delegation as a list: `assignments` for a parallel batch, otherwise the single domain/task. */
@@ -809,7 +814,7 @@ function parseAssignments(params: OrchestrateParams): Assignment[] {
     const list = params.assignments.map((entry) => {
       const instruction = entry.task?.trim();
       if (!instruction) throw new Error("every assignment needs a task (what to implement)");
-      return { domain: parseDomain(entry.domain, "implement"), instruction, ...(entry.minutes ? { minutes: entry.minutes } : {}) };
+      return { domain: parseDomain(entry.domain, "implement"), instruction };
     });
     const domains = list.map((entry) => entry.domain);
     if (new Set(domains).size !== domains.length) throw new Error("parallel assignments need distinct domains (one worker per domain)");
@@ -818,7 +823,7 @@ function parseAssignments(params: OrchestrateParams): Assignment[] {
   const domain = parseDomain(params.domain, "implement");
   const instruction = params.task?.trim();
   if (!instruction) throw new Error("implement requires task (what to implement)");
-  return [{ domain, instruction, ...(params.minutes ? { minutes: params.minutes } : {}) }];
+  return [{ domain, instruction }];
 }
 
 /**
@@ -918,10 +923,9 @@ function provenanceNote(files: readonly FileProvenance[] | undefined): string {
 }
 
 /** Record one worker's outcome on the task and return its report for the Master. */
-function absorbWorkerOutcome(task: Task, deps: WorkflowDeps, outcome: WorkerOutcome, time?: WorkerTime): string {
+function absorbWorkerOutcome(task: Task, deps: WorkflowDeps, outcome: WorkerOutcome): string {
   const domain = outcome.result.domain;
   recordWorkerRun(task, outcome.run);
-  if (time) settleAllotment(task, deps, time.id, stoppedForTime(outcome) ? "out of time" : outcome.run.status === "success" ? "finished" : "stopped");
   appendChange(deps.root, deps.configDir, {
     source: "worker",
     id: outcome.run.runId,
@@ -938,8 +942,30 @@ function absorbWorkerOutcome(task: Task, deps: WorkflowDeps, outcome: WorkerOutc
   task.blockers = [...task.blockers.filter((blocker) => blocker.domain !== domain), ...outcome.result.blockers];
   updateScratchpad(deps, task, outcome);
   const grown = qaJoinsGrownFastTask(task, outcome);
-  const report = workerReport(outcome, approvals, pushback, onFastTrack(task) ? fastNext(task) : qaRequired(task) ? FULL_NEXT : PLANNED_NEXT);
-  return [report, grown, timeReport(outcome)].filter(Boolean).join("\n");
+  const full = saveFullReport(deps, task, outcome);
+  const report = workerReport(outcome, approvals, pushback, onFastTrack(task) ? fastNext(task) : qaRequired(task) ? FULL_NEXT : PLANNED_NEXT, full);
+  return [report, grown].filter(Boolean).join("\n");
+}
+
+/** Reports longer than this are kept whole in a file and the oracle gets the path. */
+const LONG_REPORT = 2400;
+
+/**
+ * Keep a long worker report whole in the task's `reports/` folder, so the
+ * oracle reads what it needs from the file instead of getting a shortened
+ * copy relayed through its own context. Returns the path, or "".
+ */
+function saveFullReport(deps: WorkflowDeps, task: Task, outcome: WorkerOutcome): string {
+  const output = outcome.run.output?.trim() ?? "";
+  if (output.length <= LONG_REPORT) return "";
+  const stamp = (outcome.run.finishedAt ?? new Date().toISOString()).replace(/[:.]/g, "-");
+  const path = join(taskDirFor(deps.root, deps.configDir, task.id), "reports", `${outcome.result.domain}-${stamp}.md`);
+  try {
+    writeFileEnsured(path, `${output}\n`);
+    return path;
+  } catch {
+    return "";
+  }
 }
 
 /**
@@ -1005,7 +1031,6 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   if (short.length > 0) throw new Error(short.join("\n"));
   for (const { domain } of assignments) assertNoPendingApprovals(task, domain);
   for (const { domain } of assignments) if (!task.domains.includes(domain)) task.domains.push(domain);
-  // Under a time budget every step is given its share before any starts; a spent budget starts none.
   if (task.track && onFastTrack(task)) task.track.roster = parseRoster([...task.track.roster, ...assignments.map((entry) => entry.domain)]);
   if (starting) startFast(task);
   if (task.track?.autoPlan) addFastSteps(task, deps, assignments);
@@ -1013,24 +1038,16 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   await takeBaseline(task, deps);
   // A QA step after work is in verifies it at its risk: read the change first.
   if (assignments.some((entry) => entry.domain === "qa") && builtSomething(task)) await assessBuilt(task, deps);
-  const times = await workerTimes(task, deps, assignments);
+  const boardBefore = readBoard(taskBoard(deps, task)).at(-1)?.seq ?? 0;
   let report: string;
-  try {
-    if (assignments.length === 1) {
-      const { domain, instruction } = assignments[0]!;
-      const outcome = await runWorker(workerRequest(deps, task, domain, instruction, times.get(domain)), deps.runProcess ?? spawnPiProcess);
-      report = absorbWorkerOutcome(task, deps, outcome, times.get(domain));
-    } else report = await runParallelWorkers(task, deps, assignments, times);
-  } finally {
-    // A step that never reported (the call failed) does not stay "running" in the budget.
-    for (const time of times.values()) {
-      settleAllotment(task, deps, time.id, "stopped");
-      time.finish?.();
-    }
-  }
+  if (assignments.length === 1) {
+    const { domain, instruction } = assignments[0]!;
+    const outcome = await runWorker(workerRequest(deps, task, domain, instruction), deps.runProcess ?? spawnPiProcess);
+    report = absorbWorkerOutcome(task, deps, outcome);
+  } else report = await runParallelWorkers(task, deps, assignments);
   const tree = await changeState(deps, task, task.baseline?.head);
   const lint = lintNote(await lintTask(task, deps, tree), deps.config.lint.mode, ownersOf(tree?.files));
-  return [report, provenanceNote(tree?.files), lint].filter(Boolean).join("\n\n");
+  return [report, boardNews(deps, task, boardBefore), provenanceNote(tree?.files), lint].filter(Boolean).join("\n\n");
 }
 
 /**
@@ -1130,34 +1147,62 @@ function stepLine(instruction: string): string {
  * Several domains at once. The workers share one file desk: each claims a file
  * before editing it, queues for a busy one, and hands it over with a note; a
  * worker that finishes hands over whatever it still holds automatically.
+ * In `worktrees` mode each worker has a checkout of its own instead (no
+ * claims, no queues), and their changes are applied back when the batch ends.
+ * Either way the desk carries the board and the workers' questions to each other.
  */
-async function runParallelWorkers(task: Task, deps: WorkflowDeps, assignments: Assignment[], times: ReadonlyMap<Domain, WorkerTime>): Promise<string> {
-  const session = new DeskSession({ cwd: deps.cwd });
+async function runParallelWorkers(task: Task, deps: WorkflowDeps, assignments: Assignment[]): Promise<string> {
+  const batch = assignments.map((entry) => entry.domain);
+  const opened = deps.config.workflow.parallelMode === "worktrees" ? await openWorkerTrees(deps.cwd, batch) : undefined;
+  const trees = opened && typeof opened !== "string" ? opened : undefined;
+  const session = new DeskSession({ cwd: deps.cwd, boardPath: taskBoard(deps, task), peers: true, ...(trees ? { claims: false } : {}) });
   await session.open();
   let outcomes: WorkerOutcome[];
   let unenforced: Domain[];
+  let merged = "";
   try {
-    outcomes = await mapConcurrent(assignments, deps.config.workflow.maxParallelWorkers, ({ domain, instruction }) => {
-      const request = workerRequest(deps, task, domain, instruction, times.get(domain));
-      request.agent = {
-        env: session.env(domain),
-        extraTools: DESK_TOOLS,
-        onStart: (handle) => session.attach(domain, handle),
-        onAttemptEnd: (run) => {
-          const result = parseWorkerResult(domain, run.output);
-          session.release(domain, (path, next) => autoNote(domain, path, next, result.filesChanged, result.completed));
-        },
-      };
-      return runWorker(request, deps.runProcess ?? spawnPiProcess);
-    });
-    unenforced = assignments.map((entry) => entry.domain).filter((domain) => !session.greetedBy(domain));
+    try {
+      outcomes = await mapConcurrent(assignments, deps.config.workflow.maxParallelWorkers, ({ domain, instruction }) => {
+        const request = workerRequest(deps, task, domain, instruction, batch);
+        const tree = trees?.trees.get(domain);
+        if (tree) {
+          request.cwd = tree.cwd;
+          request.ownCheckout = true;
+        }
+        request.agent = {
+          env: session.env(domain),
+          extraTools: session.tools(),
+          onStart: (handle) => session.attach(domain, handle),
+          onAttemptEnd: (run) => {
+            const result = parseWorkerResult(domain, run.output);
+            session.release(domain, (path, next) => autoNote(domain, path, next, result.filesChanged, result.completed));
+          },
+        };
+        return runWorker(request, deps.runProcess ?? spawnPiProcess);
+      });
+      unenforced = trees ? [] : assignments.map((entry) => entry.domain).filter((domain) => !session.greetedBy(domain));
+    } finally {
+      await session.close();
+    }
+    if (trees) {
+      const results = await mergeWorkerTrees(trees, batch, join(taskDirFor(deps.root, deps.configDir, task.id), "patches")).catch((error: unknown) => {
+        // Keep every worktree: nothing is lost while the oracle sorts it out.
+        for (const tree of trees.trees.values()) tree.keep = true;
+        return batch.map((worker): MergeOutcome => ({ worker, status: "conflict", patch: "", saved: trees.trees.get(worker)?.dir ?? "", reason: `merging back failed (${(error as Error).message}); the worktree is kept as it was` }));
+      });
+      // The edits were made in the worktrees: the task's record names the same files in its own tree.
+      outcomes = outcomes.map((outcome) => (outcome.run.edited?.length ? { ...outcome, run: { ...outcome.run, edited: outcome.run.edited.map((path) => mapToTop(trees, outcome.result.domain, path)) } } : outcome));
+      merged = mergeReport(results);
+    }
   } finally {
-    await session.close();
+    if (trees) await closeWorkerTrees(trees);
   }
-  const reports = outcomes.map((outcome) => absorbWorkerOutcome(task, deps, outcome, times.get(outcome.result.domain)));
+  const reports = outcomes.map((outcome) => absorbWorkerOutcome(task, deps, outcome));
   return [
-    `Parallel batch: ${assignments.map((entry) => entry.domain).join(", ")}.`,
+    `Parallel batch: ${batch.join(", ")}${trees ? " (a worktree each)" : ""}.`,
+    typeof opened === "string" ? `Worktrees were not used (${opened}); the workers shared the file desk.` : "",
     ...reports,
+    merged,
     handoverLog(session.handovers()),
     unenforced.length > 0
       ? `File checkout was not enforced for ${unenforced.join(", ")} (bot-lobby did not load in those workers); inspect the diff for overlapping edits.`
@@ -1167,6 +1212,24 @@ async function runParallelWorkers(task: Task, deps: WorkflowDeps, assignments: A
     .join("\n\n");
 }
 
+/** What came of applying each worker's worktree back to the task's tree. */
+function mergeReport(results: readonly MergeOutcome[]): string {
+  const label = (worker: string): string => AGENT_LABELS[worker as Domain] ?? worker;
+  const applied = results.filter((entry) => entry.status === "applied").map((entry) => label(entry.worker));
+  const kept = results.filter((entry): entry is Extract<MergeOutcome, { status: "conflict" | "partial" }> => entry.status === "conflict" || entry.status === "partial");
+  return [
+    applied.length > 0 ? `Worktrees merged back: ${applied.join(", ")}.` : "",
+    ...kept.map((entry) => {
+      const where = [entry.patch ? `patch ${entry.patch}` : "", entry.saved.startsWith("refs/") ? `git ref ${entry.saved}` : entry.saved ? `worktree ${entry.saved}` : ""].filter(Boolean).join(", ");
+      const state =
+        entry.status === "partial"
+          ? `, and applying it failed part way: these files are left changed and need checking: ${(entry.leftChanged ?? []).slice(0, 10).join(", ")}`
+          : ", so none of it is in the tree";
+      return `${label(entry.worker)}'s change did not apply (${truncate(entry.reason, 300)})${state}.${where ? ` It is saved (${where}): delegate a fix step to ${label(entry.worker)} to bring it onto the current files (\`git apply --3way\` on the patch, or \`git diff <ref>^ <ref>\`), reconciling it with the others' changes.` : ""}`;
+    }),
+  ].filter(Boolean).join("\n");
+}
+
 function handoverLog(handovers: readonly Handover[]): string {
   if (handovers.length === 0) return "";
   const lines = handovers.map((entry) => `- ${entry.path}: ${entry.from} → ${entry.to}${entry.auto ? " (on finish)" : ""} — ${truncate(entry.note, 200)}`);
@@ -1254,11 +1317,14 @@ function qaRequest(deps: WorkflowDeps, task: Task, diff: string, risk: QaRiskAss
     taskId: task.id,
     domain: "qa",
     taskText: workerTaskText(task, 9000),
-    workerSummary: allScratchpads(deps, task),
+    // A clean review sees what was built, not how the builders describe it.
+    workerSummary: deps.config.workflow.cleanReview ? "" : allScratchpads(deps, task),
+    ...(deps.config.workflow.cleanReview ? { clean: true } : {}),
     ...(rounds ? { previousRound: rounds } : {}),
-    scoutOutcomes: loadScoutResults(taskReadDirs(deps.root, deps.configDir, task.id), [...new Set<Domain>(["qa", ...task.domains])]),
+    scoutOutcomes: deps.config.workflow.cleanReview ? [] : loadScoutResults(taskReadDirs(deps.root, deps.configDir, task.id), [...new Set<Domain>(["qa", ...task.domains])]),
     diff,
     risk: qaRiskBrief(risk),
+    board: boardContext(taskBoard(deps, task), "qa"),
     ...(provenance && provenance.length > 0 ? { provenance: provenanceLines(provenance) } : {}),
     ...(lint ? { lint: lintContext(lint, deps.config.lint.mode) } : {}),
     instruction: instruction?.trim() || qaInstruction(risk),
@@ -1371,19 +1437,19 @@ async function handleQa(task: Task, params: OrchestrateParams, deps: WorkflowDep
   ]);
   const provenance = tree?.files;
   // The gate's base is the task's own; a legacy task measured from an older commit lints from a fresh look.
-  const lint = await lintTask(task, deps, base === task.baseline?.head ? tree : undefined);
+  // Before any QA agent runs, Jev reads what was built: the gate's depth and test budget follow its risk. Neither waits for the other.
+  const [lint, risk] = await Promise.all([
+    lintTask(task, deps, base === task.baseline?.head ? tree : undefined),
+    assessTask(task, deps, diff, tree, base),
+  ]);
   const lintLine = lintBrief(lint, deps.config.lint.mode, Boolean(task.lintWaiver));
-  // Before any QA agent runs, Jev reads what was built: the gate's depth and test budget follow its risk.
-  const risk = await assessTask(task, deps, diff, tree, base);
   if (!risk.qaRequired) {
     const result = checksVerdict(lint, deps, Boolean(task.lintWaiver));
     const decision = await settleQaRound(task, result, iterations, deps, true);
     const header = `QA gate: ${result.verdict.toUpperCase()} on the engine's checks; no QA agent ran. ${qaRiskLine(risk)}.\nWhy: ${risk.reasoning}\nChecks:\n${result.verification}`;
     return qaReport(header, result, decision, provenance, lintLine);
   }
-  const time = qaTime(task, deps);
-  const outcome = await runReviewer({ ...qaRequest(deps, task, diff, risk, params.task, provenance, lint), effort: deps.effort, ...(time ? { time } : {}) }, deps.runProcess ?? spawnPiProcess);
-  if (time) settleAllotment(task, deps, time.id, "finished");
+  const outcome = await runReviewer({ ...qaRequest(deps, task, diff, risk, params.task, provenance, lint), effort: deps.effort }, deps.runProcess ?? spawnPiProcess);
   const { result, run } = outcome;
   recordAdvisoryPushbacks(task, [{ pushback: result.pushback, who: "qa" }]);
   if (result.relaxed) recordDecision(task, `QA round ${iterations} passed: ${result.relaxed}.`, "qa");
@@ -1558,6 +1624,12 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   // New lint errors in what the task touched hold it in block mode, unless the user accepted the work as it is.
   const lint = await lintTask(task, deps);
   if (lint && lintHolds(lint, deps.config.lint.mode, Boolean(task.lintWaiver))) throw new Error(`cannot complete: ${lintRefusal(lint)}`);
+  const goal = await checkGoal(task, params, deps);
+  if (goal.refusal) {
+    // The refusal is recorded, so a reason on the next complete is an answer to it.
+    saveTask(deps.root, deps.configDir, task);
+    throw new Error(goal.refusal);
+  }
   // The gate refuses before any side effect, so a refusal leaves the task untouched.
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
@@ -1575,7 +1647,61 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   flushDecisions(deps, task);
   const delivery = await offerDelivery(task, deps);
   const left = lint?.state === "failing" ? ` ${task.lintWaiver ? "Accepted by the user with lint errors" : "Lint (advisory)"}: ${lintSummary(lint)} Tell the user.` : "";
-  return `Task ${task.id} completed.${committed} History recorded and temporary scratchpads removed. ${delivery}${left}`;
+  return `Task ${task.id} completed.${committed} History recorded and temporary scratchpads removed. ${delivery}${left}${goal.note ?? ""}`;
+}
+
+/**
+ * The goal check before completion: one read-only agent compares the change
+ * with the user's own request (not the plan). Gaps refuse completion once;
+ * the oracle fixes them, or completes again with a `reason` when they are
+ * deliberate (the user agreed). The same change is never checked twice, and
+ * an unreadable check holds nothing.
+ */
+/** Enough of the change to tell one from another; the check itself reads a shorter cut. */
+const GOAL_HASH_CHARS = 4_000_000;
+
+async function checkGoal(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<{ refusal?: string; note?: string }> {
+  if (!deps.config.workflow.goalCheck || !builtSomething(task) || task.qaWaiver) return {};
+  const base = await reviewBase(task, deps);
+  // The whole change is hashed, so an edit past what the check reads still counts as a new change.
+  const diff = await readRepositoryDiff(deps.cwd, { ...(base ? { base } : {}), exclude: ownRecords(deps), limitChars: GOAL_HASH_CHARS });
+  if (!diff.trim() || /^Unable to read git state/.test(diff)) return {};
+  const key = createHash("sha256").update(diff).digest("hex").slice(0, 16);
+  if (task.goalCheck?.key !== key) {
+    let result: Awaited<ReturnType<typeof runGoalCheck>> | undefined;
+    // One more read when the first could not be read: a lost verdict should not let a gap through unseen.
+    for (let attempt = 0; attempt < 2 && result?.verdict !== "met" && result?.verdict !== "not_met"; attempt++) {
+      deps.signal?.throwIfAborted();
+      result = await runGoalCheck({
+        taskId: task.id,
+        request: taskRequest(task),
+        amendments: task.amendments,
+        diff,
+        cwd: deps.cwd,
+        config: deps.config,
+        ...(deps.profile ? { profile: deps.profile } : {}),
+        ...(deps.signal ? { signal: deps.signal } : {}),
+        ...(deps.onUpdate ? { onUpdate: deps.onUpdate } : {}),
+      }, deps.runProcess ?? spawnPiProcess);
+    }
+    deps.signal?.throwIfAborted();
+    if (!result || result.verdict === "unread") {
+      // Not recorded, so the next complete checks again.
+      const why = result?.run.error ? `: ${truncate(result.run.error, 160)}` : "";
+      return { note: ` The goal check could not be read (twice${why}), so the change was not checked against the request; tell the user.` };
+    }
+    task.goalCheck = { key, verdict: result.verdict, gaps: result.gaps, at: new Date().toISOString() };
+  }
+  const check = task.goalCheck!;
+  if (check.verdict !== "not_met") return {};
+  const gaps = check.gaps.slice(0, 12).map((gap) => `- ${truncate(gap, 300)}`).join("\n");
+  // A reason answers a refusal the oracle has seen; given up front, it is not an answer to anything yet.
+  if (params.reason?.trim() && check.refusedAt) {
+    recordDecision(task, `Completed although the goal check named gaps (${check.gaps.map((gap) => truncate(gap, 120)).join("; ")}): ${params.reason.trim()}`);
+    return { note: ` Completed with the goal check's gaps left open, because: ${truncate(params.reason.trim(), 300)}. Tell the user which parts of their request are not done:\n${gaps}` };
+  }
+  check.refusedAt = new Date().toISOString();
+  return { refusal: `cannot complete: the goal check read the change against the user's request and found it does not meet all of it:\n${gaps}\nDelegate a fix step for each gap and complete again (the next check reads the new change). If a gap is deliberate (the user agreed to leave it out, or it is out of scope), call complete again with reason saying so; tell the user.` };
 }
 
 /** The files a task's own workers changed: not one that held changes before they started, nor another task's. */
@@ -1769,150 +1895,13 @@ function handleCancel(task: Task): string {
   return `Task ${task.id} abandoned. Its scratchpad is kept until the task is formally resolved.`;
 }
 
-/* ------------------------------------------------------------ time budget */
-
-/** Shares of what is left that a scout batch and the researcher are given (within their configured limits). */
-const SCOUT_SHARE = 0.1;
-const RESEARCH_SHARE = 0.15;
-/** Minutes a worker out of time is taken to ask for when its report names none. */
-const DEFAULT_MORE_MINUTES = 10;
-
-/** A delegation's time, with the allotment it is recorded under. */
-type WorkerTime = AgentTime & { id: string; finish?: () => void };
-
-/** The task's budget and where it stands, when it has one. */
-function budgetFor(task: Task, deps: WorkflowDeps): { budget: TaskBudget; state: BudgetState } | undefined {
-  const budget = readBudget(deps.root, deps.configDir, task.id);
-  return budget ? { budget, state: budgetState(task.id, budget, !qaStillDue(task)) } : undefined;
-}
-
-/** No new work starts once the budget is spent: the oracle asks the user for more, or wraps up. */
-function budgetSpent(state: BudgetState, what: string): Error {
-  const reserve = state.reserveMs > 0 ? `, ${formatMinutes(state.reserveMs)} of it kept for the QA gate` : "";
-  const wrap = state.reserveMs >= MIN_READ_MS ? "run action=qa on what is done" : "complete or block with what is done";
-  return new Error(`the task's time budget has no room for ${what}: ${formatMinutes(state.usedMs)} of ${formatMinutes(state.totalMs)} used, ${formatMinutes(state.leftMs)} left${reserve}. Ask the user for more time with action=budget (minutes and reason), or wrap up: ${wrap}.`);
-}
-
-/** What an agent is told about its time. */
-function timeNote(allotMs: number, state: BudgetState, worker: boolean): string {
-  return [
-    "## Time",
-    `You have ${formatMinutes(allotMs)} for this ${worker ? "step" : "work"}; the task has ${formatMinutes(state.leftMs)} of its ${formatMinutes(state.totalMs)} left.`,
-    worker
-      ? "This is the total allowance shared across startup, retries, children, tools and reporting. At about 75% you get a heads-up. Before the hard deadline, stop and report where you left off (`## Left Off`) and how much more you need (`## More Time`); only the user can grant it. Land the most important part first, and keep every file consistent as you go."
-      : "When the time is up you are asked to stop and report what you have, so cover the most important questions first.",
-  ].join("\n");
-}
-
-function recordAllotment(task: Task, deps: WorkflowDeps, entry: Omit<Allotment, "startedAt" | "granted">): void {
-  updateBudget(deps.root, deps.configDir, task.id, (budget) => {
-    budget.allotments.push({ ...entry, granted: 0, startedAt: new Date().toISOString() });
-  });
-}
-
-function settleAllotment(task: Task, deps: WorkflowDeps, id: string, outcome: NonNullable<Allotment["outcome"]>): void {
-  updateBudget(deps.root, deps.configDir, task.id, (budget) => {
-    const entry = budget.allotments.find((allotment) => allotment.id === id);
-    if (entry && !entry.endedAt) Object.assign(entry, { endedAt: new Date().toISOString(), outcome });
-  });
-}
-
 function oneLine(text: string, max: number): string {
   return truncate(text.replace(/\s+/g, " ").trim(), max).replace(/\n\[\.\.\.\d+ characters omitted\]$/, "…");
 }
 
-/** A read-only batch's time (scouts, the researcher): a share of what is left, within its configured limit. */
-function readerTime(task: Task, deps: WorkflowDeps, who: string, what: string, share: number, limitMs: number, label: string): WorkerTime | undefined {
-  const now = budgetFor(task, deps);
-  if (!now) return undefined;
-  const ms = readerAllotment(now.state, share, Math.min(STEP_LIMIT_MS, limitMs));
-  if (ms === undefined) throw budgetSpent(now.state, label);
-  const id = `${who.toLowerCase()}-${Date.now().toString(36)}`;
-  recordAllotment(task, deps, { id, who, what: oneLine(what, 120), minutes: Math.round(ms / 60_000) });
-  return { id, endsAt: Date.now() + ms, allotMs: ms, note: timeNote(ms, now.state, false) };
-}
-
-/** The QA gate's time: its reserve at least, never more than is left. */
-function qaTime(task: Task, deps: WorkflowDeps): WorkerTime | undefined {
-  const now = budgetFor(task, deps);
-  if (!now) return undefined;
-  const ms = qaAllotment(now.state, Math.min(STEP_LIMIT_MS, deps.config.agents.qa.timeoutMs ?? deps.config.workflow.agentTimeoutMs));
-  if (ms === undefined) throw budgetSpent(now.state, "the QA gate");
-  const id = `qa-${Date.now().toString(36)}`;
-  recordAllotment(task, deps, { id, who: "QA gate", what: "review the task's work", minutes: Math.round(ms / 60_000) });
-  return { id, endsAt: Date.now() + ms, allotMs: ms, note: timeNote(ms, now.state, false) };
-}
-
-/** Plan domains still to build, the batch counted once: what is left before the QA reserve is split across them by default. */
-function openSlots(task: Task, batch: readonly Domain[]): number {
-  const built = new Set((task.workerRuns ?? []).filter((run) => run.status === "success").map((run) => run.domain));
-  return task.domains.filter((domain) => !built.has(domain) && !batch.includes(domain)).length + 1;
-}
-
-/**
- * Each step's time, given before any starts: the minutes the oracle asked
- * for (it divides by scope) or an even share, never past what is left before
- * the QA gate's reserve. A spent budget starts nothing.
- */
-async function workerTimes(task: Task, deps: WorkflowDeps, assignments: readonly Assignment[]): Promise<Map<Domain, WorkerTime>> {
-  const times = new Map<Domain, WorkerTime>();
-  const now = budgetFor(task, deps);
-  const slots = openSlots(task, assignments.map((entry) => entry.domain));
-  const steps = planSteps(task.plan ?? "");
-  const completed = new Set(planChecklist(task.plan ?? "", (task.workerRuns ?? []).map((record) => ({ ...record, taskId: task.id, role: "worker" as const, output: "", attempts: 1 })), task.skippedSteps).flatMap((step, index) => step.status === "done" || step.status === "skipped" ? [index] : []));
-  const prepared = [];
-  for (const { domain, instruction, minutes } of assignments) {
-    const covered = runSteps(steps, instruction, completed);
-    const keys = covered.length ? covered.map((index) => `${domain}:step-${index + 1}`) : [`${domain}:unplanned`];
-    const limitMs = Math.min(STEP_LIMIT_MS, profileFor(deps.config, deps.profile, domain, "worker").timeoutMs);
-    let left = stepTimeLeft(deps.root, deps.configDir, task.id, keys, limitMs);
-    if (left <= 0) {
-      const wanted = DEFAULT_MORE_MINUTES;
-      const granted = await decideMoreTime(task, deps, {
-        label: AGENT_LABELS[domain], instruction, wanted,
-        result: parseWorkerResult(domain, scratchpadSummary(deps, task, domain)),
-        run: { runId: "", taskId: task.id, domain, role: "worker", status: "timeout", output: "", attempts: 1, startedAt: new Date().toISOString(), allotMs: limitMs },
-        state: now?.state,
-      });
-      if (granted <= 0) throw new Error(`${AGENT_LABELS[domain]}'s step allowance is exhausted. Return the unfinished report; continuing requires user-approved time.`);
-      grantStepTime(deps.root, deps.configDir, task.id, keys, limitMs, granted * 60_000);
-      recordDecision(task, `The user gave ${AGENT_LABELS[domain]}'s exhausted step ${granted} more minutes.`);
-      left = stepTimeLeft(deps.root, deps.configDir, task.id, keys, limitMs);
-    }
-    const given = now ? workerAllotment(now.state, minutes, slots) : { ms: left };
-    if (!given) throw budgetSpent(now!.state, `the ${domain} step`);
-    const ms = Math.min(left, given.ms);
-    prepared.push({ domain, instruction, keys, limitMs, ms });
-  }
-  try {
-    for (const { domain, instruction, keys, limitMs, ms } of prepared) {
-      const reservation = reserveStepTime(deps.root, deps.configDir, task.id, keys, limitMs, ms);
-      const id = `${domain}-${Date.now().toString(36)}`;
-      let exhausted = false;
-      const askMore = moreTimeFor(task, deps, domain, instruction, id, (extraMs) => reservation.grant(extraMs));
-      recordAllotment(task, deps, { id, who: AGENT_LABELS[domain], what: oneLine(instruction, 120), minutes: Math.round(ms / 60_000) });
-      const time: WorkerTime = { id, endsAt: Date.now() + ms, allotMs: ms, strict: true,
-        note: now ? timeNote(ms, now.state, true) : `## Time\nYou have ${formatMinutes(ms)} total for this step, shared across retries and children. Report unfinished work before the deadline; only the user can grant more time.`,
-        onTimeUp: async (run, report) => {
-          const extraMs = await askMore(run, report);
-          const result = parseWorkerResult(domain, report);
-          if (extraMs <= 0 && (result.leftOff || result.moreTime)) exhausted = true;
-          return extraMs;
-        },
-      };
-      time.finish = () => reservation.finish(time.usedMs ?? ms, exhausted);
-      times.set(domain, time);
-    }
-  } catch (error) {
-    for (const time of times.values()) { time.usedMs = 0; time.finish?.(); }
-    throw error;
-  }
-  return times;
-}
-
 const AGENT_LABELS: Record<Domain, string> = { backend: "DEV", designer: "DESIGN", qa: "QA" };
 
-/** Out-of-time questions one at a time, even when parallel workers run out together. */
+/** Questions to the user one at a time, even when parallel workers ask together. */
 let asking: Promise<unknown> = Promise.resolve();
 function oneAtATime<T>(ask: () => Promise<T>): Promise<T> {
   const next = asking.then(ask, ask);
@@ -1920,134 +1909,6 @@ function oneAtATime<T>(ask: () => Promise<T>): Promise<T> {
   return next;
 }
 
-/**
- * A worker out of time has reported what it did, where it left off and how
- * much more it needs. Only the user grants more time; a grant past the task budget grows it,
- * and the same agent carries on. Resolves with the ms granted, 0 to stop it.
- */
-function moreTimeFor(task: Task, deps: WorkflowDeps, domain: Domain, instruction: string, id: string, onGrant?: (ms: number) => void): NonNullable<AgentTime["onTimeUp"]> {
-  return (run, report) => oneAtATime(async () => {
-    const result = parseWorkerResult(domain, report);
-    // A report with nothing left to do finished in time.
-    if (!result.leftOff && !result.moreTime) return 0;
-    const label = AGENT_LABELS[domain];
-    const wanted = result.moreTime?.minutes ?? DEFAULT_MORE_MINUTES;
-    const now = budgetFor(task, deps);
-    const minutes = await decideMoreTime(task, deps, { label, instruction, result, wanted, run, state: now?.state });
-    if (minutes <= 0) return 0;
-    const over = Math.max(0, Math.ceil((minutes * 60_000 - (now?.state.windowMs ?? minutes * 60_000)) / 60_000));
-    updateBudget(deps.root, deps.configDir, task.id, (budget) => {
-      budget.granted += over;
-      const entry = budget.allotments.find((allotment) => allotment.id === id);
-      if (entry) Object.assign(entry, { minutes: entry.minutes + minutes, granted: entry.granted + minutes });
-    });
-    recordDecision(task, `${label} ran out of time; the user gave it ${minutes} more minutes${over > 0 ? `, ${over} of them added to the task's budget` : ""}. Left off: ${oneLine(result.leftOff ?? result.moreTime?.reason ?? "", 200)}`);
-    onGrant?.(minutes * 60_000);
-    return minutes * 60_000;
-  });
-}
-
-interface MoreTimeAsk {
-  label: string;
-  instruction: string;
-  result: WorkerResult;
-  wanted: number;
-  run: AgentRun;
-  state?: BudgetState;
-}
-
-const MORE_TIME = "Give it the time it asks for";
-const OTHER_TIME = "Give a different amount";
-
-async function decideMoreTime(task: Task, deps: WorkflowDeps, ask: MoreTimeAsk): Promise<number> {
-  const { label, instruction, result, wanted, run, state } = ask;
-  if (isAutoMode(deps.root, deps.configDir, task.id)) {
-    recordDecision(task, `Auto mode: ${label}'s step allowance is spent. More time requires the user; return the unfinished report.`);
-    return 0;
-  }
-  const over = Math.max(0, Math.ceil((wanted * 60_000 - (state?.windowMs ?? wanted * 60_000)) / 60_000));
-  const had = run.allotMs ?? 0;
-  const choice = await deps.choose(
-    [
-      `${label} is out of time: it had ${formatMinutes(had + (run.extendedMs ?? 0))} for "${oneLine(instruction, 160)}".`,
-      result.completed ? `Done so far: ${oneLine(result.completed, 400)}` : "",
-      result.leftOff ? `Left to do: ${oneLine(result.leftOff, 400)}` : "",
-      `It needs about ${wanted} more minutes${result.moreTime?.reason ? `: ${oneLine(result.moreTime.reason, 200)}` : ""}.`,
-      state ? `The task has used ${formatMinutes(state.usedMs)} of ${formatMinutes(state.totalMs)} (${formatMinutes(state.leftMs)} left)${over > 0 ? `; ${wanted} more minutes adds ${over} to its budget` : ""}.` : "This step has a shared allowance even though the task has no overall time budget.",
-      `Give ${label} ${wanted} more minutes to finish?`,
-    ].filter(Boolean).join("\n\n"),
-    [MORE_TIME, OTHER_TIME, `Stop ${label} here`],
-  );
-  if (choice === MORE_TIME) return wanted;
-  if (choice === OTHER_TIME) return parseMinutes((await deps.ask(`How many more minutes for ${label}?`)) ?? "") ?? 0;
-  recordDecision(task, `The user stopped ${label} at its time limit. Left off: ${oneLine(result.leftOff ?? "", 200)}`);
-  return 0;
-}
-
-/** Stopped at its time with work left: a report that finished everything as time ran out is not. */
-function stoppedForTime(outcome: WorkerOutcome): boolean {
-  return Boolean(outcome.run.status === "timeout" || (outcome.run.timeUp && (outcome.result.leftOff || outcome.result.moreTime)));
-}
-
-/** How a step's time went, for the oracle: out of time and stopped, or given more. */
-function timeReport(outcome: WorkerOutcome): string {
-  const { run, result } = outcome;
-  const label = AGENT_LABELS[result.domain];
-  if (stoppedForTime(outcome)) {
-    return [
-      `${label} ran out of its time and was not given more: this step is unfinished.`,
-      result.leftOff ? `Left off: ${oneLine(result.leftOff, 600)}` : "",
-      result.moreTime ? `It asked for ${result.moreTime.minutes ?? "more"} minutes${result.moreTime.reason ? `: ${oneLine(result.moreTime.reason, 300)}` : ""}.` : "",
-      "Decide with the user: trim the scope, ask for task time with action=budget, or wrap up with what is done.",
-    ].filter(Boolean).join("\n");
-  }
-  return run.extendedMs ? `${label} ran out of its ${formatMinutes(run.allotMs ?? 0)} and was given ${formatMinutes(run.extendedMs)} more.` : "";
-}
-
-/**
- * `action=budget`: with no minutes, where the budget stands; with minutes and
- * a reason, the oracle asks the user for more task time. Only the user can
- * grant it; in auto mode nobody can, and the task wraps up.
- */
-async function handleBudget(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
-  const now = budgetFor(task, deps);
-  if (!now) return "This task has no time budget. The user sets one with /bot-lobby budget <minutes>.";
-  const minutes = params.minutes;
-  if (!minutes || minutes <= 0) return allotmentReport(now.budget);
-  const reason = params.reason?.trim() || params.text?.trim();
-  if (!reason) throw new Error("budget requires reason: why the task needs more time");
-  if (isAutoMode(deps.root, deps.configDir, task.id)) {
-    recordDecision(task, `Auto mode: asked for ${minutes} more minutes (${oneLine(reason, 160)}), which only the user can give.`);
-    return "Auto mode: nobody can give the task more time. Wrap up with what is done: finish or drop the step in hand, run the QA gate if there is room, and tell the user what is left.";
-  }
-  const choice = await deps.choose(
-    [`The oracle asks for ${minutes} more minutes on ${task.id}: ${oneLine(reason, 400)}`, budgetLine(now.budget, now.state)].join("\n\n"),
-    [`Give ${minutes} more minutes`, OTHER_TIME, "No"],
-  );
-  const granted = choice === `Give ${minutes} more minutes` ? minutes : choice === OTHER_TIME ? parseMinutes((await deps.ask(`How many more minutes for ${task.id}?`)) ?? "") ?? 0 : 0;
-  if (granted <= 0) {
-    recordDecision(task, `The user did not give ${minutes} more minutes: ${oneLine(reason, 200)}`);
-    return "The user did not give more time. Wrap up with what is done and tell them what is left.";
-  }
-  updateBudget(deps.root, deps.configDir, task.id, (budget) => {
-    budget.granted += granted;
-  });
-  recordDecision(task, `The user gave the task ${granted} more minutes: ${oneLine(reason, 200)}`);
-  return `The user gave the task ${granted} more minutes.`;
-}
-
-/** What each delegation was given, newest last. */
-function allotmentReport(budget: TaskBudget): string {
-  const rows = budget.allotments.slice(-8).map((entry) => `- ${entry.who}: ${entry.minutes}m${entry.granted > 0 ? ` (${entry.granted} granted)` : ""} — ${entry.what}${entry.outcome ? ` · ${entry.outcome}` : entry.endedAt ? "" : " · running"}`);
-  return rows.length > 0 ? `Allotted so far:\n${rows.join("\n")}` : "Nothing allotted yet.";
-}
-
-/** Every orchestrate result ends with where the budget stands, when the task has one. */
-function budgetFooter(task: Task, deps: WorkflowDeps): string {
-  const now = budgetFor(task, deps);
-  return now ? `\n\n${budgetLine(now.budget, now.state)}` : "";
-}
-
 const HANDLERS: Record<OrchestrateAction, (task: Task, params: OrchestrateParams, deps: WorkflowDeps) => Promise<string> | string> = {
   clarify: handleClarify,
   scout: handleScout,
@@ -2064,7 +1925,6 @@ const HANDLERS: Record<OrchestrateAction, (task: Task, params: OrchestrateParams
   block: handleBlock,
   resume: handleResume,
   decide: handleDecide,
-  budget: handleBudget,
   track: handleTrack,
   status: (task) => describeTask(task),
   cancel: handleCancel,
@@ -2150,11 +2010,11 @@ export async function runWorkflowAction(params: OrchestrateParams, deps: Workflo
     execution.signal.throwIfAborted();
     const runs = recordRunLog(task, finished, deps);
     saveTask(deps.root, deps.configDir, task);
-    return { ok: true, taskId: task.id, state: task.state, message: `${message}${runsFooter(runs)}${budgetFooter(task, deps)}`, runs };
+    return { ok: true, taskId: task.id, state: task.state, message: `${message}${runsFooter(runs)}`, runs };
   } catch (error) {
     const runs = recordRunLog(task, finished, deps);
     saveTask(deps.root, deps.configDir, task);
-    return { ok: false, taskId: task.id, state: task.state, message: `Rejected: ${(error as Error).message}${budgetFooter(task, deps)}`, runs };
+    return { ok: false, taskId: task.id, state: task.state, message: `Rejected: ${(error as Error).message}`, runs };
   } finally {
     execution.release();
     for (const runId of working) noteWorkerRun(deps.root, deps.configDir, task.id, { runId, startedAt: "", status: "cancelled" });