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

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

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { Key, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Key, type Component, type TUI } from "@earendil-works/pi-tui";
+import { clip } from "../width.ts";
 import type { AgentRun } from "../schemas/findings.ts";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { activeTask } from "../state/persistence.ts";
@@ -25,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";
 
@@ -51,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. */
@@ -254,8 +258,9 @@ 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 lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => truncateToWidth(line, width));
+    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;
   }
@@ -355,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-large.ts

@@ -1,4 +1,4 @@
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { clip, textWidth } from "../width.ts";
 import {
   BAR,
   BUBBLE,
@@ -243,11 +243,11 @@ function labelPaint(status: SlotState, theme?: PanelTheme): ((text: string) => s
 }
 
 function padTo(text: string, width: number): string {
-  return truncateToWidth(text, width, "", true);
+  return clip(text, width, "", true);
 }
 
 function centre(text: string, width: number): string {
-  return padTo(" ".repeat(Math.max(0, Math.floor((width - visibleWidth(text)) / 2))) + text, width);
+  return padTo(" ".repeat(Math.max(0, Math.floor((width - textWidth(text)) / 2))) + text, width);
 }
 
 function mod(index: number, length: number): number {
@@ -273,7 +273,7 @@ function sceneCentre(width: number): number {
 
 /** Place a row of at most `SCENE_WIDTH` columns on the scene's centre column. */
 function place(row: string, width: number): string {
-  return " ".repeat(Math.max(0, sceneLeft(width) + Math.floor((SCENE_WIDTH - visibleWidth(row)) / 2))) + row;
+  return " ".repeat(Math.max(0, sceneLeft(width) + Math.floor((SCENE_WIDTH - textWidth(row)) / 2))) + row;
 }
 
 function alertLine(
@@ -283,7 +283,7 @@ function alertLine(
   kind: "warning" | "error" = "warning",
 ): string {
   const left = sceneLeft(width);
-  const line = paint(truncateToWidth(`! ${alert}`, width - left, "…"), kind, theme, true);
+  const line = paint(clip(`! ${alert}`, width - left, "…"), kind, theme, true);
   return " ".repeat(left) + line;
 }
 
@@ -294,8 +294,8 @@ function boxLines(input: LargeSceneInput, width: number, theme?: PanelTheme): st
 
 function topBorder(input: LargeSceneInput, theme?: PanelTheme): string {
   const lead = "┌─ BOT-LOBBY ── ";
-  const label = truncateToWidth(`${input.taskTitle} · ${input.state} `, SCENE_WIDTH - 18, "…");
-  const tail = "─".repeat(Math.max(0, SCENE_WIDTH - 1 - visibleWidth(lead) - visibleWidth(label)));
+  const label = clip(`${input.taskTitle} · ${input.state} `, SCENE_WIDTH - 18, "…");
+  const tail = "─".repeat(Math.max(0, SCENE_WIDTH - 1 - textWidth(lead) - textWidth(label)));
   return paint(lead, "muted", theme) + paint(label, "accent", theme, true) + paint(`${tail}┐`, "muted", theme);
 }
 
@@ -349,7 +349,7 @@ function bodyLines(
 /** One dim line under the agent strip; warnings take the warning colour. */
 function feedRow(feed: FeedLine, width: number, theme?: PanelTheme): string {
   const left = sceneLeft(width) + 1;
-  const text = truncateToWidth(feed.text, Math.max(0, Math.min(SCENE_WIDTH - 2, width - left)), "…");
+  const text = clip(feed.text, Math.max(0, Math.min(SCENE_WIDTH - 2, width - left)), "…");
   return " ".repeat(left) + (feed.kind === "warning" ? paint(text, "warning", theme) : paint(text, "dim", theme));
 }
 
@@ -494,7 +494,7 @@ export function oracleAside(input: LargeSceneInput): string {
 function bubbleRows(input: LargeSceneInput, theme?: PanelTheme): string[] {
   const accent = ORACLE_COLORS[input.oracle.pose];
   const border = (text: string) => paint(text, "muted", theme);
-  const text = (value: string) => padTo(truncateToWidth(value, BUBBLE_TEXT, "…"), BUBBLE_TEXT);
+  const text = (value: string) => padTo(clip(value, BUBBLE_TEXT, "…"), BUBBLE_TEXT);
   const rule = "─".repeat(BUBBLE.width - 2);
   return [
     border(`╭${rule}╮`),
@@ -661,7 +661,7 @@ function assemble(end: number, cells: readonly Cell[]): string {
   let cursor = 0;
   for (const cell of cells) {
     row += " ".repeat(Math.max(0, cell.offset - cursor)) + (cell.paint ? cell.paint(cell.text) : cell.text);
-    cursor = cell.offset + visibleWidth(cell.text);
+    cursor = cell.offset + textWidth(cell.text);
   }
   return row + " ".repeat(Math.max(0, end - cursor));
 }

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

@@ -7,7 +7,7 @@
  * arrive on its run. Everything here is pure: expression frames and the spinner
  * tick arrive from the caller, and every timestamp arrives as `now`.
  */
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { clip, textWidth } from "../width.ts";
 import type { AgentRun } from "../schemas/findings.ts";
 import { TERMINAL_STATES, type Task, type TaskState } from "../schemas/task.ts";
 import { truncate } from "../text.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;
 }
 
@@ -399,9 +404,9 @@ const BANNER_MIN_WIDTH = 60;
 /** Boxed title for wide terminals, one-line title otherwise; never wider than `width`. */
 export function bannerLines(width: number): string[] {
   if (width < 1) return [];
-  if (width < BANNER_MIN_WIDTH) return [truncateToWidth(BANNER_NARROW, width, "")];
+  if (width < BANNER_MIN_WIDTH) return [clip(BANNER_NARROW, width, "")];
   const inner = BANNER_WIDTH - 2;
-  const titleWidth = visibleWidth(BANNER_TITLE);
+  const titleWidth = textWidth(BANNER_TITLE);
   const left = Math.floor((inner - titleWidth) / 2);
   const border = "─".repeat(inner);
   return [`┌${border}┐`, `│${" ".repeat(left)}${BANNER_TITLE}${" ".repeat(inner - titleWidth - left)}│`, `└${border}┘`];
@@ -476,7 +481,7 @@ function compactFrame(slot: SlotView, expressions: ExpressionFrames): string {
 }
 
 function compactRow(content: string, color: PanelColor, theme?: PanelTheme): string {
-  const body = truncateToWidth(content, COMPACT_INNER, "", true);
+  const body = clip(content, COMPACT_INNER, "", true);
   return `|${theme ? theme.fg(color, body) : body}|`;
 }
 
@@ -518,13 +523,13 @@ 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) => truncateToWidth(line, width));
+  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). */
@@ -646,7 +653,7 @@ export function panelLines(
   // The still scene has no tower or agent strip to fit, so any height keeps the large tier's status box.
   if (width >= LARGE_MIN_WIDTH && (budget >= MIN_LARGE_LINES || opts.still)) {
     const scene = largeLines(sceneInput(task, runs, now, quiet, tick, steps, opts), width, budget, opts.theme, opts.still);
-    return scene.map((line) => truncateToWidth(line, width));
+    return scene.map((line) => clip(line, width));
   }
   return compactPanel(task, runs, now, quiet, tick, steps, opts, width);
 }

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

@@ -66,6 +66,10 @@ export interface WorkflowConfig {
   wrapUpAt: number;
   /** Workers that may run at once when the Master delegates several domains together. */
   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 {
@@ -201,6 +205,8 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     toolStallTimeoutMs: 10 * 60 * 1000,
     wrapUpAt: 0.75,
     maxParallelWorkers: 3,
+    freshContext: true,
+    taskBudgetMinutes: 0,
   },
   knowledge: {
     compactionThreshold: 20000,
@@ -336,6 +342,8 @@ function normalizeClassifier(value: unknown): ClassifierConfig {
 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;
 }

package/src/schemas/task.ts

@@ -114,6 +114,21 @@ export interface TaskTriage {
   at: string;
 }
 
+/** What the working tree held when a task's agents started editing: its changed files, repository-relative, and the commit it stood on. */
+export interface ChangeBaseline {
+  at: string;
+  files: string[];
+  /** HEAD when the first worker started: the QA gate reviews everything since, committed work included. */
+  head?: string;
+}
+
+/** The user accepted a task's work without a QA pass. */
+export interface QaWaiver {
+  at: string;
+  /** What QA still asked for when the user accepted. */
+  open: string[];
+}
+
 export interface Task {
   id: string;
   title: string;
@@ -145,6 +160,12 @@ export interface Task {
   archivedAt?: string;
   /** The classifier's read of the request, when it was on as the task started. */
   triage?: TaskTriage;
+  /** Files already changed when the first worker started: the QA gate reads them as pre-existing, not as this task's work. */
+  baseline?: ChangeBaseline;
+  /** Review rounds the user granted past `workflow.maxReviewIterations`. */
+  extraReviewRounds?: number;
+  /** Set only by the user: the work is accepted without a QA pass, so the task may complete. */
+  qaWaiver?: QaWaiver;
 }
 
 export function createTask(

package/src/state/archive.ts

@@ -6,11 +6,12 @@
  * abandoned before it is archived, so it never comes back half-driven.
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, sep } from "node:path";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { taskDir, tasksRoot } from "../knowledge/paths.ts";
 import { transition } from "./task-state.ts";
 import { dataRoot, readDataRoots } from "./project.ts";
+import { forgetCachedUnder, readJsonCached } from "./file-cache.ts";
 
 export function archiveRoot(root: string, configDir: string): string {
   return join(dataRoot(root, configDir), "archive", "tasks");
@@ -43,15 +44,23 @@ function archivedDir(root: string, configDir: string, taskId: string): string {
   return join(archiveRoot(root, configDir), checkId(taskId));
 }
 
-/** Archived tasks, most recently archived first. */
+function isObject(value: unknown): value is Task {
+  return typeof value === "object" && value !== null;
+}
+
+/** Archived tasks, most recently archived first (parsed again only when a file changes; shared, for reading). */
 export function listArchivedTasks(root: string, configDir: string): Task[] {
   const dir = archiveRoot(root, configDir);
   if (!existsSync(dir)) return [];
   const tasks: Task[] = [];
+  const seen = new Set<string>();
   for (const entry of readdirSync(dir)) {
-    const task = readAt(join(dir, entry));
+    const path = join(dir, entry, "state.json");
+    seen.add(path);
+    const task = readJsonCached(path, isObject);
     if (task) tasks.push(task);
   }
+  forgetCachedUnder(`${dir}${sep}`, seen);
   return tasks.sort((a, b) => (b.archivedAt ?? b.updatedAt).localeCompare(a.archivedAt ?? a.updatedAt));
 }