pi-subagents 0.49.0 → 0.51.0

package/src/runs/background/subagent-wait.ts

@@ -267,6 +267,7 @@ function activeRunsForSession(params: SubagentWaitParams, deps: SubagentWaitDeps
 		resultsDir,
 		kill: deps.kill,
 		now: deps.now,
+		includeNested: false,
 		...(params.id ? { runId: params.id } : {}),
 	});
 	return params.id ? runs.filter((run) => matchesId(run, params.id!)) : runs;
@@ -277,18 +278,19 @@ function attentionRunsForSession(params: SubagentWaitParams, deps: SubagentWaitD
 	return activeRunsForSession(params, deps).filter((run) => needsAttention(run) && initialIds.has(run.id));
 }
 
-/** All runs (any state) for this session, for the final summary. */
-function allRunsForSession(params: SubagentWaitParams, deps: SubagentWaitDeps): AsyncRunSummary[] {
+/** Exact initial runs in any state, for the final summary. */
+function runsForIds(runIds: Iterable<string>, deps: SubagentWaitDeps): AsyncRunSummary[] {
 	const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
 	const resultsDir = deps.resultsDir ?? DIRS.results;
-	const runs = listAsyncRuns(asyncDirRoot, {
+	return [...runIds].flatMap((runId) => listAsyncRuns(asyncDirRoot, {
 		sessionId: deps.state.currentSessionId ?? undefined,
 		resultsDir,
 		kill: deps.kill,
 		now: deps.now,
-		...(params.id ? { runId: params.id } : {}),
-	});
-	return params.id ? runs.filter((run) => matchesId(run, params.id!)) : runs;
+		includeNested: false,
+		runId,
+		exactRunId: true,
+	}));
 }
 
 function summarizeTerminalRuns(runs: AsyncRunSummary[], providerFinishedCount = 0): string {
@@ -609,7 +611,7 @@ export async function waitForSubagents(
 	const activeProviderIds = new Set(providerActive.map(backgroundWorkIdentity));
 	const providerFinishedCount = [...initialProviderIds].filter((id) => !activeProviderIds.has(id)).length;
 	try {
-		const allNow = allRunsForSession(waitParams, deps);
+		const allNow = runsForIds(initialAsyncIds, deps);
 		const terminal = allNow.filter((run) => !ACTIVE_STATES.includes(run.state) && initialAsyncIds.has(run.id));
 		finishedAsyncCount = terminal.length;
 		failedAsyncCount = terminal.filter((run) => run.state === "failed").length;

package/src/runs/background/terminal-run-index.ts

@@ -0,0 +1,129 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AsyncStatus } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { encodeIndexSegment } from "./index-segment.ts";
+
+export const TERMINAL_RUN_INDEX_DIR = ".terminal-runs";
+
+const TERMINAL_RUN_INDEX_VERSION = 1;
+const TIMESTAMP_WIDTH = 16;
+
+interface TerminalRunIndexEntry {
+	version: 1;
+	runId: string;
+	sessionId: string;
+	endedAt: number;
+}
+
+function isTerminalState(state: AsyncStatus["state"]): boolean {
+	return state === "complete" || state === "failed" || state === "paused" || state === "stopped" || state === "rejected";
+}
+
+function indexRoot(asyncDirRoot: string): string {
+	return path.join(asyncDirRoot, TERMINAL_RUN_INDEX_DIR);
+}
+
+function sessionIndexDir(asyncDirRoot: string, sessionId: string): string {
+	return path.join(indexRoot(asyncDirRoot), encodeIndexSegment(sessionId));
+}
+
+function markerName(endedAt: number, runId: string): string {
+	return `${Math.max(0, Math.floor(endedAt)).toString().padStart(TIMESTAMP_WIDTH, "0")}-${encodeIndexSegment(runId)}.json`;
+}
+
+function markerPath(asyncDir: string, sessionId: string, endedAt: number): string {
+	return path.join(sessionIndexDir(path.dirname(asyncDir), sessionId), markerName(endedAt, path.basename(asyncDir)));
+}
+
+function parseEntry(value: unknown): TerminalRunIndexEntry | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const entry = value as Partial<TerminalRunIndexEntry>;
+	if (entry.version !== TERMINAL_RUN_INDEX_VERSION
+		|| typeof entry.runId !== "string" || !entry.runId
+		|| typeof entry.sessionId !== "string" || !entry.sessionId
+		|| typeof entry.endedAt !== "number" || !Number.isFinite(entry.endedAt)) return undefined;
+	return { version: TERMINAL_RUN_INDEX_VERSION, runId: entry.runId, sessionId: entry.sessionId, endedAt: entry.endedAt };
+}
+
+export function updateTerminalRunIndex(asyncDir: string, status: AsyncStatus): void {
+	if (!isTerminalState(status.state) || typeof status.sessionId !== "string" || !status.sessionId) return;
+	const endedAt = status.endedAt ?? status.lastUpdate ?? status.startedAt;
+	const marker = markerPath(asyncDir, status.sessionId, endedAt);
+	const entry: TerminalRunIndexEntry = {
+		version: TERMINAL_RUN_INDEX_VERSION,
+		runId: status.runId || path.basename(asyncDir),
+		sessionId: status.sessionId,
+		endedAt,
+	};
+	writeAtomicJson(marker, entry);
+}
+
+function removeInvalidMarker(marker: string): void {
+	try {
+		fs.rmSync(marker, { force: true });
+	} catch {
+		// An advisory marker can remain for a later read when cleanup is contended.
+	}
+}
+
+function markerFiles(dir: string): string[] {
+	try {
+		return fs.readdirSync(dir, { withFileTypes: true })
+			.filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+			.map((entry) => path.join(dir, entry.name));
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		throw error;
+	}
+}
+
+function sessionDirs(asyncDirRoot: string, sessionId: string | undefined): string[] {
+	if (sessionId) return [sessionIndexDir(asyncDirRoot, sessionId)];
+	try {
+		return fs.readdirSync(indexRoot(asyncDirRoot), { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => path.join(indexRoot(asyncDirRoot), entry.name));
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		throw error;
+	}
+}
+
+export function readRecentTerminalRunIndex(asyncDirRoot: string, options: { sessionId?: string; limit?: number } = {}): string[] {
+	const limit = options.limit === undefined ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(options.limit));
+	const candidates = sessionDirs(asyncDirRoot, options.sessionId)
+		.flatMap(markerFiles)
+		.sort((left, right) => path.basename(right).localeCompare(path.basename(left)))
+		.slice(0, limit);
+	const runIds: string[] = [];
+	const seen = new Set<string>();
+	for (const marker of candidates) {
+		let entry: TerminalRunIndexEntry | undefined;
+		try {
+			entry = parseEntry(JSON.parse(fs.readFileSync(marker, "utf-8")));
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+		}
+		if (!entry || (options.sessionId !== undefined && entry.sessionId !== options.sessionId)) {
+			removeInvalidMarker(marker);
+			continue;
+		}
+		const asyncDir = path.join(asyncDirRoot, entry.runId);
+		const status = readStatus(asyncDir);
+		if (!status || !isTerminalState(status.state) || status.sessionId !== entry.sessionId || (status.runId && status.runId !== entry.runId)) {
+			removeInvalidMarker(marker);
+			continue;
+		}
+		if (seen.has(entry.runId)) {
+			removeInvalidMarker(marker);
+			continue;
+		}
+		seen.add(entry.runId);
+		runIds.push(entry.runId);
+	}
+	return runIds;
+}

package/src/runs/background/wait-completions.ts

@@ -1,8 +1,8 @@
 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";
+import { fallbackResultPayloadPathForSessionRun, resultFilePath, resultPayloadPathForSessionRun } from "./result-files.ts";
 
 function asNonEmptyString(value: unknown): string | undefined {
 	return typeof value === "string" && value ? value : undefined;
@@ -14,6 +14,11 @@ function errorCode(error: unknown): string | undefined {
 		: undefined;
 }
 
+function isAccessDenied(error: unknown): boolean {
+	const code = errorCode(error);
+	return code === "EPERM" || code === "EACCES";
+}
+
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -114,7 +119,22 @@ export function collectWaitCompletions(terminal: AsyncRunSummary[], state: Subag
 			completions.push(recorded.completion);
 			continue;
 		}
-		const resultPath = path.join(resultsDir, `${run.id}.json`);
+		const publicResultPath = resultFilePath(resultsDir, run.id);
+		let resultPath = publicResultPath;
+		try {
+			resultPath = run.sessionId
+				? resultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath
+				: publicResultPath;
+		} catch (error) {
+			if (!isAccessDenied(error) || !run.sessionId) throw error;
+			try {
+				resultPath = fallbackResultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath;
+			} catch (fallbackError) {
+				throw new Error(`Failed to read subagent result '${publicResultPath}': ${errorMessage(fallbackError)}`, {
+					cause: fallbackError instanceof Error ? fallbackError : undefined,
+				});
+			}
+		}
 		try {
 			const raw = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as Record<string, unknown>;
 			completions.push(toWaitCompletion(raw, run.id));

package/src/runs/background/wait-subscriptions.ts

@@ -21,6 +21,20 @@ import {
 
 const SUBSCRIPTION_VERSION = 1;
 const RECONCILE_INTERVAL_MS = 1_000;
+/**
+ * How often the subscriptions directory is re-scanned for expired records left
+ * by other sessions. Rare compared to RECONCILE_INTERVAL_MS because it costs a
+ * directory read, and nothing depends on the sweep being prompt.
+ */
+const FOREIGN_SWEEP_INTERVAL_MS = 60_000;
+/**
+ * How far past expiry a record armed by another session is kept before it is
+ * swept. The owning session settles its own expired records with a "timed out"
+ * notice on the next restore(), so removing one the moment it expires would take
+ * that notice away from a session that simply had not resumed yet. A day is long
+ * enough for an ordinary return and short enough to bound the directory.
+ */
+const FOREIGN_SWEEP_GRACE_MS = 24 * 60 * 60 * 1000;
 
 export interface ArmWaitSubscriptionInput {
 	targetKind: "async" | "foreground";
@@ -95,6 +109,63 @@ export function createWaitSubscriptionManager(
 	state.waitSubscriptions = subscriptions;
 	const unresolvedRestoredForegroundTokens = new Set<string>();
 	let disposed = false;
+	let lastForeignSweepAt = 0;
+
+	/**
+	 * Remove expired records armed by another session.
+	 *
+	 * Only the owning session can be woken, so restore() never loads a foreign
+	 * record into `subscriptions` and reconcileRecord() returns before its
+	 * timeout branch. Nothing reconciles such a record and nothing expires it, so
+	 * a session that arms a wait and never comes back (forked, renamed, deleted)
+	 * leaves one file here per wait, forever.
+	 *
+	 * Kept for FOREIGN_SWEEP_GRACE_MS past expiry so an owner that resumes late
+	 * still finds its record and gets the timeout notice.
+	 *
+	 * Runs on the reconcile timer as well as at restore(), because a record that
+	 * is still live when another session starts would otherwise never be looked
+	 * at again: restore() only fires on session_start, and reconcile() walks the
+	 * in-memory map, which holds current-session records only. A host that keeps
+	 * one session open for hours is exactly where that gap bites.
+	 *
+	 * Never throws: it runs from the reconcile timer.
+	 */
+	const sweepExpiredForeignSubscriptions = (force = false) => {
+		const sweptAt = now();
+		if (!force && sweptAt - lastForeignSweepAt < FOREIGN_SWEEP_INTERVAL_MS) return;
+		lastForeignSweepAt = sweptAt;
+		let files: string[];
+		try {
+			files = fs.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
+		} catch (error) {
+			if (!isNotFound(error)) console.error(`Failed to scan wait subscriptions in '${subscriptionsDir}':`, error);
+			return;
+		}
+		for (const file of files) {
+			const filePath = path.join(subscriptionsDir, file);
+			let record: WaitSubscriptionRecord | undefined;
+			try {
+				record = parseRecord(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+			} catch (error) {
+				console.error(`Ignoring invalid wait subscription '${filePath}':`, error);
+				continue;
+			}
+			if (!record || file !== `${record.token}.json`) continue;
+			// The owning session keeps its own expired records so reconcileRecord()
+			// can still settle them with the "timed out" notice callers expect.
+			if (record.sessionId === state.currentSessionId) continue;
+			if (sweptAt < record.expiresAt + FOREIGN_SWEEP_GRACE_MS) continue;
+			try {
+				fs.unlinkSync(filePath);
+			} catch (error) {
+				// Losing this race is harmless: another session may have swept the
+				// same expired record. Anything else is reported and retried on the
+				// next sweep rather than interrupting the caller.
+				if (!isNotFound(error)) console.error(`Failed to remove expired wait subscription '${filePath}':`, error);
+			}
+		}
+	};
 
 	const remove = (record: WaitSubscriptionRecord) => {
 		try {
@@ -160,6 +231,7 @@ export function createWaitSubscriptionManager(
 		const runs = listAsyncRuns(asyncDirRoot, {
 			sessionId: record.sessionId,
 			runId: record.runId,
+			exactRunId: true,
 			resultsDir,
 			kill: options.kill,
 			now,
@@ -187,7 +259,11 @@ export function createWaitSubscriptionManager(
 	};
 
 	const reconcile = () => {
-		if (disposed || !state.currentSessionId) return;
+		if (disposed) return;
+		// Before the session check: with no current session every record is
+		// foreign, and expired ones should still be cleaned up.
+		sweepExpiredForeignSubscriptions();
+		if (!state.currentSessionId) return;
 		for (const record of [...subscriptions.values()]) {
 			try {
 				reconcileRecord(record);
@@ -233,6 +309,9 @@ export function createWaitSubscriptionManager(
 		restore() {
 			subscriptions.clear();
 			unresolvedRestoredForegroundTokens.clear();
+			// Unconditional: a process that starts without a session identity should
+			// still clear records nobody can act on.
+			sweepExpiredForeignSubscriptions(true);
 			if (!state.currentSessionId) return;
 			let files: string[];
 			try {

package/src/runs/foreground/async-dismiss-action.ts

@@ -6,6 +6,7 @@ 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";
+import { resultFilePath } from "../background/result-files.ts";
 
 export function dismissRecoveredWorkflow(
 	state: SubagentState,
@@ -50,7 +51,7 @@ export function dismissRecoveredWorkflow(
 		};
 	}
 	let latestStatus = status;
-	const resultPath = path.join(DIRS.results, `${status.runId}.json`);
+	const resultPath = resultFilePath(DIRS.results, status.runId);
 	if (fs.existsSync(resultPath)) {
 		const reconciled = reconcileAsyncRun(asyncDir).status;
 		if (reconciled && reconciled.state !== "running") {

package/src/runs/foreground/async-steering-action.ts

@@ -8,7 +8,17 @@ import { readStatus } from "../../shared/utils.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, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
+import { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, steeringReceipt, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
+
+export function canQueueRetainedAsyncFollowUp(status: AsyncStatus, index?: number): boolean {
+	const steps = status.steps ?? [];
+	return status.state === "complete"
+		&& Boolean(status.parentWorkflowRunId)
+		&& steps.length === 1
+		&& (steps[0]?.status === "complete" || steps[0]?.status === "completed")
+		&& Boolean(steps[0]?.sessionFile ?? status.sessionFile)
+		&& (index === undefined || index === 0);
+}
 
 export async function steerAsyncRun(input: {
 	state: SubagentState;
@@ -51,7 +61,7 @@ export async function steerAsyncRun(input: {
 	}
 	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);
+		const retained = input.mode === "follow_up" && canQueueRetainedAsyncFollowUp(status, input.index);
 		if (!retained) {
 			return {
 				content: [{ type: "text", text: `Async run '${input.runId}' is not running or queued and cannot be steered.` }],
@@ -59,9 +69,6 @@ export async function steerAsyncRun(input: {
 				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);
@@ -72,7 +79,7 @@ export async function steerAsyncRun(input: {
 		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 } };
+		return { content: [{ type: "text", text: steeringReceipt(request.message, `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) {
@@ -135,17 +142,17 @@ export async function steerAsyncRun(input: {
 	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, 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 } };
+		return { content: [{ type: "text", text: steeringReceipt(input.message, `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, 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 } };
+		return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering pending for async run ${status.runId} (request ${requestId}); caller aborted before recovery.`) }], details: { mode: "management", results: [], steering: result } };
 	}
 	const finalStatus = readStatus(asyncDir);
 	const finalResult = finalStatus?.steering ? actionResultFromSteeringStatus(finalStatus.steering, status.runId, requestId) : undefined;
 	if (finalResult?.state === "delivered") {
-		return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: finalResult } };
+		return { content: [{ type: "text", text: steeringReceipt(input.message, `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 = (input.mode ?? "steer") === "steer" && status.mode === "single" && status.isNested !== true && running.length === 1 && Boolean(finalStatus?.steering) && (input.index === undefined || input.index === 0);
@@ -160,7 +167,7 @@ export async function steerAsyncRun(input: {
 		try {
 			const latest = readStatus(asyncDir);
 			const latestResult = latest?.steering ? actionResultFromSteeringStatus(latest.steering, status.runId, requestId) : undefined;
-			if (latestResult?.state === "delivered") return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: latestResult } };
+			if (latestResult?.state === "delivered") return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering delivered for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: latestResult } };
 			const committedAt = Date.now();
 			input.onBeforeRecoveryClaim?.(requestId, committedAt);
 			const { claimPath, markerPath } = claimSteeringRecovery(asyncDir, { requestId, sourceRunId: status.runId, committedAt });
@@ -170,7 +177,7 @@ export async function steerAsyncRun(input: {
 			if (preCommitResult?.state === "delivered" && preCommitResult.targets.every((target) => target.deliveredAt !== undefined && target.deliveredAt <= committedAt)) {
 				fs.rmSync(markerPath, { force: true });
 				fs.rmSync(claimPath, { force: true });
-				return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: preCommitResult } };
+				return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering delivered for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: preCommitResult } };
 			}
 			try {
 				deliverInterruptRequest({ asyncDir, source: "steering-recovery" });
@@ -228,7 +235,7 @@ export async function steerAsyncRun(input: {
 			}
 			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, deliveryStatus: "delivered", targets: [{ index: input.index ?? 0, state: "recovered" }] } } };
+			return { content: [{ type: "text", text: steeringReceipt(input.message, `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);
@@ -242,13 +249,13 @@ 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, deliveryStatus: "queued", targets: [{ index: input.index ?? 0, state: "failed", reason }] } } };
+			return { content: [{ type: "text", text: steeringReceipt(input.message, `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 === "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}).` }],
+		content: [{ type: "text", text: steeringReceipt(input.message, `Steering ${stateText} for async run ${status.runId} (request ${requestId}).`) }],
 		...(isError ? { isError: true } : {}),
 		details: { mode: "management", results: [], steering: result },
 	};