@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/src/runs/background/subagent-wait.ts

@@ -58,8 +58,11 @@ import {
 	type Details,
 	type ForegroundResumeRun,
 	type SubagentState,
+	type WaitCompletion,
 } from "../../shared/types.ts";
 import { formatDuration, shortenPath } from "../../shared/formatters.ts";
+import { collectWaitCompletions } from "./wait-completions.ts";
+import { formatResumeFirstFailedRunsNote } from "./resume-guidance.ts";
 export { WAIT_TOOL_ENABLED_ENV, resolveWaitToolConfig, type ResolvedWaitToolConfig } from "./wait-config.ts";
 
 /** States that mean a run is still in flight (not yet resolved). */
@@ -303,11 +306,15 @@ function summarizeTerminalRuns(runs: AsyncRunSummary[], providerFinishedCount =
 	return parts.join(", ");
 }
 
-function result(text: string, isError = false): AgentToolResult<Details> {
+function result(text: string, isError = false, completions?: WaitCompletion[]): AgentToolResult<Details> {
 	return {
 		content: [{ type: "text", text }],
 		...(isError ? { isError: true } : {}),
-		details: { mode: "management", results: [] },
+		details: {
+			mode: "management",
+			results: [],
+			...(completions && completions.length > 0 ? { completions } : {}),
+		},
 	};
 }
 
@@ -597,6 +604,8 @@ export async function waitForSubagents(
 	let terminalSummary: string;
 	let finishedAsyncCount: number;
 	let failedAsyncCount: number;
+	let completions: WaitCompletion[] | undefined;
+	let resumeGuidance = "";
 	const activeProviderIds = new Set(providerActive.map(backgroundWorkIdentity));
 	const providerFinishedCount = [...initialProviderIds].filter((id) => !activeProviderIds.has(id)).length;
 	try {
@@ -605,6 +614,8 @@ export async function waitForSubagents(
 		finishedAsyncCount = terminal.length;
 		failedAsyncCount = terminal.filter((run) => run.state === "failed").length;
 		terminalSummary = summarizeTerminalRuns(terminal, providerFinishedCount);
+		resumeGuidance = formatResumeFirstFailedRunsNote(terminal);
+		completions = collectWaitCompletions(terminal, deps.state, deps.resultsDir ?? DIRS.results);
 	} catch (error) {
 		return result(error instanceof Error ? error.message : String(error), true);
 	}
@@ -629,8 +640,9 @@ export async function waitForSubagents(
 				: `${initialAsyncIds.size} async run(s) and ${initialProviderIds.size} provider item(s)`;
 		const status = relevantAttention.length > 0 ? "attention required" : "done";
 		return result(
-			`Waited ${elapsed} for ${scope}; ${status}.${outcome}${attentionNote} Completion/control events have been observed; inspect status if a notification is not visible yet.`,
+			`Waited ${elapsed} for ${scope}; ${status}.${outcome}${resumeGuidance}${attentionNote} Completion/control events have been observed; inspect status if a notification is not visible yet.`,
 			deps.failOnFailedRuns === true && failedAsyncCount > 0,
+			completions,
 		);
 	}
 
@@ -645,7 +657,8 @@ export async function waitForSubagents(
 		? `${relevantAttention.length} of ${initialCount} ${subject} need attention`
 		: `${finishedCount} of ${initialCount} ${subject} finished`;
 	return result(
-		`Waited ${elapsed}; ${progress}.${outcome}${attentionNote}${remainder} Relevant completion/control events have been observed; inspect status if a notification is not visible yet.`,
+		`Waited ${elapsed}; ${progress}.${outcome}${resumeGuidance}${attentionNote}${remainder} Relevant completion/control events have been observed; inspect status if a notification is not visible yet.`,
 		deps.failOnFailedRuns === true && failedAsyncCount > 0,
+		completions,
 	);
 }

package/dist/extensions/pi-subagents/src/runs/background/wait-completions.ts

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ArtifactPaths, SubagentState, WaitCompletion, WaitCompletionChild } from "../../shared/types.ts";
+import type { AsyncRunSummary } from "./async-status.ts";
+import { readCompletionReplay, writeCompletionReplay } from "./completion-replay.ts";
+
+function asNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value ? value : undefined;
+}
+
+function errorCode(error: unknown): string | undefined {
+	return typeof error === "object" && error !== null && "code" in error
+		? (error as NodeJS.ErrnoException).code
+		: undefined;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Project a terminal result payload into the slim shape that is safe to surface in
+ * tool_result details: run identity, per-child outcome, and the artifact trail.
+ * Output text is deliberately excluded — it already travels in the tool result
+ * content, and duplicating it in details would double the payload for every wait.
+ */
+export function toWaitCompletion(data: Record<string, unknown>, runId: string): WaitCompletion {
+	const results = Array.isArray(data.results)
+		? data.results.flatMap((entry): WaitCompletionChild[] => {
+			if (entry === null || typeof entry !== "object") return [];
+			const child = entry as Record<string, unknown>;
+			const outputState = child.outputState === "present" || child.outputState === "absent" || child.outputState === "unknown"
+				? child.outputState
+				: undefined;
+			const artifactPaths = child.artifactPaths !== null && typeof child.artifactPaths === "object"
+				? (child.artifactPaths as Partial<ArtifactPaths>)
+				: undefined;
+			const agent = asNonEmptyString(child.agent);
+			const childRunId = asNonEmptyString(child.runId);
+			const error = asNonEmptyString(child.error);
+			const model = asNonEmptyString(child.model);
+			return [{
+				...(agent ? { agent } : {}),
+				...(childRunId ? { runId: childRunId } : {}),
+				...(typeof child.success === "boolean" ? { success: child.success } : {}),
+				...(outputState ? { outputState } : {}),
+				...(error ? { error } : {}),
+				...(model ? { model } : {}),
+				...(artifactPaths ? { artifactPaths } : {}),
+			}];
+		})
+		: undefined;
+	const agent = asNonEmptyString(data.agent);
+	const mode = asNonEmptyString(data.mode);
+	const state = asNonEmptyString(data.state);
+	return {
+		runId,
+		...(agent ? { agent } : {}),
+		...(mode ? { mode } : {}),
+		...(state ? { state } : {}),
+		...(typeof data.success === "boolean" ? { success: data.success } : {}),
+		...(results && results.length > 0 ? { results } : {}),
+	};
+}
+
+/**
+ * Record a consumed terminal payload for later surfacing by subagent_wait, pruning
+ * stale entries with the same TTL that dedupes completion notifications. The result
+ * file is deleted after delivery, so this record is the only in-process source once
+ * the watcher has consumed it.
+ */
+export function recordWaitCompletion(
+	state: SubagentState,
+	runId: string,
+	data: Record<string, unknown>,
+	now: number,
+	ttlMs: number,
+	persistence?: { resultsDir: string; sessionId: string },
+): void {
+	const store = state.completedResults ??= new Map();
+	for (const [key, entry] of store) {
+		if (now - entry.seenAt > ttlMs) store.delete(key);
+	}
+	let completion = toWaitCompletion(data, runId);
+	if (persistence) {
+		try {
+			completion = writeCompletionReplay({
+				...persistence,
+				runId,
+				completion,
+				data,
+				now,
+				ttlMs,
+			}).completion;
+		} catch (error) {
+			console.error(`Failed to persist completion replay for '${runId}':`, error);
+		}
+	}
+	store.set(runId, { seenAt: now, completion });
+}
+
+/**
+ * Terminal payloads for the runs a wait covered: the watcher's in-memory record
+ * first, then the not-yet-consumed result file. Result files are written atomically,
+ * so a direct read never observes a torn write; the read is deliberately read-only —
+ * the watcher owns notification and cleanup.
+ */
+export function collectWaitCompletions(terminal: AsyncRunSummary[], state: SubagentState, resultsDir: string): WaitCompletion[] | undefined {
+	if (terminal.length === 0) return undefined;
+	const completions: WaitCompletion[] = [];
+	for (const run of terminal) {
+		const recorded = state.completedResults?.get(run.id);
+		if (recorded) {
+			completions.push(recorded.completion);
+			continue;
+		}
+		const resultPath = path.join(resultsDir, `${run.id}.json`);
+		try {
+			const raw = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as Record<string, unknown>;
+			completions.push(toWaitCompletion(raw, run.id));
+		} catch (error) {
+			if (errorCode(error) !== "ENOENT") {
+				throw new Error(`Failed to read subagent result '${resultPath}': ${errorMessage(error)}`, {
+					cause: error instanceof Error ? error : undefined,
+				});
+			}
+			// The watcher may have consumed the file between the store check and the
+			// read. Prefer its in-memory record, then the durable replay written before
+			// result cleanup so watcher reloads do not lose completion details.
+			const late = state.completedResults?.get(run.id);
+			if (late) {
+				completions.push(late.completion);
+				continue;
+			}
+			try {
+				const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+				if (replay) completions.push(replay.completion);
+			} catch (replayError) {
+				throw new Error(`Failed to read completion replay for '${run.id}': ${errorMessage(replayError)}`, {
+					cause: replayError instanceof Error ? replayError : undefined,
+				});
+			}
+		}
+	}
+	return completions.length > 0 ? completions : undefined;
+}

package/dist/extensions/pi-subagents/src/runs/background/wait-subscriptions.ts

@@ -2,7 +2,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@selesai/code";
-import { listAsyncRuns } from "./async-status.ts";
+import { listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
+import { formatResumeFirstFailedRunDetail } from "./resume-guidance.ts";
+import { readCompletionReplay } from "./completion-replay.ts";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import {
 	DIRS,
@@ -13,6 +15,7 @@ import {
 	SUBAGENT_FOREGROUND_COMPLETE_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
 	type SubagentState,
+	type WaitCompletion,
 	type WaitSubscriptionRecord,
 } from "../../shared/types.ts";
 
@@ -61,7 +64,7 @@ function parseRecord(value: unknown): WaitSubscriptionRecord | undefined {
 	return record as WaitSubscriptionRecord;
 }
 
-function needsAttention(run: ReturnType<typeof listAsyncRuns>[number]): boolean {
+function needsAttention(run: AsyncRunSummary): boolean {
 	return run.activityState === "needs_attention" || run.steps.some((step) => step.activityState === "needs_attention");
 }
 
@@ -103,7 +106,7 @@ export function createWaitSubscriptionManager(
 		unresolvedRestoredForegroundTokens.delete(record.token);
 	};
 
-	const settle = (record: WaitSubscriptionRecord, outcome: string, detail: string) => {
+	const settle = (record: WaitSubscriptionRecord, outcome: string, detail: string, completion?: WaitCompletion) => {
 		if (disposed || state.currentSessionId !== record.sessionId) return;
 		try {
 			remove(record);
@@ -116,7 +119,12 @@ export function createWaitSubscriptionManager(
 				customType: "subagent-wait-subscription",
 				content: `Wait subscription ${record.token} fired for run ${record.runId}: ${outcome}. ${detail}`,
 				display: true,
-				details: { token: record.token, runId: record.runId, outcome },
+				details: {
+					token: record.token,
+					runId: record.runId,
+					outcome,
+					...(completion ? { completions: [completion] } : {}),
+				},
 			}, { triggerTurn: true });
 		} catch (error) {
 			console.error(`Failed to deliver wait subscription '${record.token}' after clearing it:`, error);
@@ -166,7 +174,15 @@ export function createWaitSubscriptionManager(
 			return;
 		}
 		if (run.state !== "queued" && run.state !== "running") {
-			settle(record, run.state === "complete" ? "completed" : run.state, "Inspect the run status for its final output.");
+			let completion: WaitCompletion | undefined;
+			try {
+				completion = readCompletionReplay(resultsDir, record.runId, { sessionId: record.sessionId, now: now() })?.completion;
+			} catch (error) {
+				console.error(`Failed to read completion replay for wait subscription '${record.token}':`, error);
+			}
+			const detail = formatResumeFirstFailedRunDetail(run) ?? "Inspect the run status for its final output.";
+			const archiveDetail = completion?.archivePath ? ` Completion archive: ${completion.archivePath}.` : "";
+			settle(record, run.state === "complete" ? "completed" : run.state, `${detail}${archiveDetail}`, completion);
 		}
 	};
 

package/dist/extensions/pi-subagents/src/runs/foreground/async-dismiss-action.ts

@@ -0,0 +1,85 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { DIRS, type Details, type SubagentState } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { updateActiveRunIndex } from "../background/active-run-index.ts";
+import { reconcileAsyncRun } from "../background/stale-run-reconciler.ts";
+
+export function dismissRecoveredWorkflow(
+	state: SubagentState,
+	location: { asyncDir: string | null; resolvedId?: string },
+): AgentToolResult<Details> {
+	const asyncDir = location.asyncDir;
+	const runId = location.resolvedId ?? (asyncDir ? path.basename(asyncDir) : "requested");
+	if (!asyncDir) {
+		return {
+			content: [{ type: "text", text: `Recovered workflow '${runId}' has no disk status to dismiss.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	const status = readStatus(asyncDir);
+	if (!status || status.mode !== "workflow") {
+		return {
+			content: [{ type: "text", text: `Run '${runId}' is not a recovered workflow.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	if (!state.currentSessionId || status.sessionId !== state.currentSessionId) {
+		return {
+			content: [{ type: "text", text: `Recovered workflow '${runId}' was not found in the active session.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	if (state.workflowControllers?.has(status.runId) || state.workflowControllers?.has(runId)) {
+		return {
+			content: [{ type: "text", text: `Workflow '${runId}' still has a live controller and cannot be dismissed.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	if (status.state !== "running") {
+		return {
+			content: [{ type: "text", text: `Recovered workflow '${runId}' is ${status.state}, not running.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	let latestStatus = status;
+	const resultPath = path.join(DIRS.results, `${status.runId}.json`);
+	if (fs.existsSync(resultPath)) {
+		const reconciled = reconcileAsyncRun(asyncDir).status;
+		if (reconciled && reconciled.state !== "running") {
+			return {
+				content: [{ type: "text", text: `Recovered workflow '${runId}' is ${reconciled.state}, not running.` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+		if (reconciled) latestStatus = reconciled;
+	}
+
+	const dismissed = { ...latestStatus, displayDismissedAt: Date.now() };
+	writeAtomicJson(path.join(asyncDir, "status.json"), dismissed);
+	const repaired = reconcileAsyncRun(asyncDir).status;
+	if (repaired && repaired.state !== "running") {
+		return {
+			content: [{ type: "text", text: `Recovered workflow '${runId}' is ${repaired.state}, not running.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	updateActiveRunIndex(asyncDir, "complete");
+	state.asyncJobs.delete(status.runId);
+	state.asyncJobs.delete(runId);
+	state.fleetJobs?.delete(status.runId);
+	state.fleetJobs?.delete(runId);
+	return {
+		content: [{ type: "text", text: `Dismissed recovered workflow ${status.runId} from the display. No running work was terminated.` }],
+		details: { mode: "management", results: [] },
+	};
+}

package/dist/extensions/pi-subagents/src/runs/foreground/async-steering-action.ts

@@ -5,15 +5,16 @@ import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import type { AsyncStatus, Details, SubagentState, ToolBudgetConfig, TurnBudgetConfig } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { consumeSteerAcks, deliverInterruptRequest, requestAsyncSteer } from "../background/control-channel.ts";
+import { consumeSteerAcks, deliverInterruptRequest, queueRevivalBrief, requestAsyncSteer, type SteerDeliveryMode, type SteerRequest } from "../background/control-channel.ts";
 import { resolveAsyncResumeTarget } from "../background/async-resume.ts";
 import { reconcileAsyncRun } from "../background/stale-run-reconciler.ts";
-import { actionResultFromSteeringStatus, claimSteeringRecovery, remainingSteeringRecoveryLimits, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
+import { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
 
 export async function steerAsyncRun(input: {
 	state: SubagentState;
 	runId: string;
 	message: string;
+	mode?: SteerDeliveryMode;
 	index?: number;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	location: { asyncDir: string | null };
@@ -41,14 +42,38 @@ export async function steerAsyncRun(input: {
 			details: { mode: "management", results: [] },
 		};
 	}
-	if (!status || (status.state !== "running" && status.state !== "queued")) {
+	if (!status) {
 		return {
-			content: [{ type: "text", text: `Async run '${input.runId}' is not running or queued and cannot be steered.` }],
+			content: [{ type: "text", text: `Async run '${input.runId}' was not found.` }],
 			isError: true,
 			details: { mode: "management", results: [] },
 		};
 	}
 	const steps = status.steps ?? [];
+	if (status.state !== "running" && status.state !== "queued") {
+		const retained = input.mode === "follow_up" && status.state === "complete" && Boolean(status.parentWorkflowRunId) && steps.length === 1 && (steps[0]?.status === "complete" || steps[0]?.status === "completed") && Boolean(steps[0]?.sessionFile ?? status.sessionFile);
+		if (!retained) {
+			return {
+				content: [{ type: "text", text: `Async run '${input.runId}' is not running or queued and cannot be steered.` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+		if (input.index !== undefined && input.index !== 0) {
+			return { content: [{ type: "text", text: `Retained async run '${status.runId}' has one child. Index ${input.index} is out of range.` }], isError: true, details: { mode: "management", results: [] } };
+		}
+		const request: SteerRequest = { type: "steer", id: randomUUID(), ts: Date.now(), message: input.message.trim(), mode: "follow_up", targetIndex: 0, source: "steer-action" };
+		try {
+			queueRevivalBrief(asyncDir, request);
+		} catch (error) {
+			return { content: [{ type: "text", text: `Failed to queue retained follow-up for async run ${status.runId}: ${error instanceof Error ? error.message : String(error)}` }], isError: true, details: { mode: "management", results: [] } };
+		}
+		status.steering ??= createSteeringStatus();
+		recordSteeringRequest(status.steering, { id: request.id, requestedAt: request.ts, source: request.source, message: request.message, targets: [{ index: 0, state: "scheduled" }] });
+		writeAtomicJson(path.join(asyncDir, "status.json"), status);
+		const queued = { requestId: request.id, state: "scheduled" as const, deliveryStatus: "queued" as const, sourceRunId: status.runId, targets: [{ index: 0, state: "scheduled" as const }] };
+		return { content: [{ type: "text", text: `Follow-up queued for the next resume of retained async run ${status.runId} (request ${request.id}).` }], details: { mode: "management", results: [], steering: queued } };
+	}
 	if (input.index !== undefined) {
 		if (input.index < 0 || input.index >= steps.length) {
 			return {
@@ -92,6 +117,7 @@ export async function steerAsyncRun(input: {
 	try {
 		requestPath = requestAsyncSteer(asyncDir, {
 			message: input.message,
+			mode: input.mode,
 			...(effectiveTargetIndex !== undefined ? { targetIndex: effectiveTargetIndex } : { targetIndexes }),
 			source: "steer-action",
 			id: requestId,
@@ -108,11 +134,11 @@ export async function steerAsyncRun(input: {
 	if (tracked) tracked.updatedAt = Date.now();
 	const targets = targetIndexes.map((index) => ({ index, state: status.steps?.[index]?.status === "pending" ? "scheduled" as const : "pending" as const }));
 	if (targets.every((target) => target.state === "scheduled")) {
-		const scheduled = { requestId, state: "scheduled" as const, sourceRunId: status.runId, targets };
+		const scheduled = { requestId, state: "scheduled" as const, deliveryStatus: "queued" as const, sourceRunId: status.runId, targets };
 		return { content: [{ type: "text", text: `Steering scheduled for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: scheduled } };
 	}
 	const waited = await waitForSteeringAction({ asyncDir, sourceRunId: status.runId, requestId, timeoutMs: input.ackTimeoutMs ?? 3_000, signal: input.signal });
-	const result = waited ?? { requestId, state: "pending" as const, sourceRunId: status.runId, targets };
+	const result = waited ?? { requestId, state: "pending" as const, deliveryStatus: "queued" as const, sourceRunId: status.runId, targets };
 	if (input.signal?.aborted) {
 		return { content: [{ type: "text", text: `Steering pending for async run ${status.runId} (request ${requestId}); caller aborted before recovery.` }], details: { mode: "management", results: [], steering: result } };
 	}
@@ -122,7 +148,7 @@ export async function steerAsyncRun(input: {
 		return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: finalResult } };
 	}
 	const running = (finalStatus?.steps ?? status.steps ?? []).filter((step) => step.status === "running");
-	const recoveryAllowed = status.mode === "single" && status.isNested !== true && running.length === 1 && Boolean(finalStatus?.steering) && (input.index === undefined || input.index === 0);
+	const recoveryAllowed = (input.mode ?? "steer") === "steer" && status.mode === "single" && status.isNested !== true && running.length === 1 && Boolean(finalStatus?.steering) && (input.index === undefined || input.index === 0);
 	if (recoveryAllowed && finalResult?.state !== "scheduled" && input.recover) {
 		const appendSteeringNotice = (state: "failed" | "recovered", message: string): void => {
 			try {
@@ -147,7 +173,7 @@ export async function steerAsyncRun(input: {
 				return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: preCommitResult } };
 			}
 			try {
-				deliverInterruptRequest({ asyncDir, pid: latest?.pid ?? status.pid, kill: input.kill, source: "steering-recovery" });
+				deliverInterruptRequest({ asyncDir, source: "steering-recovery" });
 			} catch (error) {
 				fs.rmSync(markerPath, { force: true });
 				fs.rmSync(claimPath, { force: true });
@@ -193,17 +219,16 @@ export async function steerAsyncRun(input: {
 			const limits = remainingSteeringRecoveryLimits(recoveryTarget.recoveryDescriptor, paused);
 			const revived = await input.recover(limits);
 			if (revived.isError || !revived.details.asyncId) throw new Error(revived.content[0]?.type === "text" ? revived.content[0].text : "Replacement launch failed; source run remains paused.");
-			const sourceStatus = readStatus(asyncDir);
-			const targetIndex = input.index ?? status.steps?.findIndex((step) => step.status === "running") ?? -1;
-			if (sourceStatus?.state === "paused" && sourceStatus.steering && targetIndex >= 0) {
-				updateSteeringTarget(sourceStatus.steering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
-				const stepSteering = sourceStatus.steps?.[targetIndex]?.steering;
+			const targetIndex = input.index ?? paused.steering?.recent.find((request) => request.id === requestId)?.targets[0]?.index ?? status.steps?.findIndex((step) => step.status === "running") ?? -1;
+			if (paused.steering && targetIndex >= 0) {
+				updateSteeringTarget(paused.steering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
+				const stepSteering = paused.steps?.[targetIndex]?.steering;
 				if (stepSteering) updateSteeringTarget(stepSteering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
-				writeAtomicJson(path.join(asyncDir, "status.json"), sourceStatus);
+				writeAtomicJson(path.join(asyncDir, "status.json"), paused);
 			}
-			const recovered = sourceStatus?.steering ? actionResultFromSteeringStatus(sourceStatus.steering, status.runId, requestId, revived.details.asyncId) : undefined;
+			const recovered = paused.steering ? actionResultFromSteeringStatus(paused.steering, status.runId, requestId, revived.details.asyncId) : undefined;
 			appendSteeringNotice("recovered", `Steering recovered for run ${status.runId}; replacement ${revived.details.asyncId} launched.`);
-			return { content: [{ type: "text", text: `Steering recovered for async run ${status.runId}; replacement ${revived.details.asyncId} launched after the source paused.` }], details: { mode: "management", results: [], steering: recovered ?? { requestId, state: "recovered", sourceRunId: status.runId, replacementRunId: revived.details.asyncId, targets: [{ index: input.index ?? 0, state: "recovered" }] } } };
+			return { content: [{ type: "text", text: `Steering recovered for async run ${status.runId}; replacement ${revived.details.asyncId} launched after the source paused.` }], details: { mode: "management", results: [], steering: recovered ?? { requestId, state: "recovered", sourceRunId: status.runId, replacementRunId: revived.details.asyncId, deliveryStatus: "delivered", targets: [{ index: input.index ?? 0, state: "recovered" }] } } };
 		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
 			const failedStatus = readStatus(asyncDir);
@@ -217,10 +242,10 @@ export async function steerAsyncRun(input: {
 			}
 			const failed = failedStatus?.steering ? actionResultFromSteeringStatus(failedStatus.steering, status.runId, requestId) : undefined;
 			appendSteeringNotice("failed", `Steering failed for run ${status.runId}: ${reason}`);
-			return { content: [{ type: "text", text: `Steering failed for async run ${status.runId} (request ${requestId}): ${reason}` }], isError: true, details: { mode: "management", results: [], steering: failed ?? { requestId, state: "failed", sourceRunId: status.runId, targets: [{ index: input.index ?? 0, state: "failed", reason }] } } };
+			return { content: [{ type: "text", text: `Steering failed for async run ${status.runId} (request ${requestId}): ${reason}` }], isError: true, details: { mode: "management", results: [], steering: failed ?? { requestId, state: "failed", sourceRunId: status.runId, deliveryStatus: "queued", targets: [{ index: input.index ?? 0, state: "failed", reason }] } } };
 		}
 	}
-	const stateText = result.state === "delivered" ? "delivered" : result.state === "scheduled" ? "scheduled" : result.state === "recovered" ? "recovered" : result.state === "failed" ? "failed" : result.state === "partial" ? "partial" : "pending";
+	const stateText = result.state === "failed" ? "failed" : result.state === "partial" ? "partial" : result.deliveryStatus === "queued" ? "queued" : result.state === "delivered" ? "delivered" : result.state === "scheduled" ? "scheduled" : result.state === "recovered" ? "recovered" : "pending";
 	const isError = result.state === "failed" || result.state === "partial";
 	return {
 		content: [{ type: "text", text: `Steering ${stateText} for async run ${status.runId} (request ${requestId}).` }],

package/dist/extensions/pi-subagents/src/runs/foreground/chain-clarify.ts

@@ -532,7 +532,7 @@ export class ChainClarifyComponent implements Component {
 			buffer = template.split("\n")[0] ?? "";
 		} else if (mode === "output") {
 			const behavior = this.getEffectiveBehavior(this.selectedStep);
-			buffer = behavior.output === false ? "" : (behavior.output || "");
+			buffer = typeof behavior.output === "string" ? behavior.output : "";
 		} else if (mode === "reads") {
 			const behavior = this.getEffectiveBehavior(this.selectedStep);
 			buffer = behavior.reads === false ? "" : (behavior.reads?.join(", ") || "");
@@ -882,25 +882,22 @@ export class ChainClarifyComponent implements Component {
 		}
 	}
 
-	render(_width: number): string[] {
+	render(width: number): string[] {
+		let lines: string[] = [];
 		if (this.editingStep !== null) {
-			if (this.editMode === "model") {
-				return this.renderModelSelector();
-			}
-			if (this.editMode === "thinking") {
-				return this.renderThinkingSelector();
-			}
-			if (this.editMode === "skills") {
-				return this.renderSkillSelector();
+			if (this.editMode === "model") lines = this.renderModelSelector();
+			else if (this.editMode === "thinking") lines = this.renderThinkingSelector();
+			else if (this.editMode === "skills") lines = this.renderSkillSelector();
+			else lines = this.renderFullEditMode();
+		} else {
+			switch (this.mode) {
+				case 'single': lines = this.renderSingleMode(); break;
+				case 'parallel': lines = this.renderParallelMode(); break;
+				case 'chain': lines = this.renderChainMode(); break;
 			}
-			return this.renderFullEditMode();
-		}
-		// Mode-based navigation rendering
-		switch (this.mode) {
-			case 'single': return this.renderSingleMode();
-			case 'parallel': return this.renderParallelMode();
-			case 'chain': return this.renderChainMode();
 		}
+		const renderWidth = Math.max(0, Math.min(this.width, Math.floor(width)));
+		return lines.map((line) => truncateToWidth(line, renderWidth));
 	}
 
 	/** Render the model selector view */
@@ -1168,7 +1165,9 @@ export class ChainClarifyComponent implements Component {
 
 		const writesValue = behavior.output === false
 			? th.fg("dim", "(disabled)")
-			: (behavior.output || th.fg("dim", "(none)"));
+			: (typeof behavior.output === "string" && behavior.output
+				? behavior.output
+				: th.fg("dim", "(none)"));
 		const writesLabel = th.fg("dim", "writes: ");
 		lines.push(this.row(`     ${writesLabel}${truncateToWidth(writesValue, innerW - 14)}`));
 
@@ -1299,7 +1298,9 @@ export class ChainClarifyComponent implements Component {
 
 			const writesValue = behavior.output === false
 				? th.fg("dim", "(disabled)")
-				: (behavior.output || th.fg("dim", "(none)"));
+				: (typeof behavior.output === "string" && behavior.output
+					? behavior.output
+					: th.fg("dim", "(none)"));
 			const writesLabel = th.fg("dim", "writes: ");
 			lines.push(this.row(`     ${writesLabel}${truncateToWidth(writesValue, innerW - 14)}`));