@maxiaochao/pi-toolkit 0.10.1 → 0.10.3

package/packages/herdr-subagents/src/blocking.ts

@@ -9,7 +9,7 @@ import { cleanupRunTab } from "./tab-cleanup.ts";
 import type { OwnerIdentity } from "./ownership.ts";
 import { ownerRecord } from "./ownership.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
-import { applyReport, applyTaskStatus, isActiveStatus, persistFailureReport, readReport, readRunRecord, readTaskRecord, readTurnRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type TaskRecord, type TaskStatus, type TurnRecord } from "./records.ts";
+import { applyReport, applyTaskStatus, isActiveStatus, persistFailureReport, projectTaskActivity, readReport, readRunRecord, readTaskRecord, readTurnRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type TaskActivity, type TaskRecord, type TaskStatus, type TurnRecord } from "./records.ts";
 import { isAbortError } from "./errors.ts";
 import { continuationSystemPrompt } from "./protocol.ts";
 import { RunPaneAllocator } from "./run-pane-allocator.ts";
@@ -28,7 +28,7 @@ export interface ResumeBlockedResult {
 	requestedConcurrency: number;
 	effectiveConcurrency: number;
 	tasks?: Array<{ index: number; name: string; status: TaskStatus; summary: string; documents: PersistedDocument[]; error?: string; question?: string; paneId: string; recordDirectory: string; sessionFile: string }>;
-	activity?: Array<{ index: number; name: string; status: TaskStatus; paneId?: string }>;
+	activity?: TaskActivity[];
 	tabId?: string;
 }
 
@@ -45,7 +45,7 @@ async function emitProgress(options: RespondToBlockedTaskOptions, runDirectory:
 		recordDirectory: runDirectory,
 		requestedConcurrency: Number(run.requestedConcurrency ?? 1),
 		effectiveConcurrency: Number(run.effectiveConcurrency ?? 1),
-		activity: tasks.map((entry, index) => ({ index, name: String(entry.name ?? entry.agent ?? `Task ${index + 1}`), status: entry.status, ...(entry.paneId ? { paneId: entry.paneId } : {}) })),
+		activity: tasks.map((entry, index) => projectTaskActivity(entry, index)),
 		...(run.tabId ? { tabId: run.tabId } : {}),
 	});
 }
@@ -73,7 +73,7 @@ async function projectSettledRun(runDirectory: string, runFile: string, run: Run
 	await writeJsonAtomic(runFile, run);
 	if (runStatus !== "blocked" && run.tabId) await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, onError: onCleanupError, failureStatus: "failed" });
 	const summary = runStatus === "completed" ? "All tasks completed after the answer." : runStatus === "blocked" ? `${finalTasks[blockedIndex]?.name ?? "Task"} needs input: ${blockedReport?.question ?? "Input required."}` : finalReports.map((entry, index) => `${finalTasks[index].name}: ${entry.summary}`).join("\n");
-	const activity = finalTasks.map((entry, index) => ({ index, name: String(entry.name ?? entry.agent ?? `Task ${index + 1}`), status: entry.status, ...(entry.paneId ? { paneId: String(entry.paneId) } : {}) }));
+	const activity = finalTasks.map((entry, index) => projectTaskActivity(entry, index));
 	const tasks = finalTasks.map((entry, index) => ({ index, name: activity[index].name, status: entry.status, summary: String(finalReports[index].summary ?? "Task has no report."), documents: finalReports[index].documents ?? [], ...(entry.error ? { error: String(entry.error) } : {}), ...(entry.question ? { question: String(entry.question) } : {}), paneId: String(entry.paneId ?? ""), recordDirectory: taskDirectories[index], sessionFile: String(entry.sessionFile ?? "") }));
 	return { ok: runStatus === "completed", runId: run.id, label: String(run.label ?? "batch"), status: runStatus, summary, ...(blockedReport?.question ? { question: blockedReport.question } : {}), documents: finalReports.flatMap((entry) => entry.documents ?? []), recordDirectory: runDirectory, requestedConcurrency: Number(run.requestedConcurrency ?? run.effectiveConcurrency ?? 1), effectiveConcurrency: Number(run.effectiveConcurrency ?? 1), tasks, activity, ...(run.tabId ? { tabId: String(run.tabId) } : {}) };
 }

package/packages/herdr-subagents/src/fleet-controller.ts

@@ -1,40 +1,175 @@
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
 import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { Container, isKeyRelease, matchesKey, Text } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, isKeyRelease, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
 import type { HerdrAutomation } from "./herdr.ts";
-import { fleetEditorHasFocus, FleetSelection, fleetLines } from "./fleet.ts";
+import { fleetEditorHasFocus, FleetSelection, fleetLines, readSessionTokens, type FleetTaskMetrics } from "./fleet.ts";
 import { focusActiveTask } from "./monitor.ts";
 import { isActiveStatus } from "./records.ts";
 import type { HerdrSubagentsBatchDetails } from "./tool.ts";
 
+interface Closable { close(): void; }
+export interface FleetWidgetRuntime {
+	watchSession(path: string, onChange: () => void, onError: () => void): Closable;
+	setInterval(callback: () => void, ms: number): unknown;
+	clearInterval(handle: unknown): void;
+	setTimeout(callback: () => void, ms: number): unknown;
+	clearTimeout(handle: unknown): void;
+	readTokens(path: string): Promise<number | undefined>;
+}
+
+const defaultFleetWidgetRuntime: FleetWidgetRuntime = {
+	watchSession(path, onChange, onError) {
+		const watcher = watch(dirname(path), (_event, filename) => {
+			if (!filename || filename.toString() === basename(path)) onChange();
+		});
+		watcher.on("error", () => { watcher.close(); onError(); });
+		return watcher;
+	},
+	setInterval: (callback, ms) => setInterval(callback, ms),
+	clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
+	setTimeout: (callback, ms) => setTimeout(callback, ms),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+	readTokens: readSessionTokens,
+};
+
+export class FleetWidget implements Component {
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly selection: FleetSelection;
+	private readonly runtime: FleetWidgetRuntime;
+	private batch: HerdrSubagentsBatchDetails;
+	private readonly metrics = new Map<number, FleetTaskMetrics>();
+	private readonly watchers = new Map<string, Closable>();
+	private elapsedTimer?: unknown;
+	private refreshTimer?: unknown;
+	private generation = 0;
+	private disposed = false;
+	private sourceKey = "";
+
+	constructor(tui: TUI, theme: Theme, batch: HerdrSubagentsBatchDetails, selection: FleetSelection, runtime: FleetWidgetRuntime = defaultFleetWidgetRuntime) {
+		this.tui = tui;
+		this.theme = theme;
+		this.selection = selection;
+		this.runtime = runtime;
+		this.batch = batch;
+		this.configureLiveUpdates();
+	}
+
+	update(batch: HerdrSubagentsBatchDetails): void {
+		if (this.disposed) return;
+		this.batch = batch;
+		this.configureLiveUpdates();
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		return fleetLines(this.batch, this.selection, { width, metrics: this.metrics, theme: this.theme });
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.generation += 1;
+		for (const watcher of this.watchers.values()) watcher.close();
+		this.watchers.clear();
+		if (this.elapsedTimer) this.runtime.clearInterval(this.elapsedTimer);
+		if (this.refreshTimer) this.runtime.clearTimeout(this.refreshTimer);
+		this.elapsedTimer = undefined;
+		this.refreshTimer = undefined;
+	}
+
+	private configureLiveUpdates(): void {
+		const sessionFiles = new Set(this.batch.activity.map((task) => task.sessionFile).filter((path): path is string => Boolean(path)));
+		const nextSourceKey = `${this.batch.runId}\n${[...sessionFiles].sort().join("\n")}`;
+		if (nextSourceKey !== this.sourceKey) {
+			this.sourceKey = nextSourceKey;
+			this.generation += 1;
+			this.metrics.clear();
+		}
+		for (const [path, watcher] of this.watchers) {
+			if (sessionFiles.has(path)) continue;
+			watcher.close();
+			this.watchers.delete(path);
+		}
+		for (const path of sessionFiles) {
+			if (this.watchers.has(path)) continue;
+			try {
+				const watcher = this.runtime.watchSession(path, () => this.scheduleMetricsRefresh(), () => this.watchers.delete(path));
+				this.watchers.set(path, watcher);
+			} catch { /* The next durable activity update can retry the watch. */ }
+		}
+		const hasRunning = this.batch.activity.some((task) => task.status === "running");
+		if (hasRunning && !this.elapsedTimer) this.elapsedTimer = this.runtime.setInterval(() => this.tui.requestRender(), 1_000);
+		else if (!hasRunning && this.elapsedTimer) { this.runtime.clearInterval(this.elapsedTimer); this.elapsedTimer = undefined; }
+		this.scheduleMetricsRefresh(0);
+	}
+
+	private scheduleMetricsRefresh(delay = 25): void {
+		if (this.disposed) return;
+		if (this.refreshTimer) this.runtime.clearTimeout(this.refreshTimer);
+		this.refreshTimer = this.runtime.setTimeout(() => { this.refreshTimer = undefined; void this.refreshMetrics(); }, delay);
+	}
+
+	private async refreshMetrics(): Promise<void> {
+		const generation = ++this.generation;
+		const next = await Promise.all(this.batch.activity.map(async (task) => ({ index: task.index, tokens: task.sessionFile ? await this.runtime.readTokens(task.sessionFile) : undefined })));
+		if (this.disposed || generation !== this.generation) return;
+		this.metrics.clear();
+		for (const metric of next) if (metric.tokens !== undefined) this.metrics.set(metric.index, { tokens: metric.tokens });
+		this.tui.requestRender();
+	}
+}
+
 export class FleetController {
+	private readonly herdr: HerdrAutomation;
+	private readonly isEditor: (value: unknown) => boolean;
+	private readonly createWidget?: (lines: string[]) => Container;
+	private readonly widgetRuntime: FleetWidgetRuntime;
 	private activeBatch?: HerdrSubagentsBatchDetails;
 	private readonly selection = new FleetSelection(matchesKey);
 	private unsubscribeInput?: () => void;
 	private ui?: ExtensionUIContext;
-	private tui?: { focusedComponent?: unknown };
+	private tui?: TUI;
+	private widget?: FleetWidget;
 
-	constructor(
-		private readonly herdr: HerdrAutomation,
-		private readonly isEditor: (value: unknown) => boolean,
-		private readonly createWidget?: (lines: string[]) => Container,
-	) {}
+	constructor(herdr: HerdrAutomation, isEditor: (value: unknown) => boolean, createWidget?: (lines: string[]) => Container, widgetRuntime: FleetWidgetRuntime = defaultFleetWidgetRuntime) {
+		this.herdr = herdr;
+		this.isEditor = isEditor;
+		this.createWidget = createWidget;
+		this.widgetRuntime = widgetRuntime;
+	}
 
 	get active(): HerdrSubagentsBatchDetails | undefined { return this.activeBatch; }
 
 	bind(ui: ExtensionUIContext, tuiMode: boolean): void {
 		this.unsubscribeInput?.();
+		if (this.ui && this.ui !== ui) {
+			this.ui.setWidget("herdr-subagents", undefined, { placement: "belowEditor" });
+			this.widget = undefined;
+			this.tui = undefined;
+		}
 		this.ui = ui;
 		this.unsubscribeInput = tuiMode ? ui.onTerminalInput((data) => this.handleInput(data)) : undefined;
+		if (this.activeBatch) this.render();
 	}
 
 	sync(details: unknown): void {
+		if (!this.ui) return;
 		const batch = details as Partial<HerdrSubagentsBatchDetails>;
 		if (!batch.activity || !batch.label || !batch.status) return;
+		if (this.activeBatch && batch.runId !== this.activeBatch.runId) return;
+		if (this.activeBatch?.runId !== batch.runId) this.selection.reset();
 		this.activeBatch = isActiveStatus(batch.status) ? batch as HerdrSubagentsBatchDetails : undefined;
 		this.render();
 	}
 
 	setActive(batch: HerdrSubagentsBatchDetails | undefined): void {
+		if (!this.ui) return;
+		if (this.activeBatch?.runId !== batch?.runId) this.selection.reset();
 		this.activeBatch = batch;
 		this.render();
 	}
@@ -53,18 +188,31 @@ export class FleetController {
 		this.activeBatch = undefined;
 		this.selection.reset();
 		this.render();
+		this.ui = undefined;
+		this.widget = undefined;
+		this.tui = undefined;
 	}
 
 	render(): void {
 		if (!this.ui) return;
-		this.ui.setWidget("herdr-subagents", this.activeBatch ? ((tui) => {
-			this.tui = tui as { focusedComponent?: unknown };
-			const lines = fleetLines(this.activeBatch as HerdrSubagentsBatchDetails, this.selection);
-			if (this.createWidget) return this.createWidget(lines);
-			const container = new Container();
-			for (const line of lines) container.addChild(new Text(line, 1, 0));
-			return container;
-		}) : undefined, { placement: "belowEditor" });
+		if (!this.activeBatch) {
+			this.widget = undefined;
+			this.ui.setWidget("herdr-subagents", undefined, { placement: "belowEditor" });
+			return;
+		}
+		if (this.createWidget) {
+			this.ui.setWidget("herdr-subagents", (tui) => {
+				this.tui = tui;
+				return this.createWidget?.(fleetLines(this.activeBatch as HerdrSubagentsBatchDetails, this.selection)) ?? new Container();
+			}, { placement: "belowEditor" });
+			return;
+		}
+		if (this.widget) { this.widget.update(this.activeBatch); return; }
+		this.ui.setWidget("herdr-subagents", (tui, theme) => {
+			this.tui = tui;
+			this.widget = new FleetWidget(tui, theme, this.activeBatch as HerdrSubagentsBatchDetails, this.selection, this.widgetRuntime);
+			return this.widget;
+		}, { placement: "belowEditor" });
 	}
 
 	private handleInput(data: string): { consume: true } | undefined {

package/packages/herdr-subagents/src/fleet.ts

@@ -1,4 +1,8 @@
+import { readFile } from "node:fs/promises";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { BatchResult } from "./batch-runner.ts";
+import type { TaskActivity } from "./records.ts";
 
 type FleetKey = "up" | "down" | "enter" | "escape";
 type KeyMatcher = (data: string, key: FleetKey) => boolean;
@@ -7,6 +11,8 @@ const legacyKeys: Record<FleetKey, string> = { up: "\u001b[A", down: "\u001b[B",
 const legacyMatchesKey: KeyMatcher = (data, key) => data === legacyKeys[key];
 
 export interface FleetInputResult { consume?: boolean; focusTask?: number; changed?: boolean; }
+export interface FleetTaskMetrics { tokens?: number; }
+export type FleetMetrics = ReadonlyMap<number, FleetTaskMetrics>;
 
 export function fleetEditorHasFocus(focused: unknown, isEditor: (value: unknown) => boolean): boolean {
 	return isEditor(focused);
@@ -25,6 +31,7 @@ export class FleetSelection {
 
 	handle(data: string, editorText: string, taskCount: number): FleetInputResult {
 		if (taskCount === 0) { this.reset(); return {}; }
+		this.selected = this.selectedIndex(taskCount);
 		if (!this.selecting) {
 			if (!this.matchesKey(data, "down") || editorText.length !== 0) return {};
 			this.selecting = true;
@@ -36,21 +43,125 @@ export class FleetSelection {
 			this.selected = (this.selected + delta + taskCount) % taskCount;
 			return { consume: true, changed: true };
 		}
-		if (this.matchesKey(data, "enter")) return { consume: true, focusTask: this.selected + 1 };
+		if (this.matchesKey(data, "enter")) return { consume: true, focusTask: this.selectedIndex(taskCount) + 1 };
 		if (this.matchesKey(data, "escape")) { this.selecting = false; return { consume: true, changed: true }; }
 		this.selecting = false;
 		return { changed: true };
 	}
 }
 
-export function fleetLines(batch: Pick<BatchResult, "label" | "activity">, selection: FleetSelection): string[] {
+function finiteTokenPart(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+function usageTokens(value: unknown): number {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+	const usage = value as Record<string, unknown>;
+	return finiteTokenPart(usage.input) + finiteTokenPart(usage.output) + finiteTokenPart(usage.cacheRead) + finiteTokenPart(usage.cacheWrite);
+}
+
+/** Match Pi's cumulative footer semantics without trusting an incomplete JSONL tail. */
+export function aggregateSessionTokens(jsonl: string): number {
+	let total = 0;
+	for (const line of jsonl.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		let entry: Record<string, unknown>;
+		try {
+			const parsed: unknown = JSON.parse(line);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+			entry = parsed as Record<string, unknown>;
+		} catch { continue; }
+		if (entry.type === "usage") total += usageTokens(entry.usage);
+		else if (entry.type === "compaction" || entry.type === "branch_summary") total += usageTokens(entry.usage);
+		else if (entry.type === "message") {
+			const message = entry.message;
+			if (!message || typeof message !== "object" || Array.isArray(message)) continue;
+			const record = message as Record<string, unknown>;
+			if (record.role === "assistant" || record.role === "toolResult") total += usageTokens(record.usage);
+		}
+	}
+	return total;
+}
+
+export async function readSessionTokens(path: string): Promise<number | undefined> {
+	try { return aggregateSessionTokens(await readFile(path, "utf8")); }
+	catch { return undefined; }
+}
+
+export function formatFleetDuration(task: TaskActivity, now = Date.now()): string | undefined {
+	if (!task.startedAt || task.status === "queued" || task.status === "starting") return undefined;
+	let elapsed = typeof task.elapsedMs === "number" && Number.isFinite(task.elapsedMs) ? Math.max(0, task.elapsedMs) : undefined;
+	if (task.status === "running" && task.activeStartedAt) {
+		const activeStarted = Date.parse(task.activeStartedAt);
+		if (Number.isFinite(activeStarted) && now >= activeStarted) elapsed = (elapsed ?? 0) + (now - activeStarted);
+	}
+	if (elapsed === undefined) {
+		const started = Date.parse(task.startedAt);
+		const terminal = task.completedAt ?? (task.status === "blocked" ? task.updatedAt : undefined);
+		const ended = terminal ? Date.parse(terminal) : now;
+		if (!Number.isFinite(started) || !Number.isFinite(ended) || ended < started) return undefined;
+		elapsed = ended - started;
+	}
+	const seconds = Math.floor(elapsed / 1000);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+
+export function formatFleetTokens(tokens: number): string {
+	if (tokens < 1_000) return `${tokens} tok`;
+	if (tokens < 10_000) return `${(tokens / 1_000).toFixed(1)}k tok`;
+	if (tokens < 1_000_000) return `${Math.round(tokens / 1_000)}k tok`;
+	return `${(tokens / 1_000_000).toFixed(1)}m tok`;
+}
+
+function statusSummary(activity: TaskActivity[]): string {
 	const counts = new Map<string, number>();
-	for (const task of batch.activity) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const summary = ["running", "queued", "blocked", "failed", "completed", "cancelled"]
+	for (const task of activity) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	return ["running", "queued", "blocked", "failed", "completed", "cancelled"]
 		.filter((status) => counts.has(status)).map((status) => `${status} ${counts.get(status)}`).join(" · ");
+}
+
+function fitColumns(left: string, right: string, width: number): string {
+	if (width <= 0) return "";
+	if (!right) return truncateToWidth(left, width);
+	const rightWidth = visibleWidth(right);
+	if (rightWidth + 2 >= width) return truncateToWidth(left, width);
+	const fittedLeft = truncateToWidth(left, width - rightWidth - 1);
+	const gap = " ".repeat(Math.max(1, width - visibleWidth(fittedLeft) - rightWidth));
+	return truncateToWidth(fittedLeft + gap + right, width);
+}
+
+type FleetTheme = Pick<Theme, "fg" | "bold">;
+const plainTheme: FleetTheme = { fg: (_color, text) => text, bold: (text) => text } as FleetTheme;
+
+export function fleetLines(
+	batch: Pick<BatchResult, "label" | "activity">,
+	selection: FleetSelection,
+	options: { width?: number; now?: number; metrics?: FleetMetrics; theme?: FleetTheme } = {},
+): string[] {
+	const width = Math.max(1, options.width ?? 120);
+	const theme = options.theme ?? plainTheme;
 	const selected = selection.selectedIndex(batch.activity.length);
-	return [
-		`Subagents · ${batch.label} · ${summary}`,
-		...batch.activity.map((task, index) => `${selection.isSelecting() && index === selected ? "›" : " "} ${String(task.index + 1).padStart(2, "0")} · ${task.name}  ${task.status}`),
-	];
+	const title = `─ ${theme.bold("Fleet")} · ${batch.label} · ${statusSummary(batch.activity)} `;
+	const titleWidth = visibleWidth(title);
+	const lines = [truncateToWidth(title + "─".repeat(Math.max(0, width - titleWidth)), width)];
+	const rows = batch.activity.map((task, index) => {
+		const chosen = selection.isSelecting() && index === selected;
+		const circle = task.status === "queued" || task.status === "starting" ? "○" : "●";
+		const color = task.status === "completed" ? "success" : task.status === "running" ? "warning" : task.status === "failed" ? "error" : task.status === "blocked" ? "warning" : task.status === "cancelled" ? "dim" : "accent";
+		const marker = chosen ? theme.fg("accent", "›") : " ";
+		const persona = theme.fg("muted", task.agent || "worker");
+		const left = `${marker} ${theme.fg(color, circle)} ${persona}  ${task.name}  ${theme.fg("dim", task.status)}`;
+		const duration = formatFleetDuration(task, options.now);
+		const tokens = task.status === "queued" || task.status === "starting" ? undefined : options.metrics?.get(task.index)?.tokens;
+		const right = [duration, tokens === undefined ? undefined : formatFleetTokens(tokens)].filter(Boolean).join("  ");
+		return { left, right: theme.fg("dim", right) };
+	});
+	const maxLeft = Math.max(0, ...rows.map(({ left }) => visibleWidth(left)));
+	const maxRight = Math.max(0, ...rows.map(({ right }) => visibleWidth(right)));
+	const contentWidth = Math.min(width, maxLeft + (maxRight ? 2 + maxRight : 0));
+	for (const row of rows) lines.push(fitColumns(row.left, row.right, contentWidth));
+	return lines;
 }

package/packages/herdr-subagents/src/history.ts

@@ -8,7 +8,7 @@ import { cleanupRunTab } from "./tab-cleanup.ts";
 import type { OwnerIdentity } from "./ownership.ts";
 import { ownerRecord } from "./ownership.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
-import { applyReport, applyTaskStatus, isActiveStatus, readReport, readRunRecord, readTaskRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type RunStatus, type TaskRecord, type TaskStatus } from "./records.ts";
+import { applyReport, applyTaskStatus, isActiveStatus, projectTaskActivity, readReport, readRunRecord, readTaskRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type RunStatus, type TaskActivity, type TaskRecord, type TaskStatus } from "./records.ts";
 import { continuationSystemPrompt } from "./protocol.ts";
 import { isAbortError } from "./errors.ts";
 import { findRunDirectory } from "./run-locator.ts";
@@ -96,9 +96,10 @@ export async function cleanSubagentRun(cwd: string, runId: string): Promise<bool
 	return true;
 }
 
-export interface ResumeHistoricalTaskOptions { herdr?: HerdrAutomation; signal?: AbortSignal; owner?: OwnerIdentity; onCleanupError?: (message: string) => void; stalledWarningSeconds?: number; onStalled?: (message: string) => void; }
+export interface ResumeHistoricalTaskOptions { herdr?: HerdrAutomation; signal?: AbortSignal; owner?: OwnerIdentity; onCleanupError?: (message: string) => void; stalledWarningSeconds?: number; onStalled?: (message: string) => void; onUpdate?: (result: ResumeHistoricalTaskResult) => void; }
+export interface ResumeHistoricalTaskResult { runId: string; label: string; status: TaskStatus; summary: string; documents: PersistedDocument[]; tabId: string; paneId: string; sessionFile: string; activity: TaskActivity[]; }
 
-export async function resumeHistoricalTask(cwd: string, runId: string, taskNumber: number, prompt: string, options: ResumeHistoricalTaskOptions = {}): Promise<{ runId: string; status: TaskStatus; summary: string; documents: PersistedDocument[]; tabId: string; paneId: string; sessionFile: string }> {
+export async function resumeHistoricalTask(cwd: string, runId: string, taskNumber: number, prompt: string, options: ResumeHistoricalTaskOptions = {}): Promise<ResumeHistoricalTaskResult> {
 	const runDirectory = await findRunDirectory(join(cwd, ".pi", "herdr-subagents", "runs"), runId);
 	if (!runDirectory) throw new Error(`Unknown Subagent run '${runId}'.`);
 	const lockDirectory = join(runDirectory, ".resume.lock");
@@ -111,7 +112,7 @@ export async function resumeHistoricalTask(cwd: string, runId: string, taskNumbe
 	finally { await rmdir(lockDirectory); }
 }
 
-async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber: number, prompt: string, options: ResumeHistoricalTaskOptions): Promise<{ runId: string; status: TaskStatus; summary: string; documents: PersistedDocument[]; tabId: string; paneId: string; sessionFile: string }> {
+async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber: number, prompt: string, options: ResumeHistoricalTaskOptions): Promise<ResumeHistoricalTaskResult> {
 	const herdr = options.herdr ?? new CliHerdrAutomation();
 	const { signal, onCleanupError } = options;
 	const run = (await listSubagentHistory(cwd)).find((candidate) => candidate.id === runId);
@@ -158,6 +159,8 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 				writeJsonAtomic(turnFile, { attempt, prompt, status: "running", sessionFile: historical.sessionFile, tabId: tab.tabId, paneId: tab.paneId, agentName, startedAt: new Date().toISOString() }),
 				writeJsonAtomic(activeRunFile, activeRunRecord),
 			]);
+			const runningActivity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
+			options.onUpdate?.({ runId, label: run.label, status: "running", summary: `${historical.name} is continuing.`, documents: [], tabId: tab.tabId, paneId: tab.paneId, sessionFile: historical.sessionFile, activity: runningActivity });
 			report = (await promptLiveAgent({ herdr, task: { ...task, id: historical.id, sessionFile: historical.sessionFile }, paneId: tab.paneId, prompt, systemPromptFile: followupPrompt, agentName, signal, stalledWarningMs: options.stalledWarningSeconds ? options.stalledWarningSeconds * 1000 : undefined, onStalled: () => options.onStalled?.(`${historical.name} appears stalled; it is still running.`) })).report;
 			status = applyReport(task, report);
 		} catch (error) {
@@ -182,7 +185,8 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 		if (status !== "blocked") {
 			await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError, failureStatus: "failed" });
 		}
-		return { runId, status, summary: report.summary, documents: report.documents ?? [], tabId: tab.tabId, paneId: tab.paneId, sessionFile: historical.sessionFile };
+		const activity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
+		return { runId, label: run.label, status, summary: report.summary, documents: report.documents ?? [], tabId: tab.tabId, paneId: tab.paneId, sessionFile: historical.sessionFile, activity };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		const completedAt = new Date().toISOString();
@@ -204,6 +208,8 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 			writeJsonAtomic(turnFile, { attempt, prompt, status, summary: report.summary, documents: report.documents, error: message, sessionFile: historical.sessionFile, ...(tab ? { tabId: tab.tabId, paneId: tab.paneId } : {}), completedAt }),
 			writeJsonAtomic(join(run.recordDirectory, "run.json"), runRecord),
 		]);
+		const activity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
+		options.onUpdate?.({ runId, label: run.label, status, summary: report.summary, documents: report.documents, tabId: tab?.tabId ?? "", paneId: tab?.paneId ?? "", sessionFile: historical.sessionFile, activity });
 		if (tab) await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError, failureStatus: "failed" });
 		throw error;
 	}

package/packages/herdr-subagents/src/parameters.ts

@@ -1,21 +1,24 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 
+const HerdrSubagentsTaskParams = Type.Object({
+	name: Type.String({ minLength: 1, maxLength: 48, description: "Short task name shown in the pane and task list." }),
+	prompt: Type.String({ minLength: 1, description: "Self-contained prompt for this task." }),
+	agent: Type.Optional(Type.String({ minLength: 1, description: "Persona for this task. Defaults to worker." })),
+	model: Type.Optional(Type.String({ minLength: 1, description: "Optional model override for this task." })),
+}, { additionalProperties: false });
+
 export const HerdrSubagentsParams = Type.Object({
-	action: Type.Optional(StringEnum(["list", "respond", "history", "resume", "cleanup"] as const, { description: "Operation mode. Omit it to execute one task or a batch." })),
+	tasks: Type.Array(HerdrSubagentsTaskParams, { minItems: 1, description: "Ordered tasks to execute. Use one item for a single task; independent read-only tasks may run concurrently." }),
+	label: Type.Optional(Type.String({ minLength: 1, maxLength: 48, description: "Short Herdr run-tab label." })),
+	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Maximum simultaneously active Agents. Write-capable tasks force concurrency one." })),
+	background: Type.Optional(Type.Boolean({ description: "Return a run ID immediately while the run continues in this parent session." })),
+}, { additionalProperties: false });
+
+export const HerdrSubagentsControlParams = Type.Object({
+	action: StringEnum(["list", "respond", "history", "resume", "cleanup"] as const, { description: "Control operation to perform." }),
 	runId: Type.Optional(Type.String({ minLength: 1, description: "Durable run ID used by respond, resume, or cleanup." })),
 	answer: Type.Optional(Type.String({ minLength: 1, description: "Answer sent to a blocked task when action is respond." })),
 	task: Type.Optional(Type.Integer({ minimum: 1, description: "One-based task number selected for respond or resume." })),
-	prompt: Type.Optional(Type.String({ minLength: 1, description: "Task prompt for single execution, or follow-up prompt for resume." })),
-	agent: Type.Optional(Type.String({ minLength: 1, description: "Persona for single execution. Defaults to worker." })),
-	label: Type.Optional(Type.String({ minLength: 1, maxLength: 48, description: "Short Herdr run-tab label." })),
-	model: Type.Optional(Type.String({ minLength: 1, description: "Optional Pi model override, for example provider/model:high." })),
-	tasks: Type.Optional(Type.Array(Type.Object({
-		name: Type.String({ minLength: 1, maxLength: 48, description: "Short task name shown in the pane and task list." }),
-		prompt: Type.String({ minLength: 1, description: "Self-contained prompt for this task." }),
-		agent: Type.Optional(Type.String({ minLength: 1, description: "Persona for this task. Defaults to worker." })),
-		model: Type.Optional(Type.String({ minLength: 1, description: "Optional model override for this task." })),
-	}), { minItems: 1, description: "Ordered tasks for bounded-concurrency batch execution." })),
-	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Maximum simultaneously active Agents in a batch." })),
-	background: Type.Optional(Type.Boolean({ description: "Return a run ID immediately while the batch continues in this parent session." })),
+	prompt: Type.Optional(Type.String({ minLength: 1, description: "Follow-up prompt used by resume." })),
 }, { additionalProperties: false });

package/packages/herdr-subagents/src/queued-runs.ts

@@ -1,15 +1,15 @@
 import { existsSync, readdirSync } from "node:fs";
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
-import type { HerdrSubagentsToolParams } from "./tool.ts";
+import type { HerdrSubagentsRunParams } from "./tool.ts";
 import { isProcessAlive, ownerRecord, type OwnerIdentity } from "./ownership.ts";
 import { writeJsonAtomic } from "./state.ts";
 import { findRunDirectory } from "./run-locator.ts";
 
-export interface QueuedRunRecord { runId: string; cwd: string; ownerSessionId?: string; ownerProcessId?: number; params: HerdrSubagentsToolParams; queuedAt: string; }
+export interface QueuedRunRecord { runId: string; cwd: string; ownerSessionId?: string; ownerProcessId?: number; params: HerdrSubagentsRunParams; queuedAt: string; }
 function queueDirectory(cwd: string): string { return join(cwd, ".pi", "herdr-subagents", "queue"); }
 
-export async function persistQueuedRun(cwd: string, runId: string, params: HerdrSubagentsToolParams, owner?: OwnerIdentity): Promise<void> {
+export async function persistQueuedRun(cwd: string, runId: string, params: HerdrSubagentsRunParams, owner?: OwnerIdentity): Promise<void> {
 	const directory = queueDirectory(cwd);
 	await mkdir(directory, { recursive: true, mode: 0o700 });
 	await writeJsonAtomic(join(directory, `${runId}.json`), { runId, cwd, ...ownerRecord(owner), params: { ...params, background: true }, queuedAt: new Date().toISOString() });

package/packages/herdr-subagents/src/records.ts

@@ -64,6 +64,8 @@ export interface TaskRecord {
 	systemPrompt?: string;
 	sessionFile?: string;
 	startedAt?: string;
+	activeStartedAt?: string;
+	elapsedMs?: number;
 	updatedAt?: string;
 	completedAt?: string;
 	tabId?: string;
@@ -76,6 +78,38 @@ export interface TaskRecord {
 	error?: string;
 }
 
+export interface TaskActivity {
+	index: number;
+	name: string;
+	status: TaskStatus;
+	agent: string;
+	prompt?: string;
+	paneId?: string;
+	sessionFile?: string;
+	startedAt?: string;
+	activeStartedAt?: string;
+	elapsedMs?: number;
+	completedAt?: string;
+	updatedAt?: string;
+}
+
+export function projectTaskActivity(task: TaskRecord, index = task.order - 1): TaskActivity {
+	return {
+		index,
+		name: String(task.name ?? task.agent ?? `Task ${index + 1}`),
+		status: task.status,
+		agent: String(task.agent ?? "worker"),
+		...(task.prompt ? { prompt: task.prompt } : {}),
+		...(task.paneId ? { paneId: task.paneId } : {}),
+		...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
+		...(task.startedAt ? { startedAt: task.startedAt } : {}),
+		...(task.activeStartedAt ? { activeStartedAt: task.activeStartedAt } : {}),
+		...(typeof task.elapsedMs === "number" ? { elapsedMs: task.elapsedMs } : {}),
+		...(task.completedAt ? { completedAt: task.completedAt } : {}),
+		...(task.updatedAt ? { updatedAt: task.updatedAt } : {}),
+	};
+}
+
 export interface TurnRecord {
 	attempt: number;
 	prompt?: string;
@@ -184,7 +218,25 @@ export function applyLifecycleStatus<T extends { status: string; question?: stri
 }
 
 export function applyTaskStatus<T extends TaskRecord | TurnRecord>(record: T, status: TaskStatus, options: { question?: string; error?: string; at?: string } = {}): T {
-	return applyLifecycleStatus(record, status, options);
+	const at = options.at ?? new Date().toISOString();
+	if ("order" in record) {
+		if (record.status === "running" && status !== "running") {
+			const activeStarted = Date.parse(record.activeStartedAt ?? record.startedAt ?? "");
+			const ended = Date.parse(at);
+			if (Number.isFinite(activeStarted) && Number.isFinite(ended) && ended >= activeStarted) record.elapsedMs = Math.max(0, Number(record.elapsedMs ?? 0)) + (ended - activeStarted);
+			delete record.activeStartedAt;
+		} else if (status === "running" && record.status !== "running") {
+			if (!(typeof record.elapsedMs === "number" && Number.isFinite(record.elapsedMs))) {
+				const frozenAt = record.status === "blocked" ? record.updatedAt : isSettledRunStatus(record.status) ? record.completedAt : undefined;
+				const started = Date.parse(record.startedAt ?? "");
+				const ended = Date.parse(frozenAt ?? "");
+				if (Number.isFinite(started) && Number.isFinite(ended) && ended >= started) record.elapsedMs = ended - started;
+			}
+			record.startedAt ??= at;
+			record.activeStartedAt = at;
+		}
+	}
+	return applyLifecycleStatus(record, status, { ...options, at });
 }
 
 export async function settleAttemptFailure<T extends TaskRecord | TurnRecord>(