@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/background/run-id-resolver.js

@@ -1,64 +1,84 @@
 import { ASYNC_DIR, RESULTS_DIR } from "../../shared/types.js";
+import { hasText } from "./async-value.js";
 import { formatRunIdAmbiguity } from "../shared/run-id-ambiguity.js";
-import { exactAsyncRunLocation, findAsyncRunPrefixMatches } from "./async-resume.js";
-import { assertSafeNestedId, findNestedRunMatchesById, findNestedRouteForRootId } from "../shared/nested-events.js";
+import { exactAsyncRunLocation, findAsyncRunPrefixMatches } from "./async-run-location.js";
+import { assertSafeNestedId, findNestedRunMatchesById, findNestedRouteForRootId, } from "../shared/nested-events.js";
 function nestedScopeFromState(state) {
-    if (!state)
+    if (!state) {
         return undefined;
+    }
     const routes = [];
     const seen = new Set();
     const add = (route) => {
-        if (!route)
+        if (!route) {
             return;
+        }
         const key = `${route.rootRunId}:${route.eventSink}:${route.controlInbox}`;
-        if (seen.has(key))
+        if (seen.has(key)) {
             return;
+        }
         seen.add(key);
-        routes.push(route);
+        routes.push({ ...route });
     };
-    for (const run of state.ownedRuns?.values() ?? [])
+    for (const run of state.ownedRuns?.values() ?? []) {
         add(findNestedRouteForRootId(run.runId));
-    for (const job of state.asyncJobs.values())
+    }
+    for (const job of state.asyncJobs.values()) {
         add(job.nestedRoute);
+    }
     return { routes };
 }
-function asyncPrefixMatches(prefix, asyncDirRoot, resultsDir) {
-    return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
-}
-export function resolveSubagentRunId(id, deps = {}) {
-    assertSafeNestedId("id", id);
-    const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-    const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-    const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
-    // In a session scope, storage discovery must not hide an authorized descendant route.
-    const preferDirectAsync = (runId) => !nestedScope || deps.state?.ownedRuns?.has(runId) || deps.state?.asyncJobs.has(runId);
-    const exactAsync = exactAsyncRunLocation(id, asyncDirRoot, resultsDir);
-    if ((exactAsync.asyncDir || exactAsync.resultPath) && preferDirectAsync(id))
-        return { kind: "async", id, location: exactAsync };
-    const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
-    if (exactNested.length > 1)
+function resolveExact(id, location, scope, preferDirect) {
+    const exists = hasText(location.asyncDir) || hasText(location.resultPath);
+    if (exists && preferDirect) {
+        return { kind: "async", id, location };
+    }
+    const matches = findNestedRunMatchesById(id, scope === undefined ? {} : { scope });
+    if (matches.length > 1) {
         throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
-    if (exactNested[0])
-        return { kind: "nested", id, match: exactNested[0] };
-    if (exactAsync.asyncDir || exactAsync.resultPath)
-        return { kind: "async", id, location: exactAsync };
-    const asyncMatches = asyncPrefixMatches(id, asyncDirRoot, resultsDir);
-    const nestedMatches = findNestedRunMatchesById(id, nestedScope ? { prefix: true, scope: nestedScope } : { prefix: true });
+    }
+    const match = matches.at(0);
+    if (match) {
+        return { kind: "nested", id, match };
+    }
+    return exists ? { kind: "async", id, location } : undefined;
+}
+function resolvePrefix(id, options, preferDirect) {
+    const asyncMatches = findAsyncRunPrefixMatches(id, options.asyncDirRoot ?? ASYNC_DIR, options.resultsDir ?? RESULTS_DIR);
+    const nestedMatches = findNestedRunMatchesById(id, { prefix: true, scope: options.nested });
     const matches = [];
     for (const match of asyncMatches) {
-        if (!preferDirectAsync(match.id) && nestedMatches.some((nested) => nested.run.id === match.id))
+        if (!preferDirect(match.id) && nestedMatches.some((nested) => nested.run.id === match.id)) {
             continue;
+        }
         matches.push({ kind: "async", id: match.id, location: match.location });
     }
     for (const match of nestedMatches) {
-        if (preferDirectAsync(match.run.id) && asyncMatches.some((candidate) => candidate.id === match.run.id))
+        if (preferDirect(match.run.id) &&
+            asyncMatches.some((candidate) => candidate.id === match.run.id)) {
             continue;
+        }
         matches.push({ kind: "nested", id: match.run.id, match });
     }
-    const unique = new Map(matches.map((match) => [match.kind === "nested" ? `nested:${match.match.rootRunId}:${match.id}` : `async:${match.id}`, match]));
+    const unique = new Map(matches.map((match) => [
+        match.kind === "nested" ? `nested:${match.match.rootRunId}:${match.id}` : `async:${match.id}`,
+        match,
+    ]));
     const values = [...unique.values()];
     if (values.length > 1) {
         throw new Error(formatRunIdAmbiguity("subagent", id, values.map((match) => `${match.kind}:${match.id}`)));
     }
-    return values[0];
+    return values.at(0);
+}
+export function resolveSubagentRunId(id, deps = {}) {
+    assertSafeNestedId("id", id);
+    const root = deps.asyncDirRoot ?? ASYNC_DIR;
+    const results = deps.resultsDir ?? RESULTS_DIR;
+    const scope = deps.nested ?? nestedScopeFromState(deps.state);
+    // Storage discovery must not hide an authorized descendant route in a session scope.
+    const preferDirect = (runId) => scope === undefined ||
+        deps.state?.ownedRuns?.has(runId) === true ||
+        deps.state?.asyncJobs.has(runId) === true;
+    const exact = resolveExact(id, exactAsyncRunLocation(id, root, results), scope, preferDirect(id));
+    return exact ?? resolvePrefix(id, { ...deps, nested: scope }, preferDirect);
 }

package/dist/runs/background/run-schemas.js

@@ -0,0 +1,189 @@
+import { validateStatusForSummary } from "./async-status-validation.js";
+import { isRecord } from "./async-value.js";
+import * as guards from "../../../generated/RunValidators.js";
+// AJV's standalone guards preserve canonical validation without compiling in every process.
+function errorsText(errors) {
+    if (!errors || errors.length === 0) {
+        return "No errors";
+    }
+    return errors.map((error) => `data${error.instancePath} ${String(error.message)}`).join(", ");
+}
+export function parseNativeFinalizationConfig(value) {
+    const check = guards.NativeFinalizationConfig;
+    if (!check(value)) {
+        throw new SyntaxError("Invalid native finalization configuration");
+    }
+    return value;
+}
+export function parseNativeFinalizationEvent(value) {
+    const check = guards.NativeFinalizationEvent;
+    if (!check(value)) {
+        throw new SyntaxError("Invalid native finalization boundary");
+    }
+    return value;
+}
+export function parseSubagentRunConfig(value) {
+    const check = guards.SubagentRunConfig;
+    if (!check(value)) {
+        throw new Error(`Invalid runner config: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseDetails(value) {
+    const check = guards.Details;
+    if (!check(value)) {
+        throw new Error(`Invalid run details: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseSubagentExecutionResult(value) {
+    const check = guards.SubagentExecutionResult;
+    if (!check(value)) {
+        throw new Error(`Invalid run result: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryRunRow(value) {
+    const check = guards.HistoryRunRow;
+    if (!check(value)) {
+        throw new Error(`Invalid history run: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryRunPage(value) {
+    const check = guards.HistoryRunPage;
+    if (!check(value)) {
+        throw new Error(`Invalid history runs: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryPage(value) {
+    const check = guards.HistoryPage;
+    if (!check(value)) {
+        throw new Error(`Invalid history page: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistorySearchPage(value) {
+    const check = guards.HistorySearchPage;
+    if (!check(value)) {
+        throw new Error(`Invalid history search: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryIndexStatus(value) {
+    const check = guards.HistoryIndexStatus;
+    if (!check(value)) {
+        throw new Error(`Invalid history status: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryEntry(value) {
+    const check = guards.HistoryEntry;
+    if (!check(value)) {
+        throw new Error(`Invalid history entry: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseHistoryResult(value) {
+    const check = guards.HistoryResult;
+    if (!check(value)) {
+        throw new Error(`Invalid history result: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseAsyncStatus(value) {
+    validateStatusForSummary(value, "status.json");
+    const check = guards.AsyncStatus;
+    if (!check(value)) {
+        throw new Error(`Invalid async status: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+function resultErrors(errors) {
+    return errors
+        .map((error) => {
+        if (!isRecord(error) ||
+            typeof error.instancePath !== "string" ||
+            typeof error.message !== "string") {
+            return "invalid shape";
+        }
+        const field = error.instancePath
+            .split("/")
+            .slice(1)
+            .map((part, index) => /^\d+$/.test(part) ? `[${part}]` : `${index === 0 ? "" : "."}${part}`)
+            .join("");
+        return `${field} ${error.message.replace("must be string", "must be a string")}`;
+    })
+        .join("; ");
+}
+export function parseAsyncResult(value) {
+    const check = guards.AsyncResultFile;
+    if (!check(value)) {
+        throw new Error(`Invalid async result: ${resultErrors(check.errors ?? [])}.`);
+    }
+    return value;
+}
+export function parseForegroundResumeRun(value) {
+    const check = guards.ForegroundResumeRun;
+    if (!check(value)) {
+        throw new Error(`Invalid foreground run: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseAsyncStartedEvent(value) {
+    const check = guards.AsyncStartedEvent;
+    if (!check(value)) {
+        throw new Error(`Invalid async start event: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseControlEvent(value) {
+    const check = guards.ControlEvent;
+    if (!check(value)) {
+        throw new Error(`Invalid control event: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseSupervisorRunContract(value) {
+    const check = guards.SupervisorRunContract;
+    if (!check(value)) {
+        throw new Error(`Invalid supervisor contract: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseSupervisorQuestion(value) {
+    const check = guards.SupervisorQuestion;
+    if (!check(value)) {
+        throw new Error(`Invalid supervisor question: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseQuestionAnswer(value) {
+    const check = guards.QuestionAnswer;
+    if (!check(value)) {
+        throw new Error(`Invalid question answer: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseQuestionDelivery(value) {
+    const check = guards.QuestionDelivery;
+    if (!check(value)) {
+        throw new Error(`Invalid question delivery: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseQuestionRevival(value) {
+    const check = guards.SupervisorQuestionView;
+    if (!check(value)) {
+        throw new Error(`Invalid question revival: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}
+export function parseOwnedRun(value) {
+    const check = guards.OwnedRun;
+    if (!check(value)) {
+        throw new Error(`Invalid owned run: ${errorsText(check.errors)}.`);
+    }
+    return value;
+}

package/dist/runs/background/run-status-contracts.js

@@ -0,0 +1,14 @@
+import * as fs from "node:fs";
+export const ASYNC_COMPLETION_REMINDER = "Completion will be delivered automatically. If you are only waiting, end your turn instead of polling status again.";
+export function hasExistingSessionFile(value) {
+    return typeof value === "string" && fs.existsSync(value);
+}
+export function normalizedState(state) {
+    if (state === "running" || state === "queued") {
+        return "live";
+    }
+    if (state === "complete") {
+        return "completed";
+    }
+    return state;
+}

package/dist/runs/background/run-status-render.js

@@ -0,0 +1,270 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readOutputPage } from "../../shared/journal-reader.js";
+import { formatActivityFacts, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, } from "./async-status-render.js";
+import { formatNestedRunStatusLines } from "../shared/nested-render.js";
+import { formatModelThinking } from "../../shared/formatters.js";
+import { formatActivityLabel, formatLiveIntercomActionLines, formatRunAction, } from "../../shared/status-format.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.js";
+import { hasExistingSessionFile, normalizedState, } from "./run-status-contracts.js";
+import { errorMessage, hasText } from "./async-value.js";
+export function formatResumeGuidance(runId, children, fallbackSessionFile, childSafe = false) {
+    const known = children
+        .map((child, index) => ({ child, index }))
+        .filter(({ child }) => typeof child.agent === "string");
+    if (!hasText(runId) || known.length === 0) {
+        return "Resume: unavailable; no child session file was persisted.";
+    }
+    const single = known[0]?.child.sessionFile ?? fallbackSessionFile;
+    if (children.length === 1 && known.length === 1 && hasExistingSessionFile(single)) {
+        return `Continue: ${formatRunAction("resume", runId, { message: "..." }, childSafe)}`;
+    }
+    const child = known.find(({ child: candidate }) => hasExistingSessionFile(candidate.sessionFile));
+    if (child) {
+        return `Continue child: ${formatRunAction("resume", runId, { index: child.index, message: "..." }, childSafe)}`;
+    }
+    return "Resume: unavailable; no child session file was persisted.";
+}
+function outputExcerpt(outputPath, maxBytes = 4096, maxLines = 12) {
+    if (!hasText(outputPath) || !fs.existsSync(outputPath)) {
+        return [];
+    }
+    try {
+        const page = readOutputPage(outputPath, { length: maxBytes });
+        const text = page.text.trim();
+        if (text.length === 0) {
+            return [];
+        }
+        const all = text.split(/\r?\n/);
+        const suffix = page.offset > 0 || all.length > maxLines ? " (tail, truncated)" : "";
+        return [`Output excerpt${suffix}:`, ...all.slice(-maxLines).map((line) => `  ${line}`)];
+    }
+    catch (error) {
+        return [`Output excerpt unavailable: ${errorMessage(error)}`];
+    }
+}
+function stepLabel(status, index) {
+    const steps = status.steps ?? [];
+    const stepCount = steps.length > 0 ? steps.length : 1;
+    if (status.mode === "parallel") {
+        return `Agent ${index + 1}/${stepCount}`;
+    }
+    if (status.mode === "chain") {
+        const chainCount = status.chainStepCount ?? stepCount;
+        const groups = normalizeParallelGroups(status.parallelGroups, steps.length, chainCount);
+        const group = groups.find((candidate) => index >= candidate.start && index < candidate.start + candidate.count);
+        if (group) {
+            return `Step ${group.stepIndex + 1}/${chainCount} Agent ${index - group.start + 1}/${group.count}`;
+        }
+        return `Step ${flatToLogicalStepIndex(index, chainCount, groups) + 1}/${chainCount}`;
+    }
+    return `Step ${index + 1}`;
+}
+function acceptanceText(step) {
+    if (!step.acceptance) {
+        return "";
+    }
+    const final = step.acceptance.finalization;
+    const suffix = final
+        ? `, finalization: ${final.status} after ${final.turns.length}/${final.maxTurns} turns`
+        : "";
+    return `, acceptance: ${step.acceptance.status}${suffix}`;
+}
+function stepLine(status, step, index) {
+    const activity = step.status === "running" ? formatActivityFacts(step) : undefined;
+    const model = formatModelThinking(step.model, step.thinking);
+    const display = hasText(step.label) ? `${step.label} (${step.agent})` : step.agent;
+    const phase = hasText(step.phase) ? `[${step.phase}] ` : "";
+    return `${stepLabel(status, index)}: ${phase}${display} ${step.status}${model.length > 0 ? ` (${model})` : ""}${hasText(activity) ? `, ${activity}` : ""}${acceptanceText(step)}${hasText(step.error) ? `, error: ${step.error}` : ""}`;
+}
+export function canExtend(status) {
+    return (status.runtimeVersion === 2 &&
+        status.state === "running" &&
+        status.timedOut !== true &&
+        status.timeoutAt !== undefined &&
+        status.timeoutAt !== 0);
+}
+function runtimeTiming(status, childSafe) {
+    return [
+        `Started: ${new Date(status.startedAt).toISOString()}`,
+        `Updated: ${status.lastUpdate !== undefined && status.lastUpdate !== 0 ? new Date(status.lastUpdate).toISOString() : "n/a"}`,
+        status.timeoutAt !== undefined && status.timeoutAt !== 0
+            ? `Timeout: ${new Date(status.timeoutAt).toISOString()}`
+            : undefined,
+        canExtend(status)
+            ? `Extend: ${formatRunAction("extend", status.runId, { extendMs: 300000 }, childSafe)}`
+            : undefined,
+    ];
+}
+function runtimeResultLine(resultPath, includeRunHeader) {
+    if (!hasText(resultPath) || !fs.existsSync(resultPath)) {
+        return undefined;
+    }
+    return `${includeRunHeader === false ? "Runtime result" : "Result"}: ${resultPath}`;
+}
+export function runtimeHeader(status, asyncDir, deps, diagnosis) {
+    const childSafe = deps.nested !== undefined;
+    const progress = formatAsyncRunProgressLabel({
+        mode: status.mode,
+        state: status.state,
+        currentStep: status.currentStep,
+        chainStepCount: status.chainStepCount,
+        parallelGroups: status.parallelGroups,
+        steps: status.steps ?? [],
+    });
+    const activity = status.state === "running" ? formatActivityFacts(status) : undefined;
+    const output = formatAsyncRunOutputPath({ asyncDir, outputFile: status.outputFile });
+    const lines = [
+        ...(deps.includeRunHeader !== false
+            ? [`Run: ${status.runId}`, `State: ${status.state}`, `Mode: ${status.mode}`]
+            : []),
+        hasText(activity) ? `Activity: ${activity}` : undefined,
+        `Progress: ${progress}`,
+        ...runtimeTiming(status, childSafe),
+        `Dir: ${asyncDir}`,
+        `Status: ${formatRunAction("status", status.runId, {}, childSafe)}`,
+        hasText(output) ? `Output: ${output}` : undefined,
+        hasText(diagnosis.message) ? `Diagnosis: ${diagnosis.message}` : undefined,
+        runtimeResultLine(diagnosis.resultPath, deps.includeRunHeader),
+    ].filter((line) => line !== undefined);
+    if (status.state !== "running") {
+        lines.push(...outputExcerpt(output));
+    }
+    return lines;
+}
+export function runtimeSteps(status, asyncDir, deps) {
+    const lines = [];
+    const intercomTargets = [];
+    const childSafe = deps.nested !== undefined;
+    const output = formatAsyncRunOutputPath({ asyncDir, outputFile: status.outputFile });
+    for (const [index, step] of (status.steps ?? []).entries()) {
+        lines.push(stepLine(status, step, index));
+        if (step.tokens) {
+            lines.push(`  ${step.tokens.total} tokens`);
+        }
+        lines.push(...formatNestedRunStatusLines(step.children, {
+            indent: "  ",
+            commandHints: true,
+            maxLines: 20,
+            childSafe,
+        }));
+        const stepOutput = path.join(asyncDir, `output-${index}.log`);
+        if (stepOutput !== output && fs.existsSync(stepOutput)) {
+            lines.push(`  Output: ${stepOutput}`);
+        }
+        if (step.status === "running") {
+            const target = resolveSubagentIntercomTarget(status.runId, step.agent, index);
+            intercomTargets.push(target);
+            lines.push(...formatLiveIntercomActionLines({
+                runId: status.runId,
+                index,
+                target,
+                health: deps.intercomHealth?.get(target),
+                indent: "  ",
+                childSafe,
+            }));
+        }
+    }
+    return { lines, intercomTargets };
+}
+export function runtimeFooter(status, asyncDir, deps, nested) {
+    const childSafe = deps.nested !== undefined;
+    const attached = new Set((status.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? []));
+    const children = nested.children.filter((child) => !attached.has(child.id));
+    const lines = formatNestedRunStatusLines(children, {
+        indent: "",
+        commandHints: true,
+        maxLines: 20,
+        childSafe,
+    });
+    if (hasText(nested.warning)) {
+        lines.push(`Warning: ${nested.warning}`);
+    }
+    if (hasText(status.sessionFile)) {
+        lines.push(`Session: ${status.sessionFile}`);
+    }
+    if (status.state !== "running") {
+        lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, childSafe));
+    }
+    const log = path.join(asyncDir, `subagent-log-${status.runId}.md`);
+    const events = path.join(asyncDir, "events.jsonl");
+    if (fs.existsSync(log)) {
+        lines.push(`Log: ${log}`);
+    }
+    if (fs.existsSync(events)) {
+        lines.push(`Events: ${events}`);
+    }
+    return lines;
+}
+function nestedDisplayName(run) {
+    if (hasText(run.agent)) {
+        return run.agent;
+    }
+    return (run.agents?.length ?? 0) > 0 ? (run.agents?.join(", ") ?? run.id) : run.id;
+}
+function nestedSteps(run, childSafe) {
+    const lines = [];
+    if ((run.steps?.length ?? 0) > 0) {
+        lines.push("Steps:");
+    }
+    for (const [index, step] of (run.steps ?? []).entries()) {
+        const activity = step.status === "running"
+            ? formatActivityLabel(step.lastActivityAt, step.activityState)
+            : undefined;
+        lines.push(`  ${index + 1}. ${step.agent} ${step.status}${hasText(activity) ? `, ${activity}` : ""}${hasText(step.error) ? `, error: ${step.error}` : ""}`);
+        lines.push(...formatNestedRunStatusLines(step.children, {
+            indent: "    ",
+            commandHints: true,
+            childSafe,
+        }));
+    }
+    lines.push(...formatNestedRunStatusLines(run.children, { indent: "  ", commandHints: true, childSafe }));
+    return lines;
+}
+function nestedCommands(rootRunId, run, childSafe) {
+    const state = normalizedState(run.state);
+    const lines = ["Commands:", `  Status: ${formatRunAction("status", run.id, {}, childSafe)}`];
+    if (state === "live") {
+        lines.push(`  ${childSafe ? "Interrupt" : "Stop"}: ${formatRunAction("interrupt", run.id, {}, childSafe)}`);
+    }
+    if (state === "live" || hasText(run.sessionFile)) {
+        lines.push(`  ${childSafe ? "Resume" : "Continue"}: ${formatRunAction("resume", run.id, { message: "..." }, childSafe)}`);
+    }
+    lines.push(`  Root status: ${formatRunAction("status", rootRunId, {}, childSafe)}`);
+    return lines;
+}
+function nestedActivity(run) {
+    const activity = formatActivityLabel(run.lastActivityAt, run.activityState);
+    return hasText(activity) ? `Activity: ${activity}` : undefined;
+}
+function nestedProgress(run) {
+    if (run.currentStep === undefined) {
+        return undefined;
+    }
+    return `Progress: step ${run.currentStep + 1}/${run.chainStepCount ?? run.steps?.length ?? 1}`;
+}
+export function formatNestedExactStatus(rootRunId, run, childSafe) {
+    const lines = [
+        `Nested run: ${run.id}`,
+        `Root: ${rootRunId}`,
+        `Parent: ${run.parentRunId}${run.parentStepIndex !== undefined ? ` step ${run.parentStepIndex + 1}` : ""}`,
+        `State: ${run.state}`,
+        nestedActivity(run),
+        run.mode !== undefined ? `Mode: ${run.mode}` : undefined,
+        `Agent: ${nestedDisplayName(run)}`,
+        nestedProgress(run),
+        hasText(run.asyncDir) ? `Dir: ${run.asyncDir}` : undefined,
+        hasText(run.sessionFile) ? `Session: ${run.sessionFile}` : undefined,
+        hasText(run.error) ? `Error: ${run.error}` : undefined,
+    ].filter((line) => line !== undefined);
+    if (run.path.length > 0) {
+        const parts = run.path.map((part) => `${part.runId}${part.stepIndex !== undefined ? `:${part.stepIndex + 1}` : ""}${hasText(part.agent) ? `:${part.agent}` : ""}`);
+        lines.push(`Path: ${parts.join(" > ")} > ${run.id}`);
+    }
+    return [
+        ...lines,
+        ...nestedSteps(run, childSafe),
+        ...nestedCommands(rootRunId, run, childSafe),
+    ].join("\n");
+}