@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/src/runs/background/stale-run-reconciler.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { RESULTS_DIR, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode } from "../../shared/types.ts";
+import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
 
@@ -109,20 +110,30 @@ interface ResultChildOutcome {
 	error?: string;
 	sessionFile?: string;
 	model?: string;
+	thinking?: string;
 	attemptedModels?: string[];
 	modelAttempts?: NonNullable<AsyncStatus["steps"]>[number]["modelAttempts"];
 }
 
 interface ResultRepairData {
-	state: "complete" | "failed" | "paused";
+	state: "complete" | "failed" | "paused" | "stopped";
 	results?: ResultChildOutcome[];
 }
 
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
-		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: ResultChildOutcome[] };
-		const state = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
-		return { state, ...(Array.isArray(data.results) ? { results: data.results } : {}) };
+		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: unknown };
+		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+		const results = Array.isArray(data.results)
+			? data.results.map((entry, index) => {
+				if (!entry || typeof entry !== "object" || Array.isArray(entry)) return {};
+				const child = entry as ResultChildOutcome;
+				if (child.model !== undefined && typeof child.model !== "string") throw new Error(`Invalid async result file '${resultPath}': results[${index}].model must be a string.`);
+				if (child.thinking !== undefined && typeof child.thinking !== "string") throw new Error(`Invalid async result file '${resultPath}': results[${index}].thinking must be a string.`);
+				return child;
+			})
+			: undefined;
+		return { state, ...(results ? { results } : {}) };
 	} catch (error) {
 		if (isNotFoundError(error)) return undefined;
 		throw new Error(`Failed to read async result file '${resultPath}': ${getErrorMessage(error)}`, {
@@ -131,7 +142,7 @@ function readResultRepairData(resultPath: string): ResultRepairData | undefined
 	}
 }
 
-function childState(overallState: ResultRepairData["state"], child: ResultChildOutcome | undefined): "complete" | "failed" | "paused" {
+function childState(overallState: ResultRepairData["state"], child: ResultChildOutcome | undefined): "complete" | "failed" | "paused" | "stopped" {
 	if (child?.success === true) return "complete";
 	if (child?.success === false) return "failed";
 	return overallState;
@@ -144,22 +155,30 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 		if (step.status !== "running" && step.status !== "pending") return step;
 		const child = repair.results?.[index];
 		const state = childState(repair.state, child);
+		const model = child?.model ?? step.model;
+		const thinking = resolveEffectiveThinking(model, child?.thinking ?? step.thinking);
 		return {
 			...step,
 			status: state === "complete" ? "complete" as const : state,
 			endedAt: step.endedAt ?? now,
 			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
 			exitCode: step.exitCode ?? (state === "complete" || state === "paused" ? 0 : 1),
-			error: state === "failed" ? step.error ?? child?.error : step.error,
+			error: state === "failed" || state === "stopped" ? step.error ?? child?.error : step.error,
+			stopped: state === "stopped" ? true : step.stopped,
 			sessionFile: step.sessionFile ?? child?.sessionFile,
-			model: step.model ?? child?.model,
-			attemptedModels: step.attemptedModels ?? child?.attemptedModels,
-			modelAttempts: step.modelAttempts ?? child?.modelAttempts,
+			model,
+			thinking,
+			attemptedModels: child?.attemptedModels ?? step.attemptedModels,
+			modelAttempts: child?.modelAttempts ?? step.modelAttempts,
 		};
 	});
 	return {
 		...status,
 		state: repair.state,
+		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
+			processTerminal: { version: 1 as const, state: "unknown" as const, runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" as const },
+		} : {}),
+		...(repair.state === "stopped" ? { stopped: true } : {}),
 		activityState: undefined,
 		lastUpdate: now,
 		endedAt: status.endedAt ?? now,
@@ -215,6 +234,9 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 	const repairedStatus: AsyncStatus = {
 		...status,
 		state: "failed",
+		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
+			processTerminal: { version: 1 as const, state: "unknown" as const, runId, runnerProcessInstanceId: "observer-unavailable", reason: "stale-repair" as const },
+		} : {}),
 		activityState: undefined,
 		lastUpdate: now,
 		endedAt: now,
@@ -267,7 +289,7 @@ function writeFailedRepair(asyncDir: string, status: AsyncStatus, resultPath: st
 }
 
 function terminal(state: AsyncStatus["state"]): boolean {
-	return state === "complete" || state === "failed" || state === "paused";
+	return state === "complete" || state === "failed" || state === "paused" || state === "stopped";
 }
 
 function* nestedRuns(children: NestedRunSummary[] | undefined): Generator<NestedRunSummary> {
@@ -330,6 +352,12 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };
+	const statusPath = path.join(asyncDir, "status.json");
+	for (const [index, step] of (effectiveStatus.steps ?? []).entries()) {
+		const stepRecord = step as Record<string, unknown>;
+		if (stepRecord.model !== undefined && typeof stepRecord.model !== "string") throw new Error(`Invalid async status file '${statusPath}': steps[${index}].model must be a string.`);
+		if (stepRecord.thinking !== undefined && typeof stepRecord.thinking !== "string") throw new Error(`Invalid async status file '${statusPath}': steps[${index}].thinking must be a string.`);
+	}
 
 	const runId = effectiveStatus.runId || path.basename(asyncDir);
 	const resultPath = path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`);

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

@@ -0,0 +1,237 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
+import type {
+	AsyncStatus,
+	ResolvedToolBudget,
+	ResolvedTurnBudget,
+	SteerActionResult,
+	SteeringRecoveryDescriptor,
+	SteeringRequestStatus,
+	SteeringStatus,
+	SteeringTargetState,
+	SteeringTargetStatus,
+} from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+
+export const MAX_STEERING_REQUESTS = 20;
+export const STEERING_MESSAGE_PREVIEW_LIMIT = 160;
+
+export function createSteeringStatus(): SteeringStatus {
+	return { requested: 0, scheduled: 0, pending: 0, delivered: 0, failed: 0, recovered: 0, recent: [] };
+}
+
+export function steeringStatus(status: Pick<AsyncStatus, "steering">): SteeringStatus {
+	return status.steering ?? createSteeringStatus();
+}
+
+export function recordSteeringRequest(
+	status: SteeringStatus,
+	input: { id: string; requestedAt: number; source?: string; message: string; targets: Array<{ index: number; state: SteeringTargetState; reason?: string }> },
+): SteeringRequestStatus {
+	const existing = status.recent.find((request) => request.id === input.id);
+	if (existing) return existing;
+	const request: SteeringRequestStatus = {
+		id: input.id,
+		requestedAt: input.requestedAt,
+		...(input.source ? { source: input.source } : {}),
+		messagePreview: input.message.slice(0, STEERING_MESSAGE_PREVIEW_LIMIT),
+		targets: input.targets.map((target) => ({ index: target.index, state: target.state, ...(target.reason ? { reason: target.reason } : {}) })),
+	};
+	status.requested++;
+	status.lastRequestedAt = input.requestedAt;
+	status.recent = [...status.recent, request].slice(-MAX_STEERING_REQUESTS);
+	for (const target of request.targets) incrementStateCount(status, target.state);
+	return request;
+}
+
+function incrementStateCount(status: SteeringStatus, state: SteeringTargetState): void {
+	if (state === "scheduled") status.scheduled++;
+	else if (state === "routed") status.pending++;
+	else if (state === "delivered" || state === "late") status.delivered++;
+	else if (state === "failed") status.failed++;
+	else if (state === "recovered") status.recovered++;
+}
+
+export function updateSteeringTarget(
+	status: SteeringStatus,
+	requestId: string,
+	index: number,
+	state: SteeringTargetState,
+	now: number,
+	fields: Pick<SteeringTargetStatus, "reason" | "replacementRunId"> = {},
+): SteeringTargetStatus | undefined {
+	const request = status.recent.find((candidate) => candidate.id === requestId);
+	const target = request?.targets.find((candidate) => candidate.index === index);
+	if (!target) return undefined;
+	if (state === "late" && target.state === "recovered") {
+		if (target.lateDeliveredAt === undefined) {
+			target.lateDeliveredAt = now;
+			status.delivered++;
+			status.lastDeliveredAt = now;
+		}
+		if (fields.reason) target.reason = fields.reason;
+		return target;
+	}
+	if (target.state === state) {
+		if (state === "routed" && target.routedAt === undefined) target.routedAt = now;
+		if (state === "delivered" && target.deliveredAt === undefined) target.deliveredAt = now;
+		if (state === "late" && target.lateDeliveredAt === undefined) target.lateDeliveredAt = now;
+		if (fields.reason) target.reason = fields.reason;
+		if (fields.replacementRunId) target.replacementRunId = fields.replacementRunId;
+		return target;
+	}
+	if (target.state === "routed" && state !== "routed") status.pending = Math.max(0, status.pending - 1);
+	target.state = state;
+	if (state === "routed") target.routedAt = now;
+	if (state === "delivered") {
+		target.deliveredAt = now;
+		status.lastDeliveredAt = now;
+	}
+	if (state === "late") {
+		target.lateDeliveredAt = now;
+		status.lastDeliveredAt = now;
+	}
+	if (state === "failed") target.failedAt = now;
+	if (state === "recovered") target.recoveredAt = now;
+	if (fields.reason) target.reason = fields.reason;
+	if (fields.replacementRunId) target.replacementRunId = fields.replacementRunId;
+	incrementStateCount(status, state);
+	return target;
+}
+
+export function findSteeringRequest(status: SteeringStatus, requestId: string): SteeringRequestStatus | undefined {
+	return status.recent.find((request) => request.id === requestId);
+}
+
+export function actionResultFromSteeringStatus(status: SteeringStatus, sourceRunId: string, requestId: string, replacementRunId?: string): SteerActionResult | undefined {
+	const request = findSteeringRequest(status, requestId);
+	if (!request) return undefined;
+	const targets = request.targets.map((target) => ({
+		index: target.index,
+		state: target.state,
+		...(target.deliveredAt !== undefined ? { deliveredAt: target.deliveredAt } : {}),
+		...(target.lateDeliveredAt !== undefined ? { lateDeliveredAt: target.lateDeliveredAt } : {}),
+		...(target.reason ? { reason: target.reason } : {}),
+		...(target.replacementRunId ? { replacementRunId: target.replacementRunId } : {}),
+	}));
+	const states = targets.map((target) => target.state);
+	let state: SteerActionResult["state"] = "pending";
+	if (states.length > 0 && states.every((candidate) => candidate === "delivered")) state = "delivered";
+	else if (states.length > 0 && states.every((candidate) => candidate === "scheduled")) state = "scheduled";
+	else if (states.length > 0 && states.every((candidate) => candidate === "recovered")) state = "recovered";
+	else if (states.length > 0 && states.every((candidate) => candidate === "failed" || candidate === "late")) state = "failed";
+	else if (states.some((candidate) => candidate === "failed" || candidate === "late") && states.some((candidate) => candidate !== "failed" && candidate !== "late")) state = "partial";
+	const effectiveReplacementRunId = replacementRunId ?? request.targets.find((target) => target.replacementRunId)?.replacementRunId;
+	return { requestId, state, sourceRunId, ...(effectiveReplacementRunId ? { replacementRunId: effectiveReplacementRunId } : {}), targets };
+}
+
+export function steeringActionIsTerminal(result: SteerActionResult | undefined): boolean {
+	return result?.state === "delivered" || result?.state === "scheduled" || result?.state === "partial" || result?.state === "recovered" || result?.state === "failed";
+}
+
+export function terminalSteeringNoticeState(status: SteeringStatus, requestId: string): "failed" | "partial" | undefined {
+	const request = status.recent.find((candidate) => candidate.id === requestId);
+	if (!request || request.targets.some((target) => target.state === "routed" || target.state === "scheduled")) return undefined;
+	const hasSuccess = request.targets.some((target) => target.state === "delivered" || target.state === "recovered");
+	const hasFailure = request.targets.some((target) => target.state === "failed" || target.state === "late");
+	if (hasSuccess && hasFailure) return "partial";
+	return hasFailure ? "failed" : undefined;
+}
+
+export function claimSteeringRecovery(
+	asyncDir: string,
+	input: { requestId: string; sourceRunId: string; committedAt: number },
+): { claimPath: string; markerPath: string } {
+	const recoveryDir = path.join(asyncDir, "control", "steer-recovery");
+	fs.mkdirSync(recoveryDir, { recursive: true, mode: 0o700 });
+	const claimPath = path.join(recoveryDir, "claim.json");
+	let fd: number;
+	try {
+		fd = fs.openSync(claimPath, "wx", 0o600);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+			throw new Error("Another steering recovery is already committed for this source run.");
+		}
+		throw error;
+	}
+	let writeError: unknown;
+	try {
+		fs.writeFileSync(fd, JSON.stringify({ version: 1, ...input }, null, 2), "utf-8");
+		fs.fsyncSync(fd);
+	} catch (error) {
+		writeError = error;
+	} finally {
+		fs.closeSync(fd);
+	}
+	if (writeError !== undefined) {
+		fs.rmSync(claimPath, { force: true });
+		throw writeError;
+	}
+	const markerPath = path.join(recoveryDir, `${Buffer.from(input.requestId).toString("base64url")}.json`);
+	try {
+		writePrivateAtomicJson(markerPath, { version: 1, ...input });
+	} catch (error) {
+		fs.rmSync(claimPath, { force: true });
+		throw error;
+	}
+	return { claimPath, markerPath };
+}
+
+export function readSteeringStatus(asyncDir: string): SteeringStatus | undefined {
+	return readStatus(asyncDir)?.steering;
+}
+
+export function remainingSteeringRecoveryLimits(
+	descriptor: Pick<SteeringRecoveryDescriptor, "absoluteDeadlineAt" | "initialTurnBudget" | "initialToolBudget">,
+	status: Pick<AsyncStatus, "turnBudget" | "turnCount" | "toolBudget" | "toolCount">,
+	now = Date.now(),
+): { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } {
+	const limits: { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } = {};
+	if (descriptor.absoluteDeadlineAt !== undefined) {
+		const timeoutMs = descriptor.absoluteDeadlineAt - now;
+		if (timeoutMs <= 0) throw new Error("Source run has no remaining deadline budget; it remains paused.");
+		limits.timeoutMs = timeoutMs;
+		limits.absoluteDeadlineAt = descriptor.absoluteDeadlineAt;
+	}
+	if (descriptor.initialTurnBudget) {
+		const consumed = status.turnBudget?.turnCount ?? status.turnCount ?? 0;
+		const totalRemaining = descriptor.initialTurnBudget.maxTurns + descriptor.initialTurnBudget.graceTurns - consumed;
+		if (totalRemaining <= 0) throw new Error("Source run has no remaining turn budget; it remains paused.");
+		const softRemaining = Math.max(0, descriptor.initialTurnBudget.maxTurns - consumed);
+		limits.turnBudget = softRemaining > 0
+			? { maxTurns: softRemaining, graceTurns: totalRemaining - softRemaining }
+			: { maxTurns: 1, graceTurns: totalRemaining - 1 };
+	}
+	if (descriptor.initialToolBudget) {
+		const consumed = status.toolBudget?.toolCount ?? status.toolCount ?? 0;
+		const hard = descriptor.initialToolBudget.hard - consumed;
+		if (hard <= 0) throw new Error("Source run has no remaining tool budget; it remains paused.");
+		const soft = descriptor.initialToolBudget.soft === undefined ? undefined : descriptor.initialToolBudget.soft - consumed;
+		limits.toolBudget = {
+			hard,
+			...(soft !== undefined && soft > 0 && soft < hard ? { soft } : {}),
+			block: descriptor.initialToolBudget.block,
+		};
+	}
+	return limits;
+}
+
+export async function waitForSteeringAction(input: {
+	asyncDir: string;
+	sourceRunId: string;
+	requestId: string;
+	timeoutMs: number;
+	signal?: AbortSignal;
+}): Promise<SteerActionResult | undefined> {
+	const deadline = Date.now() + input.timeoutMs;
+	while (Date.now() <= deadline) {
+		if (input.signal?.aborted) return undefined;
+		const status = readSteeringStatus(input.asyncDir);
+		const result = status ? actionResultFromSteeringStatus(status, input.sourceRunId, input.requestId) : undefined;
+		if (steeringActionIsTerminal(result)) return result;
+		await new Promise<void>((resolve) => setTimeout(resolve, Math.min(50, Math.max(1, deadline - Date.now()))));
+	}
+	const status = readSteeringStatus(input.asyncDir);
+	return status ? actionResultFromSteeringStatus(status, input.sourceRunId, input.requestId) : undefined;
+}