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

package/src/pi/events.ts

@@ -9,20 +9,37 @@ 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 { 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, task.qaVerdict === "pass");
+  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 +64,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 +81,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 +124,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 +147,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";

package/src/pi/start-task.ts

@@ -16,6 +16,7 @@ import { setAutoMode } from "../state/auto.ts";
 import { loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest } from "../state/backlog.ts";
 import { triageFor } from "../classifier/instance.ts";
 import { freshContextOn, markContext } from "./fresh-context.ts";
+import { setBudget } from "../state/budget.ts";
 
 function uniqueTaskId(root: string, configDir: string, request: string): string {
   const base = nextTaskId(request);
@@ -25,12 +26,13 @@ function uniqueTaskId(root: string, configDir: string, request: string): string
   return id;
 }
 
-export function kickoff(task: Task): string {
+export function kickoff(task: Task, budgetMinutes = 0): string {
   return [
     `A bot-lobby task is active: ${task.id}`,
     `Title: ${task.title}`,
     `Request: ${taskRequest(task)}`,
     `State: ${task.state}`,
+    ...(budgetMinutes > 0 ? [`Time budget: ${budgetMinutes} minutes of work, for you and every agent. Size the plan to fit it and divide it by scope (see Time budget in your prompt).`] : []),
     "",
     "Drive it with the orchestrate tool:",
     "1. clarify if the request is genuinely ambiguous,",
@@ -52,6 +54,8 @@ export interface StartOptions {
   auto?: boolean;
   /** The task's short title (a planned task's own title); derived from the request otherwise. */
   title?: string;
+  /** Minutes of work time the task gets; `workflow.taskBudgetMinutes` when absent. */
+  budget?: number;
 }
 
 export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: StartOptions = {}): Promise<Task | undefined> {
@@ -71,6 +75,8 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
   if (triage) task.triage = triage;
   saveTask(root, configDir, task);
+  const budgetMinutes = options.budget ?? loadConfig().workflow.taskBudgetMinutes;
+  if (budgetMinutes > 0) setBudget(root, configDir, task.id, budgetMinutes);
   if (options.auto) setAutoMode(root, configDir, task.id, true, sessionId);
   // A session that starts a task is named after it, so /resume and the lobby list it by name.
   if (!pi.getSessionName()) pi.setSessionName(task.title);
@@ -80,7 +86,7 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   // The oracle takes the task on with a clean context: nothing said before the kickoff is sent to its model.
   if (freshContextOn()) markContext(pi, { kind: "start", taskId: task.id, at: Date.now() });
   // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
-  pi.sendUserMessage(kickoff(task), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  pi.sendUserMessage(kickoff(task, budgetMinutes), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;
 }
 

package/src/pi/tools.ts

@@ -1,6 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
+import { getMarkdownTheme, type AgentToolUpdateCallback, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
@@ -8,6 +8,10 @@ import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { classifier, effortFor, hintsFor, triageFor } from "../classifier/instance.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
+import { whileAsking } from "../state/budget.ts";
+import { askUser } from "../ask/dialog.ts";
+import type { AskQuestion } from "../ask/types.ts";
+import { unescapeBreaks } from "../lobby/markdown.ts";
 import { isQuiet } from "./quiet.ts";
 import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
@@ -36,16 +40,18 @@ const OrchestrateSchema = Type.Object({
       Type.Object({
         domain: Type.String({ description: "designer, backend, or qa" }),
         task: Type.String({ description: "the concrete step(s) for that domain's worker" }),
+        minutes: Type.Optional(Type.Number({ description: "under a time budget: minutes for this worker, by its scope" })),
       }),
       { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
     ),
   ),
+  minutes: Type.Optional(Type.Number({ description: "implement (under a time budget): minutes for this step, by its scope; budget: more minutes to ask the user for" })),
   approvalId: Type.Optional(Type.String({ description: "resolve_approval: the approval id from a worker result" })),
   decision: Type.Optional(
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
   ),
   note: Type.Optional(Type.String({ description: "resolve_approval: rationale, or what to do instead when rejected" })),
-  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue" })),
+  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time" })),
   text: Type.Optional(Type.String({ description: "decide/complete/knowledge: the decision, completion summary, or knowledge text" })),
   file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md" })),
   kind: Type.Optional(
@@ -64,7 +70,8 @@ const DESCRIPTION = [
   "review), knowledge (record approved knowledge or a decision),",
   "compact (replace a knowledge file with a rewritten version, archiving the old one),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
-  "pass), block/resume (escalate or continue), status, cancel.",
+  "pass), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
+  "user for more minutes with a reason), status, cancel.",
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
@@ -109,8 +116,11 @@ export function workflowDeps(
     classifier: classifier(),
     triage: (request, triageSignal) => triageFor({ cwd: ctx.cwd, root, configDir }, request, triageSignal),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
-    ask: async (question) => (hasUI ? ctx.ui.input(question) : undefined),
-    choose: async (title, options) => (hasUI ? ctx.ui.select(title, options) : undefined),
+    // Time spent waiting on the user is not the task's: its budget clock waits too.
+    ask: async (question) => (hasUI ? whileAsking(() => ctx.ui.input(question)) : undefined),
+    choose: async (title, options) => (hasUI ? whileAsking(() => ctx.ui.select(title, options)) : undefined),
+    // An agent's own questions (the designer's), relayed as the questionnaire.
+    ...(hasUI ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),
     notify: (message, level = "info") => {
       if (hasUI) ctx.ui.notify(message, level);
     },
@@ -135,6 +145,14 @@ function runReporter(
   };
 }
 
+/** A header line over Markdown, rendered as pi renders its own messages (a proposal's bullets, a report's code spans). */
+function headedMarkdown(header: string, body: string, color: (text: string) => string): Container {
+  const box = new Container();
+  box.addChild(new Text(header, 0, 0));
+  if (body.trim()) box.addChild(new Markdown(unescapeBreaks(body), 0, 0, getMarkdownTheme(), { color }));
+  return box;
+}
+
 /** TUI-only transcript entries; these never enter the model's context. */
 function registerBotLobbyEntries(pi: ExtensionAPI): void {
   pi.registerEntryRenderer("bot-lobby", (entry, { expanded }, theme) => {
@@ -145,7 +163,7 @@ function registerBotLobbyEntries(pi: ExtensionAPI): void {
     }
     const header = `bot-lobby ${data?.taskId ?? ""} — ${data?.kind ?? "note"}`.trim();
     const body = data?.text ?? "";
-    return new Text(`${theme.fg("accent", theme.bold(header))}\n${theme.fg("toolOutput", expanded ? body : truncate(body, 600))}`, 0, 0);
+    return headedMarkdown(theme.fg("accent", theme.bold(header)), expanded ? body : truncate(body, 600), (text) => theme.fg("toolOutput", text));
   });
 }
 
@@ -200,7 +218,7 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
       const body = result.content[0]?.type === "text" ? result.content[0].text : "";
       const icon = details?.ok ? theme.fg("success", "✓") : theme.fg("warning", "!");
       const header = `${icon} ${theme.fg("toolTitle", theme.bold("orchestrate"))} ${theme.fg("accent", details?.taskId ?? "")} ${theme.fg("muted", `→ ${details?.state ?? "?"}`)}`;
-      return new Text(expanded && body ? `${header}\n${theme.fg("dim", truncate(body, 2000))}` : header, 0, 0);
+      return expanded && body ? headedMarkdown(header, truncate(body, 2000), (text) => theme.fg("dim", text)) : new Text(header, 0, 0);
     },
   });
 }

package/src/pi/ui.ts

@@ -26,6 +26,7 @@ import { slotSituations } from "./zen-metrics.ts";
 import type { Situation } from "./kaomoji.ts";
 import { isQuiet, isSubagentProcess, toggleQuiet } from "./quiet.ts";
 import { panelLines, type ExpressionFrames, type OracleMotion } from "./zen.ts";
+import { budgetClock } from "../state/budget.ts";
 
 export const STATUS_KEY = "bot-lobby";
 
@@ -52,6 +53,8 @@ let zenOn = false;
  * keys the widget's render cache.
  */
 let zenState: { task: Task | undefined; live: AgentRun[]; runs: AgentRun[] } = { task: undefined, live: [], runs: [] };
+/** Where the widget's task lives, so its time budget can be read. */
+let zenPaths: { root: string; configDir: string } | undefined;
 let zenVersion = 0;
 
 /** Latest master tool activity; the oracle's speech bubble shows it. */
@@ -255,7 +258,8 @@ export class ZenScene {
     const motion = this.motion(now);
     const key = `${width}|${rows}|${this.tick}|${frameKey}|${motion.phase}|${motion.talk}|${zenVersion}|${Math.floor(now / 1000)}|${quiet}|${still}`;
     if (this.cache && this.cache.key === key && this.cache.theme === theme) return this.cache.lines;
-    const opts = { width, rows, tick: this.tick, theme, expressions, variants, oracleActivity, oracleMotion: motion, still };
+    const time = zenState.task && zenPaths ? budgetClock(zenPaths.root, zenPaths.configDir, zenState.task.id, now) : undefined;
+    const opts = { width, rows, tick: this.tick, theme, expressions, variants, oracleActivity, oracleMotion: motion, still, ...(time ? { time } : {}) };
     const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => clip(line, width));
     this.cache = { key, theme, lines };
     return lines;
@@ -356,6 +360,7 @@ function leaveZen(ctx: ExtensionContext): void {
 export function applyStatus(ctx: ExtensionContext, root: string, configDir: string, runs: AgentRun[] = []): void {
   const sessionId = ctx.sessionManager.getSessionId();
   const task = isSubagentProcess() || minimized ? undefined : activeTask(root, configDir, sessionId);
+  zenPaths = { root, configDir };
   const sameTask = zenState.task?.id === task?.id;
   setZenState(task, mergeRuns(sameTask ? zenState.live : [], slim(runs)));
   ctx.ui.setStatus(STATUS_KEY, statusText(task, minimized));

package/src/pi/zen-metrics.ts

@@ -11,6 +11,13 @@ import { SLOT_IDS, SLOT_LABELS, type SlotId, type SlotState } from "./mascot-art
 import { formatDuration, planChecklist } from "./zen.ts";
 import { QUIET_MS, quietFor, slotOf } from "./run-summary.ts";
 import type { Situation } from "./kaomoji.ts";
+import { formatMinutes } from "../state/budget.ts";
+
+/** A task's time budget as the scene shows it: work time spent of the whole. */
+export interface SceneTime {
+  usedMs: number;
+  totalMs: number;
+}
 
 export type { SlotId, SlotState };
 
@@ -70,7 +77,10 @@ function latestRunFor(runs: AgentRun[], id: SlotId): AgentRun | undefined {
 function runElapsedLabel(run: AgentRun | undefined, now: number): string {
   if (!run) return "—";
   const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
-  return formatDuration(end - Date.parse(run.startedAt));
+  const elapsed = end - Date.parse(run.startedAt);
+  // Under a time budget: minutes spent of the minutes given (`12/30m`).
+  if (run.allotMs) return `${Math.max(0, Math.floor(elapsed / 60_000))}/${Math.round((run.allotMs + (run.extendedMs ?? 0)) / 60_000)}m`;
+  return formatDuration(elapsed);
 }
 
 function slotView(id: SlotId, runs: AgentRun[], now: number): SlotView {
@@ -89,7 +99,7 @@ function slotView(id: SlotId, runs: AgentRun[], now: number): SlotView {
   };
 }
 
-export function sceneMetrics(task: Task, runs: AgentRun[], now: number): SceneMetrics {
+export function sceneMetrics(task: Task, runs: AgentRun[], now: number, time?: SceneTime): SceneMetrics {
   const checklist = planChecklist(task.plan ?? "", runs);
   const total = checklist.length;
   const done = checklist.filter((step) => step.status === "done").length;
@@ -98,7 +108,7 @@ export function sceneMetrics(task: Task, runs: AgentRun[], now: number): SceneMe
   const elapsed = Number.isFinite(created) ? Math.max(0, now - created) : 0;
   return {
     ...summary,
-    elapsedLabel: formatDuration(elapsed),
+    elapsedLabel: time ? `${formatMinutes(time.usedMs)} of ${formatMinutes(time.totalMs)}` : formatDuration(elapsed),
     slots: SLOT_IDS.map((id) => slotView(id, runs, now)),
   };
 }

package/src/pi/zen.ts

@@ -37,7 +37,8 @@ import {
   type LargeSlot,
   type LargeTaskRow,
 } from "./zen-large.ts";
-import { runStatus, sceneMetrics, slotSituation, type SceneMetrics, type SlotView } from "./zen-metrics.ts";
+import { runStatus, sceneMetrics, slotSituation, type SceneMetrics, type SceneTime, type SlotView } from "./zen-metrics.ts";
+import { formatMinutes } from "../state/budget.ts";
 import { feedLine, QUIET_MS, quietFor } from "./run-summary.ts";
 import { shortDuration } from "../text.ts";
 
@@ -378,18 +379,22 @@ function checklistRow(step: PlanStep, ordinal: number): string {
   return `  ${icon} ${ordinal}. ${step.text}`;
 }
 
-function headerLine(task: Task, now: number, quiet: boolean): string {
+function headerLine(task: Task, now: number, quiet: boolean, time?: SceneTime): string {
   const paused = task.paused ? " (paused)" : "";
-  const elapsed = formatDuration(now - Date.parse(task.createdAt));
+  const elapsed = time ? `${formatMinutes(time.usedMs)} of ${formatMinutes(time.totalMs)}` : formatDuration(now - Date.parse(task.createdAt));
   const mode = quiet ? "tools hidden (alt+t)" : "tools shown";
   return `bot-lobby ${task.id} · ${task.state}${paused}   ⏱ ${elapsed} · ${mode}`;
 }
 
-/** The pending approval or blocker the user must resolve, with its severity. */
-function taskAlert(task: Task): { text: string; kind: "warning" | "error" } | undefined {
+/** The pending approval or blocker the user must resolve, with its severity; then a spent time budget. */
+function taskAlert(task: Task, time?: SceneTime): { text: string; kind: "warning" | "error" } | undefined {
   const pending = task.approvals.filter((approval) => approval.status === "pending");
   if (pending.length > 0) return { text: `approvals pending: ${pending.map((approval) => approval.id).join(", ")}`, kind: "warning" };
   if (task.blockers.length > 0) return { text: `blocked: ${truncate(task.blockers[0]!.reason, 60)}`, kind: "error" };
+  if (time && time.usedMs >= time.totalMs * 0.9) {
+    const spent = time.usedMs >= time.totalMs;
+    return { text: `time budget ${spent ? "spent" : "nearly spent"}: ${formatMinutes(time.usedMs)} of ${formatMinutes(time.totalMs)}`, kind: "warning" };
+  }
   return undefined;
 }
 
@@ -518,10 +523,10 @@ function compactPanel(
   opts: PanelOptions,
   width: number,
 ): string[] {
-  const metrics = sceneMetrics(task, runs, now);
+  const metrics = sceneMetrics(task, runs, now, opts.time);
   const expressions = opts.expressions ?? {};
   const strip = opts.still ? [] : compactStrip(task.state, metrics.slots, expressions, opts.theme);
-  const fixed = [...bannerLines(width), headerLine(task, now, quiet), ...strip];
+  const fixed = [...bannerLines(width), headerLine(task, now, quiet, opts.time), ...strip];
   const tail = tailLines(task, runs, now, tick, steps, opts.theme);
   const room = Math.max(0, MAX_PANEL_LINES - fixed.length - tail.length);
   return [...fixed, ...tail, ...checklistLines(steps, room)].map((line) => clip(line, width));
@@ -577,8 +582,8 @@ function sceneInput(
   steps: PlanStep[],
   opts: PanelOptions,
 ): LargeSceneInput {
-  const metrics = sceneMetrics(task, runs, now);
-  const alert = taskAlert(task);
+  const metrics = sceneMetrics(task, runs, now, opts.time);
+  const alert = taskAlert(task, opts.time);
   return {
     taskId: task.id,
     taskTitle: task.title,
@@ -616,6 +621,8 @@ export interface PanelOptions {
   oracleMotion?: OracleMotion;
   /** Leave out the oracle and agent animations: status, alert, activity and checklist only. */
   still?: boolean;
+  /** The task's time budget: the elapsed label reads against it. */
+  time?: SceneTime;
 }
 
 /** The oracle's clocked animation state beyond its expression frame (see expressions.ts). */

package/src/roles/reviewer.ts

@@ -30,15 +30,23 @@ function parseVerdict(text: string | undefined): Verdict {
   return "blocked";
 }
 
+/** The severity a finding was tagged with, or undefined when it carries none. */
+function taggedSeverity(text: string): Severity | undefined {
+  const match = /^\[([^\]]+)\]/.exec(text);
+  return SEVERITIES.find((candidate) => match?.[1]?.toLowerCase().includes(candidate));
+}
+
 function parseFinding(text: string): ReviewFinding {
   const match = /^\[([^\]]+)\]\s*(.*)$/.exec(text);
-  const severity = SEVERITIES.find((candidate) => match?.[1]?.toLowerCase().includes(candidate)) ?? "info";
-  return { severity, text: (match?.[2] ?? text).trim() };
+  return { severity: taggedSeverity(text) ?? "info", text: (match?.[2] ?? text).trim() };
 }
 
 /** The QA gate never passes by default: a PASS must cite at least one executed check. */
 export const UNVERIFIED_PASS = "unverified pass: PASS without executed checks under ## Verification, downgraded to CHANGES_REQUIRED";
 
+/** Minor and info findings never hold the gate; what the reviewer asked for is kept as follow-ups. */
+export const MINOR_ONLY = "CHANGES_REQUIRED for minor or info findings only: passed, its asks kept as follow-ups";
+
 /** A verification bullet names a command or check and its result (`- cmd — result`). */
 function executedChecks(verification: string): string[] {
   return bullets(verification).filter((entry) => /\S\s*(?:—|–|-{1,2}|:|=>|→)\s*\S/.test(entry));
@@ -49,23 +57,34 @@ export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
   const sections = parseSections(raw);
   const verification = findSection(sections, "verification") ?? "";
   const requiredChanges = bullets(findSection(sections, "required changes"));
+  const entries = bullets(findSection(sections, "findings"));
   let verdict = parseVerdict(findSection(sections, "verdict"));
   let downgraded: string | undefined;
-  if (verdict === "pass" && executedChecks(verification).length === 0) {
+  let relaxed: string | undefined;
+  const checked = executedChecks(verification).length > 0;
+  if (verdict === "pass" && !checked) {
     verdict = "changes_required";
     downgraded = UNVERIFIED_PASS;
     requiredChanges.push("Re-run the QA gate and record the checks actually executed, each as `- command — result`.");
+  } else if (
+    verdict === "changes_required" && checked && entries.length > 0
+    // Only findings explicitly tagged minor or info: an untagged one may be serious.
+    && entries.every((entry) => { const severity = taggedSeverity(entry); return severity === "minor" || severity === "info"; })
+  ) {
+    verdict = "pass";
+    relaxed = MINOR_ONLY;
   }
   return {
     domain,
     role: "reviewer",
     verdict,
-    findings: bullets(findSection(sections, "findings")).map(parseFinding),
+    findings: entries.map(parseFinding),
     verification,
     requiredChanges,
     optionalImprovements: bullets(findSection(sections, "optional improvements")),
     pushback: parsePushback(sections),
     ...(downgraded ? { downgraded } : {}),
+    ...(relaxed ? { relaxed } : {}),
     raw,
   };
 }

package/src/roles/worker.ts

@@ -25,6 +25,8 @@ export const workerSpec: RoleSpec = {
     "the matching section instead. Do not narrate. Report only what you actually changed and verified.",
     "An optional `## Pushback` (`**Request:**`, `**Reason:**`, optional `**Alternative:**`) states a change you",
     "believe is wrong, with your reason, instead of doing it; still complete everything else you safely can.",
+    "Stopped because your time is up, also add `## Left Off` (what you were doing, what is still to do) and",
+    "`## More Time` (`N minutes — why`).",
   ].join(" "),
 };
 
@@ -65,6 +67,15 @@ export function parseBlockers(
   ];
 }
 
+/** `## More Time` as the minutes asked for (`15 minutes`, `1h`, `20m`) and the reason given. */
+export function parseMoreTime(text: string): { minutes?: number; reason: string } {
+  const flat = text.replace(/^[-*]\s*/gm, "").replace(/\s+/g, " ").trim();
+  const match = /(\d+(?:\.\d+)?)\s*(h|hrs?|hours?|m|mins?|minutes?)\b/i.exec(flat);
+  const minutes = match ? Math.round(Number(match[1]) * (/^h/i.test(match[2]!) ? 60 : 1)) : undefined;
+  const reason = match ? flat.slice(match.index + match[0].length).replace(/^\s*(?:—|–|-|:|,|because|to)?\s*/i, "").trim() : flat;
+  return { ...(minutes && minutes > 0 ? { minutes } : {}), reason: reason || flat };
+}
+
 /** Parse a worker's markdown into a structured result (never throws). */
 export function parseWorkerResult(domain: Domain, raw: string, now = new Date().toISOString()): WorkerResult {
   const sections = parseSections(raw);
@@ -72,6 +83,7 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
     domain,
     role: "worker",
     completed: findSection(sections, "completed") ?? "",
+    ...leftOffFields(sections),
     filesChanged: bullets(findSection(sections, "files changed")).map((entry): FileChange => {
       const file = parseFileBullet(entry);
       return { path: file.path, change: file.reason };
@@ -87,6 +99,12 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
   };
 }
 
+function leftOffFields(sections: Map<string, string>): Pick<WorkerResult, "leftOff" | "moreTime"> {
+  const leftOff = findSection(sections, "left off")?.trim();
+  const more = findSection(sections, "more time")?.trim();
+  return { ...(leftOff ? { leftOff } : {}), ...(more ? { moreTime: parseMoreTime(more) } : {}) };
+}
+
 /** Report contract deviations so the Master does not accept unverified work. */
 export function validateWorkerResult(result: WorkerResult): string[] {
   const issues: string[] = [];

package/src/schemas/configuration.ts

@@ -68,6 +68,8 @@ export interface WorkflowConfig {
   maxParallelWorkers: number;
   /** The oracle starts each task with a clean context: its model is sent only the conversation since the task started, or since the last one ended. */
   freshContext: boolean;
+  /** Minutes of work time a new task gets unless it is started with its own (`--budget`); 0 = no budget. */
+  taskBudgetMinutes: number;
 }
 
 export interface KnowledgeConfig {
@@ -204,6 +206,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     wrapUpAt: 0.75,
     maxParallelWorkers: 3,
     freshContext: true,
+    taskBudgetMinutes: 0,
   },
   knowledge: {
     compactionThreshold: 20000,
@@ -340,6 +343,7 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   const src = (partial ?? {}) as Record<string, unknown>;
   const workflow = { ...DEFAULT_CONFIG.workflow, ...(src.workflow as Partial<WorkflowConfig> | undefined) };
   workflow.freshContext = workflow.freshContext !== false;
+  workflow.taskBudgetMinutes = typeof workflow.taskBudgetMinutes === "number" && workflow.taskBudgetMinutes > 0 ? Math.min(24 * 60, Math.round(workflow.taskBudgetMinutes)) : 0;
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };
   const srcAgents = (src.agents ?? {}) as Partial<BotLobbyConfig["agents"]>;
   return {

package/src/schemas/findings.ts

@@ -42,6 +42,10 @@ export interface WorkerResult {
   domain: Domain;
   role: "worker";
   completed: string;
+  /** Stopped for time: what it was doing and what is still to do. */
+  leftOff?: string;
+  /** Stopped for time: the minutes it asks for, and why. */
+  moreTime?: { minutes?: number; reason: string };
   filesChanged: FileChange[];
   verification: string;
   notes: string;
@@ -69,6 +73,8 @@ export interface ReviewResult {
   pushback?: Pushback;
   /** Set when the engine downgraded an unsupported PASS. */
   downgraded?: string;
+  /** Set when the engine passed a CHANGES_REQUIRED that named only minor or info findings. */
+  relaxed?: string;
   raw: string;
 }
 
@@ -137,4 +143,12 @@ export interface AgentRun {
   routedFrom?: string;
   /** Why and where it was routed (`trivial 0.88: p/big · medium → p/cheap · low`). */
   route?: string;
+  /** Files the run changed with `edit`/`write`, absolute, across its attempts. */
+  edited?: string[];
+  /** Under a task time budget: the time it was given, when that runs out (epoch ms), and any granted since. */
+  allotMs?: number;
+  endsAt?: number;
+  extendedMs?: number;
+  /** Stopped at its allotted time and not given more: its report says where it left off. */
+  timeUp?: boolean;
 }