@a-t-h-i/bot-lobby 0.6.36 → 0.6.38

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
@@ -101,6 +106,18 @@ first, searches the codebase for missing information, and records verified findi
 agent's knowledge. Answers appear in the side pane; the **Chat / Docs** toggle inside the composer
 switches back to the selected document. Questions do not create tasks.
 
+## Scripts
+
+Jobs that come back (seeding data, regenerating fixtures, a set of checks before review) are kept
+as scripts in `.pi/bot-lobby/scripts/`, shared by every agent, so a step done once is run the next
+time instead of being worked out again, which saves tokens and time. Each is named for what it
+does, in snake_case with its language's extension (`seed_public_holidays.py`,
+`run_changed_tests.sh`), and its first lines say what it is for and how to run it. The oracle
+decides when a step is worth a script and saves it (`action=script`); workers only propose one, and
+a replaced script is kept under `archive/`. For each step, Jev picks the scripts that do part of it
+and the agent is told to run them (**Settings → Classifier → Shared scripts**; with Jev off, scripts
+whose names share words with the step are suggested).
+
 ## Keys
 
 The lobby is keyboard-first, and every action button shows its key (`Archive E`, `Delete Del`).
@@ -126,25 +143,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.36",
+  "version": "0.6.38",
   "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.
@@ -348,6 +355,31 @@ the relevant knowledge files: omit `taskId` to update project knowledge without
 creating or advancing a task. Answer from saved knowledge first, cite code
 evidence for newly learned facts, and never record a guess.
 
+## Scripts
+
+The project keeps a shared scripts library that every agent can run; your
+prompt lists it under Scripts, and each agent is shown the scripts that fit its
+step. A script saves the tokens and time of working the same job out again, so
+you decide when work becomes one.
+
+- Make a script of a job that will come back in much the same form: seeding or
+  resetting data, regenerating fixtures or generated files, a migration run per
+  environment, a set of checks run before every review, a scaffold. Not of a
+  one-off change, and not of a single command anyone would type.
+- When a step is such a job, say so in its brief: have the worker write the
+  step as a script, drafted in the task's directory under `scripts/`, and run
+  it. Then save it with `action=script`, `name`, `purpose`, `usage` and
+  `file` (the draft), or `text` (the script itself). Read it first: it runs
+  for every agent from then on.
+- Name it for what it does, in snake_case, with its language's extension:
+  `seed_public_holidays.py`, `run_changed_tests.sh`. Prefer the project's own
+  language and runtime. Arguments over hard-coded values, so it serves the
+  next case too; and it says what it did, and fails loudly.
+- Before you brief a step, look for a script that does it, and name it in the
+  brief. To improve one, save it again under the same name; the old version is
+  archived.
+- Workers may propose scripts; take one only when it meets the bar above.
+
 ## Review
 
 The repository state is the source of truth; do not blindly trust Scout or

package/prompts/worker.md

@@ -113,3 +113,14 @@ then add a `## Pushback` block to your output:
 
 The engine records the pushback and blocks that domain until the Master
 resolves it, so be specific and keep working on the rest of the task.
+
+## Shared scripts
+
+Your prompt's Scripts section lists the shared scripts that fit your step. Run
+one instead of doing its work by hand, and check its output as you would your
+own; a script that does not do what it says is a finding for `## Notes`. Do not
+edit the library yourself. When your brief asks you to write a step as a
+script, or you wrote one for a job that will clearly come back, draft it in the
+folder your Workflow Context names for script drafts, named for what it does in snake_case
+(`seed_public_holidays.py`), run it, and propose it under `## Script
+Proposals`.

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/classifier/instance.ts

@@ -9,6 +9,8 @@ import { appendMetrics } from "../state/metrics.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { Classifier } from "./classifier.ts";
+import { scriptPicker } from "./scripts.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 import { registerJevProvider, type KeySource, type KeyStatus } from "./hosts.ts";
 import { fileHinter, type FileHinter, type FileScope } from "./files.ts";
 import { knowledgePicker, type KnowledgePicker } from "./knowledge.ts";
@@ -46,9 +48,15 @@ export function hintsFor(scope: FileScope): FileHinter {
   return fileHinter(classifier(), scope, (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
-/** Relevant knowledge for agents, with what Jev kept of each long file logged to the lobby's activity feed. */
+/** Relevant knowledge and shared scripts for agents, with what Jev kept and matched logged to the lobby's activity feed. */
 export function knowledgeFor(): KnowledgePicker {
-  return knowledgePicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
+  const log = (text: string) => lobbyFeed.log("CLASSIFIER", text, "info");
+  return { ...knowledgePicker(classifier(), log), scripts: scriptPicker(classifier(), log) };
+}
+
+/** Shared scripts for a quick fix, with what Jev matched logged to the lobby's activity feed. */
+export function scriptsPickerFor(): ScriptPicker {
+  return scriptPicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
 /** Triage a request for a task in a tree, logged to the lobby's activity feed; undefined when triage is off or fails. */

package/src/classifier/knowledge.ts

@@ -16,6 +16,7 @@ import { score, selectRelevant, splitSections, tokenize, type KnowledgeInput, ty
 import type { Classifier } from "./classifier.ts";
 import { noul, yesOf, type SystemOneRequest } from "./client.ts";
 import { clip } from "./limits.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 
 /** How many characters of each knowledge file a prompt has room for. */
 export const KNOWLEDGE_BUDGET_CHARS = 4000;
@@ -27,7 +28,7 @@ export const MAX_SECTIONS = 60;
 export const KNOWLEDGE_BUDGET_MS = 1500;
 
 /** The three files a prompt carries: `knowledge`, `standards` and `decisions`. */
-export type KnowledgeSlice = keyof KnowledgeSelection;
+export type KnowledgeSlice = Exclude<keyof KnowledgeSelection, "scripts">;
 export type KnowledgePaths = Partial<Record<KnowledgeSlice, string>>;
 
 export interface SectionCall {
@@ -100,9 +101,11 @@ export function leftOutNote(kept: Kept, name: string, path?: string): string {
     : `_Kept ${kept.kept} of ${kept.total} sections of ${name} for this step.${where}_`;
 }
 
-/** Picks what an agent's prompt carries of its knowledge files. */
+/** Picks what an agent's prompt carries of its knowledge files, and of the shared scripts. */
 export interface KnowledgePicker {
   select(task: string, files: KnowledgeInput, options?: { signal?: AbortSignal; paths?: KnowledgePaths }): Promise<KnowledgeSelection>;
+  /** Which shared scripts fit a step; shared words when absent. */
+  scripts?: ScriptPicker;
 }
 
 const SLICES: readonly KnowledgeSlice[] = ["knowledge", "standards", "decisions"];

package/src/classifier/scripts.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared scripts for a step. Jev reads each script's name and purpose against
+ * the step (one yes/no per script) and the ones that do part of it are put in
+ * the agent's prompt with how to run them, so the agent runs the script rather
+ * than working the job out again. A library longer than Jev is asked about is
+ * narrowed by shared words first. Off, failed or out of time, shared words
+ * decide (`scripts/pick.ts`).
+ */
+import type { Classifier } from "./classifier.ts";
+import { noul, yesOf, type SystemOneRequest } from "./client.ts";
+import { clip } from "./limits.ts";
+import { score, tokenize } from "../knowledge/selector.ts";
+import { keywordScripts, MAX_SUGGESTED, type ScriptPicker } from "../scripts/pick.ts";
+import { nameWords, type ScriptEntry } from "../scripts/library.ts";
+
+/** Scripts Jev is asked about for one step. */
+export const MAX_CANDIDATES = 40;
+/** The step waits this long for Jev, then goes with shared words. */
+export const SCRIPTS_BUDGET_MS = 1500;
+
+export interface ScriptCall {
+  request: SystemOneRequest;
+  /** The script each question key stands for. */
+  keys: Map<string, ScriptEntry>;
+}
+
+/** The scripts to ask about: all of them, or the `MAX_CANDIDATES` that share the most words with the step. */
+export function candidateScripts(step: string, entries: readonly ScriptEntry[]): ScriptEntry[] {
+  if (entries.length <= MAX_CANDIDATES) return [...entries];
+  const tokens = tokenize(step);
+  return entries
+    .map((entry, index) => ({ entry, index, hits: score(`${nameWords(entry.name)} ${entry.purpose}`, tokens) }))
+    .sort((a, b) => b.hits - a.hits || a.index - b.index)
+    .slice(0, MAX_CANDIDATES)
+    .map((scored) => scored.entry);
+}
+
+/** One request that asks, for each script, whether it does part of the step. */
+export function scriptRequest(step: string, entries: readonly ScriptEntry[]): ScriptCall {
+  const scripts: Record<string, string> = {};
+  const questions: SystemOneRequest["questions"] = {};
+  const keys = new Map<string, ScriptEntry>();
+  entries.forEach((entry, position) => {
+    const key = `k${position + 1}`;
+    scripts[key] = clip(`${entry.name}: ${entry.purpose}`, 300);
+    questions[key] = noul(`Does the script \`scripts.${key}\` (its file name and purpose) do all or part of \`task\`, so an agent doing the task should run it instead of doing that work by hand? Yes when running it is a step the task needs; no when it is about something else or only shares words with it.`);
+    keys.set(key, entry);
+  });
+  return { request: { state: { task: clip(step, 3000), scripts }, questions }, keys };
+}
+
+/**
+ * A picker on Jev: the scripts it judges to do part of the step, most likely
+ * first. Shared words decide when it is off or cannot judge.
+ */
+export function scriptPicker(classifier: Classifier, log?: (text: string) => void): ScriptPicker {
+  return {
+    async pick(step, entries, options = {}) {
+      if (entries.length === 0) return [];
+      if (!step.trim() || !classifier.enabled("scripts")) return keywordScripts(step, entries);
+      const call = scriptRequest(step, candidateScripts(step, entries));
+      const result = await classifier.ask("scripts", call.request, { ...(options.signal ? { signal: options.signal } : {}), timeoutMs: Math.min(classifier.config.timeoutMs, SCRIPTS_BUDGET_MS) });
+      if (!result) return keywordScripts(step, entries);
+      const judged = [...call.keys].map(([key, entry]) => ({ entry, yes: yesOf(result.answers, key) }));
+      // An answer to none of the questions says nothing: shared words decide.
+      if (judged.every((entry) => entry.yes === undefined)) return keywordScripts(step, entries);
+      const picked = judged
+        .filter((entry) => (entry.yes ?? 0) >= classifier.config.thresholds.scriptRelevantAt)
+        .sort((a, b) => b.yes! - a.yes!)
+        .slice(0, MAX_SUGGESTED)
+        .map((entry) => entry.entry);
+      log?.(`scripts: ${picked.length > 0 ? picked.map((entry) => entry.name).join(", ") : "none"} fit the step (of ${entries.length}) · ${result.ms} ms`);
+      return picked;
+    },
+  };
+}

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";
 
@@ -16,13 +18,15 @@ export interface AgentContext {
   standards?: string;
   knowledge?: string;
   decisions?: string;
+  /** The shared scripts that fit the step. */
+  scripts?: string;
   /** Per-agent custom instructions from the global config. */
   instructions?: string;
   workflowContext?: string;
 }
 
 /** 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 +39,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 +84,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 +118,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 +152,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 +220,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 +260,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 +294,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

@@ -6,6 +6,8 @@ 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";
@@ -108,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,
@@ -131,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 {
@@ -173,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: `${canDelegate(agent, quota.used) ? `Begin every step by delegating your first two sub-briefs via ${DELEGATE_TOOL} — split the work into two disjoint pieces with separate files. If you need more brainpower, delegate more, at most five children total; children 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." : ""}`,
+    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/knowledge/selector.ts

@@ -9,6 +9,8 @@ export interface KnowledgeSelection {
   knowledge: string;
   standards: string;
   decisions: string;
+  /** The shared scripts that fit the step and how to run them (see `scripts/pick.ts`). */
+  scripts?: string;
 }
 
 export interface KnowledgeInput {