pi-subagents 0.66.0 → 0.68.0

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

@@ -3,13 +3,18 @@ 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 type { AsyncStatus, Details, SubagentState, ToolBudgetConfig } from "../../shared/types.ts";
+import type { AsyncStatus, Details, SteerActionResult, SubagentState, ToolBudgetConfig } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.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";
 
+function steerTargetsAccepted(result: Pick<SteerActionResult, "targets"> | undefined): boolean {
+	const targets = result?.targets ?? [];
+	return targets.length > 0 && targets.every((target) => target.state === "queued" || target.state === "delivered");
+}
+
 export function canQueueRetainedAsyncFollowUp(status: AsyncStatus, index?: number): boolean {
 	const steps = status.steps ?? [];
 	return status.state === "complete"
@@ -170,9 +175,11 @@ export async function steerAsyncRun(input: {
 	}
 	const finalStatus = readStatus(asyncDir);
 	const finalResult = finalStatus?.steering ? actionResultFromSteeringStatus(finalStatus.steering, status.runId, requestId) : undefined;
-	if (finalResult?.state === "delivered") {
-		return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering delivered for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: finalResult } };
-	}
+	const acceptedReply = (accepted: SteerActionResult): AgentToolResult<Details> => {
+		const acceptedState = accepted.state === "delivered" ? "delivered" : "queued";
+		return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering ${acceptedState} for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: accepted } };
+	};
+	if (finalResult && steerTargetsAccepted(finalResult)) return acceptedReply(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);
 	if (recoveryAllowed && finalResult?.state !== "scheduled" && input.recover) {
@@ -186,17 +193,21 @@ 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: steeringReceipt(input.message, `Steering delivered for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: latestResult } };
+			if (latestResult && steerTargetsAccepted(latestResult)) return acceptedReply(latestResult);
 			const committedAt = Date.now();
 			input.onBeforeRecoveryClaim?.(requestId, committedAt);
 			const { claimPath, markerPath } = claimSteeringRecovery(asyncDir, { requestId, sourceRunId: status.runId, committedAt });
 			input.onRecoveryCommitted?.(requestId, committedAt);
 			const preCommitStatus = readStatus(asyncDir);
 			const preCommitResult = preCommitStatus?.steering ? actionResultFromSteeringStatus(preCommitStatus.steering, status.runId, requestId) : undefined;
-			if (preCommitResult?.state === "delivered" && preCommitResult.targets.every((target) => target.deliveredAt !== undefined && target.deliveredAt <= committedAt)) {
+			if (
+				preCommitResult
+				&& preCommitResult.targets.length > 0
+				&& preCommitResult.targets.every((target) => target.state === "queued" || (target.deliveredAt !== undefined && target.deliveredAt <= committedAt))
+			) {
 				fs.rmSync(markerPath, { force: true });
 				fs.rmSync(claimPath, { force: true });
-				return { content: [{ type: "text", text: steeringReceipt(input.message, `Steering delivered for async run ${status.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering: preCommitResult } };
+				return acceptedReply(preCommitResult);
 			}
 			try {
 				deliverInterruptRequest({ asyncDir, source: "steering-recovery" });

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

@@ -1,7 +1,12 @@
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { Details, SubagentState } from "../../shared/types.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { DIRS, type AsyncStatus, type Details, type SubagentState } from "../../shared/types.ts";
+import { updateActiveRunIndex } from "../background/active-run-index.ts";
 import { deliverStopRequest } from "../background/control-channel.ts";
+import { readProcessTerminal } from "../background/process-terminal.ts";
+import { resultFilePath, resultPayloadPathForSessionRun, writeAsyncResultFile } from "../background/result-files.ts";
 import { reconcileAsyncRun } from "../background/stale-run-reconciler.ts";
 import { isStoppableAsyncStatusStep, resolveAsyncStatusChild, type ResolvedAsyncStatusChild } from "../shared/child-identity.ts";
 
@@ -21,6 +26,80 @@ function getAsyncStopTarget(
 	return direct ? { asyncId: direct.asyncId, asyncDir: direct.asyncDir } : undefined;
 }
 
+const STOP_MESSAGE = "Subagent stopped by user.";
+
+function sealPausedRun(asyncDir: string, status: AsyncStatus): string | undefined {
+	const runnerProcessInstanceId = status.processTerminal?.runnerProcessInstanceId;
+	if (!runnerProcessInstanceId) return "runner process identity is missing";
+	const proof = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId });
+	if (proof?.state !== "observed" || proof.runId !== status.runId || proof.runnerProcessInstanceId !== runnerProcessInstanceId) {
+		return `process-terminal proof is ${proof?.state === "unknown" ? `unknown (${proof.reason})` : proof?.state ?? "missing"}`;
+	}
+	if (!status.sessionId) return "session identity is missing";
+	const existingResultPath = resultPayloadPathForSessionRun(DIRS.results, status.sessionId, status.runId);
+	if (!existingResultPath) return "paused result is missing";
+	let existingResult: Record<string, unknown>;
+	try {
+		const parsed: unknown = JSON.parse(fs.readFileSync(existingResultPath, "utf-8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("result is not an object");
+		existingResult = parsed as Record<string, unknown>;
+	} catch (error) {
+		return `paused result is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	const resultRunId = typeof existingResult.runId === "string" ? existingResult.runId : existingResult.id;
+	if (resultRunId !== status.runId || existingResult.sessionId !== status.sessionId) {
+		return "paused result identity does not match the run";
+	}
+
+	const now = Date.now();
+	const steps = (status.steps ?? []).map((step) => {
+		if (step.status !== "pending" && step.status !== "running" && step.status !== "paused") return step;
+		const { activityState: _activityState, ...rest } = step;
+		return {
+			...rest,
+			status: "stopped" as const,
+			error: STOP_MESSAGE,
+			exitCode: 1,
+			stopped: true,
+			endedAt: now,
+			durationMs: step.startedAt ? now - step.startedAt : 0,
+			lastActivityAt: now,
+		};
+	});
+	const results = Array.isArray(existingResult.results)
+		? existingResult.results.map((entry, index) => {
+			const stepState = status.steps?.[index]?.status;
+			if ((stepState !== "pending" && stepState !== "running" && stepState !== "paused") || !entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+			const { interrupted: _interrupted, ...result } = entry as Record<string, unknown>;
+			return { ...result, output: STOP_MESSAGE, error: STOP_MESSAGE, success: false, exitCode: 1, stopped: true };
+		})
+		: existingResult.results;
+	const stoppedResult = {
+		...existingResult,
+		success: false,
+		state: "stopped",
+		summary: STOP_MESSAGE,
+		error: STOP_MESSAGE,
+		stopped: true,
+		exitCode: 1,
+		timestamp: now,
+		...(Array.isArray(existingResult.results) ? { results } : {}),
+	};
+	const stoppedStatus: AsyncStatus = {
+		...status,
+		state: "stopped",
+		stopped: true,
+		error: STOP_MESSAGE,
+		endedAt: now,
+		lastUpdate: now,
+		steps,
+	};
+	delete stoppedStatus.activityState;
+	writeAsyncResultFile(resultFilePath(DIRS.results, status.runId), stoppedResult);
+	writeAtomicJson(path.join(asyncDir, "status.json"), stoppedStatus);
+	updateActiveRunIndex(asyncDir, "stopped", status.toolCallId, { retryCapacityErrors: true, terminalIndexBeforeRelease: true });
+}
+
 export function stopAsyncRun(
 	state: SubagentState,
 	runId: string | undefined,
@@ -38,7 +117,8 @@ export function stopAsyncRun(
 			details: { mode: "management", results: [] },
 		};
 	}
-	if (!status || (status.state !== "running" && status.state !== "queued")) {
+	const pausedWholeRun = status?.state === "paused" && childId === undefined;
+	if (!status || (status.state !== "running" && status.state !== "queued" && !pausedWholeRun)) {
 		return {
 			content: [{ type: "text", text: `No running or queued async run was found for '${runId ?? "current"}'.` }],
 			isError: true,
@@ -66,13 +146,23 @@ export function stopAsyncRun(
 	}
 	try {
 		deliverStopRequest({ asyncDir: target.asyncDir, pid: typeof status.pid === "number" ? status.pid : undefined, kill, source: "stop-action", targetIndex: child?.index, childId: child?.id ?? childId });
+		if (pausedWholeRun) {
+			const failure = sealPausedRun(target.asyncDir, status);
+			if (failure) {
+				return {
+					content: [{ type: "text", text: `Stop request persisted for paused async run ${target.asyncId}, but terminal proof is not ready (${failure}). Retry stop after runner shutdown is observed.` }],
+					isError: true,
+					details: { mode: "management", results: [] },
+				};
+			}
+		}
 		const tracked = state.asyncJobs.get(target.asyncId);
 		if (tracked) {
 			tracked.activityState = undefined;
 			tracked.updatedAt = Date.now();
 		}
 		return {
-			content: [{ type: "text", text: child ? `Stop requested for child ${child.id} in async run ${target.asyncId}.` : `Stop requested for async run ${target.asyncId}.` }],
+			content: [{ type: "text", text: pausedWholeRun ? `Stopped paused async run ${target.asyncId}.` : child ? `Stop requested for child ${child.id} in async run ${target.asyncId}.` : `Stop requested for async run ${target.asyncId}.` }],
 			details: { mode: "management", results: [] },
 		};
 	} catch (error) {