@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/runs/shared/nested-path.js

@@ -1,42 +1,46 @@
 import * as path from "node:path";
+import { isRecord } from "../../shared/unknown.js";
 const MAX_NESTED_ID_LENGTH = 128;
 export const MAX_NESTED_PATH_ENTRIES = 4;
 export function isSafeNestedPathId(value) {
-    return typeof value === "string"
-        && value.length > 0
-        && value.length <= MAX_NESTED_ID_LENGTH
-        && !path.isAbsolute(value)
-        && !value.includes("/")
-        && !value.includes("\\")
-        && !value.includes("..");
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= MAX_NESTED_ID_LENGTH &&
+        !path.isAbsolute(value) &&
+        !value.includes("/") &&
+        !value.includes("\\") &&
+        !value.includes(".."));
 }
-function stepIndex(value) {
-    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
-}
-function nonEmptyString(value, max) {
-    return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
+function pathEntry(value) {
+    if (!isRecord(value) || !isSafeNestedPathId(value.runId)) {
+        return;
+    }
+    const stepIndex = value.stepIndex;
+    const agent = value.agent;
+    return {
+        runId: value.runId,
+        ...(typeof stepIndex === "number" && Number.isInteger(stepIndex) && stepIndex >= 0
+            ? { stepIndex }
+            : {}),
+        ...(typeof agent === "string" && agent.length > 0 ? { agent: agent.slice(0, 128) } : {}),
+    };
 }
 export function sanitizeNestedPath(value) {
-    if (!Array.isArray(value))
+    if (!Array.isArray(value)) {
         return [];
-    return value.map((part) => {
-        if (!part || typeof part !== "object")
-            return undefined;
-        const record = part;
-        if (!isSafeNestedPathId(record.runId))
-            return undefined;
-        return {
-            runId: record.runId,
-            ...(stepIndex(record.stepIndex) !== undefined ? { stepIndex: stepIndex(record.stepIndex) } : {}),
-            ...(nonEmptyString(record.agent, 128) ? { agent: nonEmptyString(record.agent, 128) } : {}),
-        };
-    }).filter((part) => Boolean(part)).slice(0, MAX_NESTED_PATH_ENTRIES);
+    }
+    return value
+        .map(pathEntry)
+        .filter((part) => part !== undefined)
+        .slice(0, MAX_NESTED_PATH_ENTRIES);
 }
 export function parseNestedPathEnv(value) {
-    if (!value)
+    if (value === undefined || value.length === 0) {
         return [];
+    }
     try {
-        return sanitizeNestedPath(JSON.parse(value));
+        const parsed = JSON.parse(value);
+        return sanitizeNestedPath(parsed);
     }
     catch {
         return [];
@@ -44,5 +48,5 @@ export function parseNestedPathEnv(value) {
 }
 export function encodeNestedPathEnv(value) {
     const sanitized = sanitizeNestedPath(value);
-    return sanitized.length ? JSON.stringify(sanitized) : "";
+    return sanitized.length > 0 ? JSON.stringify(sanitized) : "";
 }

package/dist/runs/shared/nested-projection.js

@@ -0,0 +1,155 @@
+import * as path from "node:path";
+import { RESULTS_DIR, } from "../../shared/types.js";
+import { assertSafeNestedId as assertSafeId, MAX_CHILDREN, MAX_STEPS } from "./nested-protocol.js";
+import { projectNestedEvents, terminal } from "./nested-registry.js";
+import { acceptanceHumanAction } from "./acceptance-evaluation.js";
+export function attachRootChildrenToSteps(rootRunId, steps, children) {
+    if (steps === undefined || steps.length === 0) {
+        return;
+    }
+    for (const step of steps) {
+        step.children = undefined;
+    }
+    for (const child of children ?? []) {
+        if (child.parentRunId !== rootRunId || child.parentStepIndex === undefined) {
+            continue;
+        }
+        const step = steps.find((candidate, index) => (candidate.index ?? index) === child.parentStepIndex);
+        if (!step) {
+            continue;
+        }
+        step.children = [
+            ...(step.children ?? []).filter((existing) => existing.id !== child.id),
+            child,
+        ].slice(0, MAX_CHILDREN);
+    }
+}
+export function updateAsyncJobNestedProjection(job) {
+    if (!job.nestedRoute) {
+        return;
+    }
+    const registry = projectNestedEvents(job.nestedRoute);
+    job.nestedChildren = registry.children;
+    attachRootChildrenToSteps(job.asyncId, job.steps, registry.children);
+}
+export function hasLiveNestedDescendants(children) {
+    if (children === undefined || children.length === 0) {
+        return false;
+    }
+    for (const child of children) {
+        if (!terminal(child.state)) {
+            return true;
+        }
+        if (hasLiveNestedDescendants(child.children)) {
+            return true;
+        }
+        if (hasLiveNestedDescendants(child.steps?.flatMap((step) => step.children ?? []))) {
+            return true;
+        }
+    }
+    return false;
+}
+function parentPath(identity) {
+    return (identity.path ?? [
+        {
+            runId: identity.parentRunId,
+            ...(identity.parentStepIndex !== undefined ? { stepIndex: identity.parentStepIndex } : {}),
+        },
+    ]);
+}
+function summaryIdentity(status, asyncDir, identity) {
+    return {
+        id: status.runId === "" ? identity.id : status.runId,
+        indexedControl: status.indexedControl,
+        parentRunId: identity.parentRunId,
+        ...(identity.parentStepIndex !== undefined
+            ? { parentStepIndex: identity.parentStepIndex }
+            : {}),
+        depth: identity.depth,
+        path: parentPath(identity),
+        asyncDir,
+        ...(status.pid !== undefined && status.pid !== 0 ? { pid: status.pid } : {}),
+        ...(status.sessionId !== undefined && status.sessionId !== ""
+            ? { sessionId: status.sessionId }
+            : {}),
+        mode: status.mode ?? identity.mode,
+    };
+}
+function summaryActivity(status) {
+    return {
+        ...(status.activityState !== undefined ? { activityState: status.activityState } : {}),
+        ...(status.lastActivityAt !== undefined ? { lastActivityAt: status.lastActivityAt } : {}),
+        ...(status.currentTool !== undefined && status.currentTool !== ""
+            ? { currentTool: status.currentTool }
+            : {}),
+        ...(status.currentToolStartedAt !== undefined
+            ? { currentToolStartedAt: status.currentToolStartedAt }
+            : {}),
+        ...(status.currentPath !== undefined && status.currentPath !== ""
+            ? { currentPath: status.currentPath }
+            : {}),
+    };
+}
+function summaryCounters(status) {
+    return {
+        ...(status.currentStep !== undefined ? { currentStep: status.currentStep } : {}),
+        ...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
+        ...(status.turnCount !== undefined ? { turnCount: status.turnCount } : {}),
+        ...(status.toolCount !== undefined ? { toolCount: status.toolCount } : {}),
+        ...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
+    };
+}
+function summaryTiming(status, identity) {
+    return {
+        ...summaryCounters(status),
+        startedAt: status.startedAt ?? identity.ts,
+        ...(status.endedAt !== undefined ? { endedAt: status.endedAt } : {}),
+        lastUpdate: status.lastUpdate ?? identity.ts,
+        ...(status.sessionFile !== undefined && status.sessionFile !== ""
+            ? { sessionFile: status.sessionFile }
+            : {}),
+    };
+}
+function summaryStep(step) {
+    return {
+        agent: step.agent,
+        status: step.status,
+        ...(step.sessionFile !== undefined && step.sessionFile !== ""
+            ? { sessionFile: step.sessionFile }
+            : {}),
+        ...summaryActivity(step),
+        ...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
+        ...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
+        ...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+        ...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
+        error: step.error ?? acceptanceHumanAction(step.acceptance),
+    };
+}
+function summaryError(status) {
+    if (status.error !== undefined) {
+        return status.error;
+    }
+    if (status.state !== "blocked") {
+        return;
+    }
+    return status.steps
+        ?.map((step) => acceptanceHumanAction(step.acceptance))
+        .filter(Boolean)
+        .join("\n");
+}
+export function nestedSummaryFromAsyncStatus(status, asyncDir, identity) {
+    const steps = status.steps;
+    return {
+        ...summaryIdentity(status, asyncDir, identity),
+        state: status.state,
+        error: summaryError(status),
+        ...summaryActivity(status),
+        ...summaryTiming(status, identity),
+        ...(steps && steps.length > 0 ? { steps: steps.map(summaryStep).slice(0, MAX_STEPS) } : {}),
+    };
+}
+export function nestedResultsPath(rootRunId, id) {
+    assertSafeId("rootRunId", rootRunId);
+    assertSafeId("id", id);
+    return path.join(RESULTS_DIR, "nested", rootRunId, `${id}.json`);
+}

package/dist/runs/shared/nested-protocol.js

@@ -0,0 +1,18 @@
+import * as path from "node:path";
+import { TEMP_ROOT_DIR } from "../../shared/types.js";
+import { isSafeNestedPathId } from "./nested-path.js";
+export const NESTED_EVENTS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-events");
+export const ROUTE_FILE = "route.json";
+export const REGISTRY_FILE = "registry.json";
+export const MAX_EVENT_BYTES = 64 * 1024;
+export const MAX_STEPS = 12;
+export const MAX_CHILDREN = 16;
+export const MAX_DEPTH = 3;
+export function isSafeNestedId(value) {
+    return isSafeNestedPathId(value);
+}
+export function assertSafeNestedId(label, value) {
+    if (!isSafeNestedId(value)) {
+        throw new Error(`${label} must be a non-empty safe id token.`);
+    }
+}

package/dist/runs/shared/nested-registry.js

@@ -0,0 +1,191 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isRecord, isUnknownArray, hasErrorCode } from "../../shared/unknown.js";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import { assertSafeNestedId as assertSafeId, MAX_CHILDREN, REGISTRY_FILE, } from "./nested-protocol.js";
+import { commonRouteRoot, validateRouteShape, listNestedRoutes, readRouteFiles, } from "./nested-route.js";
+import { parseNestedEventRecords, sanitizeSummary } from "./nested-validation.js";
+export function terminal(state) {
+    return state === "complete" || state === "failed" || state === "blocked" || state === "paused";
+}
+function rejectsSummaryUpdate(existing, incoming) {
+    const previous = existing.lastUpdate ?? 0;
+    const next = incoming.lastUpdate ?? 0;
+    return (next < previous ||
+        (terminal(existing.state) && !terminal(incoming.state)) ||
+        (terminal(existing.state) && terminal(incoming.state) && next === previous));
+}
+function mergeSummary(existing, event) {
+    const incomingState = event.type === "subagent.nested.completed" && event.child.state === "running"
+        ? "complete"
+        : event.child.state;
+    const incoming = {
+        ...event.child,
+        state: incomingState,
+        lastUpdate: event.child.lastUpdate ?? event.ts,
+    };
+    if (!existing) {
+        return incoming;
+    }
+    if (rejectsSummaryUpdate(existing, incoming)) {
+        return existing;
+    }
+    return {
+        ...existing,
+        ...incoming,
+        state: incoming.state,
+        lastUpdate: Math.max(existing.lastUpdate ?? 0, incoming.lastUpdate),
+    };
+}
+function mergeChild(items, event) {
+    const index = items.findIndex((child) => child.id === event.child.id);
+    const child = mergeSummary(index < 0 ? undefined : items.at(index), event);
+    return index < 0
+        ? [...items, child].slice(0, MAX_CHILDREN)
+        : items.map((existing, position) => (position === index ? child : existing));
+}
+/** An event owns one tree traversal and the fact that its parent was found. */
+class NestedEventAttachment {
+    matched = false;
+    event;
+    constructor(event) {
+        this.event = event;
+    }
+    attach(children) {
+        const next = this.walk(children);
+        return this.matched ? next : mergeChild(next, this.event);
+    }
+    walk(items) {
+        return items.map((item) => this.attachItem(item));
+    }
+    attachItem(item) {
+        if (item.id === this.event.parentRunId) {
+            this.matched = true;
+            return {
+                ...item,
+                children: mergeChild(item.children ?? [], this.event).slice(0, MAX_CHILDREN),
+                lastUpdate: Math.max(item.lastUpdate ?? 0, this.event.ts),
+            };
+        }
+        if ((item.children?.length ?? 0) === 0) {
+            return item;
+        }
+        return { ...item, children: this.walk(item.children ?? []) };
+    }
+}
+export function applyNestedEvent(registry, event) {
+    return {
+        ...registry,
+        updatedAt: Math.max(registry.updatedAt, event.ts),
+        children: new NestedEventAttachment(event).attach(registry.children),
+    };
+}
+function registryPath(route) {
+    return path.join(commonRouteRoot(route), REGISTRY_FILE);
+}
+export function findNestedRouteForRootId(rootRunId) {
+    assertSafeId("rootRunId", rootRunId);
+    return listNestedRoutes(rootRunId)[0];
+}
+export function projectNestedRegistryForRoot(rootRunId) {
+    const route = findNestedRouteForRootId(rootRunId);
+    return route ? projectNestedEvents(route) : undefined;
+}
+export function findNestedRun(children, id) {
+    if (children === undefined || children.length === 0) {
+        return undefined;
+    }
+    for (const child of children) {
+        if (child.id === id) {
+            return child;
+        }
+        const nested = findNestedRun(child.children, id) ??
+            findNestedRun(child.steps?.flatMap((step) => step.children ?? []), id);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function collectNestedRuns(children) {
+    return (children ?? []).flatMap((child) => [child].concat(collectNestedRuns(child.children), collectNestedRuns(child.steps?.flatMap((step) => step.children ?? []))));
+}
+function collectScopedNestedRuns(children, scope) {
+    if (!scope) {
+        return collectNestedRuns(children);
+    }
+    return (children ?? []).flatMap((child) => {
+        if (child.parentRunId === scope.parentRunId &&
+            (scope.parentStepIndex === undefined || child.parentStepIndex === scope.parentStepIndex)) {
+            return collectNestedRuns([child]);
+        }
+        return collectScopedNestedRuns(child.children, scope).concat(collectScopedNestedRuns(child.steps?.flatMap((step) => step.children ?? []), scope));
+    });
+}
+function routeMatches(route, id, options) {
+    try {
+        const registry = projectNestedEvents(route);
+        return collectScopedNestedRuns(registry.children, options.scope?.descendantOf)
+            .filter((run) => (options.prefix === true ? run.id.startsWith(id) : run.id === id))
+            .map((run) => ({ rootRunId: route.rootRunId, route, run }));
+    }
+    catch {
+        // An invalid route never authorizes an indexed control target.
+        return [];
+    }
+}
+export function findNestedRunMatchesById(id, options = {}) {
+    assertSafeId("id", id);
+    return (options.scope?.routes ?? listNestedRoutes()).flatMap((route) => routeMatches(route, id, options));
+}
+export function readNestedRegistry(route) {
+    validateRouteShape(route);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(registryPath(route), "utf-8"));
+        if (!isRecord(parsed)) {
+            throw new Error("Invalid nested registry.");
+        }
+        return {
+            rootRunId: route.rootRunId,
+            updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : 0,
+            children: isUnknownArray(parsed.children)
+                ? parsed.children
+                    .map((child) => sanitizeSummary(child))
+                    .filter((child) => Boolean(child))
+                : [],
+            processedEvents: isUnknownArray(parsed.processedEvents)
+                ? parsed.processedEvents.filter((item) => typeof item === "string")
+                : [],
+        };
+    }
+    catch (error) {
+        if (!hasErrorCode(error, "ENOENT")) {
+            throw error;
+        }
+        return { rootRunId: route.rootRunId, updatedAt: 0, children: [], processedEvents: [] };
+    }
+}
+export function projectNestedEvents(route) {
+    validateRouteShape(route);
+    let registry = readNestedRegistry(route);
+    const seen = new Set(registry.processedEvents);
+    let changed = false;
+    for (const { entry, content } of readRouteFiles(route.eventSink, (name) => !seen.has(name) && (name.endsWith(".json") || name.endsWith(".jsonl")))) {
+        for (const event of parseNestedEventRecords(content, route)) {
+            registry = applyNestedEvent(registry, event);
+            changed = true;
+        }
+        seen.add(entry);
+        changed = true;
+    }
+    if (changed) {
+        // ponytail: directory enumeration and durable IDs still grow with route history.
+        // Archive immutable files with an atomic registry checkpoint if that becomes costly.
+        registry = { ...registry, processedEvents: [...seen] };
+        // Parent projection is the only writer to this sidecar registry. Child and
+        // runner processes only create immutable event files, so parent status.json
+        // remains owned by the existing runner writer and is never rewritten here.
+        writeAtomicJson(registryPath(route), registry);
+    }
+    return registry;
+}

package/dist/runs/shared/nested-render.js

@@ -1,11 +1,22 @@
 import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.js";
 import { formatActivityLabel, formatRunAction } from "../../shared/status-format.js";
 export function countNestedRuns(children) {
-    const counts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, blocked: 0, queued: 0 };
+    const counts = {
+        total: 0,
+        running: 0,
+        paused: 0,
+        complete: 0,
+        failed: 0,
+        blocked: 0,
+        queued: 0,
+    };
     for (const child of children ?? []) {
         counts.total++;
         counts[child.state]++;
-        const nested = countNestedRuns([...(child.children ?? []), ...(child.steps?.flatMap((step) => step.children ?? []) ?? [])]);
+        const nested = countNestedRuns([
+            ...(child.children ?? []),
+            ...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
+        ]);
         counts.total += nested.total;
         counts.running += nested.running;
         counts.paused += nested.paused;
@@ -18,8 +29,9 @@ export function countNestedRuns(children) {
 }
 export function formatNestedAggregate(children) {
     const counts = countNestedRuns(children);
-    if (counts.total === 0)
-        return undefined;
+    if (counts.total === 0) {
+        return;
+    }
     const parts = [
         counts.running > 0 ? `${counts.running} running` : "",
         counts.paused > 0 ? `${counts.paused} paused` : "",
@@ -28,81 +40,117 @@ export function formatNestedAggregate(children) {
         counts.complete > 0 ? `${counts.complete} complete` : "",
         counts.queued > 0 ? `${counts.queued} queued` : "",
     ].filter(Boolean);
-    return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+    return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}`;
 }
 function nestedRunLabel(run) {
-    if (run.agent)
+    if (run.agent !== undefined && run.agent !== "") {
         return run.agent;
-    if (run.agents?.length)
-        return run.agents.length === 1 ? run.agents[0] : `${run.agents.slice(0, 2).join(", ")}${run.agents.length > 2 ? ` +${run.agents.length - 2}` : ""}`;
-    return run.id;
+    }
+    const agents = run.agents ?? [];
+    if (agents.length === 0) {
+        return run.id;
+    }
+    if (agents.length === 1) {
+        return agents[0] ?? run.id;
+    }
+    return `${agents.slice(0, 2).join(", ")}${agents.length > 2 ? ` +${agents.length - 2}` : ""}`;
+}
+function toolActivity(input) {
+    if (input.currentTool === undefined || input.currentTool === "") {
+        return;
+    }
+    if (input.currentToolStartedAt === undefined) {
+        return `tool ${input.currentTool}`;
+    }
+    return `tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`;
 }
 function formatNestedActivity(input) {
-    const facts = [];
-    if (input.currentTool && input.currentToolStartedAt !== undefined)
-        facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
-    else if (input.currentTool)
-        facts.push(`tool ${input.currentTool}`);
-    if (input.currentPath)
-        facts.push(shortenPath(input.currentPath));
-    if (input.turnCount !== undefined)
-        facts.push(`${input.turnCount} turns`);
-    if (input.toolCount !== undefined)
-        facts.push(`${input.toolCount} tools`);
-    if (input.totalTokens)
-        facts.push(`${formatTokens(input.totalTokens.total)} tok`);
+    const tool = toolActivity(input);
+    const path = input.currentPath;
+    const facts = [
+        tool,
+        path !== undefined && path !== "" ? shortenPath(path) : undefined,
+        input.turnCount !== undefined ? `${input.turnCount} turns` : undefined,
+        input.toolCount !== undefined ? `${input.toolCount} tools` : undefined,
+        input.totalTokens ? `${formatTokens(input.totalTokens.total)} tok` : undefined,
+    ];
     const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
-    return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
+    const text = [activity, ...facts].filter(Boolean).join(" | ");
+    return text === "" ? undefined : text;
+}
+function runLine(child, indent) {
+    const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
+    return `${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity === undefined ? "" : ` | ${activity}`}${(child.error ?? "") !== "" ? ` | error: ${child.error ?? ""}` : ""}`;
+}
+function stepLine(step, position, index) {
+    const activity = step.status === "running" ? formatNestedActivity(step) : undefined;
+    return `${position.indent}  ${index + 1}. ${step.agent} ${step.status}${activity === undefined ? "" : ` | ${activity}`}${(step.error ?? "") !== "" ? ` | error: ${step.error ?? ""}` : ""}`;
 }
-function formatNestedRunLines(children, options) {
-    const lines = [];
-    const append = (items, depth, indent) => {
-        if (!items?.length || lines.length >= options.maxLines)
+/** Owns one rendering budget; recursion cannot silently bypass depth or line limits. */
+class NestedRunRenderer {
+    lines = [];
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    atLimit() {
+        return this.lines.length >= this.options.maxLines;
+    }
+    aggregate(items, indent) {
+        const aggregate = formatNestedAggregate(items);
+        if (aggregate !== undefined && !this.atLimit()) {
+            this.lines.push(`${indent}↳ ${aggregate}`);
+        }
+    }
+    append(items, position) {
+        if (items === undefined || items.length === 0 || this.atLimit()) {
             return;
-        if (depth > options.maxDepth) {
-            const aggregate = formatNestedAggregate(items);
-            if (aggregate && lines.length < options.maxLines)
-                lines.push(`${indent}↳ ${aggregate}`);
+        }
+        if (position.depth > this.options.maxDepth) {
+            this.aggregate(items, position.indent);
             return;
         }
-        for (let index = 0; index < items.length; index++) {
-            const child = items[index];
-            if (lines.length >= options.maxLines) {
+        for (const [index, child] of items.entries()) {
+            if (this.atLimit()) {
                 const aggregate = formatNestedAggregate(items.slice(index));
-                if (aggregate)
-                    lines[lines.length - 1] = `${indent}↳ ${aggregate}`;
+                if (aggregate !== undefined) {
+                    this.lines[this.lines.length - 1] = `${position.indent}↳ ${aggregate}`;
+                }
                 return;
             }
-            const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
-            const error = child.error ? ` | error: ${child.error}` : "";
-            lines.push(`${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity ? ` | ${activity}` : ""}${error}`);
-            if (options.commandHints && lines.length < options.maxLines)
-                lines.push(`${indent}  Status: ${formatRunAction("status", child.id, {}, options.childSafe)}`);
-            if (depth === options.maxDepth) {
-                const aggregate = formatNestedAggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])]);
-                if (aggregate && lines.length < options.maxLines)
-                    lines.push(`${indent}  ↳ ${aggregate}`);
-                continue;
-            }
-            for (const [stepIndex, step] of (child.steps ?? []).entries()) {
-                if (lines.length >= options.maxLines)
-                    return;
-                const stepActivity = step.status === "running" ? formatNestedActivity(step) : undefined;
-                lines.push(`${indent}  ${stepIndex + 1}. ${step.agent} ${step.status}${stepActivity ? ` | ${stepActivity}` : ""}${step.error ? ` | error: ${step.error}` : ""}`);
-                append(step.children, depth + 1, `${indent}    `);
+            this.appendRun(child, position);
+        }
+    }
+    appendRun(child, position) {
+        this.lines.push(runLine(child, position.indent));
+        if (this.options.commandHints === true && !this.atLimit()) {
+            this.lines.push(`${position.indent}  Status: ${formatRunAction("status", child.id, {}, this.options.childSafe)}`);
+        }
+        if (position.depth === this.options.maxDepth) {
+            this.aggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])], `${position.indent}  `);
+            return;
+        }
+        this.appendSteps(child, position);
+        this.append(child.children, { depth: position.depth + 1, indent: `${position.indent}  ` });
+    }
+    appendSteps(child, position) {
+        for (const [index, step] of (child.steps ?? []).entries()) {
+            if (this.atLimit()) {
+                return;
             }
-            append(child.children, depth + 1, `${indent}  `);
+            this.lines.push(stepLine(step, position, index));
+            this.append(step.children, { depth: position.depth + 1, indent: `${position.indent}    ` });
         }
-    };
-    append(children, 0, options.indent);
-    return lines;
+    }
 }
 export function formatNestedRunStatusLines(children, options = {}) {
-    return formatNestedRunLines(children, {
+    const renderer = new NestedRunRenderer({
         indent: options.indent ?? "  ",
         maxDepth: options.maxDepth ?? 2,
         maxLines: options.maxLines ?? 40,
         commandHints: options.commandHints ?? false,
         childSafe: options.childSafe,
     });
+    renderer.append(children, { depth: 0, indent: options.indent ?? "  " });
+    return renderer.lines;
 }