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

package/src/desk/session.ts

@@ -8,10 +8,20 @@ import { basename } from "node:path";
 import type { AgentHandle } from "../execution/agent-runner.ts";
 import { FileDesk, type Claim, type DeskEvent, type FileView, type Handover, type WorkerId } from "./desk.ts";
 import { startDeskServer, type DeskRequest, type DeskResponse, type DeskServer } from "./ipc.ts";
+import { appendPost, formatPost, isPostKind, PUSHED_KINDS, SUBSCRIPTIONS, subscriptionFor, type BoardPost } from "./board.ts";
 
 /** Tools the desk adds to every parallel worker's allowlist. */
 export const DESK_TOOLS: readonly string[] = ["claim_file", "handover_file", "my_files", "wait_for_files"];
 
+/** The desk tools of a worker with a checkout of its own: questions only, no claims. */
+export const PEER_TOOLS: readonly string[] = ["ask_peer", "answer_peer"];
+
+/** How long `ask_peer` waits for an answer by default, and at most. */
+export const ASK_WAIT_MS = 90_000;
+export const MAX_ASK_WAIT_MS = 180_000;
+const MAX_QUESTION = 800;
+const MAX_ANSWER = 1500;
+
 /** Env names the desk client extension reads inside a worker process. */
 export const DESK_ENV = { address: "BOT_LOBBY_DESK", worker: "BOT_LOBBY_DESK_ID" } as const;
 
@@ -29,6 +39,27 @@ function label(worker: WorkerId): string {
   return names[worker] ?? worker.toUpperCase();
 }
 
+/** A peer named the way workers know each other (DEV, DESIGN, QA) or by domain. */
+export function peerId(name: string): WorkerId {
+  const key = name.trim().toLowerCase();
+  const ids: Record<string, string> = { dev: "backend", backend: "backend", design: "designer", designer: "designer", qa: "qa" };
+  return ids[key] ?? name.trim();
+}
+
+function flat(text: string, max: number): string {
+  const value = text.replace(/\s+/g, " ").trim();
+  return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}
+
+interface PeerQuestion {
+  id: number;
+  from: WorkerId;
+  to: WorkerId;
+  question: string;
+  resolve: (answer: string | undefined) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
 function queueLines(queue: readonly Claim[]): string {
   return queue.map((claim, index) => `${index + 1}) ${label(claim.worker)} — ${claim.intent}`).join("; ");
 }
@@ -58,6 +89,12 @@ function describeHeld(files: readonly FileView[]): string {
 
 export interface DeskSessionOptions {
   cwd: string;
+  /** The task board's file: workers post to it through the desk, and contracts and blockers reach the other workers at once. */
+  boardPath?: string;
+  /** False when every worker has a checkout of its own: edits need no claim, and the desk only carries questions and the board. */
+  claims?: boolean;
+  /** Workers of one parallel batch may ask each other questions (`ask_peer`). */
+  peers?: boolean;
   /** A worker that finished without handing a file over leaves this note for the next worker. */
   onHandover?: (handover: Handover) => void;
 }
@@ -75,6 +112,8 @@ export class DeskSession {
   private readonly handles = new Map<WorkerId, AgentHandle>();
   private readonly greeted = new Set<WorkerId>();
   private readonly options: DeskSessionOptions;
+  private readonly questions = new Map<number, PeerQuestion>();
+  private nextQuestion = 1;
 
   constructor(options: DeskSessionOptions) {
     this.options = options;
@@ -97,6 +136,16 @@ export class DeskSession {
     this.handles.set(worker, handle);
   }
 
+  /** False when every worker has a checkout of its own and edits need no claim. */
+  get usesClaims(): boolean {
+    return this.options.claims !== false;
+  }
+
+  /** The desk tools its workers get: claims, questions, or both. */
+  tools(): readonly string[] {
+    return [...(this.usesClaims ? DESK_TOOLS : []), ...(this.options.peers ? PEER_TOOLS : [])];
+  }
+
   /** True once the worker's desk extension has checked in. */
   greetedBy(worker: WorkerId): boolean {
     return this.greeted.has(worker);
@@ -106,8 +155,13 @@ export class DeskSession {
   release(worker: WorkerId, note: (path: string, next: Claim) => string): void {
     this.releaseFiles(worker, note);
     this.handles.delete(worker);
+    // A finished worker can no longer answer, and its own questions need no answer.
+    for (const question of [...this.questions.values()]) {
+      if (question.to === worker || question.from === worker) this.settle(question, undefined);
+    }
   }
 
+
   /** A coordinating worker releases claims but still receives steering messages. */
   releaseFiles(worker: WorkerId, note: (path: string, next: Claim) => string): void {
     this.handles.get(worker)?.annotate({ waitingFor: undefined });
@@ -119,6 +173,7 @@ export class DeskSession {
   }
 
   async close(): Promise<void> {
+    for (const question of [...this.questions.values()]) this.settle(question, undefined);
     if (this.server) sessions.delete(this.server.address);
     this.desk.close();
     await this.server?.close();
@@ -158,13 +213,19 @@ export class DeskSession {
         return { ok: true, text: this.mine(worker) };
       case "wait":
         return this.wait(worker, Math.min(MAX_WAIT_MS, Math.max(1000, request.timeoutMs ?? MAX_WAIT_MS)));
+      case "post":
+        return this.post(request.from?.trim() || worker, worker, request.kind ?? "", request.text ?? "", request.files ?? []);
+      case "ask":
+        return this.ask(worker, request.to ?? "", request.path ?? "", request.text ?? "", Math.min(MAX_ASK_WAIT_MS, Math.max(5000, request.timeoutMs ?? ASK_WAIT_MS)));
+      case "answer":
+        return this.answer(worker, request.questionId ?? 0, request.text ?? "");
       default:
         return { ok: false, text: `unknown desk operation ${String(request.op)}` };
     }
   }
 
   private check(worker: WorkerId, path: string): Omit<DeskResponse, "id"> {
-    if (this.desk.holds(worker, path)) return { ok: true, allowed: true, text: "" };
+    if (this.options.claims === false || this.desk.holds(worker, path)) return { ok: true, allowed: true, text: "" };
     const key = this.desk.normalize(path);
     const holder = this.desk.holderOf(path);
     if (!holder) {
@@ -217,6 +278,73 @@ export class DeskSession {
     if (queuedFor.length === 0) return { ok: true, text: "You are not waiting for any file." };
     return { ok: true, text: `Still waiting:\n${this.mine(worker)}\nIf nothing else is left, finish your report and list the dependency under Notes; files are handed over automatically when their holder finishes.` };
   }
+
+  private post(from: string, worker: WorkerId, kind: string, text: string, files: readonly string[]): Omit<DeskResponse, "id"> {
+    if (!this.options.boardPath) return { ok: false, text: "This task has no board." };
+    if (!isPostKind(kind)) return { ok: false, text: `Unknown post kind "${kind}".` };
+    let post: BoardPost;
+    try {
+      post = appendPost(this.options.boardPath, { from, kind, text, files: files.map((file) => this.desk.normalize(file)) });
+    } catch (error) {
+      return { ok: false, text: (error as Error).message };
+    }
+    let told: string[] = [];
+    if (PUSHED_KINDS.has(post.kind)) {
+      // Only the batch's named workers hear posts as they land; children read the board when they need it.
+      told = [...this.handles.keys()].filter((peer) => peer !== worker && peer in SUBSCRIPTIONS && subscriptionFor(peer).includes(post.kind));
+      for (const peer of told) this.steer(peer, `bot-lobby board: ${formatPost(post)}`);
+    }
+    return { ok: true, text: `Posted #${post.seq}.${told.length > 0 ? ` ${told.map(label).join(", ")} ${told.length === 1 ? "was" : "were"} told now.` : ""}` };
+  }
+
+  private async ask(worker: WorkerId, to: string, path: string, question: string, timeoutMs: number): Promise<Omit<DeskResponse, "id">> {
+    if (!this.options.peers) return { ok: false, text: "No peers work alongside you here." };
+    const text = flat(question, MAX_QUESTION);
+    if (!text) return { ok: false, text: "ask_peer needs a question." };
+    if (path.trim() && !this.usesClaims) return { ok: false, text: "Every worker in this batch has a checkout of its own, so nobody holds files: name the peer (DEV, DESIGN or QA) instead." };
+    const target = path.trim() ? this.desk.holderOf(path)?.worker : to.trim() ? peerId(to) : undefined;
+    if (!target) return { ok: false, text: path.trim() ? `Nobody holds \`${this.desk.normalize(path)}\`; read it yourself.` : "Name the peer (DEV, DESIGN or QA) or a file its holder should answer about." };
+    if (target === worker) return { ok: false, text: "That is you." };
+    if (!this.handles.has(target)) return { ok: false, text: `${label(target)} is not working right now. Post a \`question\` on the board instead; the oracle sees it.` };
+    // A worker waiting on its own question cannot answer until that returns: asking it would chain the waits (or close a cycle).
+    const theirs = [...this.questions.values()].find((entry) => entry.from === target);
+    if (theirs?.to === worker) return { ok: false, text: `${label(target)} is waiting on your answer to its question #${theirs.id} ("${theirs.question}"). Answer it with answer_peer first.` };
+    if (theirs) return { ok: false, text: `${label(target)} is waiting on an answer from ${label(theirs.to)} and cannot answer yet. Carry on with your other work and ask again shortly, or post a \`question\` on the board.` };
+    const id = this.nextQuestion++;
+    const answer = await new Promise<string | undefined>((resolve) => {
+      const timer = setTimeout(() => this.settle(this.questions.get(id), undefined), timeoutMs);
+      this.questions.set(id, { id, from: worker, to: target, question: text, resolve, timer });
+      this.steer(target, `bot-lobby desk: question #${id} from ${label(worker)}: ${text} Answer it now with answer_peer (id ${id}) in a line or two, from what you know or have built, then carry on with your own work. It is a question, not a task: you take work only from your brief.`);
+      this.handles.get(worker)?.annotate({ note: `asked ${label(target)}`, noteKind: "info" });
+    });
+    if (answer === undefined) {
+      return { ok: true, text: `${label(target)} did not answer within ${Math.round(timeoutMs / 1000)} seconds (it may be in a long command, or it finished). Carry on with your best reading of the brief and the board, and list the open question under Notes.` };
+    }
+    if (this.options.boardPath) {
+      try {
+        appendPost(this.options.boardPath, { from: worker, kind: "note", text: `Asked ${label(target)}: ${text} Answer: ${answer}` });
+      } catch {
+        // The answer still reaches the asker.
+      }
+    }
+    return { ok: true, text: `${label(target)} answers: ${answer}` };
+  }
+
+  private answer(worker: WorkerId, id: number, text: string): Omit<DeskResponse, "id"> {
+    const question = this.questions.get(id);
+    if (!question || question.to !== worker) return { ok: false, text: `There is no open question #${id} for you (it may have timed out).` };
+    const answer = flat(text, MAX_ANSWER);
+    if (!answer) return { ok: false, text: "answer_peer needs an answer." };
+    this.settle(question, answer);
+    return { ok: true, text: `Answer sent to ${label(question.from)}.` };
+  }
+
+  private settle(question: PeerQuestion | undefined, answer: string | undefined): void {
+    if (!question || !this.questions.has(question.id)) return;
+    clearTimeout(question.timer);
+    this.questions.delete(question.id);
+    question.resolve(answer);
+  }
 }
 
 /** A handover note for `next`, written from a finished worker's report. */

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";
 
@@ -44,13 +42,18 @@ export interface AgentRequest {
   instruction: string;
   /** Prompt layers selected for this run. */
   context: AgentContext;
+  /** A whole system prompt of its own instead of the compiled role layers (the goal check). */
+  systemPrompt?: string;
   model?: string;
   mcpTools?: string[];
   /** False when the agent's settings turn its auto-compaction off. */
   autoCompact?: boolean;
-  delegationQuota?: { used: number };
+  delegationQuota?: { used: number; consults?: number };
+  /** 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;
@@ -60,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>;
@@ -72,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;
@@ -149,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);
@@ -175,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!;
@@ -202,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 } : {}),
   };
 }
@@ -221,34 +157,23 @@ 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 = 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 systemPrompt = request.systemPrompt ?? compilePrompt({ domain: request.domain, role: request.role, ...request.context });
     const result = await runPiAgent({
       cwd: request.cwd,
       agent: { runId: base.runId, taskId: request.taskId, domain: request.domain, role: request.role },
       delegationQuota: quota,
+      ...(request.expert ? { expert: request.expert } : {}),
       effort: request.effort,
       effortProfile: request.effortProfile,
       onChildRun: (child) => {
@@ -256,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}`;
 }
@@ -353,7 +245,10 @@ async function mapWithConcurrencyLimit<TIn, TOut>(items: TIn[], concurrency: num
       results[index] = await fn(items[index]!);
     }
   });
-  await Promise.all(workers);
+  // Every worker settles before a failure is raised, so no caller cleans up under a sibling still running.
+  const settled = await Promise.allSettled(workers);
+  const failed = settled.find((entry): entry is PromiseRejectedResult => entry.status === "rejected");
+  if (failed) throw failed.reason;
   return results;
 }