pi-subagents 0.69.0 → 0.70.0

package/src/workflows/workflow-checklist.ts

@@ -1,436 +0,0 @@
-import type { AsyncJobStep, HostStepNode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowPreflightLane, WorkflowPreflight } from "../shared/types.ts";
-import { sanitizeDisplayText } from "../shared/display-text.ts";
-import { workflowPreflightLaneForRuntimeKey as laneFor } from "./workflow-preflight.ts";
-
-export type WorkflowChecklistState = "complete" | "running" | "queued" | "blocked" | "failed" | "paused" | "stopped";
-
-export interface WorkflowChecklistStep {
-	key?: string;
-	workflowKey?: string;
-	runId?: string;
-	label?: string;
-	description?: string;
-	phase?: string;
-	agent?: string;
-	status: string;
-	context?: "fresh" | "fork";
-	activityState?: string;
-	startedAt?: number;
-	endedAt?: number;
-	durationMs?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	outputName?: string;
-	error?: string;
-	toolBudgetBlocked?: boolean;
-	turnBudgetExceeded?: boolean;
-	timedOut?: boolean;
-	stopped?: boolean;
-	acceptance?: { status?: string; reviewResult?: { status?: string } };
-	review?: { status?: string };
-	watchdog?: { phase?: string };
-}
-
-export interface WorkflowChecklistTraceEntry {
-	operation?: string;
-	key: string;
-	state: string;
-	agent?: string;
-	runId?: string;
-	phase?: string;
-	label?: string;
-	generatedLaneKey?: string;
-	durationMs?: number;
-	error?: string;
-}
-
-export interface WorkflowChecklistItem {
-	key: string;
-	label: string;
-	phase: string;
-	state: WorkflowChecklistState;
-	agent?: string;
-	context?: "fresh" | "fork";
-	startedAt?: number;
-	durationMs?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	toolCount?: number;
-	outputName?: string;
-	error?: string;
-	preflight?: WorkflowPreflightLane;
-	kind?: "child" | "host";
-	monitorKind?: HostStepNode["monitorKind"];
-	provider?: string;
-	role?: string;
-	verdict?: HostStepNode["verdict"];
-	target?: string;
-	reasonCode?: string;
-	stale?: boolean;
-	reportPath?: string;
-}
-
-export interface WorkflowChecklistPhase {
-	key: string;
-	label: string;
-	state: WorkflowChecklistState;
-	items: WorkflowChecklistItem[];
-	total: number;
-	done: number;
-	running: number;
-	queued: number;
-	blocked: number;
-	failed: number;
-	paused: number;
-	stopped: number;
-	parallel: boolean;
-}
-
-export interface WorkflowChecklistProjection {
-	phases: WorkflowChecklistPhase[];
-	total: number;
-	done: number;
-	running: number;
-	queued: number;
-	blocked: number;
-	failed: number;
-	paused: number;
-	stopped: number;
-	bottleneck?: WorkflowChecklistItem;
-}
-
-export interface WorkflowChecklistInput {
-	graph?: WorkflowGraphSnapshot;
-	steps?: readonly WorkflowChecklistStep[] | readonly AsyncJobStep[];
-	hostSteps?: readonly HostStepNode[];
-	preflight?: WorkflowPreflight;
-	trace?: readonly WorkflowChecklistTraceEntry[];
-	now?: number;
-}
-
-const MAX_TEXT = 160;
-const TERMINAL_STATES = new Set<WorkflowChecklistState>(["complete", "blocked", "failed", "paused", "stopped"]);
-
-function text(value: unknown, fallback?: string): string | undefined {
-	if (typeof value !== "string") return fallback;
-	const clean = sanitizeDisplayText(value).replace(/\s+/g, " ").trim();
-	return clean ? clean.slice(0, MAX_TEXT) : fallback;
-}
-
-function keyText(value: unknown, fallback: string): string {
-	return text(value, fallback) ?? fallback;
-}
-
-function normalizedStatus(value: unknown): string {
-	return typeof value === "string" ? value.toLowerCase() : "queued";
-}
-
-function finite(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function count(value: unknown): number | undefined {
-	const number = finite(value);
-	return number !== undefined && number >= 0 ? Math.round(number) : undefined;
-}
-
-function explicitBlocked(source: Pick<WorkflowChecklistStep, "activityState" | "toolBudgetBlocked" | "turnBudgetExceeded" | "timedOut" | "acceptance" | "review" | "watchdog"> & { verdict?: unknown; stale?: unknown }): boolean {
-	const acceptance = normalizedStatus(source.acceptance?.status);
-	const review = normalizedStatus(source.review?.status ?? source.acceptance?.reviewResult?.status);
-	return source.toolBudgetBlocked === true
-		|| source.turnBudgetExceeded === true
-		|| source.activityState === "needs_attention"
-		|| source.timedOut === true
-		|| source.watchdog?.phase === "stale"
-		|| source.stale === true
-		|| source.verdict === "inconclusive"
-		|| acceptance === "rejected"
-		|| acceptance === "blockers"
-		|| review === "blockers"
-		|| review === "review-required";
-}
-
-function checklistState(source: Pick<WorkflowChecklistStep, "status" | "activityState" | "toolBudgetBlocked" | "turnBudgetExceeded" | "timedOut" | "acceptance" | "review" | "watchdog"> & { verdict?: unknown; stale?: unknown }): WorkflowChecklistState {
-	if (explicitBlocked(source)) return "blocked";
-	switch (normalizedStatus(source.status)) {
-		case "complete":
-		case "completed":
-		case "done":
-		case "pass":
-		case "accepted": return "complete";
-		case "running":
-		case "started":
-		case "active": return "running";
-		case "failed":
-		case "error":
-		case "fail": return "failed";
-		case "blocked":
-		case "rejected":
-		case "partial":
-		case "needs_attention": return "blocked";
-		case "paused":
-		case "detached": return "paused";
-		case "stopped":
-		case "cancelled":
-		case "canceled": return "stopped";
-		default: return "queued";
-	}
-}
-
-function duration(step: Pick<WorkflowChecklistStep, "durationMs" | "startedAt" | "endedAt">, now: number | undefined, state: WorkflowChecklistState): number | undefined {
-	const explicit = finite(step.durationMs);
-	const startedAt = finite(step.startedAt);
-	if (explicit !== undefined) return Math.max(0, explicit);
-	if (startedAt === undefined) return undefined;
-	const end = state === "running" ? now : finite(step.endedAt);
-	return end === undefined ? undefined : Math.max(0, end - startedAt);
-}
-
-function stepKey(step: WorkflowChecklistStep): string | undefined {
-	return step.key ?? step.workflowKey ?? step.runId;
-}
-
-function stepItem(step: WorkflowChecklistStep, index: number, phase: string, key = stepKey(step) ?? `step-${index + 1}`, label = step.label ?? step.description ?? stepKey(step) ?? step.agent ?? key, preflight?: WorkflowPreflightLane): WorkflowChecklistItem {
-	const state = checklistState(step);
-	return {
-		key: keyText(key, `step-${index + 1}`),
-		label: keyText(label, key),
-		phase,
-		state,
-		...(text(step.agent) ? { agent: text(step.agent) } : {}),
-		...(step.context ? { context: step.context } : {}),
-		...(finite(step.startedAt) !== undefined ? { startedAt: finite(step.startedAt) } : {}),
-		...(duration(step, undefined, state) !== undefined ? { durationMs: duration(step, undefined, state) } : {}),
-		...(text(step.currentTool) ? { currentTool: text(step.currentTool) } : {}),
-		...(finite(step.currentToolStartedAt) !== undefined ? { currentToolStartedAt: finite(step.currentToolStartedAt) } : {}),
-		...(text(step.currentPath) ? { currentPath: text(step.currentPath) } : {}),
-		...(count(step.toolCount) !== undefined ? { toolCount: count(step.toolCount) } : {}),
-		...(text(step.outputName) ? { outputName: text(step.outputName) } : {}),
-		...(text(step.error) ? { error: text(step.error) } : {}),
-		...(preflight ? { preflight } : {}),
-	};
-}
-
-function hostItem(host: HostStepNode, phase: string, key = host.id): WorkflowChecklistItem {
-	const state = checklistState({ status: host.state, verdict: host.verdict, stale: host.freshness?.stale });
-	return {
-		key: keyText(key, "host-step"),
-		label: keyText(host.label, "host step"),
-		phase,
-		state,
-		kind: "host",
-		monitorKind: host.monitorKind,
-		...(text(host.provider) ? { provider: text(host.provider) } : {}),
-		...(text(host.role) ? { role: text(host.role) } : {}),
-		...(host.verdict ? { verdict: host.verdict } : {}),
-		...(text(host.target) ? { target: text(host.target) } : {}),
-		...(text(host.reasonCode) ? { reasonCode: text(host.reasonCode) } : {}),
-		...(text(host.detail) ? { error: text(host.detail) } : {}),
-		...(host.freshness?.stale !== undefined ? { stale: host.freshness.stale } : {}),
-		...(text(host.reportPath) ? { reportPath: text(host.reportPath) } : {}),
-	};
-}
-
-function graphNodes(graph: WorkflowGraphSnapshot | undefined): WorkflowGraphNode[] {
-	const out: WorkflowGraphNode[] = [];
-	const visit = (node: WorkflowGraphNode): void => {
-		if (node.kind === "parallel-group" || node.kind === "dynamic-parallel-group") {
-			for (const child of node.children ?? []) visit(child);
-			if (!node.children?.length) out.push(node);
-		} else {
-			out.push(node);
-		}
-	};
-	for (const node of graph?.nodes ?? []) visit(node);
-	return out;
-}
-
-function traceSources(trace: readonly WorkflowChecklistTraceEntry[] | undefined): WorkflowChecklistTraceEntry[] {
-	const latest = new Map<string, WorkflowChecklistTraceEntry>();
-	for (const entry of trace ?? []) {
-		const state = normalizedStatus(entry.state);
-		if ((entry.operation !== undefined && entry.operation !== "run" && entry.operation !== "host") || !entry.key || state === "delivered" || state === "missed") continue;
-		const existing = latest.get(entry.key);
-		latest.set(entry.key, state === "reused" && existing ? { ...existing, ...entry, state: existing.state } : { ...existing, ...entry });
-	}
-	return [...latest.values()];
-}
-
-function traceItem(entry: WorkflowChecklistTraceEntry, index: number, preflight: WorkflowPreflightLane | undefined): WorkflowChecklistItem {
-	const phase = keyText(preflight?.key ?? entry.generatedLaneKey ?? entry.phase, "Workflow");
-	const item = stepItem({ key: entry.key, label: entry.label, phase, agent: entry.agent, status: entry.state === "started" ? "running" : entry.state, durationMs: entry.durationMs, error: entry.error }, index, phase, entry.key, entry.label ?? entry.key, preflight);
-	if (entry.operation === "host") item.kind = "host";
-	return item;
-}
-
-function phaseFor(phases: Map<string, WorkflowChecklistPhase>, label: string): WorkflowChecklistPhase {
-	let phase = phases.get(label);
-	if (!phase) {
-		phase = { key: label, label, state: "queued", items: [], total: 0, done: 0, running: 0, queued: 0, blocked: 0, failed: 0, paused: 0, stopped: 0, parallel: false };
-		phases.set(label, phase);
-	}
-	return phase;
-}
-
-function add(phases: Map<string, WorkflowChecklistPhase>, phase: string, item: WorkflowChecklistItem): void {
-	phaseFor(phases, phase).items.push(item);
-}
-
-function mergeNodeStep(node: WorkflowGraphNode, step: WorkflowChecklistStep, phase: string, trace: WorkflowChecklistTraceEntry | undefined, preflight: WorkflowPreflightLane | undefined): WorkflowChecklistItem {
-	const state = checklistState(step);
-	const nodeState = checklistState({ status: node.status, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined });
-	const status = TERMINAL_STATES.has(nodeState) && !TERMINAL_STATES.has(state)
-		? nodeState
-		: trace && !TERMINAL_STATES.has(state)
-		? (trace.state === "started" ? "running" : trace.state)
-		: normalizedStatus(step.status) === "pending" && normalizedStatus(node.status) !== "pending" ? node.status : step.status;
-	return stepItem({ ...step, status, key: node.id, label: step.label ?? node.label, phase: step.phase ?? phase, agent: step.agent ?? node.agent, outputName: step.outputName ?? node.outputName, error: step.error ?? trace?.error ?? node.error, acceptance: step.acceptance ?? (node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined), durationMs: step.durationMs ?? trace?.durationMs }, node.flatIndex ?? 0, phase, node.id, step.label ?? node.label, preflight);
-}
-
-function priority(item: WorkflowChecklistItem): number {
-	return item.state === "blocked" ? 0 : item.state === "failed" ? 1 : item.state === "running" ? 2 : item.state === "paused" ? 3 : item.state === "stopped" ? 4 : item.state === "queued" ? 5 : 6;
-}
-
-function applyNow(item: WorkflowChecklistItem, now: number | undefined): WorkflowChecklistItem {
-	return item.state === "running" && item.startedAt !== undefined && now !== undefined ? { ...item, durationMs: Math.max(0, now - item.startedAt) } : item;
-}
-
-function finalize(phase: WorkflowChecklistPhase): void {
-	phase.total = phase.items.length;
-	phase.done = phase.items.filter((item) => item.state === "complete").length;
-	phase.running = phase.items.filter((item) => item.state === "running").length;
-	phase.queued = phase.items.filter((item) => item.state === "queued").length;
-	phase.blocked = phase.items.filter((item) => item.state === "blocked").length;
-	phase.failed = phase.items.filter((item) => item.state === "failed").length;
-	phase.paused = phase.items.filter((item) => item.state === "paused").length;
-	phase.stopped = phase.items.filter((item) => item.state === "stopped").length;
-	phase.parallel = phase.total > 1;
-	phase.state = phase.blocked ? "blocked" : phase.failed ? "failed" : phase.running ? "running" : phase.paused ? "paused" : phase.stopped ? "stopped" : phase.queued ? "queued" : "complete";
-}
-
-export function projectWorkflowChecklist(input: WorkflowChecklistInput): WorkflowChecklistProjection {
-	const phases = new Map<string, WorkflowChecklistPhase>();
-	const steps = (input.steps ?? []) as readonly WorkflowChecklistStep[];
-	const nodes = graphNodes(input.graph);
-	const trace = traceSources(input.trace);
-	const traceByKey = new Map(trace.map((entry) => [entry.key, entry]));
-	const phaseByNode = new Map<string, string>();
-	for (const phase of input.graph?.phases ?? []) {
-		const title = keyText(phase.title, "Workflow");
-		phaseFor(phases, title);
-		for (const nodeId of phase.nodeIds) if (!phaseByNode.has(nodeId)) phaseByNode.set(nodeId, title);
-	}
-
-	const stepsByKey = new Map<string, Array<{ step: WorkflowChecklistStep; index: number }>>();
-	for (const [index, step] of steps.entries()) {
-		const key = stepKey(step);
-		if (!key) continue;
-		stepsByKey.set(key, [...(stepsByKey.get(key) ?? []), { step, index }]);
-	}
-
-	const usedSteps = new Set<number>();
-	const hostById = new Map((input.hostSteps ?? []).map((host) => [host.id, host]));
-	const graphKeys = new Set(nodes.map((node) => node.id));
-	const stepKeys = new Set([...stepsByKey.keys()]);
-	const hostKeys = new Set(hostById.keys());
-
-	for (const node of nodes) {
-		const host = node.hostStep ?? hostById.get(node.id);
-		const phase = keyText(phaseByNode.get(node.id) ?? node.phase ?? (host ? host.label : node.label), "Workflow");
-		if (host) {
-			add(phases, phase, hostItem(host, phase, node.id));
-			hostById.delete(node.id);
-			continue;
-		}
-		const matches = (stepsByKey.get(node.id) ?? []).filter(({ index }) => !usedSteps.has(index));
-		if (matches.length) {
-			for (const match of matches) {
-				usedSteps.add(match.index);
-				add(phases, phase, applyNow(mergeNodeStep(node, match.step, phase, traceByKey.get(stepKey(match.step) ?? node.id), laneFor(input.preflight, node.id, [phase])), input.now));
-			}
-			continue;
-		}
-		add(phases, phase, applyNow(mergeNodeStep(node, { key: node.id, label: node.label, phase, agent: node.agent, status: node.status, outputName: node.outputName, error: node.error, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined }, phase, traceByKey.get(node.id), laneFor(input.preflight, node.id, [phase])), input.now));
-	}
-
-	for (const [index, step] of steps.entries()) {
-		if (usedSteps.has(index)) continue;
-		const key = keyText(stepKey(step), `step-${index + 1}`);
-		const traceEntry = traceByKey.get(key);
-		const lane = laneFor(input.preflight, key, [step.phase, traceEntry?.generatedLaneKey, traceEntry?.phase]);
-		const phase = keyText(lane?.key ?? step.phase ?? traceEntry?.generatedLaneKey ?? traceEntry?.phase, "Workflow");
-		add(phases, phase, applyNow(stepItem(step, index, phase, key, step.label ?? step.key ?? step.agent, lane), input.now));
-	}
-
-	for (const host of hostById.values()) add(phases, keyText(host.label, "Host"), hostItem(host, keyText(host.label, "Host")));
-	for (const entry of trace) {
-		if (graphKeys.has(entry.key) || stepKeys.has(entry.key) || hostKeys.has(entry.key)) continue;
-		const item = traceItem(entry, phases.size, laneFor(input.preflight, entry.key, [entry.generatedLaneKey, entry.phase]));
-		add(phases, item.phase, item);
-	}
-
-	const finalized = [...phases.values()].filter((phase) => phase.items.length > 0);
-	for (const phase of finalized) {
-		phase.items = phase.items.map((item) => applyNow(item, input.now));
-		finalize(phase);
-	}
-	const all = finalized.flatMap((phase) => phase.items);
-	const counts = (state: WorkflowChecklistState): number => all.filter((item) => item.state === state).length;
-	const bottleneck = [...all].sort((left, right) => priority(left) - priority(right))[0];
-	return { phases: finalized, total: all.length, done: counts("complete"), running: counts("running"), queued: counts("queued"), blocked: counts("blocked"), failed: counts("failed"), paused: counts("paused"), stopped: counts("stopped"), ...(bottleneck && bottleneck.state !== "complete" ? { bottleneck } : {}) };
-}
-
-function stateLabel(state: WorkflowChecklistState): string {
-	return state === "running" ? "active" : state;
-}
-
-export function formatWorkflowChecklistSummary(projection: WorkflowChecklistProjection): string {
-	if (!projection.total) return "";
-	return [`${projection.done}/${projection.total} done`, projection.running ? `${projection.running} active` : undefined, projection.queued ? `${projection.queued} queued` : undefined, projection.blocked ? `${projection.blocked} blocked` : undefined, projection.failed ? `${projection.failed} failed` : undefined, projection.paused ? `${projection.paused} paused` : undefined, projection.stopped ? `${projection.stopped} stopped` : undefined].filter((value): value is string => Boolean(value)).join(" · ");
-}
-
-export function formatWorkflowChecklistPhase(phase: WorkflowChecklistPhase): string {
-	const counts = [phase.total > 1 && phase.done ? `${phase.done} done` : undefined, phase.running ? `${phase.running} active` : undefined, phase.queued ? `${phase.queued} queued` : undefined, phase.blocked ? `${phase.blocked} blocked` : undefined, phase.failed ? `${phase.failed} failed` : undefined, phase.paused ? `${phase.paused} paused` : undefined, phase.stopped ? `${phase.stopped} stopped` : undefined].filter((value): value is string => Boolean(value));
-	return counts.length ? `${phase.label} ${counts.join(" · ")}` : phase.label;
-}
-
-export function formatWorkflowChecklistBottleneck(item: WorkflowChecklistItem | undefined, options: { includeOutput?: boolean; includeError?: boolean } = {}): string | undefined {
-	if (!item) return undefined;
-	const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value): value is string => Boolean(value)).join(" · ") || item.key;
-	const includeOutput = options.includeOutput ?? true;
-	const includeError = options.includeError ?? true;
-	const details = [item.context ? `(${item.context})` : undefined, item.currentTool ? `${item.currentTool}${item.durationMs !== undefined ? ` ${formatDurationText(item.durationMs)}` : ""}` : undefined, !item.currentTool && item.currentPath ? item.currentPath : undefined, !item.currentTool && item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, includeOutput && item.outputName ? `out:${item.outputName}` : undefined, includeError && item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value): value is string => Boolean(value));
-	return [identity, ...details].join(" · ");
-}
-
-function formatWorkflowChecklistItem(item: WorkflowChecklistItem): string {
-	const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value): value is string => Boolean(value)).join(" · ") || item.key;
-	const details = [item.kind && item.monitorKind ? item.monitorKind : undefined, item.provider ? `provider:${item.provider}` : undefined, item.role ? `role:${item.role}` : undefined, item.target, item.currentTool, !item.currentTool && item.currentPath ? item.currentPath : undefined, item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, item.outputName ? `out:${item.outputName}` : undefined, item.reportPath ? `out:${item.reportPath}` : undefined, item.stale ? "stale" : undefined, item.reasonCode ? `reason:${item.reasonCode}` : undefined, item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value): value is string => Boolean(value));
-	return `${identity}${item.context ? ` (${item.context})` : ""}${item.state === "complete" ? "" : ` · ${stateLabel(item.state)}`}${details.length ? ` · ${details.join(" · ")}` : ""}`;
-}
-
-function formatDurationText(ms: number): string {
-	const seconds = Math.max(0, Math.round(ms / 1000));
-	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-}
-
-export function formatWorkflowChecklistText(projection: WorkflowChecklistProjection, indent = "", options: { includeItems?: boolean } = {}): string[] {
-	if (!projection.total) return [];
-	const lines = [`${indent}Workflow checklist: ${formatWorkflowChecklistSummary(projection)}`];
-	for (const phase of projection.phases) {
-		const phaseMarker = phase.state === "complete" ? "✓" : phase.state === "running" ? "⠼" : phase.state === "blocked" ? "!" : phase.state === "failed" ? "✗" : phase.state === "paused" || phase.state === "stopped" ? "■" : "◦";
-		lines.push(`${indent}  ${phaseMarker} ${formatWorkflowChecklistPhase(phase)}`);
-		if (options.includeItems === false) continue;
-		for (const item of phase.items) {
-			const marker = item.state === "complete" ? "✓" : item.state === "running" ? "⠼" : item.state === "blocked" ? "!" : item.state === "failed" ? "✗" : item.state === "paused" || item.state === "stopped" ? "■" : "◦";
-			lines.push(`${indent}    ${marker} ${formatWorkflowChecklistItem(item)}`);
-		}
-	}
-	const bottleneck = formatWorkflowChecklistBottleneck(projection.bottleneck, { includeError: options.includeItems === false });
-	if (bottleneck) lines.push(`${indent}  bottleneck · ${bottleneck}`);
-	return lines;
-}

package/src/workflows/workflow-child-summary.ts

@@ -1,170 +0,0 @@
-import type { AgentProgress, AsyncStatus, WorkflowChildActivity, WorkflowChildSummary } from "../shared/types.ts";
-import type { WorkflowScriptChildResult, WorkflowScriptTraceEntry } from "./scripted-workflow.ts";
-
-const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const TERMINAL_STATES = new Set(["completed", "failed", "paused", "stopped", "rejected", "detached"]);
-const MAX_REQUIRED_ID_BYTES = 4_096;
-const ACTIVITY_COUNTERS = ["currentToolStartedAt", "lastActivityAt", "durationMs", "toolCount", "turnCount", "tokens", "inputTokens", "outputTokens"] as const;
-type WorkflowChildLiveProgress = WorkflowChildActivity & Pick<AgentProgress, "agent" | "sessionName" | "model" | "thinking">;
-
-export function workflowChildProgress(progress: AgentProgress): WorkflowChildLiveProgress {
-	return {
-		...workflowChildActivity(progress),
-		agent: bounded(progress.agent, 256) ?? "",
-		...(bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {}),
-		...(bounded(progress.model, 256) ? { model: progress.model } : {}),
-		...(bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {}),
-	};
-}
-
-/** Fixed field count and a 256 UTF-8 byte tool name keep JSON activity below 2 KiB, including escaping. */
-export function workflowChildActivity(progress: WorkflowChildActivity): WorkflowChildActivity {
-	const activity: WorkflowChildActivity = {};
-	if (bounded(progress.currentTool, 256)) activity.currentTool = progress.currentTool;
-	for (const field of ACTIVITY_COUNTERS) {
-		const value = progress[field];
-		if (typeof value === "number" && Number.isFinite(value) && value >= 0) activity[field] = value;
-	}
-	return activity;
-}
-
-function parseActivity(value: unknown): WorkflowChildActivity | undefined {
-	if (value === undefined) return undefined;
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("workflowChildren child activity is invalid.");
-	const input = value as Record<string, unknown>;
-	for (const [key, value] of Object.entries(input)) {
-		if (key === "currentTool" ? !bounded(value, 256) : !ACTIVITY_COUNTERS.includes(key as typeof ACTIVITY_COUNTERS[number]) || typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error("workflowChildren child activity is invalid.");
-	}
-	return { ...input } as WorkflowChildActivity;
-}
-
-function bounded(value: unknown, maxBytes: number): string | undefined {
-	if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value, "utf8") > maxBytes) return undefined;
-	return value;
-}
-
-function requiredId(value: string, label: string): string {
-	const id = bounded(value, MAX_REQUIRED_ID_BYTES);
-	if (!id) throw new Error(`${label} must be a non-empty identifier of at most ${MAX_REQUIRED_ID_BYTES} UTF-8 bytes.`);
-	return id;
-}
-
-export function workflowChildSummary(input: {
-	parentToolCallId: string;
-	workflowRunId: string;
-	workflowState: WorkflowChildSummary["workflowState"];
-	inventoryComplete: boolean;
-	trace?: WorkflowScriptTraceEntry[];
-	children?: WorkflowScriptChildResult[];
-	steps?: NonNullable<AsyncStatus["steps"]>;
-	/** In-memory snapshots from synchronous child callbacks, keyed by workflow key. */
-	progress?: ReadonlyMap<string, WorkflowChildLiveProgress>;
-}): WorkflowChildSummary {
-	const rows = new Map<string, WorkflowChildSummary["children"][number]>();
-	for (const entry of input.trace ?? []) {
-		if (entry.operation !== "run" || !KEY_PATTERN.test(entry.key)) continue;
-		const previous = rows.get(entry.key);
-		const state = entry.state === "completed" ? "completed"
-			: entry.state === "failed" ? "failed"
-				: entry.state === "stopped" ? "stopped"
-					: entry.state === "detached" ? "detached"
-						: previous?.state ?? "running";
-		rows.set(entry.key, {
-			childId: entry.key,
-			state,
-			...(bounded(entry.runId, 256) ? { runId: bounded(entry.runId, 256) } : {}),
-			...(previous?.agent ? { agent: previous.agent } : {}),
-			...(previous?.sessionName ? { sessionName: previous.sessionName } : {}),
-			...(previous?.model ? { model: previous.model } : {}),
-			...(previous?.thinking ? { thinking: previous.thinking } : {}),
-		});
-	}
-	for (const step of input.steps ?? []) {
-		const key = step.workflowKey;
-		if (!key || !KEY_PATTERN.test(key)) continue;
-		const state = step.status === "complete" || step.status === "completed" ? "completed"
-			: step.status === "failed" ? "failed"
-				: step.status === "paused" ? "paused"
-					: step.status === "stopped" ? "stopped"
-						: step.status === "rejected" ? "rejected"
-							: step.status === "pending" ? "pending" : "running";
-		const launchResolved = step.async !== undefined || step.sessionFile !== undefined || step.runId !== undefined || step.model !== undefined;
-		rows.set(key, {
-			childId: key,
-			state,
-			...(bounded(step.runId, 256) ? { runId: bounded(step.runId, 256) } : {}),
-			...(launchResolved && bounded(step.agent, 256) ? { agent: bounded(step.agent, 256) } : {}),
-			...(bounded(step.sessionName, 256) ? { sessionName: bounded(step.sessionName, 256) } : {}),
-			...(bounded(step.model, 256) ? { model: bounded(step.model, 256) } : {}),
-			...(bounded(step.thinking, 32) ? { thinking: bounded(step.thinking, 32) } : {}),
-		});
-	}
-	for (const child of input.children ?? []) {
-		if (!KEY_PATTERN.test(child.key)) continue;
-		const result = Array.isArray(child.results) ? child.results.find((value) => value && typeof value === "object") as Record<string, unknown> | undefined : undefined;
-		const state = child.detached ? "detached" : child.stopped ? "stopped" : child.interrupted ? "paused" : child.ok ? "completed" : result?.acceptance && typeof result.acceptance === "object" && (result.acceptance as { status?: unknown }).status === "rejected" ? "rejected" : "failed";
-		rows.set(child.key, {
-			childId: child.key,
-			state,
-			...(bounded(child.runId, 256) ? { runId: bounded(child.runId, 256) } : {}),
-			...(bounded(child.agent, 256) ? { agent: bounded(child.agent, 256) } : {}),
-			...(bounded(result?.sessionName, 256) ? { sessionName: bounded(result?.sessionName, 256) } : {}),
-			...(bounded(result?.model, 256) ? { model: bounded(result?.model, 256) } : {}),
-			...(bounded(result?.thinking, 32) ? { thinking: bounded(result?.thinking, 32) } : {}),
-		});
-	}
-	if (input.inventoryComplete) {
-		for (const [key, row] of rows) {
-			if (!TERMINAL_STATES.has(row.state)) rows.set(key, { ...row, state: input.workflowState === "stopped" ? "stopped" : "failed" });
-		}
-	}
-	for (const [key, progress] of input.progress ?? []) {
-		const row = rows.get(key);
-		if (!row || row.state !== "running") continue;
-		rows.set(key, {
-			...row,
-			...(bounded(progress.agent, 256) ? { agent: progress.agent } : {}),
-			...(bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {}),
-			...(bounded(progress.model, 256) ? { model: progress.model } : {}),
-			...(bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {}),
-			activity: workflowChildActivity(progress),
-		});
-	}
-	return {
-		version: 1,
-		parentToolCallId: requiredId(input.parentToolCallId, "parentToolCallId"),
-		workflowRunId: requiredId(input.workflowRunId, "workflowRunId"),
-		inventoryComplete: input.inventoryComplete,
-		workflowState: input.workflowState,
-		children: [...rows.values()],
-	};
-}
-
-export function parseWorkflowChildSummary(value: unknown): WorkflowChildSummary | undefined {
-	if (value === undefined) return undefined;
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("workflowChildren must be an object.");
-	const input = value as Record<string, unknown>;
-	const allowed = new Set(["version", "parentToolCallId", "workflowRunId", "inventoryComplete", "workflowState", "children"]);
-	if (Object.keys(input).some((key) => !allowed.has(key))) throw new Error("workflowChildren has unsupported fields.");
-	if (input.version !== 1 || typeof input.inventoryComplete !== "boolean" || !Array.isArray(input.children)) throw new Error("workflowChildren is invalid.");
-	const workflowState = input.workflowState;
-	if (workflowState !== "queued" && workflowState !== "running" && workflowState !== "completed" && workflowState !== "failed" && workflowState !== "paused" && workflowState !== "stopped") throw new Error("workflowChildren.workflowState is invalid.");
-	const children = input.children.map((row): WorkflowChildSummary["children"][number] => {
-		if (!row || typeof row !== "object" || Array.isArray(row)) throw new Error("workflowChildren child row is invalid.");
-		const child = row as Record<string, unknown>;
-		if (Object.keys(child).some((key) => !["childId", "runId", "agent", "sessionName", "model", "thinking", "state", "activity"].includes(key))) throw new Error("workflowChildren child row has unsupported fields.");
-		if (typeof child.childId !== "string" || !KEY_PATTERN.test(child.childId)) throw new Error("workflowChildren childId is invalid.");
-		const state = child.state;
-		if (state !== "pending" && state !== "running" && state !== "completed" && state !== "failed" && state !== "paused" && state !== "stopped" && state !== "rejected" && state !== "detached") throw new Error("workflowChildren child state is invalid.");
-		for (const [field, maxBytes] of [["runId", 256], ["agent", 256], ["sessionName", 256], ["model", 256], ["thinking", 32]] as const) {
-			if (child[field] !== undefined && bounded(child[field], maxBytes) === undefined) throw new Error(`workflowChildren child ${field} is invalid.`);
-		}
-		const activity = parseActivity(child.activity);
-		if (activity && state !== "running") throw new Error("workflowChildren child activity requires running state.");
-		return { childId: child.childId, state, ...(activity ? { activity } : {}), ...(child.runId ? { runId: child.runId as string } : {}), ...(child.agent ? { agent: child.agent as string } : {}), ...(child.sessionName ? { sessionName: child.sessionName as string } : {}), ...(child.model ? { model: child.model as string } : {}), ...(child.thinking ? { thinking: child.thinking as string } : {}) };
-	});
-	if (new Set(children.map((child) => child.childId)).size !== children.length) throw new Error("workflowChildren has duplicate childId values.");
-	if (typeof input.parentToolCallId !== "string") throw new Error("workflowChildren.parentToolCallId is invalid.");
-	if (typeof input.workflowRunId !== "string") throw new Error("workflowChildren.workflowRunId is invalid.");
-	return { version: 1, parentToolCallId: requiredId(input.parentToolCallId, "workflowChildren.parentToolCallId"), workflowRunId: requiredId(input.workflowRunId, "workflowChildren.workflowRunId"), inventoryComplete: input.inventoryComplete, workflowState, children };
-}