@a-t-h-i/bot-lobby 0.6.54 → 0.6.55

package/README.md

@@ -73,4 +73,4 @@ Settings live in `~/.pi/bot-lobby/config.json` (`BOT_LOBBY_CONFIG_DIR` moves the
 project knowledge stay in `.pi/bot-lobby/` inside your project.
 
 The [guide](docs/guide.md) covers the rest: delivery and commits, crash recovery, knowledge and
-shared scripts, the classifier, delegation, time limits, compaction and MCP tools.
+shared scripts, the classifier, delegation, compaction, and MCP tools and skills.

package/package.json

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

package/prompts/master.md

@@ -339,36 +339,16 @@ agents share facts without you:
   `reports/` folder and the report gives its path; long findings go in the
   task's `notes/` folder. Read the file when the detail matters rather than
   asking for it again.
-- A report flagged as wrapped up early or timed out may be partial: check what
-  is missing and delegate only the remainder.
-
-## 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.
-
-- Size the plan to fit it, and say so in the proposal when it does not.
-- Divide what is left by scope: give each `implement` its `minutes` (per
-  assignment in a parallel batch). Bigger steps get more; keep the QA gate's
-  reserve (the engine holds it back). Without `minutes` a step gets an even
-  share.
-- Every agent is told its minutes. One that runs out stops, reports what it
-  did, where it left off and how much more it needs, and the user decides; if
-  they give it more, the same agent carries on where it stopped. A step that
-  was not given more comes back unfinished: trim the scope, or ask for task
-  time.
-- When the budget is spent the engine starts no new work. Ask the user with
-  `action=budget` (`minutes` and a `reason`: what is left and why it is worth
-  it), or wrap up with what is done. `action=budget` with no minutes shows
-  where it stands.
+- A report flagged as stalled may be partial: check what is missing and
+  delegate only the remainder.
+
+## No time limits
+
+Agents have no time limit. An assignment runs until its agent reports, the
+user stops it, or it goes silent so long that the stall watchdog stops it.
+Size steps by scope, not by the clock, and never cut a step short or split it
+to save time. In auto mode keep going until the task is complete or truly
+blocked: nobody needs to grant more time.
 
 ## Git branch or worktree
 

package/prompts/worker.md

@@ -58,18 +58,14 @@ no code deleted or bent just to make a rule pass. Every one of them is listed
 for QA, who reads it as a finding unless it carries a reason that holds. When
 a rule is wrong for your change, leave it failing and say why under Notes.
 
-## Time budget
-
-Work efficiently: read what you need, make the change, verify, report. If the
-engine asks you to wrap up, stop exploring, leave every file consistent, and
-write your report with anything unfinished under Blockers or Notes.
-
-When your context has a **Time** section, the step has that many minutes. Land
-the most important part first and keep files consistent as you go. When the
-time is up you are told to stop: finish or revert the edit in progress, then
-report with `## Left Off` (what you were doing, what is still to do) and
-`## More Time` (`N minutes — why`), honestly sized. If the user gives you more,
-you carry on from where you stopped.
+## Pace
+
+There is no time limit: finish the step properly and verify it rather than
+cutting it short. Work efficiently all the same: read what you need, make the
+change, verify, report, and do not explore past what the step needs. Keep
+every file consistent as you go. A long silent command (one that prints
+nothing for many minutes) can be stopped as stalled, so give such commands
+output or a bash `timeout`.
 
 ## Working alongside other workers (file desk)
 

package/src/desk/ipc.ts

@@ -132,7 +132,7 @@ export interface DeskClient {
 export function createDeskClient(address: string, worker: string): DeskClient {
   let socket: Socket | undefined;
   let nextId = 1;
-  const pending = new Map<number, { done: (response: DeskResponse) => void; timer: ReturnType<typeof setTimeout> }>();
+  const pending = new Map<number, { done: (response: DeskResponse) => void; timer: ReturnType<typeof setTimeout> | undefined }>();
   const failAll = (text: string) => {
     for (const [id, entry] of pending) {
       clearTimeout(entry.timer);
@@ -170,10 +170,11 @@ export function createDeskClient(address: string, worker: string): DeskClient {
     request(request, timeoutMs = 10_000) {
       const id = nextId++;
       return new Promise((done) => {
-        const timer = setTimeout(() => {
+        // 0 waits for as long as the answer takes (a delegation, a consult): no time limit.
+        const timer = timeoutMs > 0 ? setTimeout(() => {
           pending.delete(id);
           done({ id, ok: false, text: "the file desk did not answer" });
-        }, timeoutMs);
+        }, timeoutMs) : undefined;
         pending.set(id, { done, timer });
         try {
           connect().write(`${JSON.stringify({ ...request, id, worker })}\n`);

package/src/execution/agent-runner.ts

@@ -5,10 +5,8 @@ import type { AgentRun } from "../schemas/findings.ts";
 import { roleSpec } from "../roles/registry.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
 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";
 
@@ -54,7 +52,8 @@ export interface AgentRequest {
   /** See PiRunOptions.expert. */
   expert?: { model?: string; thinking: string };
   thinking?: string;
-  timeoutMs: number;
+  /** Skill files this agent may load; absent keeps pi's own discovery. */
+  skills?: string[];
   cwd: string;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
@@ -64,8 +63,6 @@ export interface AgentRequest {
   stallTimeoutMs?: number;
   /** Silence allowed while one tool call runs. */
   toolStallTimeoutMs?: number;
-  /** Fraction of `timeoutMs` at which the agent is asked to wrap up; 0 disables. */
-  wrapUpAt?: number;
   /** Extra tools on top of the role allowlist (the file desk's tools). */
   extraTools?: readonly string[];
   env?: Record<string, string>;
@@ -76,76 +73,26 @@ export interface AgentRequest {
   /** The classifier routed this run down from this configured profile (receipts and metrics show it). */
   routedFrom?: string;
   route?: string;
-  /** Under a task time budget: the run's allotted time, which replaces `timeoutMs`. */
-  time?: AgentTime;
-  /** Lets the agent ask the user (ask_user_question, relayed through the master); its clocks wait for the answers. */
+  /** Lets the agent ask the user (ask_user_question, relayed through the master). */
   onAsk?: RelayAsk;
 }
 
-/**
- * A run under a task time budget. The agent is told its minutes up front,
- * warned at 75%, and asked to stop and report when they run out. A worker
- * then reports where it left off and how much more it needs; `onTimeUp`
- * (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. */
-  allotMs: number;
-  /** What the agent is told about its time, in its context. */
-  note?: string;
-  /** Workers only: decide on more time once it has reported where it left off; resolve with ms, 0 to stop it. */
-  onTimeUp?: (run: AgentRun, report: string) => Promise<number>;
-}
-
-/** The warning at 75% of an allotment. */
-export function headsUpMessage(leftMs: number, allotMs: number): string {
-  return `bot-lobby: about ${formatMinutes(leftMs)} of your ${formatMinutes(allotMs)} for this step are left. Finish what you have started and make sure it works; leave nice-to-haves.`;
-}
-
-/** The steer when an allotment is spent: a worker says where it left off and what more it needs; any other role reports what it has. */
-export function timeUpMessage(allotMs: number, canAskForMore: boolean): string {
-  return canAskForMore
-    ? `bot-lobby: your ${formatMinutes(allotMs)} for this step are up. Stop here: finish or revert the edit in progress so every file is consistent, start nothing new, and write your report now in the required format, adding \`## Left Off\` (what you were doing and what is still to do) and \`## More Time\` (how many more minutes you need, and why). The user decides whether you get more time to finish.`
-    : `bot-lobby: your ${formatMinutes(allotMs)} are up. Stop now and write your report in the required format with what you have.`;
-}
-
-/** The follow-up that sends an agent on once the user gave it more time. */
-export function carryOnMessage(extraMs: number): string {
-  return `bot-lobby: the user gave you ${formatMinutes(extraMs)} more. Carry on from where you left off and finish the step, then write your final report in the required format (leave out Left Off and More Time if you finish).`;
-}
-
-/** 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;
   stallTimeoutMs: number;
   toolStallTimeoutMs: number;
-  wrapUpAt: number;
-}): Pick<AgentRequest, "retries" | "stallTimeoutMs" | "toolStallTimeoutMs" | "wrapUpAt"> {
+}): Pick<AgentRequest, "retries" | "stallTimeoutMs" | "toolStallTimeoutMs"> {
   return {
     retries: workflow.maxAgentRetries,
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
-    wrapUpAt: workflow.wrapUpAt,
   };
 }
 
 const activeControllers = new Set<AbortController>();
 
-/** A stall or crash is worth one more try; a spent deadline or a cancel is not. */
+/** A stall or crash is worth one more try; a cancel is not. */
 function retryable(run: AgentRun): boolean {
   if (run.status === "failed") return true;
   return run.status === "timeout" && run.stalled === true;
@@ -153,23 +100,11 @@ function retryable(run: AgentRun): boolean {
 
 /**
  * Run one domain/role agent, retrying transient failures a bounded number of
- * times. Cancellation and a spent deadline never retry, so Esc stays responsive
- * and a slow agent cannot double its time budget.
+ * times. Cancellation never retries, so Esc stays responsive. There is no
+ * time limit: an agent works until it reports, is cancelled, or stalls.
  */
 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);
@@ -179,8 +114,6 @@ export async function runAgent(request: AgentRequest, run: ProcessRunner = spawn
     last = await runAgentOnce(request, run, attempt, startedAt, edits, quota);
     request.onAttemptEnd?.(last);
     if (!retryable(last)) break;
-    // Under a budget a retry only uses what is left of the allotment.
-    if (request.time && request.time.endsAt - Date.now() < MIN_ATTEMPT_MS) break;
   }
   const edited = edits.list();
   return edited.length > 0 ? { ...last!, edited } : last!;
@@ -206,7 +139,6 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     ...(request.thinking ? { thinking: request.thinking } : {}),
     ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
     ...(request.route ? { route: request.route } : {}),
-    ...(request.time ? { allotMs: request.time.allotMs, endsAt: request.time.endsAt } : {}),
     ...(attempts > 1 ? { note: `retry ${attempts - 1} of ${(request.retries ?? 0)}`, noteKind: "warning" as const } : {}),
   };
 }
@@ -225,30 +157,18 @@ 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 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 live = createLiveRun(base, { onUpdate: (update) => request.onUpdate?.({ ...update, activeMs: elapsed() }) }, 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 = request.systemPrompt ?? compilePrompt({ domain: request.domain, role: request.role, ...request.context });
-    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 },
@@ -261,88 +181,55 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
         request.onUpdate?.(child);
       },
       mcpTools: request.mcpTools,
+      ...(request.skills ? { skills: request.skills } : {}),
       ...(request.autoCompact === false ? { autoCompact: false } : {}),
       task: request.instruction,
       systemPrompt,
       tools: toolsFor(request),
       model: request.model,
       thinking: request.thinking,
-      timeoutMs: left,
-      ...(time ? {
-        time: {
-          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: `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) => {
-              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) };
-            },
-          } : {}),
-        },
-      } : {}),
       signal,
       ...(request.onAsk ? { onAsk: request.onAsk } : {}),
       env: request.onAsk ? { ...request.env, [ASK_ENV]: "1" } : request.env,
       stallTimeoutMs: request.stallTimeoutMs,
       toolStallTimeoutMs: request.toolStallTimeoutMs,
-      wrapUpAtMs: wrapUp,
       onEvent: (event) => {
-        if (event.type === "asking") { if (!asking) askStarted = Date.now(); asking += 1; clearTimeout(deadline); }
+        if (event.type === "asking") { if (!asking) askStarted = Date.now(); asking += 1; }
         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: expired ? "timeout" : result.status,
+      status: result.status,
       output: result.output,
-      error: expired ? describeError("hit the shared assignment time limit", current, false) : result.error ? describeError(result.error, current, result.stalled === true) : undefined,
+      error: result.error ? describeError(result.error, current, result.stalled === true) : undefined,
       usage: result.usage,
       finishedAt: new Date().toISOString(),
-      activeMs: (time.usedMs ?? 0) + elapsed(),
+      activeMs: 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 || 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 } : {}) };
+    const final: AgentRun = { ...live.current(), status: signal.aborted ? "cancelled" : "failed", error: (error as Error).message, activeMs: elapsed(), edited: edits.list(), finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined };
     request.onUpdate?.(final);
     return final;
   } finally {
-    clearTimeout(deadline!);
-    time.usedMs = (time.usedMs ?? 0) + elapsed();
     activeControllers.delete(controller);
   }
 }
 
-/** Name what the agent was doing when a stall or deadline hit. */
+/** Name what the agent was doing when a stall hit. */
 function describeError(error: string, current: AgentRun, stalled: boolean): string {
-  if (!stalled && !/time limit/.test(error)) return error;
+  if (!stalled) return error;
   const doing = current.activity ? ` while ${current.activity}${current.detail ? ` ${current.detail}` : ""}` : "";
   return `${error}${doing}`;
 }

package/src/execution/delegation.ts

@@ -23,7 +23,6 @@ export const EXPERT_TOOL = "ask_expert";
 /** Consults one step may make: advice on the hard part, not a second worker. */
 export const MAX_CONSULTS = 2;
 /** Longest an expert may take to answer. */
-export const EXPERT_TIMEOUT_MS = 5 * 60 * 1000;
 /** Marks an expert's run, so its host gives it an adviser's note rather than a child's. */
 export const EXPERT_ENV = "BOT_LOBBY_EXPERT";
 
@@ -85,7 +84,7 @@ export interface AgentPolicy {
   depth: number;
 }
 
-/** The host owns quotas, deadlines, file identities and child lifetimes, outside model context. */
+/** The host owns quotas, file identities and child lifetimes, outside model context. */
 export async function delegationHost(options: PiRunOptions, run: ProcessRunner) {
   const config = loadConfig();
   const id = options.agent?.runId ?? randomUUID();
@@ -112,14 +111,11 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   desk ??= ownedDesk;
   const controller = new AbortController();
   const lifetime = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
-  let timeController = new AbortController();
-  const childSignal = () => AbortSignal.any([lifetime, timeController.signal]);
+  const childSignal = () => lifetime;
   const key = `${options.cwd}:${agent.taskId}`;
   const pool = pools.get(key) ?? { active: 0, users: 0, waiters: [] };
   pool.users += 1;
   pools.set(key, pool);
-  let deadlineAt = Date.now() + (options.time?.upAtMs ?? options.timeoutMs);
-  let deadline = setTimeout(() => timeController.abort(), Math.max(1, deadlineAt - Date.now()));
   const children = new Map<string, AgentRun>();
   const pending = new Set<Promise<AgentRun>>();
   const parentDeskId = options.env?.[DESK_ENV.worker] ?? id;
@@ -137,18 +133,16 @@ 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", endsAt: deadlineAt, 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", 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);
+    const live = createLiveRun(base, { onUpdate: update }, edits);
     update(base);
     try {
       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({
@@ -159,10 +153,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
         thinking,
         tools: [...new Set([...tools.filter((tool) => tool !== DELEGATE_TOOL && tool !== EXPERT_TOOL), ...(childDesk ? childDesk.tools().filter((tool) => !PEER_TOOLS.includes(tool)) : [])])],
         mcpTools,
-        timeoutMs: left,
         signal,
-        time: undefined,
-        wrapUpAtMs: Math.floor(left * 0.85),
         delegationQuota: undefined,
         onChildRun: undefined,
         onEvent: live.onEvent,
@@ -172,7 +163,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
       };
       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) {
+      if (route && (route.level === "simple" || route.level === "trivial") && fellShort(result) && !signal.aborted) {
         retried = true;
         result = await attempt(configured.model, configured.thinking);
       }
@@ -180,7 +171,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
       update(final);
       return final;
     } catch (error) {
-      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 };
+      const final: AgentRun = { ...live.current(), edited: edits.list(), status: signal.aborted ? "cancelled" : "failed", error: (error as Error).message, finishedAt: new Date().toISOString(), note: undefined, noteKind: undefined };
       update(final);
       return final;
     } finally {
@@ -192,14 +183,12 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   quota.consults ??= 0;
   const consultations = new Map<string, AbortController>();
   const consult = async (question: string, signal: AbortSignal): Promise<{ ok: boolean; text: string }> => {
-    const left = Math.min(EXPERT_TIMEOUT_MS, deadlineAt - Date.now());
-    if (left < 30_000) return { ok: false, text: "Too little of your time is left to consult; carry on with your best reading." };
     // The oracle resolves the expert (its session model when settings name none); settings alone, then the worker's own, without it.
     const settled = options.expert ?? expertProfile(config);
     const expert = { model: settled.model ?? options.model, thinking: settled.thinking };
     const expertId = randomUUID();
-    const base: AgentRun = { runId: expertId, parentRunId: id, depth: 2, taskId: agent.taskId, domain: agent.domain, role: "reviewer", instruction: question, stepInstruction: options.task, status: "running", endsAt: Date.now() + left, output: "", attempts: 1, startedAt: new Date().toISOString(), thinking: expert.thinking, ...(expert.model ? { model: expert.model } : {}), note: "expert consult", noteKind: "info" };
-    const live = createLiveRun(base, { onUpdate: update, timeoutMs: left }, new EditLog(options.cwd));
+    const base: AgentRun = { runId: expertId, parentRunId: id, depth: 2, taskId: agent.taskId, domain: agent.domain, role: "reviewer", instruction: question, stepInstruction: options.task, status: "running", output: "", attempts: 1, startedAt: new Date().toISOString(), thinking: expert.thinking, ...(expert.model ? { model: expert.model } : {}), note: "expert consult", noteKind: "info" };
+    const live = createLiveRun(base, { onUpdate: update }, new EditLog(options.cwd));
     update(base);
     let final: AgentRun;
     try {
@@ -212,8 +201,6 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
         mcpTools: [],
         ...(expert.model ? { model: expert.model } : {}),
         thinking: expert.thinking,
-        timeoutMs: left,
-        wrapUpAtMs: Math.floor(left * 0.8),
         ...(options.stallTimeoutMs !== undefined ? { stallTimeoutMs: options.stallTimeoutMs } : {}),
         ...(options.toolStallTimeoutMs !== undefined ? { toolStallTimeoutMs: options.toolStallTimeoutMs } : {}),
         signal,
@@ -275,7 +262,6 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
     const results = await Promise.all(runs);
     return { ok: true, text: JSON.stringify(results.map((child) => ({ runId: child.runId, status: child.status, report: child.output.slice(0, 12_000), reportPath: join(dataRoot(detectProjectRoot(options.cwd, CONFIG_DIR_NAME), CONFIG_DIR_NAME), "delegations", `${child.runId}.json`), error: child.error, usage: child.usage }))) };
   }, () => controller.abort()).catch(async (error) => {
-    clearTimeout(deadline);
     if (ownedDesk) await ownedDesk.close();
     pool.users -= 1;
     if (pool.users === 0) pools.delete(key);
@@ -286,25 +272,17 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   return {
     tools: desk ? [...new Set([...tools, ...desk.tools()])] : tools,
     mcpTools,
-    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: `${consults ? `When you are stuck on a hard step after a real attempt, or about to make a choice you are unsure of (a tricky algorithm, a subtle bug, an unfamiliar API), ${EXPERT_TOOL} asks a stronger model for advice, at most ${MAX_CONSULTS} times; it reads the repository and answers, you still do the work. ` : ""}${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?.usesClaims ? " Before edit/write, claim_file; handover_file when finished. Release files before delegating or waiting." : ""}`,
+    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 }) },
+    note: `${consults ? `When you are stuck on a hard step after a real attempt, or about to make a choice you are unsure of (a tricky algorithm, a subtle bug, an unfamiliar API), ${EXPERT_TOOL} asks a stronger model for advice, at most ${MAX_CONSULTS} times; it reads the repository and answers, you still do the work. ` : ""}${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 cannot delegate further. Integrate and verify their work yourself. ` : ""}Use codemode for concise parallel calls, inspect failures, and return only useful evidence.${desk?.usesClaims ? " 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);
     },
     get children() { return [...children.values()]; },
-    pause() { clearTimeout(deadline); },
-    extend(ms: number, reset = false) {
-      deadlineAt = reset ? Date.now() + ms : deadlineAt + ms;
-      clearTimeout(deadline);
-      if (timeController.signal.aborted) timeController = new AbortController();
-      deadline = setTimeout(() => timeController.abort(), Math.max(1, deadlineAt - Date.now()));
-    },
     async close() {
       if (closed) return;
       closed = true;
       controller.abort();
-      clearTimeout(deadline);
       await Promise.allSettled([...pending]);
       await server.close();
       if (ownedDesk) { ownedDesk.release(parentDeskId, () => "Parent finished; re-read before editing."); await ownedDesk.close(); }

package/src/execution/live-run.ts

@@ -3,7 +3,7 @@ import type { AgentRun } from "../schemas/findings.ts";
 import type { PiStreamEvent } from "./pi-runner.ts";
 import { EditLog } from "../state/changes.ts";
 import { activityDetail, activityWord, describeToolCall } from "../pi/activity.ts";
-import { shortDuration, truncate } from "../text.ts";
+import { truncate } from "../text.ts";
 
 const THROTTLE_MS = 2000;
 
@@ -12,7 +12,7 @@ const THROTTLE_MS = 2000;
  * `onUpdate`: activity changes, retries and notes immediately, counters and
  * heartbeats at most every couple of seconds.
  */
-export function createLiveRun(base: AgentRun, request: Pick<AgentRequest, "onUpdate" | "timeoutMs" | "time">, edits: EditLog) {
+export function createLiveRun(base: AgentRun, request: Pick<AgentRequest, "onUpdate">, edits: EditLog) {
   let state: AgentRun = base;
   let lastEmit = 0;
   const emit = (patch: Partial<AgentRun>, force: boolean) => {
@@ -55,22 +55,11 @@ export function createLiveRun(base: AgentRun, request: Pick<AgentRequest, "onUpd
       case "compaction_end":
         emit({ note: event.error, noteKind: event.error ? "warning" : undefined }, true);
         return;
-      case "wrap_up":
-        emit({ note: `asked to wrap up (${shortDuration(request.timeoutMs)} limit)`, noteKind: "warning", wrappedUp: true }, true);
-        return;
-      case "time_up":
-        emit({ note: request.time?.onTimeUp ? "out of time: reporting where it left off" : "out of time: reporting", noteKind: "warning" }, true);
-        return;
-      case "extended":
-        emit({ endsAt: request.time?.endsAt, extendedMs: (state.extendedMs ?? 0) + event.ms }, true);
-        return;
       case "asking":
         emit({ note: `waiting on you: ${event.questions} question${event.questions === 1 ? "" : "s"}`, noteKind: "info" }, true);
         return;
       case "answered":
-        // Its time waited with it.
-        if (request.time) request.time.endsAt += event.waitedMs;
-        emit({ note: "you answered; carrying on", noteKind: "info", ...(request.time ? { endsAt: request.time.endsAt } : {}) }, true);
+        emit({ note: "you answered; carrying on", noteKind: "info" }, true);
         return;
       case "usage": {
         const usage = state.usage ?? { input: 0, output: 0, cost: 0, turns: 0 };