@saadnvd1/agent-os 0.3.737 → 0.3.742

package/lib/chat/events.ts

@@ -185,6 +185,8 @@ export type ChatItem =
       input: unknown;
       status: ToolStatus;
       output?: string;
+      // How it ended ("exit 1", "HTTP 404"), kept when the output is deferred.
+      outcome?: string;
       diff?: FileDiff;
       // When it finished, to show how long a step took.
       endedAt?: number;
@@ -320,6 +322,14 @@ export interface Compacting {
   before?: number;
 }
 
+// A model call the turn is waiting on: since when, the last measured prompt
+// size (a floor: the next prompt is at least that big), and a retry under way.
+export interface ModelWait {
+  since: number;
+  promptTokens?: number;
+  retry?: { attempt: number; message?: string };
+}
+
 export interface UndoPreview {
   canUndo: boolean;
   error?: string;
@@ -345,7 +355,11 @@ export type DriverEvent =
   | { type: "at_rest" } // it has run every message it was given
   | { type: "state"; state: ChatState }
   // The agent started (true) or finished (false) compacting its context.
-  | { type: "compacting"; active: boolean };
+  | { type: "compacting"; active: boolean }
+  // One model response's measured prompt (input plus cache), in tokens.
+  | { type: "prompt_tokens"; tokens: number }
+  // The agent is retrying a failed model request.
+  | { type: "model_retry"; attempt: number; message?: string };
 
 // A tool call's output and diff, loaded when it's opened.
 export interface ToolBody {
@@ -366,6 +380,7 @@ export type ChatServerMessage =
       tasks: ChatItem[];
       state: ChatState;
       compacting?: Compacting | null;
+      modelWait?: ModelWait | null;
       queue: QueuedMessage[];
       suggestion: string | null;
     }
@@ -391,6 +406,7 @@ export type ChatServerMessage =
   | { type: "delta"; id: string; text: string }
   | { type: "state"; state: ChatState }
   | { type: "compacting"; compacting: Compacting | null }
+  | { type: "model_wait"; wait: ModelWait | null }
   | {
       type: "capabilities";
       commands: ChatCommand[];

package/lib/chat/group.ts

@@ -1,12 +1,14 @@
 import type { ChatItem } from "./events";
 import { readingOrder } from "./reading-order";
+import { stepCounts, type StepCounts } from "./tool-outcome";
 import { eventTurnAt, type EventTurn } from "./turns";
 
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 
 export type TimelineBlock =
-  | { type: "item"; item: ChatItem }
+  // `steps` rides on the end of a stopped or failed turn: what ran in it.
+  | { type: "item"; item: ChatItem; steps?: StepCounts }
   | { type: "tools"; id: string; tools: ToolItem[] }
   | { type: "undone"; id: string; undo: UndoItem; items: ChatItem[] }
   // Consecutive turns an event started, with the reply to each.
@@ -30,6 +32,8 @@ export function groupTimeline(
   const items = opts.foldEvents ? readingOrder(all) : all;
   const blocks: TimelineBlock[] = [];
   let tools: ToolItem[] = [];
+  // Every tool call since the last turn ended, grouped or not.
+  let turnTools: ToolItem[] = [];
   const flush = () => {
     if (tools.length) blocks.push({ type: "tools", id: tools[0].id, tools });
     tools = [];
@@ -74,8 +78,10 @@ export function groupTimeline(
       i = end;
     } else if (item.kind === "tool" && STANDALONE_TOOLS.has(item.name)) {
       flush();
+      turnTools.push(item);
       blocks.push({ type: "item", item });
     } else if (item.kind === "tool") {
+      turnTools.push(item);
       tools.push(item);
     } else if (item.kind === "reasoning" && tools.length) {
       continue;
@@ -91,7 +97,15 @@ export function groupTimeline(
       continue;
     } else {
       flush();
-      blocks.push({ type: "item", item });
+      const cut =
+        item.kind === "turn_end" &&
+        (item.interrupted || item.ended?.reason === "error");
+      blocks.push(
+        cut && turnTools.length
+          ? { type: "item", item, steps: stepCounts(turnTools) }
+          : { type: "item", item }
+      );
+      if (item.kind === "turn_end") turnTools = [];
     }
   }
   flush();
@@ -123,7 +137,13 @@ function undoneRanges(items: ChatItem[]): Map<number, number> {
 // until they change, so a streamed delta re-renders only its own block.
 export function sameBlock(a: TimelineBlock, b: TimelineBlock): boolean {
   if (a === b) return true;
-  if (a.type === "item" && b.type === "item") return a.item === b.item;
+  if (a.type === "item" && b.type === "item")
+    return (
+      a.item === b.item &&
+      a.steps?.total === b.steps?.total &&
+      a.steps?.ok === b.steps?.ok &&
+      a.steps?.failed === b.steps?.failed
+    );
   if (a.type === "tools" && b.type === "tools")
     return sameItems(a.tools, b.tools);
   if (a.type === "undone" && b.type === "undone")

package/lib/chat/model-wait-live.ts

@@ -0,0 +1,19 @@
+import { emit, type Live } from "./registry";
+import { ModelWaitTracker } from "./model-wait";
+import type { WorkerEvent } from "./worker/protocol";
+
+// Keeps the model call the turn waits on current; the events that only feed
+// it (prompt size, a retry) go no further.
+export function trackModelWait(
+  sessionId: string,
+  live: Live,
+  e: WorkerEvent
+): boolean {
+  const tracker = (live.waitTracker ??= new ModelWaitTracker());
+  const changed = tracker.on(e);
+  if (changed) {
+    live.modelWait = tracker.wait;
+    emit(sessionId, { type: "model_wait", wait: tracker.wait });
+  }
+  return e.type === "prompt_tokens" || e.type === "model_retry";
+}

package/lib/chat/model-wait.ts

@@ -0,0 +1,88 @@
+import type { ModelWait } from "./events";
+import type { WorkerEvent } from "./worker/protocol";
+
+// Follows a running turn's events to know when it is waiting on a model
+// call: no tool running, nothing streaming, not compacting. Only what a
+// driver measured is kept as the prompt size; nothing is guessed.
+export class ModelWaitTracker {
+  wait: ModelWait | null = null;
+  private lastPrompt: number | undefined;
+  private running = new Set<string>();
+  private active = false;
+
+  // Returns whether `wait` changed.
+  on(e: WorkerEvent, now = Date.now()): boolean {
+    const before = this.wait;
+    switch (e.type) {
+      case "state":
+        if (e.state === "running") {
+          if (!this.active) {
+            this.active = true;
+            this.begin(now);
+          }
+        } else this.end();
+        break;
+      case "item": {
+        const i = e.item;
+        if (i.kind === "turn_end") this.end();
+        else if (i.kind === "compacted") this.lastPrompt = undefined;
+        else if (i.kind === "tool") {
+          if (i.status === "running") {
+            this.running.add(i.id);
+            this.wait = null;
+          } else {
+            this.running.delete(i.id);
+            if (this.active && !this.running.size) this.begin(now);
+          }
+        } else if (i.kind === "assistant" || i.kind === "reasoning") {
+          if (i.streaming) this.wait = null;
+          else if (this.active && !this.running.size && !this.wait)
+            this.begin(now);
+        }
+        break;
+      }
+      case "delta":
+        this.wait = null;
+        break;
+      case "compacting":
+        if (e.compacting) {
+          this.wait = null;
+          this.lastPrompt = undefined;
+        } else if (this.active && !this.running.size) this.begin(now);
+        break;
+      case "prompt_tokens":
+        this.lastPrompt = e.tokens;
+        break;
+      case "context":
+        this.lastPrompt = e.context.usedTokens || this.lastPrompt;
+        break;
+      case "model_retry":
+        if (this.active)
+          this.wait = {
+            ...(this.wait ?? this.fresh(now)),
+            retry: { attempt: e.attempt, message: e.message },
+          };
+        break;
+    }
+    return (
+      before !== this.wait &&
+      JSON.stringify(before) !== JSON.stringify(this.wait)
+    );
+  }
+
+  private fresh(now: number): ModelWait {
+    return this.lastPrompt
+      ? { since: now, promptTokens: this.lastPrompt }
+      : { since: now };
+  }
+
+  private begin(now: number) {
+    this.wait = this.fresh(now);
+  }
+
+  private end() {
+    this.active = false;
+    this.wait = null;
+    this.running.clear();
+  }
+}

package/lib/chat/page.ts

@@ -1,5 +1,6 @@
 import { db } from "../db";
 import type { ChatItem, ToolBody } from "./events";
+import { toolCode } from "./tool-outcome";
 
 // A conversation opens on its latest items and pages older ones in as the
 // reader scrolls up, so a long one costs what's on screen, not its history.
@@ -23,8 +24,10 @@ export function lighten(item: ChatItem): ChatItem {
   if (item.kind !== "tool" || (item.output === undefined && !item.diff))
     return item;
   const { output, diff, ...rest } = item;
+  const outcome = toolCode(output);
   return {
     ...rest,
+    ...(outcome ? { outcome } : {}),
     deferred: true,
     ...(diff ? { hasDiff: true } : {}),
     ...(output ? { hasOutput: true } : {}),

package/lib/chat/progress.ts

@@ -0,0 +1,169 @@
+import type { ChatItem, ChatState, Compacting, ModelWait } from "./events";
+import { formatTokens } from "./context";
+
+type Tool = Extract<ChatItem, { kind: "tool" }>;
+
+export type Phase = "planning" | "coding" | "testing" | "error";
+
+// A wait on one model call this long gets a hint that it may be normal.
+export const LONG_WAIT_MS = 2 * 60_000;
+export const LONG_WAIT_HINT =
+  "Still waiting on the model; large prompts on local models can take minutes";
+
+const TEST_RE =
+  /\b(test|tests|vitest|jest|pytest|mocha|playwright|tsc|typecheck|lint|eslint|build|check)\b|cargo (test|build|check)|go (test|build|vet)/;
+const EDIT_TOOLS = new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "apply_patch",
+]);
+const VERBS: Record<string, string> = {
+  Read: "Reading",
+  Edit: "Editing",
+  Write: "Writing",
+  MultiEdit: "Editing",
+  NotebookEdit: "Editing",
+  Search: "Searching",
+  Find: "Finding",
+  Fetch: "Fetching",
+  List: "Listing",
+  Run: "Running",
+};
+
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+const input = (t: Tool) => (t.input ?? {}) as Record<string, unknown>;
+const command = (t: Tool) => str(input(t).command);
+
+// "ollama/qwen3-coder:30b" -> "qwen3-coder:30b"; nothing known -> "the model".
+export function shortModel(label: string | undefined): string {
+  let m = (label ?? "").trim().split("/").at(-1) ?? "";
+  m = m.replace(/:latest$/, "").replace(/-\d{8}$/, "");
+  if (!m || m.toLowerCase() === "default") return "the model";
+  return m.length > 24 ? `${m.slice(0, 23)}…` : m;
+}
+
+const tail = (path: string) => path.split("/").slice(-3).join("/");
+const clip = (s: string, n = 60) =>
+  s.length > n ? `${s.slice(0, n - 1)}…` : s;
+
+// A tool call in plain words: "Running npm test", "Editing src/a/b.ts".
+export function stepLabel(t: Tool): string {
+  const cmd = command(t);
+  if (cmd) return `Running ${clip(cmd.replace(/\s+/g, " ").trim())}`;
+  const path = str(input(t).file_path);
+  if (path && EDIT_TOOLS.has(t.name)) {
+    const verb = VERBS[t.name] ?? "Editing";
+    return `${verb} ${tail(path)}`;
+  }
+  const [first, ...rest] = t.title.split(" ");
+  return VERBS[first] && rest.length
+    ? `${VERBS[first]} ${rest.join(" ")}`
+    : t.title;
+}
+
+export function turnTools(items: ChatItem[]): Tool[] {
+  let start = 0;
+  items.forEach((i, n) => {
+    if (i.kind === "user" && !i.midTurn) start = n + 1;
+  });
+  return items.slice(start).filter((i): i is Tool => i.kind === "tool");
+}
+
+const edited = (t: Tool) => EDIT_TOOLS.has(t.name) || !!t.diff;
+
+// Planning, coding, testing or error, from the turn's tools: the current
+// step (running, else the last one) decides error and testing; having
+// edited anything in the turn makes the rest coding.
+export function phaseOf(tools: Tool[]): Phase {
+  const step = tools.findLast((t) => t.status === "running") ?? tools.at(-1);
+  if (!step) return "planning";
+  if (step.status === "error") return "error";
+  if (TEST_RE.test(command(step))) return "testing";
+  return tools.some(edited) ? "coding" : "planning";
+}
+
+export interface Activity {
+  label: string;
+  since?: number;
+  compacting?: boolean;
+  kind: "answer" | "compacting" | "tool" | "writing" | "waiting" | "retry";
+  // The last measured prompt, when a driver reported one.
+  tokens?: number;
+  phase?: Phase;
+  steps: number;
+  // The last finished step, while no tool runs.
+  lastStep?: string;
+  turnSince?: number;
+  hint?: string;
+}
+
+// What the turn is doing now and for how long, from its items.
+export function currentActivity(
+  items: ChatItem[],
+  state: ChatState,
+  compacting: Compacting | null = null,
+  modelWait: ModelWait | null = null,
+  model?: string,
+  now: number = Date.now()
+): Activity | null {
+  if (state === "waiting")
+    return { label: "Waiting for your answer", kind: "answer", steps: 0 };
+  if (state !== "running") return null;
+  if (compacting)
+    return {
+      label: `Compacting context…${compacting.before ? ` ${formatTokens(compacting.before)} tokens` : ""}`,
+      since: compacting.since,
+      compacting: true,
+      kind: "compacting",
+      steps: 0,
+    };
+  const lastUser = items.findLast((i) => i.kind === "user" && !i.midTurn);
+  const tools = turnTools(items);
+  const base = {
+    steps: tools.length,
+    turnSince: lastUser?.createdAt,
+    phase: tools.length ? phaseOf(tools) : undefined,
+  };
+  const tool = tools.findLast((t) => t.status === "running");
+  if (tool)
+    return {
+      ...base,
+      label: stepLabel(tool),
+      since: tool.createdAt,
+      kind: "tool",
+    };
+  const last = items.at(-1);
+  if (
+    last &&
+    (last.kind === "assistant" || last.kind === "reasoning") &&
+    last.streaming
+  )
+    return {
+      ...base,
+      label: last.kind === "assistant" ? "Writing" : "Thinking",
+      since: lastUser?.createdAt,
+      kind: "writing",
+    };
+  const done = tools.findLast((t) => t.status !== "running");
+  const since =
+    modelWait?.since ?? done?.endedAt ?? done?.createdAt ?? lastUser?.createdAt;
+  const retry = modelWait?.retry;
+  return {
+    ...base,
+    label: retry
+      ? `Retrying model request (attempt ${retry.attempt})`
+      : `Waiting for ${shortModel(model)}`,
+    since,
+    kind: retry ? "retry" : "waiting",
+    tokens: modelWait?.promptTokens,
+    lastStep: done
+      ? `${stepLabel(done)}${done.status === "error" ? " failed" : ""}`
+      : undefined,
+    hint:
+      since !== undefined && now - since > LONG_WAIT_MS
+        ? LONG_WAIT_HINT
+        : undefined,
+  };
+}

package/lib/chat/registry.ts

@@ -10,9 +10,11 @@ import type {
   ChatServerMessage,
   ChatState,
   Compacting,
+  ModelWait,
 } from "./events";
 import { markStatusDirty } from "../status/dirty";
 import { FLUSH_MS } from "./store";
+import type { ModelWaitTracker } from "./model-wait";
 
 // Long enough for the worker's buffered write of an item to land.
 const EMIT_SETTLE_MS = 2 * FLUSH_MS;
@@ -23,6 +25,9 @@ export interface Live {
   state: ChatState;
   // Set while its agent compacts the context, over a "running" state.
   compacting?: Compacting | null;
+  // The model call the turn is waiting on, if any (lib/chat/model-wait).
+  modelWait?: ModelWait | null;
+  waitTracker?: ModelWaitTracker;
   // Streamed items carry their latest text here, ahead of SQLite.
   streaming: Map<string, ChatItem>;
   // What the turn is doing right now, for the session list.

package/lib/chat/runner-watch.ts

@@ -0,0 +1,68 @@
+import type { ChatContext, ChatItem } from "./events";
+import { getSession, registry, type Listener } from "./registry";
+import { releaseUnwatchedSoon, sendCapabilities } from "./settings";
+import { recentTasks, settle } from "./store";
+import { readPage, toolBody, type ItemPage } from "./page";
+import { listQueue } from "./queued";
+import { runningWorkers } from "./worker/client";
+
+function savedContext(sessionId: string): ChatContext | null {
+  const raw = getSession(sessionId).chat_context;
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as ChatContext;
+  } catch {
+    return null;
+  }
+}
+
+// What a watcher is sent of stored items: the live text of what's still
+// streaming, or with no conversation running, nothing left running.
+function present(sessionId: string, items: ChatItem[]): ChatItem[] {
+  const live = registry.live.get(sessionId);
+  if (live) return items.map((i) => live.streaming.get(i.id) ?? i);
+  return runningWorkers().includes(sessionId) ? items : settle(items);
+}
+
+// Snapshot then live updates. Returns the unsubscribe function. Every
+// client gets the latest page and asks for older ones.
+export function watchChat(sessionId: string, listener: Listener): () => void {
+  const live = registry.live.get(sessionId);
+  const page = readPage(sessionId);
+  const onPage = new Set(page.items.map((i) => i.id));
+  // The composer lists background work still going or just done, even when
+  // it started before the page.
+  const recent = Date.now() - 60 * 60 * 1000;
+  const tasks = recentTasks(sessionId, recent).filter((t) => !onPage.has(t.id));
+  listener({
+    type: "snapshot",
+    items: present(sessionId, page.items),
+    cursor: page.cursor,
+    hasMore: page.hasMore,
+    tasks: present(sessionId, tasks),
+    state: live?.state ?? "idle",
+    compacting: live?.compacting ?? null,
+    modelWait: live?.modelWait ?? null,
+    queue: listQueue(sessionId),
+    suggestion: getSession(sessionId).chat_suggestion ?? null,
+  });
+  listener({ type: "context", context: savedContext(sessionId) });
+  sendCapabilities(sessionId, listener).catch((error) =>
+    console.error(`[chat ${sessionId}] capabilities not sent:`, error)
+  );
+  let set = registry.listeners.get(sessionId);
+  if (!set) registry.listeners.set(sessionId, (set = new Set()));
+  set.add(listener);
+  return () => {
+    set?.delete(listener);
+    releaseUnwatchedSoon();
+  };
+}
+
+// The page before `before`, as the reader scrolls up.
+export function chatHistory(sessionId: string, before: number): ItemPage {
+  const page = readPage(sessionId, before);
+  return { ...page, items: present(sessionId, page.items) };
+}
+
+export const chatToolBody = toolBody;

package/lib/chat/runner.ts

@@ -16,9 +16,9 @@ import { randomUUID } from "crypto";
 import os from "os";
 import { db, type Session } from "../db";
 import type { CompactFirst } from "./stale";
+import { trackModelWait } from "./model-wait-live";
 import type {
   ApprovalDecision,
-  ChatContext,
   ChatFile,
   ChatImage,
   ChatServerMessage,
@@ -34,26 +34,17 @@ import {
   type Listener,
   type Live,
 } from "./registry";
-import {
-  capsKey,
-  emitCapabilities,
-  releaseUnwatchedSoon,
-  sendCapabilities,
-  setChatPlan,
-} from "./settings";
+import { capsKey, emitCapabilities, setChatPlan } from "./settings";
 import {
   endOrphanedTasks,
   endRunningTasks,
   getItem,
   hasItem,
   itemsOfKind,
-  recentTasks,
   sessionsWithRunningTasks,
   saveItem,
-  settle,
 } from "./store";
 import { noteToolResult } from "../health/env/recordHit";
-import { readPage, toolBody, type ItemPage } from "./page";
 import {
   deleteQueued,
   editQueued,
@@ -101,16 +92,6 @@ export {
   setChatPlan,
 } from "./settings";
 
-function savedContext(sessionId: string): ChatContext | null {
-  const raw = getSession(sessionId).chat_context;
-  if (!raw) return null;
-  try {
-    return JSON.parse(raw) as ChatContext;
-  } catch {
-    return null;
-  }
-}
-
 const CARRY_OUT = "Carry out the plan.";
 
 // Leaves plan mode and starts the plan. The message's id comes from the
@@ -192,6 +173,7 @@ function emitEnded(
 
 function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   track(live, e);
+  if (trackModelWait(sessionId, live, e)) return;
   if (e.type === "item" && e.item.kind === "tool")
     noteToolResult(sessionId, e.item);
   if (
@@ -968,55 +950,7 @@ export function chatTaskOutput(
   return taskOutputTail(taskId, task.outputFile);
 }
 
-// What a watcher is sent of stored items: the live text of what's still
-// streaming, or with no conversation running, nothing left running.
-function present(sessionId: string, items: ChatItem[]): ChatItem[] {
-  const live = registry.live.get(sessionId);
-  if (live) return items.map((i) => live.streaming.get(i.id) ?? i);
-  return runningWorkers().includes(sessionId) ? items : settle(items);
-}
-
-// Snapshot then live updates. Returns the unsubscribe function. Every
-// client gets the latest page and asks for older ones.
-export function watchChat(sessionId: string, listener: Listener): () => void {
-  const live = registry.live.get(sessionId);
-  const page = readPage(sessionId);
-  const onPage = new Set(page.items.map((i) => i.id));
-  // The composer lists background work still going or just done, even when
-  // it started before the page.
-  const recent = Date.now() - 60 * 60 * 1000;
-  const tasks = recentTasks(sessionId, recent).filter((t) => !onPage.has(t.id));
-  listener({
-    type: "snapshot",
-    items: present(sessionId, page.items),
-    cursor: page.cursor,
-    hasMore: page.hasMore,
-    tasks: present(sessionId, tasks),
-    state: live?.state ?? "idle",
-    compacting: live?.compacting ?? null,
-    queue: listQueue(sessionId),
-    suggestion: getSession(sessionId).chat_suggestion ?? null,
-  });
-  listener({ type: "context", context: savedContext(sessionId) });
-  sendCapabilities(sessionId, listener).catch((error) =>
-    console.error(`[chat ${sessionId}] capabilities not sent:`, error)
-  );
-  let set = registry.listeners.get(sessionId);
-  if (!set) registry.listeners.set(sessionId, (set = new Set()));
-  set.add(listener);
-  return () => {
-    set?.delete(listener);
-    releaseUnwatchedSoon();
-  };
-}
-
-// The page before `before`, as the reader scrolls up.
-export function chatHistory(sessionId: string, before: number): ItemPage {
-  const page = readPage(sessionId, before);
-  return { ...page, items: present(sessionId, page.items) };
-}
-
-export const chatToolBody = toolBody;
+export { chatHistory, chatToolBody, watchChat } from "./runner-watch";
 
 // After a restart: reconnect to every worker still running a conversation,
 // and send the queues of conversations whose worker is gone.

package/lib/chat/tool-outcome.ts

@@ -0,0 +1,45 @@
+import type { ToolItem } from "./group";
+
+const EDGE = 4096;
+
+// A short label for how a command ended, read from its output: the last HTTP
+// status line (a redirect chain reports where it landed) or an exit code.
+export function toolCode(output?: string): string | undefined {
+  if (!output) return undefined;
+  const text =
+    output.length > EDGE * 2
+      ? `${output.slice(0, EDGE)}\n${output.slice(-EDGE)}`
+      : output;
+  const http = [...text.matchAll(/^HTTP\/[\d.]+ (\d{3})/gm)].pop();
+  if (http) return `HTTP ${http[1]}`;
+  const exit = [
+    ...text.matchAll(
+      /(?:^Exit code |Command exited with code |exit (?:code|status)[:= ]+)(\d+)/gim
+    ),
+  ].pop();
+  return exit ? `exit ${exit[1]}` : undefined;
+}
+
+export const toolOutcome = (tool: ToolItem): string | undefined =>
+  tool.outcome ?? toolCode(tool.output);
+
+export interface StepCounts {
+  total: number;
+  ok: number;
+  failed: number;
+  // Never finished: the turn stopped first.
+  stopped: number;
+  running: number;
+}
+
+export function stepCounts(tools: ToolItem[]): StepCounts {
+  const n = (s: ToolItem["status"]) =>
+    tools.filter((t) => t.status === s).length;
+  return {
+    total: tools.length,
+    ok: n("done"),
+    failed: n("error"),
+    stopped: n("stopped"),
+    running: n("running"),
+  };
+}

package/lib/chat/tools.ts

@@ -81,3 +81,17 @@ export function clipOutput(text: string): string {
     ? `${text.slice(0, MAX_TOOL_OUTPUT)}\n… (${text.length - MAX_TOOL_OUTPUT} more characters)`
     : text;
 }
+
+export const LIVE_OUTPUT_LINES = 200;
+
+// A running step's output so far: the last lines, never more than a
+// finished step keeps. The end of a long build is what the reader wants.
+export function tailOutput(text: string): string {
+  const lines = text.split("\n");
+  let tail =
+    lines.length > LIVE_OUTPUT_LINES
+      ? lines.slice(-LIVE_OUTPUT_LINES).join("\n")
+      : text;
+  if (tail.length > MAX_TOOL_OUTPUT) tail = tail.slice(-MAX_TOOL_OUTPUT);
+  return tail === text ? tail : `…\n${tail}`;
+}