zob-harness 0.9.1 → 0.10.0

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts

@@ -97,6 +97,21 @@ function readLeasesFromDir(dir: string, nowMs: number, teamName?: string): ZobLi
     .map((lease) => leaseToPeerCard(lease, nowMs));
 }
 
+function peerRegistryKey(peer: Pick<ZobLivePeerCard, "projectId" | "roleId" | "sessionHash">): string {
+  return `${peer.projectId}:${peer.roleId}:${peer.sessionHash}`;
+}
+
+function mergeLeaseBackedAndAdhocPeers(leasePeers: ZobLivePeerCard[], agentPeers: ZobLivePeerCard[]): ZobLivePeerCard[] {
+  const byKey = new Map<string, ZobLivePeerCard>();
+  for (const peer of leasePeers) byKey.set(peerRegistryKey(peer), peer);
+  for (const peer of agentPeers) {
+    if (peer.zpeerAdhoc !== true) continue;
+    const key = peerRegistryKey(peer);
+    if (!byKey.has(key)) byKey.set(key, peer);
+  }
+  return [...byKey.values()];
+}
+
 function boundedOfflinePeerRetentionMs(value: number | undefined): number {
   const env = Number.parseInt(process.env.ZOB_COMS_OFFLINE_PEER_RETENTION_MS ?? "", 10);
   const raw = typeof value === "number" && Number.isFinite(value) ? value : Number.isFinite(env) ? env : DEFAULT_OFFLINE_PEER_RETENTION_MS;
@@ -514,8 +529,13 @@ export function unregisterCurrentZobLivePeer(repoRoot: string, teamName = "zob-c
 export function readZobLiveRegistrySnapshot(repoRoot: string, teamName?: string): ZobLiveRegistrySnapshot {
   const { dir, projectId, kind } = projectLeasesDir(repoRoot);
   const nowMs = Date.now();
-  if (existsSync(dir)) return buildSnapshot(projectId, kind, readLeasesFromDir(dir, nowMs, teamName), teamName);
   const agents = projectAgentsDir(repoRoot);
+  if (existsSync(dir)) {
+    return buildSnapshot(projectId, kind, mergeLeaseBackedAndAdhocPeers(
+      readLeasesFromDir(dir, nowMs, teamName),
+      readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName),
+    ), teamName);
+  }
   return buildSnapshot(agents.projectId, agents.kind, readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName), teamName);
 }
 
@@ -523,9 +543,10 @@ export function readZobLiveRegistryAllProjectsSnapshot(repoRoot: string, teamNam
   const { projectId, kind } = projectAgentsDir(repoRoot);
   const nowMs = Date.now();
   const leaseDirs = allProjectLeasesDirs();
+  const agentPeers = allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
   const hasLeaseDomain = leaseDirs.some((dir) => existsSync(dir));
   const peers = hasLeaseDomain
-    ? leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName))
-    : allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
+    ? mergeLeaseBackedAndAdhocPeers(leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName)), agentPeers)
+    : agentPeers;
   return buildSnapshot(projectId, kind, peers, teamName);
 }

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/types.ts

@@ -109,6 +109,7 @@ export interface ZobLivePeerCard {
   zpeerActiveRoomId?: string;
   zpeerMemberships?: ZpeerRoomMembership[];
   zpeerLocalOnly?: true;
+  zpeerAdhoc?: true;
   staleAfterMs: number;
   offlineAfterMs: number;
   bodyStored: false;

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts

@@ -234,7 +234,7 @@ export function refreshZpeerSelf(repoRoot: string, peer: ZobLivePeerCard, roomId
   const ensured = ensureZpeerFields(repoRoot, peer, roomId, alias, restoredMemberships);
   if (!hasLocalSocketEndpointEvidence(ensured)) return ensured;
   const refreshed = writeZobLivePeerCard(repoRoot, { ...ensured, heartbeatAt: new Date().toISOString(), status: "online" });
-  writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
+  if (refreshed.zpeerAdhoc !== true) writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
   return refreshed;
 }
 
@@ -479,8 +479,10 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
   };
 
   if (!selfMembership) return finish("attempt", { status: "blocked", reason: `current peer is not a member of room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
-  const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
-  if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  if (self.zpeerAdhoc !== true) {
+    const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
+    if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  }
   if (selfMembership.role === "observer") return finish("attempt", { status: "blocked", reason: `current peer is observer-only in room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
   if (!targetAlias) return finish("attempt", { status: "blocked", reason: "invalid target alias", bodyStored: false });
   if (!transientPrompt.trim()) return finish("attempt", { status: "blocked", reason: "empty peer prompt", targetAlias, bodyStored: false });

package/.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { discoverAgents } from "./agents.js";
 import { SUPERVISED_READONLY_CHILD_TOOLS } from "../../core/constants.js";
@@ -24,6 +24,28 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
   return { command: "pi", args };
 }
 
+function childModelPattern(ctx: ExtensionContext, agent: HarnessAgent, modelOverride: string | undefined): string | undefined {
+  if (modelOverride?.trim()) return modelOverride.trim();
+  if (agent.model?.trim()) return agent.model.trim();
+  const model = ctx.model;
+  if (!model?.provider || !model.id) return undefined;
+  return `${model.provider}/${model.id}`;
+}
+
+function providerFromModelPattern(model: string | undefined): string | undefined {
+  if (!model) return undefined;
+  const [provider] = model.split("/");
+  return provider && provider !== model ? provider : undefined;
+}
+
+function resolveCodexFastModeExtension(ctx: ExtensionContext, model: string | undefined): string | undefined {
+  const provider = ctx.model?.provider ?? providerFromModelPattern(model);
+  const usesCodexProvider = provider === "openai-codex" || provider === "codex-auto" || provider?.startsWith("codex-") === true;
+  if (!usesCodexProvider) return undefined;
+  const extensionPath = join(getAgentDir(), "extensions", "codex-fast-mode.ts");
+  return existsSync(extensionPath) ? extensionPath : undefined;
+}
+
 const CHILD_THINKING_LEVELS = new Set<string>(["low", "medium", "high", "xhigh"]);
 
 function validateChildThinkingOverride(thinking: string | undefined, fieldName = "thinking"): string[] {
@@ -90,13 +112,14 @@ async function runChildAgent(
   pathPolicy?: { allowedPaths?: string[]; forbiddenPaths?: string[]; sandboxRoot?: string },
   thinkingOverride?: ChildThinkingLevel,
 ): Promise<ChildResult> {
+  const resolvedModel = childModelPattern(ctx, agent, modelOverride);
   const result: ChildResult = {
     agent: agent.name,
     task,
     exitCode: 0,
     output: "",
     stderr: "",
-    model: modelOverride ?? agent.model,
+    model: resolvedModel,
     usage: usageEmpty(),
   };
 
@@ -123,10 +146,12 @@ async function runChildAgent(
 
   try {
     const childSafetyExtension = join(ctx.cwd, ".pi", "extensions", "zob-child-safety", "index.ts");
+    const childCodexFastModeExtension = resolveCodexFastModeExtension(ctx, resolvedModel);
     const args = ["--mode", "json", "-p", "--no-extensions"];
+    if (childCodexFastModeExtension) args.push("-e", childCodexFastModeExtension);
     if (existsSync(childSafetyExtension)) args.push("-e", childSafetyExtension);
     args.push("--session", sessionPath);
-    const model = modelOverride ?? agent.model;
+    const model = resolvedModel;
     if (model) args.push("--model", model);
     const thinking = resolveChildThinking(agent, thinkingOverride);
     if (thinking) args.push("--thinking", thinking);

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/events.ts

@@ -132,6 +132,19 @@ function activeZagentState(state: HarnessRuntimeState): ActiveZagentState | unde
   return state.zagent.id ? state.zagent as ActiveZagentState : undefined;
 }
 
+function zpeerStableTeamAgentLeaseRequired(zagent: ActiveZagentState | undefined): boolean {
+  return Boolean(
+    zagent?.id
+    || process.env.ZOB_ZAGENT_ID?.trim()
+    || process.env.ZOB_ZTEAM_ID?.trim()
+    || process.env.ZOB_COMS_ROLE_ID?.trim(),
+  );
+}
+
+function withZpeerLeaseMode<T extends NonNullable<HarnessRuntimeState["zobLive"]["peerCard"]>>(peer: T, useStableTeamAgentLease: boolean): T {
+  return { ...peer, zpeerAdhoc: useStableTeamAgentLease ? undefined : true } as T;
+}
+
 function formatScopedZteamModeLabel(scopedMode: ActiveZagentState["scopedMode"]): string | undefined {
   if (!scopedMode?.active || !scopedMode.teamId || !scopedMode.modeId || !scopedMode.baseMode) return undefined;
   return `zob:${scopedMode.baseMode}@${scopedMode.teamId}/${scopedMode.modeId}`;
@@ -511,6 +524,7 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
   if (carryoverProfile?.zagentId && state.zagent.id !== carryoverProfile.zagentId) loadActiveZagentById(state, repoRoot, carryoverProfile.zagentId);
   const sharedZpeerProfile = zpeerProfile ? zpeerProfileIdIsSharedFallback(zpeerProfile.profileId) : false;
   const zagent = activeZagentState(state);
+  const useStableTeamAgentLease = zpeerStableTeamAgentLeaseRequired(zagent);
   const zagentMemberships = zagent ? zagentRoomMemberships(zagent) : undefined;
   const zagentActiveRoomId = zagent?.activeRoom ?? zagentMemberships?.find((membership) => membership.roomId)?.roomId;
   const zpeerProfileRoomId = zagentActiveRoomId ?? zpeerProfile?.activeRoomId ?? zpeerProfile?.roomId ?? carryoverProfile?.activeRoomId ?? carryoverProfile?.roomId;
@@ -579,7 +593,7 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
       }, { triggerTurn: true, deliverAs: "followUp" });
       return buildZobLiveAckEnvelope(envelope);
     });
-    const peerCard = ensureZpeerFields(repoRoot, {
+    const peerCard = withZpeerLeaseMode(ensureZpeerFields(repoRoot, {
       ...basePeer,
       team: zagent?.team ?? basePeer.team,
       roleId: zagent?.id ?? basePeer.roleId,
@@ -588,58 +602,78 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
       endpoint,
       endpointHash: sha256(endpoint),
       status: "online" as const,
-    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships);
+    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships), useStableTeamAgentLease);
     state.zobLive.server = server;
-    const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_start" });
-    if (leaseClaim.ok) {
+    if (!useStableTeamAgentLease) {
+      releaseZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_adhoc" });
       state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
-      state.zobLive.leaseOwned = true;
-      state.zobLive.leaseStatus = "owned";
+      state.zobLive.leaseOwned = false;
+      state.zobLive.leaseStatus = "unavailable";
       state.zobLive.leaseBlockReason = undefined;
       state.zobLive.lastHeartbeatMs = Date.now();
       scheduleZpeerHeartbeat(pi, state, ctx);
     } else {
-      state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, server);
-      setZpeerLastEvent(state, {
-        kind: "blocked",
-        roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
-        fromAlias: state.zobLive.peerCard.zpeerAlias,
-        status: "lease_blocked",
-        reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
-      });
+      const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_start" });
+      if (leaseClaim.ok) {
+        state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
+        state.zobLive.leaseOwned = true;
+        state.zobLive.leaseStatus = "owned";
+        state.zobLive.leaseBlockReason = undefined;
+        state.zobLive.lastHeartbeatMs = Date.now();
+        scheduleZpeerHeartbeat(pi, state, ctx);
+      } else {
+        state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, server);
+        setZpeerLastEvent(state, {
+          kind: "blocked",
+          roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
+          fromAlias: state.zobLive.peerCard.zpeerAlias,
+          status: "lease_blocked",
+          reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
+        });
+      }
     }
     try { writeZpeerLocalProfileFromPeer(repoRoot, state.zobLive.peerCard, profileId); } catch { /* best-effort reload continuity; live runtime must remain available */ }
   } else {
-    const peerCard = ensureZpeerFields(repoRoot, {
+    const peerCard = withZpeerLeaseMode(ensureZpeerFields(repoRoot, {
       ...state.zobLive.peerCard,
       team: zagent?.team ?? state.zobLive.peerCard.team,
       roleId: zagent?.id ?? state.zobLive.peerCard.roleId,
       agent: zagent?.id ?? state.zobLive.peerCard.agent,
       heartbeatAt: new Date().toISOString(),
       status: "online",
-    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships);
-    const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_refresh" });
-    if (leaseClaim.ok) {
+    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships), useStableTeamAgentLease);
+    if (!useStableTeamAgentLease) {
+      releaseZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_adhoc" });
       state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
-      state.zobLive.leaseOwned = true;
-      state.zobLive.leaseStatus = "owned";
+      state.zobLive.leaseOwned = false;
+      state.zobLive.leaseStatus = "unavailable";
       state.zobLive.leaseBlockReason = undefined;
       state.zobLive.lastHeartbeatMs = Date.now();
       scheduleZpeerHeartbeat(pi, state, ctx);
-    } else if (state.zobLive.server) {
-      state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, state.zobLive.server);
-      setZpeerLastEvent(state, {
-        kind: "blocked",
-        roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
-        fromAlias: state.zobLive.peerCard.zpeerAlias,
-        status: "lease_blocked",
-        reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
-      });
     } else {
-      state.zobLive.peerCard = writeZobLivePeerCard(repoRoot, { ...peerCard, heartbeatAt: new Date().toISOString(), status: "offline" });
-      state.zobLive.leaseOwned = false;
-      state.zobLive.leaseStatus = "blocked";
-      state.zobLive.leaseBlockReason = "blocked_live_owner";
+      const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_refresh" });
+      if (leaseClaim.ok) {
+        state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
+        state.zobLive.leaseOwned = true;
+        state.zobLive.leaseStatus = "owned";
+        state.zobLive.leaseBlockReason = undefined;
+        state.zobLive.lastHeartbeatMs = Date.now();
+        scheduleZpeerHeartbeat(pi, state, ctx);
+      } else if (state.zobLive.server) {
+        state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, state.zobLive.server);
+        setZpeerLastEvent(state, {
+          kind: "blocked",
+          roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
+          fromAlias: state.zobLive.peerCard.zpeerAlias,
+          status: "lease_blocked",
+          reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
+        });
+      } else {
+        state.zobLive.peerCard = writeZobLivePeerCard(repoRoot, { ...peerCard, heartbeatAt: new Date().toISOString(), status: "offline" });
+        state.zobLive.leaseOwned = false;
+        state.zobLive.leaseStatus = "blocked";
+        state.zobLive.leaseBlockReason = "blocked_live_owner";
+      }
     }
     try { writeZpeerLocalProfileFromPeer(repoRoot, state.zobLive.peerCard, profileId); } catch { /* best-effort reload continuity; live runtime must remain available */ }
   }

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.1",
+  "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",

package/scripts/zpeer-local-e2e-smoke.mjs

@@ -200,6 +200,8 @@ async function main() {
   const gammaEndpoint = join(root, 'gamma.sock');
   const workerOneEndpoint = join(root, 'worker-one.sock');
   const workerTwoEndpoint = join(root, 'worker-two.sock');
+  const adhocOneEndpoint = join(root, 'adhoc-one.sock');
+  const adhocTwoEndpoint = join(root, 'adhoc-two.sock');
   const pendingReplies = new Map();
   const receivedPrompts = [];
   const receivedResponses = [];
@@ -244,6 +246,11 @@ async function main() {
     receivedPrompts.push(incoming);
     return envelope.buildZobLiveAckEnvelope(incoming);
   }));
+  servers.push(await localTransport.bindZobLocalEndpoint(adhocOneEndpoint, async (incoming) => envelope.buildZobLiveAckEnvelope(incoming)));
+  servers.push(await localTransport.bindZobLocalEndpoint(adhocTwoEndpoint, async (incoming) => {
+    receivedPrompts.push(incoming);
+    return envelope.buildZobLiveAckEnvelope(incoming);
+  }));
 
   const oldHeartbeatAt = new Date(Date.now() - 180_000).toISOString();
   let alpha = zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'alpha', roomId: 'room-one', endpoint: alphaEndpoint, endpointHash: hashing.sha256(alphaEndpoint), sha256: hashing.sha256, heartbeatAt: oldHeartbeatAt }), 'room-one', 'alpha');
@@ -279,6 +286,17 @@ async function main() {
     });
   });
 
+  const adhocOne = zpeer.refreshZpeerSelf(repoRoot, { ...zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'adhocone', roomId: 'adhoc-room', endpoint: adhocOneEndpoint, endpointHash: hashing.sha256(adhocOneEndpoint), sha256: hashing.sha256 }), 'adhoc-room', 'adhocone'), zpeerAdhoc: true });
+  const adhocTwo = zpeer.refreshZpeerSelf(repoRoot, { ...zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'adhoctwo', roomId: 'adhoc-room', endpoint: adhocTwoEndpoint, endpointHash: hashing.sha256(adhocTwoEndpoint), sha256: hashing.sha256 }), 'adhoc-room', 'adhoctwo'), zpeerAdhoc: true });
+  assert(adhocOne.zpeerAdhoc === true && adhocTwo.zpeerAdhoc === true, 'direct/ad-hoc zpeer peers must carry the ad-hoc marker');
+  const adhocSummary = zpeer.buildZpeerRoomSummary(repoRoot, adhocOne, 'adhoc-room');
+  assert(adhocSummary.peerCount === 2 && adhocSummary.online === 2, `ad-hoc room summary expected 2 online peers even with lease domain present, got ${adhocSummary.online}/${adhocSummary.peerCount}`);
+  assert(adhocSummary.aliases.includes('adhocone') && adhocSummary.aliases.includes('adhoctwo'), 'ad-hoc room summary must include both direct peers');
+  const adhocPromptCountBefore = receivedPrompts.length;
+  const adhocAsync = await zpeer.sendZpeerPrompt(repoRoot, adhocOne, 'adhoctwo', rawPrompt, waitForReply, { mode: 'async' });
+  assert(adhocAsync.status === 'waiting', `ad-hoc same-room send expected waiting after ACK, got ${adhocAsync.status}${adhocAsync.reason ? `: ${adhocAsync.reason}` : ''}`);
+  assert(receivedPrompts.length === adhocPromptCountBefore + 1 && receivedPrompts.at(-1).receiver === 'adhoctwo', 'ad-hoc same-room send must deliver to the target without a stable team-agent lease');
+
   const joinedAlpha = await zpeer.joinZpeerRoom(repoRoot, alpha, 'shared-room', 'sharedalpha', 'bridge');
   assert(joinedAlpha.ok === true, `alpha multi-room join expected ok, got ${joinedAlpha.reason ?? 'not ok'}`);
   alpha = joinedAlpha.peer;

package/scripts/zpeer-static-smoke.mjs

@@ -34,6 +34,7 @@ const files = [
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts',
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer-profile.ts',
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/transcript-capture.ts',
+  '.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts',
   '.pi/extensions/zob-harness/src/runtime/commands.ts',
   '.pi/extensions/zob-harness/src/runtime/tools-coms.ts',
   '.pi/extensions/zob-harness/src/runtime/events.ts',
@@ -82,7 +83,7 @@ for (const forbidden of ['transientPrompt:', 'transientResponse:', 'prompt:', 'o
 const zpeer = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts'];
 const liveRegistry = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts'];
 const zpeerProfile = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer-profile.ts'];
-for (const needle of ['networkEnabled: false', 'localOnly: true', 'bodyStored: false', 'sendZobLocalEnvelope', 'taskHash', 'outputHash', 'ZpeerSendMode', 'status: "waiting"', 'status: "reply"', 'zpeerMembershipsForPeer', 'joinZpeerRoom', 'leaveZpeerRoom', 'useZpeerRoom', 'clearZpeerRoom', 'preservedSelf: true', 'roomId?: string', 'buildZpeerPeerRoomSummaries', 'active: membership.roomId === activeRoomId', 'peerRespondsToAliasPing', 'activeAliasCollision', 'zpeer-alias-ping']) {
+for (const needle of ['networkEnabled: false', 'localOnly: true', 'bodyStored: false', 'sendZobLocalEnvelope', 'taskHash', 'outputHash', 'ZpeerSendMode', 'status: "waiting"', 'status: "reply"', 'zpeerMembershipsForPeer', 'joinZpeerRoom', 'leaveZpeerRoom', 'useZpeerRoom', 'clearZpeerRoom', 'preservedSelf: true', 'roomId?: string', 'buildZpeerPeerRoomSummaries', 'active: membership.roomId === activeRoomId', 'peerRespondsToAliasPing', 'activeAliasCollision', 'zpeer-alias-ping', 'zpeerAdhoc']) {
   if (!zpeer.includes(needle)) failures.push(`zpeer missing ${needle}`);
 }
 for (const needle of ['peer-messages.jsonl', 'peer-status.jsonl', 'appendZpeerPeerRecords', 'reasonHash', 'bodyStored: false']) {
@@ -96,7 +97,8 @@ if (!zpeer.includes('const bothPeersAreWorkers = self.roleType === "worker" && t
 if (hardTeamMismatchIndex !== -1 && (roomFirstTopologyIndex === -1 || hardTeamMismatchIndex < roomFirstTopologyIndex)) failures.push('zpeer topology must not hard-block cross-team peers before same-room allowance');
 if (!zpeer.includes('const candidates = peersInRoom(repoRoot, roomId).filter') || !zpeer.includes('if (!selfMembership)') || !zpeer.includes('current peer is observer-only in room')) failures.push('zpeer same-room allowance must preserve room candidate, self membership, and observer guards');
 if (!liveRegistry.includes('readZobLiveRegistryAllProjectsSnapshot') || !liveRegistry.includes('join(projectsDir, entry.name, "agents")')) failures.push('live registry must expose all-project agents room discovery helper');
-for (const needle of ['ZobLiveTeamAgentLease', 'zob.live-team-agent-lease.v1', 'stableLease: true', 'exclusiveBy: "teamId+agentId"', 'claimZobLiveTeamAgentLease', 'leaseRespondsToPing', 'pingZobLocalEndpoint', 'releaseZobLiveTeamAgentLease', 'ownsZobLiveTeamAgentLease', 'sameLeaseOwner', 'retireInactiveZobLiveTeamAgentLeases', 'readLeasesFromDir', 'hasLeaseDomain']) {
+if (!liveRegistry.includes('peer.zpeerAdhoc !== true') || !liveRegistry.includes('mergeLeaseBackedAndAdhocPeers(leaseDirs.flatMap')) failures.push('live registry must merge explicit ad-hoc room peer cards into lease-backed summaries');
+for (const needle of ['ZobLiveTeamAgentLease', 'zob.live-team-agent-lease.v1', 'stableLease: true', 'exclusiveBy: "teamId+agentId"', 'claimZobLiveTeamAgentLease', 'leaseRespondsToPing', 'pingZobLocalEndpoint', 'releaseZobLiveTeamAgentLease', 'ownsZobLiveTeamAgentLease', 'sameLeaseOwner', 'retireInactiveZobLiveTeamAgentLeases', 'readLeasesFromDir', 'hasLeaseDomain', 'mergeLeaseBackedAndAdhocPeers']) {
   if (!liveRegistry.includes(needle)) failures.push(`live registry stable lease support missing ${needle}`);
 }
 if (!zpeer.includes('readZobLiveRegistryAllProjectsSnapshot(repoRoot)')) failures.push('zpeer room discovery must use all-project registry snapshots');
@@ -172,7 +174,7 @@ for (const needle of ['readZpeerNewCarryoverProfile(repoRoot)', 'const carryover
 }
 if (!events.includes('event.source === "extension" && !event.text.trim()') || !events.includes('action: "handled" as const')) failures.push('runtime must handle empty extension follow-ups without continuing the agent');
 if (!events.includes('ZPeer async reply received from @') || !events.includes('{ triggerTurn: true, deliverAs: "followUp" }')) failures.push('runtime must resume an idle agent with a follow-up when an async ZPeer reply arrives');
-for (const needle of ['ZPEER AWARENESS (transient, rebuilt each turn)', 'buildZpeerPeerRoomSummaries(repoRoot, state.zobLive.peerCard)', '- rooms:', 'explicit roomId', 'zpeer_ask with mode=\\"async\\"', 'Passive wait rule', 'stop the turn and remain idle', 'avoid spam', 'Raw ZPeer bodies are transient', 'registerMessageRenderer("zob-zpeer-event"', 'scheduleZpeerHeartbeat', 'clearZpeerHeartbeatTimer', 'refreshZpeerSelf(repoRoot', 'kind: "response_sent"', 'kind: "inbound"']) {
+for (const needle of ['ZPEER AWARENESS (transient, rebuilt each turn)', 'buildZpeerPeerRoomSummaries(repoRoot, state.zobLive.peerCard)', '- rooms:', 'explicit roomId', 'zpeer_ask with mode=\\"async\\"', 'Passive wait rule', 'stop the turn and remain idle', 'avoid spam', 'Raw ZPeer bodies are transient', 'registerMessageRenderer("zob-zpeer-event"', 'scheduleZpeerHeartbeat', 'clearZpeerHeartbeatTimer', 'refreshZpeerSelf(repoRoot', 'kind: "response_sent"', 'kind: "inbound"', 'zpeerStableTeamAgentLeaseRequired', 'withZpeerLeaseMode', 'leaseStatus = "unavailable"', 'runtime_adhoc']) {
   if (!events.includes(needle)) failures.push(`runtime missing zpeer awareness/event support ${needle}`);
 }
 const responseSentBlock = events.match(/setZpeerLastEvent\(state, \{\s*kind: "response_sent"[\s\S]*?customType: "zob-zpeer-event"[\s\S]*?triggerTurn: false[\s\S]*?\}\);/)?.[0] ?? '';
@@ -212,6 +214,11 @@ const goalRuntime = contents['.pi/extensions/zob-harness/src/runtime/goal-runtim
 for (const needle of ['state.zobLive.passivePeerWait?.suppressGoalContinuation === true', 'clearRuntimeGoalContinuationTimer(state)', 'return;']) {
   if (!goalRuntime.includes(needle)) failures.push(`goal runtime missing passive peer continuation suppression ${needle}`);
 }
+
+const childRunner = contents['.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts'];
+for (const needle of ['childModelPattern', 'ctx.model', 'resolveCodexFastModeExtension', 'getAgentDir()', 'codex-fast-mode.ts', 'childCodexFastModeExtension', 'args.push("-e", childCodexFastModeExtension)', 'const model = resolvedModel']) {
+  if (!childRunner.includes(needle)) failures.push(`delegation child runner missing Codex auto/model inheritance support ${needle}`);
+}
 for (const needle of ['updatePassivePeerWaitState(state, result', 'result.status !== "waiting"', 'state.zobLive.passivePeerWait = undefined', 'schema: "zob.passive-peer-wait.v1"', 'source: "zpeer_ask"', 'suppressGoalContinuation: true', 'bodyStored: false', 'localOnly: true', 'networkEnabled: false']) {
   if (!toolsComs.includes(needle)) failures.push(`zpeer_ask missing passive peer wait state handling ${needle}`);
 }