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

package/src/pi/commands.ts

@@ -17,7 +17,7 @@ import { transition } from "../state/task-state.ts";
 import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
 import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
-import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type ApprovalChoice } from "../workflow/workflow.ts";
+import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAsks, waiveQa, type ApprovalChoice } from "../workflow/workflow.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
 import { classifierSummary, openSettings } from "./settings-ui.ts";
 import { keyStatus } from "../classifier/instance.ts";
@@ -27,16 +27,20 @@ import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
 import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
+import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startClock } from "../state/budget.ts";
 
 const HELP = [
   "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
   "/bot-lobby <request>        Start a task through the workflow",
   "/bot-lobby --task [--auto] <request>   Start a task even when the request begins with a subcommand word",
+  "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
+  "/bot-lobby budget [90m|off]  Show or set this session's task time budget",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
   "/bot-lobby pause|resume     Pause or resume the active task",
   "/bot-lobby cancel [taskId]  Abandon a task",
   "/bot-lobby approve|amend <text>|decline   Answer the current proposal",
+  "/bot-lobby accept [taskId]  Accept a task's work as it is, without a QA pass; the oracle then completes it",
   "/bot-lobby knowledge        Show persistent knowledge files",
   "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
   "/bot-lobby settings         Edit per-agent model/thinking/instructions",
@@ -50,21 +54,48 @@ const HELP = [
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
 
 function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
 }
 
-export function parseCommand(args: string): { sub: string | undefined; rest: string[]; restText: string; auto?: boolean } {
-  const trimmed = args.trim();
-  // `--task [--auto] <request>` always starts a task (a background session started from the lobby sends this).
-  const forced = /^--task(\s+--auto)?(?:\s+([\s\S]*))?$/.exec(trimmed);
-  if (forced) return { sub: undefined, rest: [], restText: (forced[2] ?? "").trim(), ...(forced[1] ? { auto: true } : {}) };
+/** A task start's leading flags: `--task` (always a task), `--auto`, `--budget <time>` (or `--budget=<time>`). */
+const START_FLAG = /^--(task|auto)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+
+export interface ParsedCommand {
+  sub: string | undefined;
+  rest: string[];
+  restText: string;
+  auto?: boolean;
+  /** Minutes from `--budget`. */
+  budget?: number;
+  /** `--budget` with something that is not a time. */
+  budgetError?: string;
+}
+
+export function parseCommand(args: string): ParsedCommand {
+  let trimmed = args.trim();
+  // Leading flags start a task: what follows is its request, even when it begins with a subcommand word
+  // (a background session started from the lobby sends `--task [--auto] <request>`).
+  let flagged = false;
+  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError"> = {};
+  for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
+    flagged = true;
+    if (match[1] === "auto") extras.auto = true;
+    else if (match[2] !== undefined) {
+      const minutes = parseMinutes(match[2]);
+      if (minutes) extras.budget = minutes;
+      else extras.budgetError = `"${match[2]}" is not a time budget (try 90m, 1h or 1h30m)`;
+    }
+    trimmed = trimmed.slice(match[0].length);
+  }
+  if (flagged) return { sub: undefined, rest: [], restText: trimmed.trim(), ...extras };
   const [sub, ...rest] = trimmed.split(/\s+/).filter(Boolean);
   if (!sub || !SUBCOMMANDS.has(sub)) return { sub: undefined, rest: [], restText: trimmed };
   const takesArgs = sub === "amend" || sub === "claim"
     || (sub === "auto" && rest.length === 1 && /^(on|off)$/i.test(rest[0]!))
+    || (sub === "budget" && rest.length >= 1 && rest.length <= 2 && (/^off$/i.test(rest[0]!) || parseMinutes(rest.join("")) !== undefined))
     || (sub === "start-plan" && rest.length >= 1 && rest.length <= 2 && /^PLAN-/.test(rest[0]!) && (rest.length === 1 || rest[1] === "auto"))
     || (sub === "switch" && rest.length >= 1 && /\.jsonl$/.test(rest.join(" ")));
   if (!takesArgs && rest.length > 0 && !(rest.length === 1 && isTaskId(rest[0]))) {
@@ -87,7 +118,9 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
     broken.length > 0 ? `Unreadable task state: ${broken.join(", ")}` : "",
   ].filter(Boolean).join("\n");
   const footer = knowledge ? `\n${knowledge}` : "";
-  ctx.ui.notify(task ? `${describeTask(task)}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
+  const budget = task ? readBudget(root, configDir, task.id) : undefined;
+  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : "";
+  ctx.ui.notify(task ? `${describeTask(task)}${time}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
 /** Recent runs of the active (or named) task, newest last, so slow models are easy to spot. */
@@ -175,6 +208,52 @@ function answerProposal(
   }
 }
 
+/**
+ * `/bot-lobby accept [taskId]`: the user accepts a task's work as it stands,
+ * without a QA pass (QA keeps asking for more, and the user has seen enough).
+ * The gate is waived and blockers cleared; the oracle is asked to complete it.
+ */
+function acceptWork(pi: ExtensionAPI, ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const sessionId = ctx.sessionManager.getSessionId();
+  const task = selectTask(root, configDir, taskId, sessionId);
+  if (!task || TERMINAL_STATES.includes(task.state)) return ctx.ui.notify("bot-lobby: no active task to accept.", "warning");
+  if (task.ownerSessionId && task.ownerSessionId !== sessionId) {
+    return ctx.ui.notify(`${task.id} is owned by another pi session; accept it there, or /bot-lobby claim ${task.id} first.`, "warning");
+  }
+  if (!["implementing", "reviewing", "blocked"].includes(task.state)) {
+    return ctx.ui.notify(`bot-lobby: ${task.id} is still ${task.state}; there is no work to accept yet.`, "warning");
+  }
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, lastQaAsks(task), "with /bot-lobby accept");
+  saveTask(root, configDir, task);
+  applyStatus(ctx, root, configDir);
+  ctx.ui.notify(`bot-lobby: ${task.id} accepted as it is; the oracle will complete it.`, "info");
+  const message = `The user accepted ${task.id}'s work as it is (the QA gate is waived). Call orchestrate action=complete now with a short summary that names anything QA still asked for.`;
+  pi.sendUserMessage(message, ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+}
+
+/**
+ * `/bot-lobby budget [time|off]`: show, set or remove the time budget of this
+ * session's task. Time already spent is kept; the oracle sees the change on
+ * its next step.
+ */
+function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
+  if (!task) return ctx.ui.notify("bot-lobby: no active task in this session — a time budget applies to a task (start one with /bot-lobby --budget 90m <request>)", "warning");
+  if (!value) {
+    const budget = readBudget(root, configDir, task.id);
+    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
+  }
+  const minutes = /^off$/i.test(value) ? 0 : parseMinutes(value);
+  if (minutes === undefined) return ctx.ui.notify(`bot-lobby: "${value}" is not a time budget (try 90m, 1h or 1h30m)`, "warning");
+  const budget = setBudget(root, configDir, task.id, minutes);
+  // Set while the oracle works: its clock runs from now, not from its next turn.
+  if (budget && !ctx.isIdle()) startClock(root, configDir, task.id);
+  applyStatus(ctx, root, configDir);
+  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
+}
+
 function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const cfg = loadConfig();
@@ -236,13 +315,14 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, budget, budgetError } = parseCommand(args ?? "");
+      if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
         if (!restText) {
           if (!showLobby()) ctx.ui.notify(HELP, "info");
           return;
         }
-        if (await startTask(pi, ctx, configDir, restText, auto ? { auto } : {})) autoOpenLobby();
+        if (await startTask(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}) })) autoOpenLobby();
         return;
       }
       switch (sub) {
@@ -269,6 +349,10 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return answerProposal(ctx, configDir, "amend", restText);
         case "decline":
           return answerProposal(ctx, configDir, "decline");
+        case "accept":
+          return acceptWork(pi, ctx, configDir, rest[0]);
+        case "budget":
+          return budgetCommand(ctx, configDir, rest.join(""));
         case "knowledge":
           return showKnowledge(ctx, configDir);
         case "settings":

package/src/pi/events.ts

@@ -9,19 +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 {
@@ -46,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);
@@ -64,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();
@@ -92,9 +122,21 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   pi.on("before_agent_start", (event, ctx) => {
     const root = detectProjectRoot(ctx.cwd, configDir);
     const sessionId = ctx.sessionManager.getSessionId();
-    const task = isSubagentProcess() || isMinimized() ? undefined : activeTask(root, configDir, sessionId);
+    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) {
-      delete event.systemPromptOptions.sections["bot-lobby"];
+      // 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);
+      if (previous) event.systemPromptOptions.sections["bot-lobby"] = previous;
+      else delete event.systemPromptOptions.sections["bot-lobby"];
       return;
     }
     const slices = readAgentKnowledge(readDataRoots(root, configDir), "master");
@@ -105,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/fresh-context.ts

@@ -0,0 +1,134 @@
+/**
+ * A clean slate for the oracle at every task. The session keeps its whole
+ * conversation (the lobby, /tree and /resume still show all of it), but the
+ * model is sent only what came after the latest task boundary: a task
+ * starting in this session, or this session's task ending. So one long
+ * session no longer carries every past task into every call; the task in
+ * hand reaches the oracle through bot-lobby's system prompt section and its
+ * task folder, which do not depend on the conversation.
+ *
+ * A boundary is a custom entry in the session file, which is never sent to
+ * the model: it survives /resume and belongs to the branch it was made on.
+ * Subagents (scouts, workers, reviewers, the planning panel, quick fixes)
+ * already run as pi processes of their own, each with its own context, and
+ * are not touched here.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { relative } from "node:path";
+import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+import { peekTasks, taskDirFor } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { CLEARED_NOTE, CONTEXT_MARK, lobbyFeed } from "../lobby/feed.ts";
+import { isSubagentProcess } from "./quiet.ts";
+
+export { CLEARED_NOTE, CONTEXT_MARK };
+
+export interface ContextMark {
+  kind: "start" | "end";
+  taskId: string;
+  /** Messages from this time on (ms) are what the model is sent. */
+  at: number;
+}
+
+/** The boundaries on a session branch, oldest first. */
+export function contextMarks(entries: readonly unknown[]): ContextMark[] {
+  const marks: ContextMark[] = [];
+  for (const entry of entries) {
+    const mark = asMark(entry);
+    if (mark) marks.push(mark);
+  }
+  return marks;
+}
+
+/** A session entry as a boundary, when it is one. */
+export function asMark(entry: unknown): ContextMark | undefined {
+  const record = entry as { type?: string; customType?: string; data?: Partial<ContextMark> } | undefined;
+  if (record?.type !== "custom" || record.customType !== CONTEXT_MARK) return undefined;
+  const data = record.data;
+  if (!data || typeof data.at !== "number" || typeof data.taskId !== "string" || (data.kind !== "start" && data.kind !== "end")) return undefined;
+  return { kind: data.kind, taskId: data.taskId, at: data.at };
+}
+
+/** Replies and tool results answer what came before them, so what the model is sent never opens with one. */
+const ANSWERS = new Set(["assistant", "toolResult"]);
+
+/**
+ * The messages from the boundary on: from the first one at or after it that
+ * can open a conversation (a request, a summary, an extension's message).
+ * All of them when nothing has come since the boundary (a task that ended
+ * mid-run still gets its closing turn).
+ */
+export function fromBoundary<T extends { role: string; timestamp?: number }>(messages: T[], boundary: number | undefined): T[] {
+  if (boundary === undefined) return messages;
+  const start = messages.findIndex((message) => typeof message.timestamp === "number" && message.timestamp >= boundary && !ANSWERS.has(message.role));
+  return start <= 0 ? messages : messages.slice(start);
+}
+
+/** Whether the oracle starts clean at each task (`workflow.freshContext`, on by default). */
+export function freshContextOn(): boolean {
+  return loadConfig().workflow.freshContext;
+}
+
+/** Record a boundary in this session. */
+export function markContext(pi: ExtensionAPI, mark: ContextMark): void {
+  pi.appendEntry<ContextMark>(CONTEXT_MARK, mark);
+  if (mark.kind === "end") lobbyFeed.say("note", CLEARED_NOTE, mark.at);
+}
+
+/** The session's newest task: the one its conversation was last about. */
+function lastTask(ctx: ExtensionContext, configDir: string): Task | undefined {
+  const sessionId = ctx.sessionManager.getSessionId();
+  return peekTasks(detectProjectRoot(ctx.cwd, configDir), configDir).find((task) => task.ownerSessionId === sessionId);
+}
+
+/** Close the session's task once it has ended (completed or abandoned): the next request starts clean. */
+export function closeEndedTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, now = Date.now()): boolean {
+  if (isSubagentProcess() || !freshContextOn()) return false;
+  const task = lastTask(ctx, configDir);
+  if (!task || !TERMINAL_STATES.includes(task.state)) return false;
+  if (contextMarks(ctx.sessionManager.getBranch()).some((mark) => mark.kind === "end" && mark.taskId === task.id)) return false;
+  markContext(pi, { kind: "end", taskId: task.id, at: now });
+  return true;
+}
+
+/**
+ * The note bot-lobby's system prompt section carries after a task ended and
+ * cleared the context: which task it was and where its record is, for when
+ * the user refers back to it.
+ */
+export function previousTaskNote(ctx: ExtensionContext, configDir: string): string | undefined {
+  if (!freshContextOn()) return undefined;
+  const last = contextMarks(ctx.sessionManager.getBranch()).at(-1);
+  if (last?.kind !== "end") return undefined;
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = peekTasks(root, configDir).find((entry) => entry.id === last.taskId);
+  if (!task) return undefined;
+  const record = relative(ctx.cwd, taskDirFor(root, configDir, task.id)) || ".";
+  return [
+    `Your previous task, ${task.id} "${task.title}", ended (${task.state}). Its conversation was cleared from your context so the next piece of work starts fresh.`,
+    `Its record (request, proposal, plan, decisions, runs) is in ${record}/. Read it only if the user refers back to that task.`,
+  ].join("\n");
+}
+
+/** Trim what the oracle is sent to its latest boundary, and close tasks as they end. */
+export function registerFreshContext(pi: ExtensionAPI, configDir: string): void {
+  if (isSubagentProcess()) return;
+  pi.on("context", (event, ctx) => {
+    if (!freshContextOn()) return undefined;
+    const boundary = contextMarks(ctx.sessionManager.getBranch()).at(-1)?.at;
+    const messages = fromBoundary(event.messages, boundary);
+    return messages.length === event.messages.length ? undefined : { messages };
+  });
+  // A task's last turn is over: whatever is asked next starts clean.
+  pi.on("agent_end", (_event, ctx) => void closeEndedTask(pi, ctx, configDir));
+  // It may have ended while the oracle was idle (abandoned or archived from the lobby, finished in another window).
+  pi.on("before_agent_start", (_event, ctx) => void closeEndedTask(pi, ctx, configDir));
+  // Compacting a conversation the next request drops anyway would only cost a model call.
+  pi.on("session_before_compact", (event) => {
+    if (event.reason === "manual" || !freshContextOn()) return undefined;
+    const last = contextMarks(event.branchEntries).at(-1);
+    if (!last) return undefined;
+    const since = event.branchEntries.some((entry) => entry.type === "message" && Date.parse(entry.timestamp) >= last.at);
+    return since ? undefined : { cancel: true };
+  });
+}

package/src/pi/owner.ts

@@ -10,7 +10,7 @@
 import type { KeyId } from "@earendil-works/pi-tui";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
-import { activeTask, loadTask } from "../state/persistence.ts";
+import { peekOwnedTask } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { commentMessage, markCommentsDelivered, readPlanComments, undeliveredComments } from "../state/comments.ts";
 import { inboxMessage, markInboxDelivered, markSessionInboxDelivered, readInbox, readSessionInbox } from "../state/inbox.ts";
@@ -42,6 +42,8 @@ interface Owner {
   configDir: string;
   timer?: ReturnType<typeof setInterval>;
   auto?: AutoTrack;
+  /** The session's task as this tick read it: one read serves the whole tick. */
+  tick?: { task: Task | undefined };
 }
 
 let owner: Owner | undefined;
@@ -53,7 +55,8 @@ export function onOwnerEvent(fn: ((event: OwnerEvent) => void) | undefined): voi
 }
 
 function ownTask(state: Owner): Task | undefined {
-  return activeTask(state.root, state.configDir, state.ctx.sessionManager.getSessionId());
+  if (state.tick) return state.tick.task;
+  return peekOwnedTask(state.root, state.configDir, state.ctx.sessionManager.getSessionId());
 }
 
 function live(task: Task | undefined): task is Task {
@@ -68,8 +71,7 @@ export function deliverComments(): number {
   if (!live(task) || task.paused) return 0;
   const fresh = undeliveredComments(readPlanComments(state.root, state.configDir, task.id));
   if (fresh.length === 0) return 0;
-  const current = loadTask(state.root, state.configDir, task.id) ?? task;
-  state.pi.sendUserMessage(commentMessage(task.id, fresh, Boolean(current.plan)), state.ctx.isIdle() ? undefined : { deliverAs: "steer" });
+  state.pi.sendUserMessage(commentMessage(task.id, fresh, Boolean(task.plan)), state.ctx.isIdle() ? undefined : { deliverAs: "steer" });
   markCommentsDelivered(state.root, state.configDir, task.id, fresh.map((comment) => comment.id));
   listener?.({ kind: "comments", taskId: task.id, count: fresh.length });
   return fresh.length;
@@ -211,11 +213,18 @@ export function toggleOwnAuto(): string {
 
 /** One tick of the owner's clock. */
 export function ownerTick(): void {
-  heartbeat();
-  deliverComments();
-  deliverInbox();
-  deliverSessionInbox();
-  driveAuto();
+  const state = owner;
+  if (!state) return;
+  state.tick = { task: ownTask(state) };
+  try {
+    heartbeat();
+    deliverComments();
+    deliverInbox();
+    deliverSessionInbox();
+    driveAuto();
+  } finally {
+    state.tick = undefined;
+  }
 }
 
 function stop(): void {
@@ -254,7 +263,7 @@ export function registerOwner(pi: ExtensionAPI, configDir: string): void {
   // Auto mode has nobody to answer a question: tell the oracle to decide instead.
   pi.on("tool_call", (event, ctx) => {
     if (event.toolName !== "ask_user_question" || !owner) return undefined;
-    const task = activeTask(owner.root, owner.configDir, ctx.sessionManager.getSessionId());
+    const task = peekOwnedTask(owner.root, owner.configDir, ctx.sessionManager.getSessionId());
     if (!live(task) || !isAutoMode(owner.root, owner.configDir, task.id)) return undefined;
     return { block: true, reason: `Auto mode is on for ${task.id}: nobody will answer. Decide this yourself from the request, the plan and your reconnaissance, record the decision, and continue.` };
   });

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

@@ -15,6 +15,8 @@ import { applyMasterModel } from "./settings-ui.ts";
 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);
@@ -24,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,",
@@ -51,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> {
@@ -70,14 +75,18 @@ 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);
   applyStatus(ctx, root, configDir);
   await applyMasterModel(pi, ctx, loadConfig());
   ctx.ui.notify(`bot-lobby ${task.id} started`, "info");
+  // 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;
 }