@selesai/code 0.13.15 → 0.13.18

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

@@ -337,6 +337,9 @@ function completionUsage(completions: WaitCompletion[] | undefined): Usage | und
 
 function result(text: string, isError = false, completions?: WaitCompletion[]): AgentToolResult<Details> {
 	const usage = completionUsage(completions);
+	for (const completion of completions ?? []) {
+		if (completion.workflowReceiptPath) text += `\nWorkflow receipt [${completion.runId}]: ${completion.workflowReceiptPath}`;
+	}
 	return {
 		content: [{ type: "text", text }],
 		...(isError ? { isError: true } : {}),

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

@@ -96,6 +96,9 @@ export function toWaitCompletion(data: Record<string, unknown>, runId: string):
 		})
 		: undefined;
 	const agent = asNonEmptyString(data.agent);
+	const receipt = data.workflowReceipt;
+	const workflowReceiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt)
+		? asNonEmptyString((receipt as Record<string, unknown>).path) : undefined;
 	const mode = asNonEmptyString(data.mode);
 	const state = asNonEmptyString(data.state);
 	const workflowChildren = parseWorkflowChildSummary(data.workflowChildren);
@@ -104,6 +107,7 @@ export function toWaitCompletion(data: Record<string, unknown>, runId: string):
 		runId,
 		...(agent ? { agent } : {}),
 		...(mode ? { mode } : {}),
+		...(workflowReceiptPath ? { workflowReceiptPath } : {}),
 		...(state ? { state } : {}),
 		...(typeof data.success === "boolean" ? { success: data.success } : {}),
 		...(results && results.length > 0 ? { results } : {}),

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

@@ -5,7 +5,7 @@ import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import type { AsyncStatus, Details, SubagentState, ToolBudgetConfig } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { consumeSteerAcks, deliverInterruptRequest, queueRevivalBrief, requestAsyncSteer, type SteerDeliveryMode, type SteerRequest } from "../background/control-channel.ts";
+import { 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, steeringReceipt, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
@@ -26,6 +26,7 @@ export async function steerAsyncRun(input: {
 	message: string;
 	mode?: SteerDeliveryMode;
 	index?: number;
+	findPendingAsks?: (target: { runId: string; agent: string; childIndex: number }) => string[];
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	location: { asyncDir: string | null };
 	signal?: AbortSignal;
@@ -44,6 +45,24 @@ export async function steerAsyncRun(input: {
 		};
 	}
 	const asyncDir = input.location.asyncDir;
+	const snapshot = input.findPendingAsks ? readStatus(asyncDir) : null;
+	if (snapshot?.mode === "single"
+		&& (!input.state.currentSessionId || snapshot.sessionId === input.state.currentSessionId)
+		&& (snapshot.state === "running" || snapshot.state === "queued")
+		&& snapshot.steps?.length === 1 && (input.index === undefined || input.index === 0)
+		&& (snapshot.steps[0]?.status === "running" || snapshot.steps[0]?.status === "pending")) {
+		const asks = input.findPendingAsks?.({ runId: snapshot.runId, agent: snapshot.steps[0].agent, childIndex: 0 }) ?? [];
+		if (asks.length > 0) {
+			const replies = asks.map(replyTo => `subagent_supervisor(${JSON.stringify({ action: "reply", replyTo, message: "<explicit answer>" })})`).join("\n");
+			return {
+				content: [{ type: "text", text: `Steering not delivered or queued: async run ${snapshot.runId} is blocked on ${asks.length === 1 ? "a pending supervisor ask" : "ambiguous pending supervisor asks"}. No reply or recovery was attempted. Reply explicitly${asks.length > 1 ? " to the intended request ID" : ""}:\n${replies}` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+	}
+	// The read-only snapshot precedes even stale-run reconciliation. An ask arriving
+	// later does not make a runner acknowledgement proof of consumption or unblocking.
 	const status = reconcileAsyncRun(asyncDir, { kill: input.kill }).status;
 	if (input.state.currentSessionId && status?.sessionId !== input.state.currentSessionId) {
 		return {
@@ -195,22 +214,6 @@ export async function steerAsyncRun(input: {
 				await new Promise<void>((resolve) => setTimeout(resolve, 50));
 			}
 			if (!paused) throw new Error("Source run did not reach confirmed paused state within 15 seconds; no replacement was launched and the recovery claim remains committed to prevent a delayed duplicate.");
-			let lateAckRecorded = false;
-			for (const ack of consumeSteerAcks(asyncDir)) {
-				if (!paused.steering?.recent.some((request) => request.id === ack.requestId && request.targets.some((target) => target.index === ack.index))) continue;
-				const state = ack.state === "delivered" ? "late" : "failed";
-				const reason = ack.state === "delivered" ? "acknowledged after recovery commit" : ack.message;
-				updateSteeringTarget(paused.steering, ack.requestId, ack.index, state, ack.ts, { reason });
-				const stepSteering = paused.steps?.[ack.index]?.steering;
-				if (stepSteering) updateSteeringTarget(stepSteering, ack.requestId, ack.index, state, ack.ts, { reason });
-				lateAckRecorded = true;
-				try {
-					fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: ack.state === "delivered" ? "subagent.steer.delivered" : "subagent.steer.failed", ts: ack.ts, runId: status.runId, requestId: ack.requestId, index: ack.index, late: true, message: ack.message })}\n`);
-				} catch {
-					// Status remains authoritative when diagnostic event persistence fails.
-				}
-			}
-			if (lateAckRecorded) writeAtomicJson(path.join(asyncDir, "status.json"), paused);
 			let recoveryTarget;
 			try {
 				recoveryTarget = resolveAsyncResumeTarget(