@a-t-h-i/bot-lobby 0.6.35 → 0.6.37

package/README.md

@@ -36,6 +36,11 @@ you to confirm merging and pushing main, then removes its worktree after verifyi
 Declining or failed verification keeps the worktree. Delivery can also be reviewed in **Tasks**,
 where you can create a PR instead. The task branch is kept.
 
+New tasks get a short title summarizing the full request, which also names their branch and
+session. Naming uses low reasoning on `classifier.effort.cheapModel` when configured, otherwise
+the session model. If naming fails or takes more than eight seconds, the request's first content
+words are used. Tasks started from an agreed plan keep that plan's title.
+
 After every worker step, before QA and at completion, the engine runs the project's own linter
 (ESLint, Biome, Oxlint, Ruff, or a command you set) on the files the task touched. Only problems on
 changed lines count, and QA judges any lint suppression a worker adds. **Settings → Linting** sets it
@@ -126,25 +131,33 @@ are kept in `themes.json` beside it, so every Pi session and project shows them.
 project knowledge stay in `.pi/bot-lobby/` inside your project.
 
 
-Requires **Pi 1.0.x** (1.0.1 or later). Every bot-lobby agent can use
-`delegate_subtasks` for substantial, separable work. Each parent gets five child
-slots total, shared across retries; children inherit its model, thinking, role,
+Requires **Pi 1.0.x** (1.0.1 or later). DEV and DESIGN workers and QA reviewers can use
+`delegate_subtasks` for useful, separable work. Delegation is optional. Each parent gets five child
+slots total, shared across retries; Jev selects each child’s model and reasoning effort from its brief, lowering
+inference for simple work and raising reasoning for complex work on the configured
+model. Children inherit the parent’s role,
 permissions, worktree and remaining time. Children report to their parent, which
 integrates and verifies the result. Children cannot delegate further. Active
 children share `workflow.maxParallelWorkers`; waiting parents do not use those
 child slots. Cancelling or finishing a parent stops its children and releases
 their file claims. Full reports are saved under `.pi/bot-lobby/delegations/`.
 
-Active task steps show the parent and active worker children, for example
+Every assignment has a 15-minute total allowance (or its shorter configured limit),
+including startup, tools, retries, children, compaction and reporting. Per-step
+allowances persist across reassignments; only the user can extend them, including
+in auto mode. Waiting for user answers pauses clocks.
+
+The conversation pane groups running agents beneath their current step, for example
 **Step 6 – Implement large feature (6 devs working)**. Queued and finished agents
 are excluded. A child finishing does not complete a checklist step.
 
 The oracle, agents and children compact at settled turn boundaries before context
-reaches 250,000 estimated tokens, or earlier at 80% of the model window or Pi's
+reaches 64,000 estimated tokens, or earlier at 60% of the model window or Pi's
 native reserve threshold. Recent messages and summaries retain unfinished work;
 raw session history remains available. A failed summary leaves context intact.
-The boundary gives headroom below 300,000 tokens; a single very large input or tool
-result can temporarily exceed it before the next boundary.
+Checkpoints preserve constraints, decisions, changed files, verification, failed
+approaches, and next actions. A single large input can exceed the threshold before
+the next settled boundary.
 
 Pi's native MCP, `tool_search` and `codemode` are available. **MCP tools** in each
 agent's Settings entry grants exact tool names, one per line, such as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.35",
+  "version": "0.6.37",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/master.md

@@ -282,6 +282,13 @@ Every delegation costs a full agent run, so keep the loop short:
 
 ## Time budget
 
+Every assignment has at most 15 minutes total, or its shorter configured limit,
+including retries, children, tools, compaction and reporting. Step allowances
+persist across reassignments: name the plan step explicitly, and do not reword
+or split an exhausted step to reset its clock. Only the user can extend it,
+including in auto mode. Return an unfinished report when time is spent; stop
+repeating failed approaches. Waiting for the user pauses clocks.
+
 When the task has a time budget (your context says how much is used and
 left), it covers everyone: you, scouts, workers and the QA gate. The clock
 runs while you work and stops while you wait on the user.

package/src/classifier/effort.ts

@@ -30,9 +30,9 @@ export interface RunProfileLike {
 }
 
 export interface EffortRoute extends RunProfileLike {
-  level: "trivial" | "simple";
+  level: EffortLevel;
   confidence: number;
-  /** The configured profile the route came down from. */
+  /** The configured profile before routing. */
   from: RunProfileLike;
 }
 
@@ -109,6 +109,8 @@ export interface EffortScore {
 
 /** Lowers the model or thinking of a step the classifier judges simple or trivial. */
 export interface EffortRouter {
+  /** Children may raise reasoning for complex work, using the parent's configured model. */
+  childRoute?(instruction: string, profile: RunProfileLike, options?: { context?: string; signal?: AbortSignal }): Promise<EffortRoute | undefined>;
   /** Score a step and plan its route in one go. */
   route(instruction: string, profile: RunProfileLike, options?: { thinkingFixed?: boolean; context?: string; signal?: AbortSignal }): Promise<EffortRoute | undefined>;
   /** Score a step once (several agents may share it)… */
@@ -119,6 +121,16 @@ export interface EffortRouter {
 
 export function effortRouter(classifier: Classifier, deps: { clamp?: RouteOptions["clamp"]; log?: (text: string) => void } = {}): EffortRouter {
   const router: EffortRouter = {
+    async childRoute(instruction, profile, options = {}) {
+      const scored = await router.score(instruction, options);
+      if (!scored) return undefined;
+      if (scored.level !== "complex" || scored.confidence < classifier.config.thresholds.simpleAt) return router.plan(scored, profile);
+      const thinking = profile.model && deps.clamp ? deps.clamp(profile.model, "max") : rank(profile.thinking) > rank("high") ? profile.thinking : "high";
+      if (thinking === profile.thinking) return undefined;
+      const route: EffortRoute = { ...profile, thinking, level: scored.level, confidence: scored.confidence, from: { ...profile } };
+      deps.log?.(`routed child ${routeLabel(route)}`);
+      return route;
+    },
     async score(instruction, options = {}) {
       if (!classifier.enabled("effort")) return undefined;
       return scoreEffort(classifier, instruction, options.context, options.signal);

package/src/execution/agent-runner.ts

@@ -8,6 +8,8 @@ import { EditLog } from "../state/changes.ts";
 import { formatMinutes, REPORT_GRACE_MS } from "../state/budget.ts";
 import { runPiAgent, spawnPiProcess, type ProcessRunner, type RelayAsk } from "./pi-runner.ts";
 import { ASK_ENV } from "../ask/relay.ts";
+import { STEP_LIMIT_MS } from "../state/step-limits.ts";
+import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
 import { ASK_TOOL } from "../ask/types.ts";
 import { agentOfRun, grantOption } from "../excalidraw/sessions.ts";
 
@@ -22,7 +24,7 @@ export interface AgentContext {
 }
 
 /** Live fields a caller (the file desk) may set on a running agent. */
-export type LivePatch = Pick<AgentRun, "note" | "noteKind" | "waitingFor">;
+export type LivePatch = Pick<AgentRun, "note" | "noteKind" | "waitingFor" | "model" | "thinking" | "route" | "routedFrom">;
 
 /** Control over one running attempt, handed to `onStart`. */
 export interface AgentHandle {
@@ -35,6 +37,8 @@ export interface AgentRequest {
   taskId: string;
   domain: Domain;
   role: Role;
+  effort?: EffortRouter;
+  effortProfile?: RunProfileLike;
   /** Concrete instruction sent as the subagent's task message. */
   instruction: string;
   /** Prompt layers selected for this run. */
@@ -78,6 +82,10 @@ export interface AgentRequest {
  * (the engine asking the user) grants more, and the same agent carries on.
  */
 export interface AgentTime {
+  /** Active time shared across attempts and model fallbacks. */
+  usedMs?: number;
+  /** Include reporting in the hard allowance. */
+  strict?: boolean;
   /** When the delegation's time runs out (epoch ms); moved out when more is granted, shared by retries and re-runs. */
   endsAt: number;
   /** The allotment, as the agent and the lobby see it. */
@@ -108,6 +116,11 @@ export function carryOnMessage(extraMs: number): string {
 /** Least time an attempt starts with; a retry with less than this left is not started. */
 const MIN_ATTEMPT_MS = 60_000;
 
+export function boundedAgentTime(timeoutMs: number): AgentTime {
+  const allotMs = Math.min(STEP_LIMIT_MS, timeoutMs);
+  return { endsAt: Date.now() + allotMs, allotMs, strict: true };
+}
+
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
 export function watchdogOptions(workflow: {
   maxAgentRetries: number;
@@ -137,7 +150,19 @@ function retryable(run: AgentRun): boolean {
  * and a slow agent cannot double its time budget.
  */
 export async function runAgent(request: AgentRequest, run: ProcessRunner = spawnPiProcess): Promise<AgentRun> {
+  request.time ??= boundedAgentTime(request.timeoutMs);
+  if (!request.time.strict) {
+    request.time.endsAt = Math.min(request.time.endsAt, Date.now() + Math.min(STEP_LIMIT_MS, request.timeoutMs));
+    request.time.allotMs = Math.min(request.time.allotMs, STEP_LIMIT_MS, request.timeoutMs);
+    request.time.strict = true;
+  }
+  request.time.usedMs ??= Math.max(0, request.time.allotMs - (request.time.endsAt - Date.now()));
   const startedAt = new Date().toISOString();
+  if (request.time.endsAt <= Date.now()) {
+    const stopped: AgentRun = { ...baseRun(request, `${request.taskId}:${randomUUID()}`, startedAt), status: "timeout", error: "The assignment's shared time limit is spent; request user-approved time before continuing.", finishedAt: startedAt, timeUp: true };
+    request.onUpdate?.(stopped);
+    return stopped;
+  }
   const attempts = Math.max(1, (request.retries ?? 0) + 1);
   // A failed attempt may have edited files before the retry: the run owns every edit.
   const edits = new EditLog(request.cwd);
@@ -193,21 +218,36 @@ function toolsFor(request: AgentRequest): readonly string[] | undefined {
 async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt: number, startedAt: string, edits: EditLog, quota: { used: number }): Promise<AgentRun> {
   const base = baseRun(request, `${request.taskId}:${request.domain}:${request.role}:${randomUUID()}`, startedAt, attempt);
   request.onUpdate?.(base);
-  const live = createLiveRun(base, request, edits);
+  const time = request.time!;
+  const attemptStart = Date.now();
+  let pausedMs = 0;
+  let asking = 0;
+  let askStarted = 0;
+  let expired = false;
+  const elapsed = () => Math.max(0, Date.now() - attemptStart - pausedMs - (asking ? Date.now() - askStarted : 0));
+  const live = createLiveRun(base, { ...request, onUpdate: (update) => request.onUpdate?.({ ...update, activeMs: (time.usedMs ?? 0) + elapsed(), endsAt: time.endsAt }) }, edits);
 
   const controller = new AbortController();
   activeControllers.add(controller);
   const signal = request.signal ? AbortSignal.any([request.signal, controller.signal]) : controller.signal;
+  let deadline: ReturnType<typeof setTimeout>;
+  const arm = () => {
+    clearTimeout(deadline);
+    deadline = setTimeout(() => { expired = true; controller.abort(new Error("Assignment time limit reached")); }, Math.max(0, time.endsAt - Date.now()));
+  };
+  arm();
   try {
     const systemPrompt = compilePrompt({ domain: request.domain, role: request.role, ...request.context });
-    const time = request.time;
-    const left = time ? Math.max(MIN_ATTEMPT_MS, time.endsAt - Date.now()) : 0;
-    const wrapUp = time ? 0 : request.wrapUpAt && request.wrapUpAt > 0 && request.wrapUpAt < 1 ? Math.floor(request.timeoutMs * request.wrapUpAt) : 0;
+    const left = Math.max(1, time.endsAt - Date.now());
+    const reportMs = Math.min(REPORT_GRACE_MS, Math.floor(left / 4));
+    const wrapUp = Math.floor(left * (request.wrapUpAt || 0.75));
     const onTimeUp = time?.onTimeUp;
     const result = await runPiAgent({
       cwd: request.cwd,
       agent: { runId: base.runId, taskId: request.taskId, domain: request.domain, role: request.role },
       delegationQuota: quota,
+      effort: request.effort,
+      effortProfile: request.effortProfile,
       onChildRun: (child) => {
         for (const path of child.edited ?? []) edits.note("edit", { path });
         request.onUpdate?.(child);
@@ -218,21 +258,28 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       tools: toolsFor(request),
       model: request.model,
       thinking: request.thinking,
-      timeoutMs: time ? left + REPORT_GRACE_MS : request.timeoutMs,
+      timeoutMs: left,
       ...(time ? {
         time: {
-          upAtMs: left,
+          hardLimit: true,
+          upAtMs: Math.max(1, left - reportMs),
           headsUpAtMs: left >= 4 * 60_000 ? Math.floor(left * 0.75) : 0,
           headsUpMessage: headsUpMessage(left - Math.floor(left * 0.75), time.allotMs),
-          upMessage: timeUpMessage(time.allotMs, Boolean(onTimeUp)),
-          graceMs: REPORT_GRACE_MS,
+          upMessage: `bot-lobby: your shared step allowance is nearly spent. Start nothing new; finish or revert the edit in progress and report completed work, verification, failed approaches, blockers, and the next action now.${onTimeUp ? " Include ## Left Off and ## More Time (minutes and reason). Only the user can grant more time." : ""}`,
+          graceMs: reportMs,
           ...(onTimeUp ? {
             onTimeUp: async (report: string) => {
-              const extraMs = await onTimeUp(live.current(), report);
+              clearTimeout(deadline);
+              const waiting = Date.now();
+              let extraMs: number;
+              try { extraMs = await onTimeUp(live.current(), report); }
+              finally { pausedMs += Date.now() - waiting; }
+              time.endsAt += Date.now() - waiting;
               if (extraMs > 0) {
                 time.endsAt = Date.now() + extraMs;
                 live.annotate({ note: `given ${formatMinutes(extraMs)} more`, noteKind: "info" });
               }
+              arm();
               return { extraMs, message: carryOnMessage(extraMs) };
             },
           } : {}),
@@ -245,30 +292,42 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       stallTimeoutMs: request.stallTimeoutMs,
       toolStallTimeoutMs: request.toolStallTimeoutMs,
       wrapUpAtMs: wrapUp,
-      onEvent: live.onEvent,
+      onEvent: (event) => {
+        if (event.type === "asking") { if (!asking) askStarted = Date.now(); asking += 1; clearTimeout(deadline); }
+        if (event.type === "answered") { asking = 0; pausedMs += event.waitedMs; }
+        live.onEvent(event);
+        if (event.type === "answered" && asking === 0) arm();
+      },
       onStart: (handle) => request.onStart?.({ runId: base.runId, steer: handle.steer, annotate: live.annotate }),
     }, run);
     const current = live.current();
     const final: AgentRun = {
       ...base,
-      status: result.status,
+      status: expired ? "timeout" : result.status,
       output: result.output,
-      error: result.error ? describeError(result.error, current, result.stalled === true) : undefined,
+      error: expired ? describeError("hit the shared assignment time limit", current, false) : result.error ? describeError(result.error, current, result.stalled === true) : undefined,
       usage: result.usage,
       finishedAt: new Date().toISOString(),
+      activeMs: (time.usedMs ?? 0) + elapsed(),
       turns: current.turns ?? (result.usage.turns || undefined),
       tools: current.tools,
       model: result.model ?? current.model,
       ...(result.stalled ? { stalled: true } : {}),
       ...(result.wrappedUp ? { wrappedUp: true } : {}),
-      ...(result.timeUp ? { timeUp: true } : {}),
+      ...(result.timeUp || expired ? { timeUp: true } : {}),
       ...(result.extendedMs ? { extendedMs: result.extendedMs } : {}),
       note: undefined,
       noteKind: undefined,
     };
     request.onUpdate?.(final);
     return final;
+  } catch (error) {
+    const final: AgentRun = { ...live.current(), status: expired ? "timeout" : signal.aborted ? "cancelled" : "failed", error: (error as Error).message, activeMs: (time.usedMs ?? 0) + elapsed(), edited: edits.list(), finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined, ...(expired ? { timeUp: true } : {}) };
+    request.onUpdate?.(final);
+    return final;
   } finally {
+    clearTimeout(deadline!);
+    time.usedMs = (time.usedMs ?? 0) + elapsed();
     activeControllers.delete(controller);
   }
 }

package/src/execution/delegation.ts

@@ -5,6 +5,9 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
 import type { AgentRun } from "../schemas/findings.ts";
+import type { Domain, Role } from "../schemas/agent.ts";
+import { effortFor } from "../classifier/instance.ts";
+import { fellShort, profileLabel, routeLabel } from "../classifier/effort.ts";
 import { agentProfile } from "../schemas/configuration.ts";
 import { dataRoot, detectProjectRoot, loadConfig } from "../state/project.ts";
 import { EditLog } from "../state/changes.ts";
@@ -18,6 +21,13 @@ export const DELEGATE_TOOL = "delegate_subtasks";
 export const AGENT_ENV = "BOT_LOBBY_AGENT_POLICY";
 export const DELEGATION_ENV = "BOT_LOBBY_DELEGATION";
 
+/** Only DESIGN/DEV workers and the QA gate may spawn children. */
+export function canDelegate(agent: { role: Role; domain: Domain; depth?: number }, quotaUsed: number): boolean {
+  if ((agent.depth ?? 1) !== 1 || quotaUsed >= MAX_CHILDREN) return false;
+  if (agent.role === "worker") return agent.domain === "designer" || agent.domain === "backend";
+  return agent.role === "reviewer" && agent.domain === "qa";
+}
+
 /** One shared child pool per task; parents waiting on children never hold its slots. */
 const pools = new Map<string, { active: number; users: number; waiters: Array<() => void> }>();
 
@@ -63,7 +73,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   const agent = options.agent ?? { runId: id, taskId: id, domain: "backend" as const, role: editable ? "worker" as const : "reviewer" as const };
   const depth = agent.depth ?? 1;
   const quota = options.delegationQuota ?? { used: 0 };
-  const tools = [...new Set([...baseTools, ...(options.excalidraw ? toolsOf(options.excalidraw) : []), "codemode", "tool_search", ...(depth === 1 ? [DELEGATE_TOOL] : [])])];
+  const tools = [...new Set([...baseTools, ...(options.excalidraw ? toolsOf(options.excalidraw) : []), "codemode", "tool_search", ...(canDelegate(agent, quota.used) ? [DELEGATE_TOOL] : [])])];
   const mcpTools = options.mcpTools ?? agentProfile(config, agent.domain, agent.role).mcpTools ?? [];
   const policy: AgentPolicy = { tools, mcpTools, readOnly: !editable, depth };
   if (depth > 1) return { tools, env: { ...options.env, [AGENT_ENV]: JSON.stringify(policy), [DELEGATION_ENV]: "" }, note: "You are a child agent. Finish only your assigned brief and report evidence to your parent; you cannot delegate further.", close: async () => {}, onStart: options.onStart, children: [] as AgentRun[] };
@@ -100,17 +110,26 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
 
   const childRun = async (brief: string, signal: AbortSignal): Promise<AgentRun> => {
     const childId = randomUUID();
-    const base: AgentRun = { runId: childId, parentRunId: id, depth: 2, taskId: agent.taskId, domain: agent.domain, role: agent.role, instruction: brief, stepInstruction: options.task, status: "running", output: "", attempts: 1, startedAt: new Date().toISOString(), ...(options.thinking ? { thinking: options.thinking } : {}) };
+    const base: AgentRun = { runId: childId, parentRunId: id, depth: 2, taskId: agent.taskId, domain: agent.domain, role: agent.role, instruction: brief, stepInstruction: options.task, status: "running", endsAt: deadlineAt, output: "", attempts: 1, startedAt: new Date().toISOString(), ...(options.thinking ? { thinking: options.thinking } : {}) };
     const edits = new EditLog(options.cwd);
     const live = createLiveRun(base, { onUpdate: update, timeoutMs: options.timeoutMs }, edits);
     update(base);
     try {
-      const left = deadlineAt - Date.now();
-      if (left <= 0) throw new Error("The parent's time is up.");
-      const result = await runPiAgent({
+      const configured = options.effortProfile ?? { model: options.model, thinking: options.thinking ?? "medium" };
+      const effort = options.effort ?? effortFor();
+      const route = await effort.childRoute?.(brief, configured, { context: options.task, signal }).catch(() => undefined);
+      const attempt = async (model: string | undefined, thinking: string) => {
+        const left = deadlineAt - Date.now();
+        signal.throwIfAborted();
+        if (left <= 0) throw new Error("The parent's time is up.");
+        const routed = route && model === route.model && thinking === route.thinking;
+        live.annotate({ model, thinking, route: routed ? routeLabel(route) : undefined, routedFrom: routed ? profileLabel(route.from) : undefined, note: routed ? routeLabel(route) : undefined, noteKind: "info" });
+        return runPiAgent({
         ...options,
         agent: { ...agent, runId: childId, depth: 2 },
         task: brief,
+        model,
+        thinking,
         tools: [...new Set([...tools.filter((tool) => tool !== DELEGATE_TOOL), ...(desk ? DESK_TOOLS : [])])],
         mcpTools,
         timeoutMs: left,
@@ -123,11 +142,18 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
         env: { ...options.env, ...(desk ? desk.env(childId) : {}) },
         onStart: (handle) => desk?.attach(childId, { runId: childId, steer: handle.steer, annotate: live.annotate }),
       }, run);
-      const final: AgentRun = { ...live.current(), ...result, edited: edits.list(), finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined };
+      };
+      let result = await attempt(route?.model ?? configured.model, route?.thinking ?? configured.thinking);
+      let retried = false;
+      if (route && (route.level === "simple" || route.level === "trivial") && fellShort(result) && !signal.aborted && deadlineAt - Date.now() >= 60_000) {
+        retried = true;
+        result = await attempt(configured.model, configured.thinking);
+      }
+      const final: AgentRun = { ...live.current(), ...result, thinking: retried ? configured.thinking : route?.thinking ?? configured.thinking, attempts: retried ? 2 : 1, ...(route && !retried ? { route: routeLabel(route), routedFrom: profileLabel(route.from) } : {}), edited: edits.list(), finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined };
       update(final);
       return final;
     } catch (error) {
-      const final: AgentRun = { ...live.current(), edited: edits.list(), status: signal.aborted ? "cancelled" : "failed", error: (error as Error).message, finishedAt: new Date().toISOString() };
+      const final: AgentRun = { ...live.current(), edited: edits.list(), status: Date.now() >= deadlineAt ? "timeout" : signal.aborted ? "cancelled" : "failed", error: (error as Error).message, finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined };
       update(final);
       return final;
     } finally {
@@ -165,7 +191,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   return {
     tools: desk ? [...new Set([...tools, ...DESK_TOOLS])] : tools,
     env: { ...options.env, ...(desk ? desk.env(parentDeskId) : {}), [AGENT_ENV]: JSON.stringify({ ...policy, tools: desk ? [...new Set([...tools, ...DESK_TOOLS])] : tools }), [DELEGATION_ENV]: JSON.stringify({ address: server.address, token, timeoutMs: options.timeoutMs }) },
-    note: `For substantial, separable work, use ${DELEGATE_TOOL} with complete briefs (goal, files, contracts, constraints, done criteria). You have at most five children total; children cannot delegate. Integrate and verify their work yourself. Use codemode for concise parallel calls, inspect failures, and return only useful evidence.${desk ? " Before edit/write, claim_file; handover_file when finished. Release files before delegating or waiting." : ""}`,
+    note: `${canDelegate(agent, quota.used) ? `Work directly when you can finish the brief yourself. Use ${DELEGATE_TOOL} only for useful, separable work with disjoint files, at most five children total; children share your remaining time and cannot delegate further. Integrate and verify their work yourself. ` : ""}Use codemode for concise parallel calls, inspect failures, and return only useful evidence.${desk ? " Before edit/write, claim_file; handover_file when finished. Release files before delegating or waiting." : ""}`,
     onStart: (handle: Parameters<NonNullable<PiRunOptions["onStart"]>>[0]) => {
       desk?.attach(parentDeskId, { runId: id, steer: handle.steer, annotate: () => {} });
       options.onStart?.(handle);

package/src/execution/pi-runner.ts

@@ -11,6 +11,7 @@ import { shortDuration } from "../text.ts";
 import { readRelayRequest } from "../ask/relay.ts";
 import type { AskQuestion, AskResult } from "../ask/types.ts";
 import { grantEnv, grantNote, type Grant } from "../excalidraw/sessions.ts";
+import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
 
 /** Live control over one running subagent: queue a steering message for its next turn. */
 export interface RunHandle {
@@ -24,6 +25,8 @@ export interface RunHandle {
 export type RelayAsk = (questions: AskQuestion[], signal: AbortSignal) => Promise<AskResult>;
 
 export interface PiRunOptions {
+  effort?: EffortRouter;
+  effortProfile?: RunProfileLike;
   agent?: { runId: string; taskId: string; domain: Domain; role: Role; depth?: number };
   mcpTools?: string[];
   delegationQuota?: { used: number };
@@ -67,6 +70,8 @@ export interface PiRunOptions {
  * the decision is pending, and move out with any time granted.
  */
 export interface TimeLimit {
+  /** Reporting time is included in the allowance, including extensions. */
+  hardLimit?: boolean;
   upAtMs: number;
   headsUpAtMs?: number;
   headsUpMessage?: string;
@@ -584,11 +589,12 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
         turnDone = false;
         clockStart = Date.now();
         lastOutput = clockStart;
-        upAtMs = extraMs;
+        upAtMs = time?.hardLimit ? Math.max(1, extraMs - Math.min(time.graceMs, Math.floor(extraMs / 4))) : extraMs;
         // The user just named the time it has: no heads-up quoting the old allotment.
         headsUpAtMs = 0;
-        deadlineAt = Date.now() + extraMs + (time?.graceMs ?? 0);
-        deadline = setTimeout(onDeadline, extraMs + (time?.graceMs ?? 0));
+        const nextLimit = extraMs + (time?.hardLimit ? 0 : time?.graceMs ?? 0);
+        deadlineAt = Date.now() + nextLimit;
+        deadline = setTimeout(onDeadline, nextLimit);
         input.send({ type: "prompt", message: message ?? "You have more time: carry on from where you left off and finish." });
         options.onEvent?.({ type: "extended", ms: extraMs });
       }, () => {

package/src/lobby/quickfix.ts

@@ -8,6 +8,7 @@ import type { AgentRun } from "../schemas/findings.ts";
  */
 import { loadPrompt } from "../prompts/loader.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
+import { MAX_CHILDREN } from "../execution/delegation.ts";
 import { grantOption } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
@@ -298,7 +299,7 @@ export class QuickFixQueue {
     this.edits.set(job.id, new EditLog(this.deps.cwd));
     try {
       const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
-      const quota = { used: 0 };
+      const quota = { used: MAX_CHILDREN };
       const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,

package/src/lobby/service.ts

@@ -7,7 +7,7 @@ import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { updateBlockingRequest } from "../state/blocking-requests.ts";
 import { randomUUID } from "node:crypto";
-import { loadTask, ownedTask, peekTasks, saveTask } from "../state/persistence.ts";
+import { loadTask, ownedTask, peekOwnedTask, peekTasks, saveTask } from "../state/persistence.ts";
 import { taskWork } from "../state/work-time.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest } from "../delivery/operations.ts";
@@ -221,6 +221,7 @@ function sessionsChanged(): void {
     const seen = announced.get(session.key) ?? 0;
     announced.set(session.key, session.dialogs.length);
     if (!state) continue;
+    syncTaskName(state, session);
     if (session.dialogs.length > seen) lobbyNotify(state, `bot-lobby: ${session.name} is waiting for you — see the Sessions page`, "info");
     if (!session.alive && !exitsSaid.has(session.key)) {
       exitsSaid.add(session.key);
@@ -229,6 +230,12 @@ function sessionsChanged(): void {
   }
 }
 
+function syncTaskName(state: Runtime, session: BackgroundSession): void {
+  if (!session.sessionId) return;
+  const task = peekOwnedTask(state.root, state.configDir, session.sessionId);
+  if (task) session.name = task.id;
+}
+
 function dialogTracker(state: Runtime): (id: string, pending: boolean, sessionId?: string) => void {
   const requests = new Map<string, { taskId: string; sessionId: string; requestId: string }>();
   const prefix = `dialog:${randomUUID()}`;

package/src/lobby/sessions.ts

@@ -64,7 +64,7 @@ export const STOP_GRACE_MS = 5000;
 export class BackgroundSession {
   readonly key: string;
   readonly projectRoot?: string;
-  readonly name: string;
+  name: string;
   /** The planned task it was started from. */
   readonly planId?: string;
   /** The task it was started to carry on. */

package/src/master/master.ts

@@ -4,7 +4,7 @@ import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schema
 import type { Domain } from "../schemas/agent.ts";
 import type { AgentRun, ReviewResult, ScoutResult, WorkerResult } from "../schemas/findings.ts";
 import { domainSpec } from "../agents/registry.ts";
-import { runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
+import { boundedAgentTime, runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { knowledgeFilePath, readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
@@ -52,7 +52,7 @@ export interface ScoutRequest {
 /** Model, thinking and time limit for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, mcpTools: profile.mcpTools, thinking: profile.thinking, timeoutMs: profile.timeoutMs };
+  return { model: profile.model, mcpTools: profile.mcpTools, thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {
@@ -142,6 +142,7 @@ export async function runScouts(request: ScoutRequest, run: ProcessRunner = spaw
   const extraTools = request.hints?.tools() ?? [];
   const requests: AgentRequest[] = request.domains.map((domain, index) => ({
     delegationQuota: { used: 0 },
+    effort: request.effort,
     taskId: request.taskId,
     domain,
     role: "scout",
@@ -161,7 +162,7 @@ export async function runScouts(request: ScoutRequest, run: ProcessRunner = spaw
   const runs = await runParallel(first, request.config.workflow.maxParallelScouts, run);
   let outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
   // A routed scout that came back unusable runs again on its configured model.
-  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted ? index : -1)).filter((index) => index >= 0);
+  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted && requests[index]!.time!.endsAt > Date.now() ? index : -1)).filter((index) => index >= 0);
   if (again.length > 0) {
     const reruns = await runParallel(again.map((index) => requests[index]!), request.config.workflow.maxParallelScouts, run);
     outcomes = outcomes.map((outcome, index) => {
@@ -288,6 +289,8 @@ export async function runWorker(
   const extraTools = [...(request.agent?.extraTools ?? []), ...hintTools];
   const base: AgentRequest = {
     delegationQuota: { used: 0 },
+    effort: request.effort,
+    effortProfile: configured,
     taskId: request.taskId,
     domain: request.domain,
     role: "worker",
@@ -311,7 +314,7 @@ export async function runWorker(
   };
   let outcome = workerOutcome(request.domain, await runAgent(route ? { ...base, ...routedFields(route) } : base, run));
   // A routed step that fell short runs again at the configured model and thinking.
-  if (route && fellShort(outcome.run, outcome.issues) && !request.signal?.aborted) {
+  if (route && fellShort(outcome.run, outcome.issues) && !request.signal?.aborted && base.time!.endsAt > Date.now()) {
     const routed = outcome.run.edited ?? [];
     outcome = workerOutcome(request.domain, await runAgent(base, run));
     // The step owns what the routed attempt edited too.
@@ -337,6 +340,7 @@ export interface ReviewerOutcome {
 }
 
 export interface ReviewerRequest {
+  effort?: EffortRouter;
   taskId: string;
   domain: Domain;
   taskText: string;
@@ -400,6 +404,7 @@ function reviewerAgentRequest(request: ReviewerRequest, selected: KnowledgeSelec
     taskId: request.taskId,
     domain: request.domain,
     role: "reviewer",
+    effort: request.effort,
     instruction:
       request.instruction?.trim() ||
       "Review the current repository changes against the approved requirements and plan.",
@@ -434,7 +439,7 @@ export async function runReviewer(
   const agentRequest = reviewerAgentRequest(request, selected);
   const attempts = Math.max(1, request.config.workflow.maxAgentRetries + 1);
   let agentRun = await runAgent(agentRequest, run);
-  for (let attempt = 2; attempt <= attempts && isRetryableReviewRun(agentRun); attempt++) {
+  for (let attempt = 2; attempt <= attempts && isRetryableReviewRun(agentRun) && agentRequest.time!.endsAt > Date.now(); attempt++) {
     agentRun = await runAgent(agentRequest, run);
   }
   const result = parseReviewResult(request.domain, agentRun.output);

package/src/pi/auto-compaction.ts

@@ -2,10 +2,10 @@ import { compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, typ
 import { contextMarks, freshContextOn } from "./fresh-context.ts";
 import { isSubagentProcess } from "./quiet.ts";
 
-export const CONTEXT_TARGET = 250_000;
+export const CONTEXT_TARGET = 64_000;
 
 export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION_SETTINGS.reserveTokens): number {
-  return Math.max(1, Math.min(CONTEXT_TARGET, Math.floor(window * 0.8), window - Math.min(reserve, Math.floor(window / 2))));
+  return Math.max(1, Math.min(CONTEXT_TARGET, Math.floor(window * 0.6), window - Math.min(reserve, Math.floor(window / 2))));
 }
 
 /** Compact at a settled tool boundary; ctx.compact() would abort the turn we need to continue. */
@@ -30,7 +30,7 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
       if (boundary !== undefined) entries = entries.filter((entry) => Date.parse(entry.timestamp) >= boundary);
     }
     if (entries.length < 2) return;
-    const keepRecentTokens = Math.min(override?.keepRecentTokens ?? configured?.keepRecentTokens ?? DEFAULT_COMPACTION_SETTINGS.keepRecentTokens, Math.floor(threshold / 4));
+    const keepRecentTokens = Math.min(16_000, override?.keepRecentTokens ?? configured?.keepRecentTokens ?? DEFAULT_COMPACTION_SETTINGS.keepRecentTokens, Math.floor(threshold / 4));
     const cut = findCutPoint(entries, 0, entries.length, keepRecentTokens);
     if (cut.firstKeptEntryIndex <= 0) return;
     const prefix = entries.slice(0, cut.firstKeptEntryIndex);
@@ -61,7 +61,7 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
       const headers = auth.headers ? Object.fromEntries(Object.entries(auth.headers).filter((entry): entry is [string, string] => entry[1] !== null)) : undefined;
       const retry = pi.getSettings().retry;
       const retryPolicy = { enabled: retry?.enabled ?? true, maxRetries: retry?.maxRetries ?? 3, baseDelayMs: retry?.baseDelayMs ?? 2_000, maxAgentDelayMs: retry?.maxAgentDelayMs };
-      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, "Preserve goals, constraints, decisions, file references, verification evidence, unfinished work and outstanding delegated subtasks. The parent remains responsible for integration and verification.", ctx.signal, undefined, undefined, auth.env, retryPolicy);
+      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.", ctx.signal, undefined, undefined, auth.env, retryPolicy);
       ctx.signal?.throwIfAborted();
       ctx.ui.notify("Agent context compacted", "info");
       return { entries: [...event.entries, { type: "compaction" as const, summary: result.summary, firstKeptEntryId, usage: result.usage, details: result.details }] };