@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/src/runs/background/chain-root-attachment.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resultFilePath, resultPayloadPathForSessionRun } from "./result-files.ts";
-import type { AcceptanceLedger, ArtifactPaths, AsyncStatus, CostSummary, EffectsProjection, ExecutionProjection, ModelAttempt, Usage } from "../../shared/types.ts";
+import type { AcceptanceLedger, ArtifactPaths, AsyncStatus, CostSummary, EffectsProjection, ExecutionProjection, Usage } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
 
 export interface ImportedAsyncRoot {
@@ -13,6 +13,7 @@ export interface ImportedAsyncRoot {
 
 export interface ImportedAsyncRootResult {
 	agent: string;
+	importedPublication?: { sessionId?: string; toolCallId?: string };
 	/** Human-readable display name for the child session, when derived at launch. */
 	sessionName?: string;
 	output: string;
@@ -22,8 +23,7 @@ export interface ImportedAsyncRootResult {
 	sessionFile?: string;
 	intercomTarget?: string;
 	model?: string;
-	attemptedModels?: string[];
-	modelAttempts?: ModelAttempt[];
+	requestedModel?: string;
 	contextOverflow?: boolean;
 	totalCost?: CostSummary;
 	usage?: Usage;
@@ -43,6 +43,8 @@ export interface ImportedAsyncRootResult {
 }
 
 interface AsyncResultFile {
+	sessionId?: string;
+	toolCallId?: string;
 	state?: string;
 	success?: boolean;
 	summary?: string;
@@ -62,8 +64,7 @@ interface AsyncResultFile {
 		sessionFile?: string;
 		intercomTarget?: string;
 		model?: string;
-		attemptedModels?: string[];
-		modelAttempts?: ModelAttempt[];
+		requestedModel?: string;
 		contextOverflow?: boolean;
 		totalCost?: CostSummary;
 		usage?: Usage;
@@ -82,23 +83,6 @@ interface AsyncResultFile {
 const TERMINAL_STATES = new Set(["complete", "failed", "partial", "paused", "stopped"]);
 const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "partial", "paused", "stopped"]);
 
-function usageFromAttempts(attempts: ModelAttempt[] | undefined): Usage | undefined {
-	if (!attempts?.length) return undefined;
-	const usage: Usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-	for (const attempt of attempts) {
-		if (!attempt.usage) continue;
-		usage.input += attempt.usage.input;
-		usage.output += attempt.usage.output;
-		usage.cacheRead += attempt.usage.cacheRead;
-		usage.cacheWrite += attempt.usage.cacheWrite;
-		usage.cost += attempt.usage.cost;
-		usage.turns += attempt.usage.turns;
-	}
-	return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0
-		? usage
-		: undefined;
-}
-
 function readResultFile(resultPath: string): AsyncResultFile | undefined {
 	try {
 		return JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultFile;
@@ -153,7 +137,6 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 	const execution = step?.execution ?? (partialStatus
 		? { status: "partial" as const, success: false, exitCode: 1, error: message }
 		: undefined);
-	const usage = usageFromAttempts(step?.modelAttempts);
 	return {
 		agent,
 		output: message,
@@ -165,11 +148,9 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 		...(step?.sessionName ? { sessionName: step.sessionName } : {}),
 		...(step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {}),
 		...(step?.model ? { model: step.model } : {}),
-		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
-		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.requestedModel ? { requestedModel: step.requestedModel } : {}),
 		...(step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
-		...(usage ? { usage } : {}),
 		...(step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
 		...(step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {}),
 		...(step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {}),
@@ -180,24 +161,21 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 	};
 }
 
-function outputFromTimeout(root: ImportedAsyncRoot, status: AsyncStatus | null, message: string): ImportedAsyncRootResult {
+function outputFromTimeout(root: ImportedAsyncRoot, status: AsyncStatus | null, message: string, stopped = false): ImportedAsyncRootResult {
 	const step = selectedStatusStep(status, root.index);
-	const usage = usageFromAttempts(step?.modelAttempts);
 	return {
 		agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
 		output: message,
 		success: false,
 		exitCode: 1,
 		error: message,
-		timedOut: true,
+		...(stopped ? { stopped: true } : { timedOut: true }),
 		...(step?.sessionName ? { sessionName: step.sessionName } : {}),
 		...(step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {}),
 		...(step?.model ? { model: step.model } : {}),
-		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
-		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.requestedModel ? { requestedModel: step.requestedModel } : {}),
 		...(step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
-		...(usage ? { usage } : {}),
 		...(step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}),
 	};
 }
@@ -213,9 +191,13 @@ function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null
 	const success = state === "complete" && !timedOut && !stopped;
 	const error = child?.error ?? (success ? undefined : stopped ? "Subagent stopped by user." : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
 	const execution = state ? { status: state === "complete" ? "completed" as const : state, success, exitCode: success ? 0 : 1, ...(error ? { error } : {}) } : undefined;
-	const usage = child?.usage ?? usageFromAttempts(step?.modelAttempts);
+	const usage = child?.usage;
 	return {
 		agent,
+		importedPublication: {
+			...(typeof result.sessionId === "string" ? { sessionId: result.sessionId } : {}),
+			...(typeof result.toolCallId === "string" ? { toolCallId: result.toolCallId } : {}),
+		},
 		output: success ? output : (output || error || ""),
 		success,
 		exitCode: success ? 0 : 1,
@@ -226,8 +208,7 @@ function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null
 		...(child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {}),
 		...(child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {}),
 		...(child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {}),
-		...(child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {}),
-		...(child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {}),
+		...(child?.requestedModel ?? step?.requestedModel ? { requestedModel: child?.requestedModel ?? step?.requestedModel } : {}),
 		...(child?.contextOverflow || step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {}),
 		...(usage ? { usage } : {}),
@@ -247,7 +228,7 @@ function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null
 
 export async function waitForImportedAsyncRoot(
 	root: ImportedAsyncRoot,
-	options: { pollIntervalMs?: number; terminalResultGraceMs?: number; now?: () => number; shouldAbort?: () => boolean; timeoutMessage?: string } = {},
+	options: { pollIntervalMs?: number; terminalResultGraceMs?: number; now?: () => number; shouldAbort?: () => boolean; timeoutMessage?: string; abortedAsStopped?: boolean } = {},
 ): Promise<ImportedAsyncRootResult> {
 	const pollIntervalMs = options.pollIntervalMs ?? 500;
 	const terminalResultGraceMs = options.terminalResultGraceMs ?? 1_000;
@@ -255,7 +236,7 @@ export async function waitForImportedAsyncRoot(
 	let terminalSince: number | undefined;
 	for (;;) {
 		const status = readStatus(root.asyncDir);
-		if (options.shouldAbort?.()) return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.");
+		if (options.shouldAbort?.()) return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.", options.abortedAsStopped === true);
 		const result = readImportedResultFile(root, status);
 		if (result) return buildImportedResult(root, status, result);
 		if (isTerminalStatus(status, root.index)) {
@@ -275,4 +256,4 @@ export async function waitForImportedAsyncRoot(
 
 export function resolveAsyncRootResultPath(resultsDir: string, runId: string): string {
 	return resultFilePath(resultsDir, runId);
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/control-channel.ts

@@ -74,11 +74,51 @@ export interface SteerRequest {
 	source?: string;
 }
 
+export interface CommandRequest {
+	type: "command";
+	id: string;
+	ownerId: string;
+	operation: "status" | "yield" | "cancel";
+	toolCallId?: string;
+	deadlineAt: number;
+}
+
+function validCommandRequest(raw: unknown): raw is CommandRequest {
+	if (!raw || typeof raw !== "object") return false;
+	const value = raw as Partial<CommandRequest>;
+	return value.type === "command" && typeof value.id === "string" && /^[a-f0-9-]{36}$/.test(value.id)
+		&& typeof value.ownerId === "string" && /^[a-f0-9-]{36}$/.test(value.ownerId)
+		&& (value.operation === "status" || value.operation === "yield" || value.operation === "cancel")
+		&& Number.isSafeInteger(value.deadlineAt) && value.deadlineAt! > 0
+		&& (value.toolCallId === undefined ? value.operation === "status" : typeof value.toolCallId === "string" && value.toolCallId.length > 0 && value.toolCallId.length <= 256);
+}
+
+function commandRequestsDir(dir: string): string { return path.join(controlInboxDir(dir), "command-requests"); }
+export function requestAsyncCommand(dir: string, request: CommandRequest): void {
+	if (!validCommandRequest(request)) throw new Error("Malformed command request.");
+	writeAtomicJson(path.join(commandRequestsDir(dir), `${request.id}.json`), request);
+}
+function consumeCommandRequests(dir: string, fsImpl: ControlChannelFs): CommandRequest[] {
+	const requests: CommandRequest[] = [];
+	for (const name of fsImpl.readdirSync(commandRequestsDir(dir)).filter((entry) => entry.endsWith(".json")).sort()) {
+		const file = path.join(commandRequestsDir(dir), name);
+		let value: unknown;
+		try { value = JSON.parse(fsImpl.readFileSync(file, "utf8")); }
+		catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; }
+		try { fsImpl.rmSync(file); }
+		catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; throw error; }
+		if (validCommandRequest(value)) requests.push(value);
+	}
+	return requests;
+}
+
 const STEER_REQUESTS_DIR = "steer-requests";
 const STOP_REQUESTS_DIR = "stop-requests";
 const REVIVAL_BRIEFS_DIR = "revival-briefs";
 export const MAX_STEER_QUEUE_SIZE = 20;
 const STEER_INBOX_CLOSED_FILE = "steer-inbox-closed.json";
+const STOP_INBOX_CLOSED_FILE = "stop-inbox-closed.json";
+const STOP_INBOX_CLOSED_MESSAGE = "Runner stop inbox is closed. Retry stop after runner shutdown is observed.";
 const MAX_STEER_MESSAGE_BYTES = 128 * 1024;
 const MAX_STEER_REQUEST_ID_LENGTH = 256;
 
@@ -116,6 +156,14 @@ export function steerInboxClosedPath(asyncDir: string): string {
 	return path.join(controlInboxDir(asyncDir), STEER_INBOX_CLOSED_FILE);
 }
 
+export function stopInboxClosedPath(asyncDir: string): string {
+	return path.join(controlInboxDir(asyncDir), STOP_INBOX_CLOSED_FILE);
+}
+
+export function closeStopInbox(asyncDir: string): void {
+	writeAtomicJson(stopInboxClosedPath(asyncDir), { version: 1, closedAt: Date.now() });
+}
+
 export function closeSteerInbox(asyncDir: string, state: string, write: (filePath: string, payload: object) => void = writeAtomicJson): void {
 	write(steerInboxClosedPath(asyncDir), { version: 1, closedAt: Date.now(), state });
 }
@@ -206,15 +254,21 @@ export function requestAsyncTimeout(
 export function requestAsyncStop(
 	asyncDir: string,
 	payload: Omit<StopRequest, "type"> = {},
-	deps: { now?: () => number } = {},
+	deps: { now?: () => number; write?: typeof writeAtomicJson } = {},
 ): string {
 	if (payload.targetIndex !== undefined) assertChildIndex(payload.targetIndex);
 	if (payload.childId !== undefined && !validStopChildId(payload.childId)) {
 		throw new Error("stop childId must be a non-empty string without newlines and at most 256 characters.");
 	}
+	const closedPath = stopInboxClosedPath(asyncDir);
+	if (fs.existsSync(closedPath)) throw new Error(STOP_INBOX_CLOSED_MESSAGE);
 	const request: StopRequest = { ...payload, ts: payload.ts ?? deps.now?.() ?? Date.now(), type: "stop" };
 	const requestPath = path.join(stopRequestsDir(asyncDir), stopRequestFileName(request));
-	writeAtomicJson(requestPath, request);
+	(deps.write ?? writeAtomicJson)(requestPath, request);
+	if (fs.existsSync(closedPath)) {
+		fs.rmSync(requestPath, { force: true });
+		throw new Error(STOP_INBOX_CLOSED_MESSAGE);
+	}
 	return requestPath;
 }
 
@@ -503,6 +557,7 @@ export function watchAsyncControlInbox(
 		onTimeout?: () => void;
 		onStop?: (request: StopRequest) => void;
 		onSteer?: (request: SteerRequest) => void;
+		onCommand?: (request: CommandRequest) => void;
 		onError?: (error: unknown, phase: "install" | "scan" | "callback", request?: SteerRequest) => void;
 		pollIntervalMs?: number;
 		safetyPollIntervalMs?: number;
@@ -526,6 +581,7 @@ export function watchAsyncControlInbox(
 		...(opts.onInterrupt || opts.onTimeout || opts.onStop ? [dir] : []),
 		...(opts.onStop ? [stopRequestsDir(asyncDir)] : []),
 		...(opts.onSteer ? [steerRequestsDir(asyncDir)] : []),
+		...(opts.onCommand ? [commandRequestsDir(asyncDir)] : []),
 	];
 	if (dirs.length === 0) return () => {};
 	try {
@@ -538,6 +594,9 @@ export function watchAsyncControlInbox(
 	const check = (): void => {
 		if (disposed) return;
 		try {
+			if (opts.onCommand) for (const request of consumeCommandRequests(asyncDir, fsImpl)) {
+				try { opts.onCommand(request); } catch (error) { report(error, "callback"); }
+			}
 			if (opts.onStop) for (const request of consumeStopRequestPayloads(asyncDir, fsImpl, (error) => report(error, "scan"))) {
 				try { opts.onStop(request); } catch (error) { report(error, "callback"); }
 			}
@@ -597,4 +656,4 @@ export function watchAsyncControlInbox(
 		if (interval) timers.clearInterval(interval);
 		if (safetyInterval) timers.clearInterval(safetyInterval);
 	};
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/fleet-view.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { safeTerminalText } from "../../shared/display-text.ts";
+import { safeTerminalText, truncateDisplayText } from "../../shared/display-text.ts";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
 import {
@@ -23,6 +23,10 @@ import { isTrustedRecordedSessionFile } from "../../shared/session-file-trust.ts
 const DEFAULT_TRANSCRIPT_LINES = 80;
 const MAX_TRANSCRIPT_LINES = 500;
 const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+const MAX_TRANSCRIPT_LINE_CHARS = 2000;
+const MAX_TRANSCRIPT_BODY_BYTES = 32 * 1024;
+const TRANSCRIPT_LINE_OMISSION = "… [content omitted]";
+const TRANSCRIPT_BODY_OMISSION = "  … [earlier lines omitted]";
 
 type ForegroundControl = SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
 type ForegroundRun = NonNullable<SubagentState["foregroundRuns"]> extends Map<string, infer T> ? T : never;
@@ -335,7 +339,16 @@ function formatDetachedForegroundFleetLines(runs: ForegroundRun[]): string[] {
 	return lines;
 }
 
-function formatAsyncFleetLines(runs: AsyncRunSummary[]): string[] {
+function externalCliStepFacts(step: AsyncRunSummary["steps"][number], now: number): string | undefined {
+	if (step.runner?.type !== "external-cli") return undefined;
+	const process = step.externalProcess;
+	const elapsed = process
+		? process.durationMs ?? Math.max(0, (process.endedAt ?? now) - process.startedAt)
+		: undefined;
+	return `external-cli${elapsed !== undefined ? ` · ${formatDuration(elapsed)}` : ""}`;
+}
+
+function formatAsyncFleetLines(runs: AsyncRunSummary[], now = Date.now()): string[] {
 	if (runs.length === 0) return [];
 	const lines = ["Async runs:"];
 	for (const run of runs) {
@@ -353,7 +366,7 @@ function formatAsyncFleetLines(runs: AsyncRunSummary[]): string[] {
 			const phase = step.phase ? `[${step.phase}] ` : "";
 			const stepActivity = formatActivityFacts(step);
 			const modelThinking = formatModelThinking(step.model, step.thinking);
-			const parts = [`${step.index}. ${phase}${display}${stepContext ? ` ${stepContext}` : ""}`, step.status, stepActivity, modelThinking].filter(Boolean);
+			const parts = [`${step.index}. ${phase}${display}${stepContext ? ` ${stepContext}` : ""}`, step.status, externalCliStepFacts(step, now), stepActivity, modelThinking].filter(Boolean);
 			lines.push(`  ${parts.join(" | ")}`);
 			const output = path.join(run.asyncDir, `output-${step.index}.log`);
 			if (fs.existsSync(output)) lines.push(`    output: ${shortenPath(output)}`);
@@ -416,7 +429,7 @@ export function inspectSubagentFleet(_params: FleetViewParams, deps: FleetViewDe
 	if (foregroundLines.length) lines.push(...foregroundLines, "");
 	const detachedForegroundLines = formatDetachedForegroundFleetLines(detachedForegroundRuns);
 	if (detachedForegroundLines.length) lines.push(...detachedForegroundLines, "");
-	const asyncLines = formatAsyncFleetLines(asyncRuns);
+	const asyncLines = formatAsyncFleetLines(asyncRuns, deps.now?.() ?? Date.now());
 	if (asyncLines.length) lines.push(...asyncLines, "");
 	lines.push("Commands:");
 	lines.push("  Refresh fleet: subagent({ action: \"status\", view: \"fleet\" })");
@@ -494,17 +507,66 @@ function appendTranscriptBody(lines: string[], sourceLabel: string, sourceLines:
 		lines.push("  (no transcript lines available yet)");
 		return;
 	}
-	for (const line of sourceLines) lines.push(`  ${line}`);
+	// Bound the rendered body, not the raw input: terminal escaping can expand it.
+	// Keep line prefixes (roles/tool names), then prefer whole recent lines. The
+	// byte budget includes indentation, separators and omission markers, but not
+	// the source label, run metadata, warnings or artifact paths above the body.
+	const body: string[] = [];
+	let bytes = 0;
+	for (let index = sourceLines.length - 1; index >= 0; index--) {
+		// Preserve assembled-line binary detection (including indentation). A
+		// binary placeholder replaces the whole line and must not be reindented.
+		const safe = safeTerminalText(`  ${sourceLines[index]!}`);
+		const lineLimit = MAX_TRANSCRIPT_LINE_CHARS + 2;
+		const line = safe.length <= lineLimit
+			? safe
+			: truncateDisplayText(safe, lineLimit - TRANSCRIPT_LINE_OMISSION.length) + TRANSCRIPT_LINE_OMISSION;
+		const size = Buffer.byteLength(line) + 1;
+		if (bytes + size > MAX_TRANSCRIPT_BODY_BYTES) {
+			const markerBytes = Buffer.byteLength(TRANSCRIPT_BODY_OMISSION) + 1;
+			while (bytes + markerBytes > MAX_TRANSCRIPT_BODY_BYTES) bytes -= Buffer.byteLength(body.pop()!) + 1;
+			body.push(TRANSCRIPT_BODY_OMISSION);
+			break;
+		}
+		body.push(line);
+		bytes += size;
+	}
+	lines.push(...body.reverse());
+}
+
+function resolveWorkflowTranscriptChild(status: AsyncStatus, asyncDir: string, options: TranscriptOptions): { status: AsyncStatus; asyncDir: string } | undefined {
+	if (status.mode !== "workflow" || options.index === undefined) return undefined;
+	const step = status.steps?.[options.index];
+	if (step?.async !== true || typeof step.runId !== "string" || !/^[A-Za-z0-9_-]+$/.test(step.runId) || step.runId === status.runId) return undefined;
+	try {
+		const asyncRoot = fs.realpathSync(path.dirname(asyncDir));
+		const childDir = path.join(asyncRoot, step.runId);
+		if (fs.realpathSync(childDir) !== childDir || fs.lstatSync(path.join(childDir, "status.json")).isSymbolicLink()) return undefined;
+		const childStatus = readStatus(childDir);
+		return childStatus?.runId === step.runId
+			&& childStatus.parentWorkflowRunId === status.runId
+			&& typeof step.workflowKey === "string" && step.workflowKey.length > 0
+			&& childStatus.workflowKey === step.workflowKey
+			&& typeof status.sessionId === "string" && status.sessionId.length > 0
+			&& childStatus.sessionId === status.sessionId
+			? { status: childStatus, asyncDir: childDir }
+			: undefined;
+	} catch (error) {
+		if (isNotFoundError(error)) return undefined;
+		throw error;
+	}
 }
 
 export function formatAsyncRunTranscript(status: AsyncStatus, asyncDir: string, options: TranscriptOptions = {}): string {
+	const workflowChild = resolveWorkflowTranscriptChild(status, asyncDir, options);
+	if (workflowChild) return formatAsyncRunTranscript(workflowChild.status, workflowChild.asyncDir, { ...options, index: undefined });
 	const lineLimit = transcriptLineLimit(options.lines);
 	const selected = selectTranscriptStep(status, options);
 	const stepOutputPath = selected.index !== undefined ? path.join(asyncDir, `output-${selected.index}.log`) : undefined;
 	const runOutputPath = resolveMaybeRelative(asyncDir, status.outputFile);
 	const logPath = path.join(asyncDir, `subagent-log-${status.runId}.md`);
 	const outputPaths = selected.index !== undefined
-		? uniqueStrings([stepOutputPath, runOutputPath && stepOutputPath && path.resolve(runOutputPath) === path.resolve(stepOutputPath) ? runOutputPath : undefined])
+		? uniqueStrings([selected.step?.externalProcess?.finalOutputPath, stepOutputPath, runOutputPath && stepOutputPath && path.resolve(runOutputPath) === path.resolve(stepOutputPath) ? runOutputPath : undefined])
 		: uniqueStrings([runOutputPath]);
 	const sessionFile = selected.index !== undefined ? selected.step?.sessionFile : status.sessionFile;
 	const eventsPath = path.join(asyncDir, "events.jsonl");
@@ -525,12 +587,22 @@ export function formatAsyncRunTranscript(status: AsyncStatus, asyncDir: string,
 	let transcriptLines: string[] = [];
 	let transcriptSource = "Transcript tail";
 	let truncated = false;
-	for (const outputPath of outputPaths) {
+	const externalProcess = selected.step?.runner?.type === "external-cli" ? selected.step.externalProcess : undefined;
+	const externalLogPaths = externalProcess ? [
+		{ path: externalProcess.stderrPath, label: "External stderr tail" },
+		{ path: externalProcess.stdoutPath, label: "External stdout tail" },
+	] : [];
+	const runningExternal = selected.step?.status === "running" && externalProcess;
+	const sources = runningExternal
+		? [...externalLogPaths, ...outputPaths.map((outputPath) => ({ path: outputPath, label: "Transcript tail" }))]
+		: [...outputPaths.map((outputPath) => ({ path: outputPath, label: "Transcript tail" })), ...externalLogPaths];
+	for (const source of sources) {
+		const outputPath = source.path;
 		const tail = readContainedTextTail(outputPath, lineLimit, [asyncDir], "output");
 		if (tail.error) warnings.push(`Output read failed for ${tail.path}: ${tail.error}`);
-		if (tail.lines.length === 0) continue;
+		if (!tail.lines.some((line) => line.trim().length > 0)) continue;
 		transcriptLines = tail.lines;
-		transcriptSource = `Transcript tail from ${tail.path}`;
+		transcriptSource = `${source.label} from ${tail.path}`;
 		truncated = tail.truncated;
 		break;
 	}
@@ -617,4 +689,4 @@ export function formatAsyncResultTranscript(data: {
 	appendKnownArtifacts(lines, { outputPaths: [], sessionFile, resultPath });
 	appendTranscriptBody(lines, "Result transcript tail", transcriptLines.filter((line) => line.trim()), output.split(/\r?\n/).length > lineLimit);
 	return safeTranscriptLines(lines);
-}
+}