zob-harness 0.9.2 → 0.10.0

package/.pi/extensions/zob-harness/src/runtime/delegation-activity.ts

@@ -0,0 +1,289 @@
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { resolve, sep } from "node:path";
+
+import { isRecord } from "../core/utils/records.js";
+import { sanitizeDelegationText } from "./delegation-markdown.js";
+
+const ACTIVITY_MAX_BYTES = 180_000;
+const DEFAULT_RECENT_LIMIT = 5;
+
+export type DelegationActivityStatus = "running" | "success" | "error";
+
+export interface DelegationActivity {
+  toolCallId: string;
+  toolName: string;
+  status: DelegationActivityStatus;
+  startedAtMs?: number;
+  endedAtMs?: number;
+  elapsedMs?: number;
+  command?: string;
+  timeoutMs?: number;
+  target?: string;
+  summary?: string;
+  outputSummary?: string;
+  errorSummary?: string;
+}
+
+export interface DelegationActivitySnapshot {
+  status: "ok" | "missing" | "blocked" | "empty";
+  note?: string;
+  fingerprint: string;
+  current?: DelegationActivity;
+  recent: DelegationActivity[];
+  lastUpdatedMs?: number;
+  quietMs?: number;
+}
+
+function normalizePath(path: string): string {
+  return resolve(path);
+}
+
+function isInside(root: string, candidate: string): boolean {
+  const normalizedRoot = normalizePath(root);
+  const normalizedCandidate = normalizePath(candidate);
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}${sep}`);
+}
+
+function readTail(path: string, size: number, maxBytes: number): string {
+  if (size <= maxBytes) {
+    const buffer = Buffer.alloc(size);
+    const fd = openSync(path, "r");
+    try {
+      readSync(fd, buffer, 0, size, 0);
+    } finally {
+      closeSync(fd);
+    }
+    return buffer.toString("utf8");
+  }
+  const buffer = Buffer.alloc(maxBytes);
+  const fd = openSync(path, "r");
+  try {
+    readSync(fd, buffer, 0, maxBytes, Math.max(0, size - maxBytes));
+  } finally {
+    closeSync(fd);
+  }
+  const text = buffer.toString("utf8");
+  const firstNewline = text.indexOf("\n");
+  const safeTail = firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+  return `{"type":"custom","customType":"zob-activity-tail-capped","data":{"omittedBytes":${size - maxBytes}}}\n${safeTail}`;
+}
+
+function timestampMs(entry: Record<string, unknown>): number | undefined {
+  if (typeof entry.timestamp !== "string") return undefined;
+  const parsed = Date.parse(entry.timestamp);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function compactWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function redactDelegationCommand(command: string): string {
+  return sanitizeDelegationText(command)
+    .replace(/\b([A-Z0-9_]*(?:DATABASE_URL|TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|ACCESS_KEY|PRIVATE_KEY)[A-Z0-9_]*)=("[^"]*"|'[^']*'|\S+)/gi, "$1=<redacted>")
+    .replace(/(Authorization\s*:\s*Bearer\s+)("[^"]*"|'[^']*'|\S+)/gi, "$1<redacted>")
+    .replace(/\b(--(?:password|passwd|token|secret|api-key|access-key|private-key|database-url)(?:=|\s+))("[^"]*"|'[^']*'|\S+)/gi, "$1<redacted>")
+    .replace(/\b(-H\s+["']?Authorization\s*:\s*Bearer\s+)([^"'\s]+)/gi, "$1<redacted>");
+}
+
+function capInline(value: string, limit: number): string {
+  const compact = compactWhitespace(sanitizeDelegationText(value));
+  if (compact.length <= limit) return compact;
+  const head = Math.max(8, Math.floor(limit * 0.65));
+  const tail = Math.max(4, limit - head - 1);
+  return `${compact.slice(0, head)}…${compact.slice(-tail)}`;
+}
+
+function contentText(content: unknown): string {
+  if (typeof content === "string") return sanitizeDelegationText(content);
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!isRecord(part) || typeof part.type !== "string") continue;
+    if (part.type === "text" && typeof part.text === "string") parts.push(sanitizeDelegationText(part.text));
+    else if (part.type === "image") parts.push("[image]");
+  }
+  return parts.join("\n");
+}
+
+function toolArguments(part: Record<string, unknown>): Record<string, unknown> {
+  const direct = part.arguments ?? part.args ?? part.input;
+  return isRecord(direct) ? direct : {};
+}
+
+function toolName(part: Record<string, unknown>): string {
+  return typeof part.name === "string" ? part.name : typeof part.toolName === "string" ? part.toolName : "tool";
+}
+
+function timeoutMsFromArgs(args: Record<string, unknown>): number | undefined {
+  const raw = args.timeout ?? args.timeout_ms ?? args.timeoutMs;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return undefined;
+  // Pi bash tool accepts timeout in seconds; keep millisecond values if callers already use them.
+  return raw > 10_000 ? Math.floor(raw) : Math.floor(raw * 1000);
+}
+
+function activityFromToolCall(entry: Record<string, unknown>, part: Record<string, unknown>): DelegationActivity | undefined {
+  const id = typeof part.id === "string" ? part.id : undefined;
+  if (!id) return undefined;
+  const name = toolName(part);
+  const lower = name.toLowerCase();
+  const args = toolArguments(part);
+  const startedAtMs = timestampMs(entry);
+  const activity: DelegationActivity = {
+    toolCallId: id,
+    toolName: name,
+    status: "running",
+    startedAtMs,
+    timeoutMs: timeoutMsFromArgs(args),
+  };
+
+  const path = typeof args.path === "string" ? args.path : typeof args.file === "string" ? args.file : undefined;
+  if (lower === "bash") {
+    const command = typeof args.command === "string" ? redactDelegationCommand(args.command) : undefined;
+    activity.command = command;
+    activity.summary = command ? capInline(command, 140) : "shell command";
+  } else if (lower === "read") {
+    activity.target = path;
+    activity.summary = path ? `read ${path}` : "read file";
+  } else if (lower === "grep") {
+    const pattern = typeof args.pattern === "string" ? args.pattern : typeof args.query === "string" ? args.query : undefined;
+    activity.target = path;
+    activity.summary = `grep ${pattern ? capInline(pattern, 60) : "pattern"}${path ? ` in ${path}` : ""}`;
+  } else if (lower === "find") {
+    const pattern = typeof args.pattern === "string" ? args.pattern : "files";
+    activity.target = path;
+    activity.summary = `find ${capInline(pattern, 60)}${path ? ` in ${path}` : ""}`;
+  } else if (lower === "edit" || lower === "write") {
+    activity.target = path;
+    const edits = Array.isArray(args.edits) ? ` · ${args.edits.length} edit${args.edits.length === 1 ? "" : "s"}` : "";
+    activity.summary = `${lower} ${path ?? "file"}${edits}`;
+  } else if (lower === "delegate_task" || lower === "delegate_agent") {
+    const agent = typeof args.agent === "string" ? args.agent : undefined;
+    activity.summary = `${lower}${agent ? ` → ${agent}` : ""}`;
+  } else {
+    activity.summary = Object.entries(args).length > 0
+      ? `${name} ${Object.entries(args).slice(0, 3).map(([key, value]) => `${key}=${typeof value === "string" ? capInline(value, 40) : Array.isArray(value) ? `${value.length} items` : String(value)}`).join(" ")}`
+      : name;
+  }
+
+  return activity;
+}
+
+function resultSummary(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  const compact = compactWhitespace(trimmed);
+  const timeout = compact.match(/Command timed out after\s+([0-9.]+)\s+seconds/i);
+  if (timeout) return `timed out after ${timeout[1]}s`;
+  const lineCount = trimmed.split("\n").length;
+  if (lineCount > 1 || trimmed.length > 120) return `${lineCount} line${lineCount === 1 ? "" : "s"} · ${trimmed.length} chars`;
+  return capInline(trimmed, 140);
+}
+
+function applyToolResult(entry: Record<string, unknown>, message: Record<string, unknown>, byId: Map<string, DelegationActivity>, order: DelegationActivity[]): void {
+  const id = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+  const name = typeof message.toolName === "string" ? message.toolName : "tool";
+  if (!id) return;
+  let activity = byId.get(id);
+  if (!activity) {
+    activity = { toolCallId: id, toolName: name, status: "running" };
+    byId.set(id, activity);
+    order.push(activity);
+  }
+  const endedAtMs = timestampMs(entry);
+  activity.endedAtMs = endedAtMs;
+  activity.elapsedMs = activity.startedAtMs && endedAtMs ? Math.max(0, endedAtMs - activity.startedAtMs) : undefined;
+  activity.status = message.isError === true ? "error" : "success";
+  const text = contentText(message.content);
+  const summary = resultSummary(text);
+  if (message.isError === true) activity.errorSummary = summary ?? "tool error";
+  else activity.outputSummary = summary ?? "completed";
+}
+
+function parseActivityText(text: string, nowMs: number): { recent: DelegationActivity[]; current?: DelegationActivity; lastUpdatedMs?: number } {
+  const byId = new Map<string, DelegationActivity>();
+  const order: DelegationActivity[] = [];
+  let lastUpdatedMs: number | undefined;
+
+  for (const rawLine of text.split("\n")) {
+    if (!rawLine.trim()) continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(rawLine);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const at = timestampMs(parsed);
+    if (at !== undefined) lastUpdatedMs = lastUpdatedMs === undefined ? at : Math.max(lastUpdatedMs, at);
+
+    if (parsed.type === "message" && isRecord(parsed.message)) {
+      const message = parsed.message;
+      if (message.role === "assistant" && Array.isArray(message.content)) {
+        for (const part of message.content) {
+          if (!isRecord(part) || part.type !== "toolCall") continue;
+          const activity = activityFromToolCall(parsed, part);
+          if (!activity) continue;
+          byId.set(activity.toolCallId, activity);
+          order.push(activity);
+        }
+      } else if (message.role === "toolResult") {
+        applyToolResult(parsed, message, byId, order);
+      }
+    }
+  }
+
+  for (const activity of order) {
+    if (activity.status === "running" && activity.startedAtMs !== undefined) activity.elapsedMs = Math.max(0, nowMs - activity.startedAtMs);
+  }
+  const current = [...order].reverse().find((activity) => activity.status === "running");
+  return { recent: order.slice(-DEFAULT_RECENT_LIMIT), current, lastUpdatedMs };
+}
+
+export function readDelegationActivitySnapshot(sessionPath: string | undefined, repoRoot: string, nowMs = Date.now()): DelegationActivitySnapshot {
+  if (!sessionPath) return { status: "missing", note: "Child session is not captured yet.", fingerprint: "no-session", recent: [] };
+  const resolved = resolve(sessionPath);
+  if (!isInside(repoRoot, resolved)) {
+    return { status: "blocked", note: `Child session path is outside repo root: ${sessionPath}`, fingerprint: `blocked:${sessionPath}`, recent: [] };
+  }
+  if (!existsSync(resolved)) return { status: "missing", note: `Child session file not found yet: ${sessionPath}`, fingerprint: `missing:${sessionPath}`, recent: [] };
+  const stat = statSync(resolved);
+  if (stat.size === 0) return { status: "empty", note: "Child session file is empty.", fingerprint: `${resolved}:0:${Math.floor(stat.mtimeMs)}`, recent: [], lastUpdatedMs: Math.floor(stat.mtimeMs), quietMs: Math.max(0, nowMs - stat.mtimeMs) };
+  const text = readTail(resolved, stat.size, ACTIVITY_MAX_BYTES);
+  const parsed = parseActivityText(text, nowMs);
+  const lastUpdatedMs = parsed.lastUpdatedMs ?? Math.floor(stat.mtimeMs);
+  const cappedNote = stat.size > ACTIVITY_MAX_BYTES ? `Activity feed read from last ${ACTIVITY_MAX_BYTES} bytes of ${stat.size} bytes.` : undefined;
+  return {
+    status: "ok",
+    note: cappedNote,
+    fingerprint: `${resolved}:${stat.size}:${Math.floor(stat.mtimeMs)}`,
+    recent: parsed.recent,
+    current: parsed.current,
+    lastUpdatedMs,
+    quietMs: Math.max(0, nowMs - Math.max(lastUpdatedMs, Math.floor(stat.mtimeMs))),
+  };
+}
+
+export function formatActivityDuration(ms: number | undefined): string | undefined {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return undefined;
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+  const seconds = totalSeconds % 60;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const hours = Math.floor(totalSeconds / 3600);
+  const pad2 = (value: number): string => String(value).padStart(2, "0");
+  if (hours > 0) return `${hours}:${pad2(minutes)}:${pad2(seconds)}`;
+  return `${pad2(minutes)}:${pad2(seconds)}`;
+}
+
+export function formatActivitySummary(activity: DelegationActivity, options: { includeCommand?: boolean; nowMs?: number } = {}): string[] {
+  const icon = activity.status === "running" ? "◉" : activity.status === "success" ? "✓" : "✗";
+  const duration = formatActivityDuration(activity.elapsedMs ?? (activity.status === "running" && activity.startedAtMs ? (options.nowMs ?? Date.now()) - activity.startedAtMs : undefined));
+  const timeout = formatActivityDuration(activity.timeoutMs);
+  const detail = activity.status === "running"
+    ? [duration ? `running ${duration}` : "running", timeout ? `timeout ${timeout}` : undefined].filter(Boolean).join(" / ")
+    : activity.errorSummary ?? activity.outputSummary ?? (activity.status === "success" ? "done" : "error");
+  const summary = activity.summary ?? activity.command ?? activity.target ?? activity.toolName;
+  const lines = [`${icon} ${activity.toolName}${detail ? ` · ${detail}` : ""}${summary && activity.toolName.toLowerCase() !== summary.toLowerCase() ? ` · ${summary}` : ""}`];
+  if (options.includeCommand && activity.command) lines.push(`$ ${activity.command}`);
+  return lines;
+}

package/.pi/extensions/zob-harness/src/runtime/delegation-feed.ts

@@ -4,6 +4,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Markdown, truncateToWidth, visibleWidth, type MarkdownTheme } from "@earendil-works/pi-tui";
 
 import { delegationDurationMs, delegationSignalBadge, delegationSignalColor, formatDelegationContextLabel, formatDelegationCostLabel, formatDelegationModelLabel, formatDelegationSignalBadge, formatDuration, statusIcon, type DelegationRunView } from "./delegation-monitor.js";
+import { formatActivityDuration, formatActivitySummary, readDelegationActivitySnapshot } from "./delegation-activity.js";
 import { sanitizeDelegationText } from "./delegation-markdown.js";
 import { isRecord } from "../core/utils/records.js";
 
@@ -180,6 +181,31 @@ function actionCard(lines: string[], title: string, details: string[], width: nu
   }
 }
 
+function renderLiveActivityCard(run: DelegationRunView, repoRoot: string, lines: string[], width: number, theme: Theme, nowMs = Date.now()): void {
+  const snapshot = readDelegationActivitySnapshot(run.sessionPath, repoRoot, nowMs);
+  if (snapshot.recent.length === 0) return;
+  pushSpacer(lines);
+  const bgKey = snapshot.current ? "toolPendingBg" : "toolSuccessBg";
+  lines.push(theme.bg(bgKey, padToWidth(theme.fg(snapshot.current ? "toolTitle" : "success", theme.bold(" Live activity")), width)));
+  if (snapshot.current) {
+    for (const line of formatActivitySummary(snapshot.current, { includeCommand: true, nowMs })) {
+      lines.push(theme.bg(bgKey, padToWidth(theme.fg(line.startsWith("$") ? "toolOutput" : "warning", `   ${line}`), width)));
+    }
+    if (typeof snapshot.quietMs === "number" && snapshot.quietMs >= 120_000) {
+      const quiet = `quiet ${formatActivityDuration(snapshot.quietMs)} since last transcript update`;
+      lines.push(theme.bg(bgKey, padToWidth(theme.fg(snapshot.quietMs >= 300_000 ? "warning" : "muted", `   ${quiet}`), width)));
+    }
+  }
+  const recent = snapshot.recent.slice(-5).filter((activity) => activity.toolCallId !== snapshot.current?.toolCallId);
+  if (recent.length > 0) lines.push(theme.bg(bgKey, padToWidth(theme.fg("muted", "   last actions"), width)));
+  for (const activity of recent) {
+    const colorKey = activity.status === "error" ? "error" : activity.status === "running" ? "warning" : "success";
+    const first = formatActivitySummary(activity, { nowMs })[0];
+    if (first) lines.push(theme.bg(bgKey, padToWidth(theme.fg(colorKey, `   ${first}`), width)));
+  }
+  if (snapshot.note) lines.push(theme.bg(bgKey, padToWidth(theme.fg("muted", `   ${snapshot.note}`), width)));
+}
+
 function failureDetails(run: DelegationRunView, fallback: string): string[] {
   const details: string[] = [];
   if (run.errorMessage) details.push(`message: ${sanitizeDelegationText(run.errorMessage)}`);
@@ -372,6 +398,7 @@ export function renderDelegationFeedLines(run: DelegationRunView | undefined, re
   lines.push(theme.fg("dim", `${statusIcon(run.status)} ${run.agent}${signalText ? ` · ${theme.fg(delegationSignalColor(signalBadge), signalText)}` : ""}${modelLabel ? ` · ${theme.fg("muted", `(${modelLabel})`)}` : ""} · ${run.status}${run.failureKind ? ` · ${run.failureKind}` : ""} · ${formatDuration(delegationDurationMs(run))} · ${formatDelegationCostLabel(run)} · ${formatDelegationContextLabel(run)}`));
   if (run.usage) lines.push(theme.fg("muted", `usage · in ${run.usage.input} · out ${run.usage.output} · cache ${run.usage.cacheRead}/${run.usage.cacheWrite} · context ${run.usage.contextTokens}`));
   if (run.taskPreview) lines.push(theme.fg("muted", `task · ${sanitizeDelegationText(run.taskPreview)}`));
+  renderLiveActivityCard(run, repoRoot, lines, safeWidth, theme);
   let renderedFailureSummary = false;
   if (run.failureKind === "preflight" || run.failureKind === "config") {
     renderedFailureSummary = true;

package/.pi/extensions/zob-harness/src/runtime/delegation-monitor.ts

@@ -40,6 +40,7 @@ export interface DelegationRunView {
   childChangedPaths?: ChildResult["childChangedPaths"];
   usage?: ChildResult["usage"];
   model?: string;
+  background?: boolean;
 }
 
 export interface DelegationMonitorState {
@@ -73,6 +74,8 @@ const TRANSCRIPT_MAX_BYTES = 240_000;
 const TRANSCRIPT_MAX_LINES = 1_200;
 const WIDGET_COMPLETE_TTL_MS = 30_000;
 const WIDGET_FAILURE_TTL_MS = 120_000;
+const WIDGET_BACKGROUND_COMPLETE_TTL_MS = 10 * 60_000;
+const WIDGET_BACKGROUND_FAILURE_TTL_MS = 30 * 60_000;
 
 function capPreview(text: string | undefined, limit = PREVIEW_LIMIT): string {
   const value = text ?? "";
@@ -362,6 +365,10 @@ export function shouldShowRunInWidget(run: DelegationRunView, nowMs = Date.now()
   if (run.status === "queued" || run.status === "running") return true;
   if (!run.endedAtMs) return false;
   const ageMs = Math.max(0, nowMs - run.endedAtMs);
+  if (run.background) {
+    if (run.status === "complete") return ageMs <= WIDGET_BACKGROUND_COMPLETE_TTL_MS;
+    return ageMs <= WIDGET_BACKGROUND_FAILURE_TTL_MS;
+  }
   if (run.status === "complete") return ageMs <= WIDGET_COMPLETE_TTL_MS;
   return ageMs <= WIDGET_FAILURE_TTL_MS;
 }
@@ -466,6 +473,7 @@ export function updateDelegationRun(state: DelegationMonitorState, id: string, p
   if (patch.errorMessage !== undefined) run.errorMessage = patch.errorMessage;
   if (patch.usage !== undefined) run.usage = patch.usage;
   if (patch.model !== undefined) run.model = patch.model;
+  if (patch.background !== undefined) run.background = patch.background;
   return run;
 }
 

package/.pi/extensions/zob-harness/src/runtime/state.ts

@@ -414,6 +414,8 @@ function restoreDelegationRunsFromEntries(state: HarnessRuntimeState, entries: u
       errorMessage: Array.isArray(data.errors) ? data.errors.map(String).join("; ") : existing?.errorMessage,
       childChangedPaths: normalizeZcommitChildChangedPathRefs(data.childChangedPathRefs) ?? existing?.childChangedPaths,
       usage: usageField(data) ?? existing?.usage,
+      model: stringField(data, "model") ?? existing?.model,
+      background: (typeof data.background === "boolean" ? data.background : undefined) ?? existing?.background,
     };
     if (event === "start") restoredRun.endedAtMs = existing?.endedAtMs;
     restored.set(runId, restoredRun);

package/.pi/extensions/zob-harness/src/runtime/tools-delegation/helpers.ts

@@ -40,7 +40,9 @@ import {
   statusIcon,
   updateDelegationRun,
   type DelegationRunMode,
+  type DelegationRunView,
 } from "../delegation-monitor.js";
+import { formatActivityDuration, formatActivitySummary, readDelegationActivitySnapshot } from "../delegation-activity.js";
 import { delegateViewLink } from "../delegation-mouse.js";
 import type { BackgroundDelegationRuntimeRun, HarnessRuntimeState } from "../state.js";
 import { strictGoalErrors, strictGoalSpecErrors } from "../state.js";
@@ -728,6 +730,32 @@ export function formatDelegationCatalogSummary(catalog: Record<string, unknown>)
   return lines.join("\n");
 }
 
+function renderMiniActivityLines(run: DelegationRunView, nowMs: number, expanded: boolean, theme: { fg: (color: any, text: string) => string }): string[] {
+  const lines: string[] = [];
+  const snapshot = readDelegationActivitySnapshot(run.sessionPath, process.cwd(), nowMs);
+  const recent = snapshot.recent.slice(-5);
+  if (recent.length === 0) {
+    if ((run.status === "running" || run.status === "queued") && snapshot.note && snapshot.status !== "missing") {
+      lines.push(`   ${theme.fg("muted", snapshot.note)}`);
+    }
+    return lines;
+  }
+  const label = expanded ? "last actions" : "last";
+  lines.push(`   ${theme.fg("dim", `${label} ${recent.length}`)}`);
+  for (const activity of recent) {
+    const color = activity.status === "running" ? "warning" : activity.status === "error" ? "error" : "success";
+    const includeCommand = activity.status === "running" && activity.toolName.toLowerCase() === "bash";
+    const rendered = formatActivitySummary(activity, { includeCommand, nowMs });
+    const [first, ...rest] = rendered;
+    if (first) lines.push(`   ${theme.fg(color, first)}`);
+    for (const extra of rest.slice(0, expanded ? 2 : 1)) lines.push(`     ${theme.fg("muted", extra)}`);
+  }
+  if (snapshot.current && typeof snapshot.quietMs === "number" && snapshot.quietMs >= 120_000) {
+    lines.push(`   ${theme.fg(snapshot.quietMs >= 300_000 ? "warning" : "muted", `quiet ${formatActivityDuration(snapshot.quietMs)} since last transcript update`)}`);
+  }
+  return lines;
+}
+
 export function renderDelegationToolResultText(source: "delegate_agent" | "delegate_task", details: DelegationDetails | undefined, state: HarnessRuntimeState, toolCallId: string | undefined, isPartial: boolean, expanded: boolean, theme: { fg: (color: any, text: string) => string; bold: (text: string) => string }): string {
   hydrateDelegationRunsFromDetails(source, details, state, toolCallId);
   const nowMs = Date.now();
@@ -754,11 +782,13 @@ export function renderDelegationToolResultText(source: "delegate_agent" | "deleg
       const prefix = index === visibleRuns.length - 1 && !hasMore ? "└─" : "├─";
       const viewHint = delegateViewLink(run.id);
       const kind = run.failureKind ? ` ${run.failureKind}` : "";
+      const background = run.background ? " bg" : "";
       const badge = delegationSignalBadge(run);
       const badgeText = formatDelegationSignalBadge(badge);
       const modelLabel = formatDelegationModelLabel(run);
       const modelSuffix = modelLabel ? ` ${theme.fg("muted", `(${modelLabel})`)}` : "";
-      lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${statusIcon(run.status)} ${run.agent}${kind}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix} ${theme.fg("dim", formatDuration(delegationDurationMs(run, nowMs)))} ${theme.fg("muted", viewHint)}`);
+      lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${statusIcon(run.status)} ${run.agent}${kind}${background}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix} ${theme.fg("dim", formatDuration(delegationDurationMs(run, nowMs)))} ${theme.fg("muted", viewHint)}`);
+      lines.push(...renderMiniActivityLines(run, nowMs, expanded, theme));
       if (expanded && (run.errorMessage || run.stopReason || run.gateErrors?.length)) lines.push(`   ${theme.fg("dim", run.errorMessage ?? run.gateErrors?.join("; ") ?? run.stopReason ?? "")}`);
     }
     if (hasMore) lines.push(theme.fg("dim", `└─ … ${monitoredRuns.length - maxRows} more child run(s)`));

package/.pi/extensions/zob-harness/src/runtime/tools-delegation/register.ts

@@ -827,6 +827,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           taskHash: sha256(structuredTask),
           originalUserAskHash: sha256(params.original_user_ask ?? state.activeGoal?.originalUserAsk ?? ""),
           outputContract,
+          background: params.run_in_background === true,
           startedAt,
         });
 
@@ -975,6 +976,8 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
       };
 
       if (params.run_in_background) {
+        updateDelegationRun(state.delegations, runId, { background: true });
+        renderDelegationMonitor();
         const backgroundController = new AbortController();
         const backgroundPromise = runDelegateTaskChild(backgroundController.signal, false);
         const backgroundRun: BackgroundDelegationRuntimeRun = { runId, startedAtMs, promise: backgroundPromise, abortController: backgroundController };

package/.pi/extensions/zob-harness/src/runtime/widget.ts

@@ -8,7 +8,8 @@ import { isRecord } from "../core/utils/records.js";
 import type { AssistantLikeMessage, ModeName } from "../types.js";
 import { readHarnessReadinessWidgetData } from "../domains/orchestration/widget-readers.js";
 import { buildZpeerPeerRoomSummaries, type ZpeerPeerRoomSummary } from "../domains/coms/coms-v2/zpeer.js";
-import { delegationCost, delegationDurationMs, formatDelegationCost, formatDuration, summarizeDelegations } from "./delegation-monitor.js";
+import { delegationCost, delegationDurationMs, formatDelegationCost, formatDuration, listWidgetDelegationRuns, summarizeDelegations } from "./delegation-monitor.js";
+import { formatActivitySummary, readDelegationActivitySnapshot } from "./delegation-activity.js";
 import { disposeDelegationMouseSupport } from "./delegation-mouse.js";
 import { formatZcompactHudLine } from "./auto-compaction.js";
 import type { HarnessRuntimeState } from "./state.js";
@@ -339,9 +340,18 @@ export function renderHarnessWidget(pi: ExtensionAPI, state: HarnessRuntimeState
             ? "working"
             : "idle";
         const assistantsCount = delegationSummary.running + delegationSummary.queued + (runtimeTodoSummary?.delegated ?? 0);
-        const assistantsState = assistantsCount > 0
-          ? `${assistantsCount} active`
-          : "none";
+        const widgetDelegationRuns = listWidgetDelegationRuns(state.delegations, renderNowMs);
+        const activeDelegationRun = widgetDelegationRuns.find((run) => run.status === "running" || run.status === "queued") ?? widgetDelegationRuns[0];
+        const activeDelegationSnapshot = activeDelegationRun ? readDelegationActivitySnapshot(activeDelegationRun.sessionPath, ctx.cwd, renderNowMs) : undefined;
+        const activeDelegationActivity = activeDelegationSnapshot?.current ?? activeDelegationSnapshot?.recent.at(-1);
+        const activeDelegationLine = activeDelegationRun && activeDelegationActivity
+          ? `${activeDelegationRun.agent}: ${formatActivitySummary(activeDelegationActivity, { nowMs: renderNowMs })[0] ?? activeDelegationActivity.toolName}`
+          : undefined;
+        const assistantsState = activeDelegationLine
+          ? truncateToWidth(`${assistantsCount > 0 ? `${assistantsCount} active` : "recent"} · ${activeDelegationLine}`, 96, "…")
+          : assistantsCount > 0
+            ? `${assistantsCount} active`
+            : "none";
         const zpeerRoomSummaries = cachedZpeerRoomSummaries(state, ctx, renderNowMs);
         const zpeerLast = state.zobLive.lastEvent
           ? `${state.zobLive.lastEvent.kind} ${state.zobLive.lastEvent.fromAlias ? `@${state.zobLive.lastEvent.fromAlias}` : "?"}→${state.zobLive.lastEvent.toAlias ? `@${state.zobLive.lastEvent.toAlias}` : "?"} ${state.zobLive.lastEvent.status}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zob-harness",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "type": "module",
   "description": "A governed Agent Factory for Pi: launch communicating agent teams, run tmux-backed factories, validate artifacts, and package repeatable workflows.",
   "license": "MIT",