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

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/THIRD_PARTY_NOTICES.md

@@ -5,7 +5,9 @@
 The web UI's look (colours, radii, shadows, control and dialog styles, the
 sidebar rail, the chat rows, the work log, the composer (its surface, footer controls and send button), the select
 fields and drop-down lists, the loading and status animations and the
-built-in colour themes) is adapted from T3 Code,
+built-in colour themes), and the third-party harness support (the model
+manifest, CLI flags, prompt injection and ACP handling behind Settings >
+Harnesses), is adapted from T3 Code,
 https://github.com/pingdotgg/t3code. No T3 Code package is a
 dependency; the styles and markup below were ported into this repository and
 rewired to bot-lobby's own data layer. Each adapted file starts with a comment
@@ -37,6 +39,15 @@ naming the file it came from.
 | `webui/src/app/TerminalDrawer.tsx` | `apps/web/src/components/ThreadTerminalDrawer.tsx` (the drawer, its floating toolbar and terminal list) |
 | `webui/src/tabs/lobby/InlineActivity.tsx` | `apps/web/src/components/chat/WorkLog.tsx` |
 | `src/webui/palette-core.ts` (the built-in themes) | `packages/shared/src/themePalettes.ts` (Blossom is their T3 Chat theme, renamed) |
+| `src/harness/model-manifest.json` (copied as is) | `apps/server/src/provider/model-manifest.json` |
+| `src/harness/catalog.ts` | `apps/server/src/provider/ClaudeModelCatalog.ts` (effort descriptors and maps), `CodexProvider.ts` (effort levels), `antigravityAuthSupport.ts` (`buildAntigravityAcpSpawnInput`) |
+| `src/harness/cli-args.ts` | `packages/shared/src/cliArgs.ts` (`tokenizeCliArgs`) |
+| `src/harness/instructions.ts` | `packages/provider-core/src/server/runtimeInstructions.ts`, `orchestrationInstructions.ts` (`t3AcpPromptWithInstructions`) |
+| `src/harness/codex.ts` | `apps/server/src/textGeneration/CodexTextGeneration.ts`, `apps/server/src/provider/codexLaunchArgs.ts` |
+| `src/harness/claude.ts` | `apps/server/src/textGeneration/ClaudeTextGeneration.ts`, `apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts` (auto-compact window) |
+| `src/harness/claude-sdk.ts` | `apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts` (Agent SDK query options) |
+| `src/harness/acp.ts` | `apps/server/src/provider/acp/AntigravityProtocol.ts` (permission answers), `packages/provider-acp/src/server/sessionConfig.ts` (session option categories) |
+| `src/schemas/harness.ts`, `webui/src/tabs/settings/HarnessesGroup.tsx` | `packages/contracts/src/settings.ts` (provider settings fields), `apps/web/src/components/settings/ProviderInstanceCard.tsx` |
 
 ```
 MIT License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.54",
+  "version": "0.6.56",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -96,5 +96,8 @@
     "typebox": "1.3.27",
     "typescript": "^5.7.0",
     "vite": "8.3.2"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.306"
   }
 }

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,12 +5,11 @@ 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";
+import type { HarnessRun } from "../schemas/harness.ts";
 
 export interface AgentContext {
   task: string;
@@ -54,7 +53,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 +64,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,56 +74,10 @@ 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 };
+  /** Run on this third-party harness instead of pi. */
+  harness?: HarnessRun;
 }
 
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
@@ -133,19 +85,17 @@ 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 +103,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 +117,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 +142,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 +160,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 +184,56 @@ 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 } : {}),
+      ...(request.harness ? { harness: request.harness } : {}),
       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 };