@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/src/runs/foreground/workflow-detach-reconcile.ts

@@ -94,7 +94,7 @@ function workflowResultChildren(status: AsyncStatus, childRunId: string, result:
 	}));
 }
 
-function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, resolution: WorkflowTerminalResolution | undefined): WorkflowReceipt | undefined {
+function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, resolution: WorkflowTerminalResolution | undefined): { receipt: WorkflowReceipt; path: string } | undefined {
 	const receiptRoot = path.dirname(asyncDir);
 	const receiptPath = workflowReceiptPath(receiptRoot, status.runId);
 	if (!fs.existsSync(receiptPath)) return undefined;
@@ -155,8 +155,7 @@ function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, resul
 		delete next.workflowResolution;
 		delete next.recovery;
 	}
-	writeWorkflowReceipt(asyncDir, next);
-	return next;
+	return { receipt: next, path: writeWorkflowReceipt(asyncDir, next) };
 }
 
 function appendDetachedWorkflowEvent(asyncDir: string, event: Record<string, unknown>): void {
@@ -209,10 +208,13 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
 	}
 	let receipt: WorkflowReceipt | undefined;
+	let receiptPath: string | undefined;
 	let receiptError: string | undefined;
 	const resolution = classifyWorkflowSettlement(next, input.result.interrupted);
 	try {
-		receipt = reconcileWorkflowReceipt(next, input.childRunId, input.result, asyncDir, resolution);
+		const publication = reconcileWorkflowReceipt(next, input.childRunId, input.result, asyncDir, resolution);
+		receipt = publication?.receipt;
+		receiptPath = publication?.path;
 	} catch (error) {
 		receiptError = `Failed to reconcile async workflow receipt: ${error instanceof Error ? error.message : String(error)}`;
 	}
@@ -243,7 +245,7 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 			completionOwnerId: next.completionOwnerId,
 		},
 		receipt,
-		receiptPath: path.join(asyncDir, "workflow-receipt.json"),
+		receiptPath,
 		receiptPersistenceError: receiptError,
 		resolution,
 		terminalOutcome: receipt?.terminalOutcome,
@@ -283,6 +285,7 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 			agent: "workflow",
 			success: plan.status.state === "complete",
 			state: plan.status.state,
+			...(plan.publicResult.workflowReceipt ? { workflowReceipt: plan.publicResult.workflowReceipt } : {}),
 			...(resolution ? { workflowResolution: resolution } : {}),
 			...(plan.receipt?.terminalOutcome ? { terminalOutcome: plan.receipt.terminalOutcome } : {}),
 			recovery: plan.recovery,

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

@@ -1,20 +1,11 @@
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Details, ForegroundRunControl, SubagentState } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { steeringReceipt } from "../background/steering.ts";
-import {
-	consumeSteerAckFromDir,
-	readSteerCapability,
-	steerAcksDir,
-	steerCapabilityPath,
-	stepSteerInboxDir,
-	writeSteerRequestToExistingDir,
-	type SteerDeliveryMode,
-	type SteerRequest,
-} from "../background/control-channel.ts";
+import { steeringReceipt, waitForSteeringAction } from "../background/steering.ts";
+import { requestAsyncSteer, type SteerDeliveryMode } from "../background/control-channel.ts";
+import { currentCompletionOwnerId } from "../../shared/completion-owner.ts";
 
 export interface WorkflowForegroundSteeringTarget {
 	control: ForegroundRunControl;
@@ -40,7 +31,6 @@ function activeWorkflowError(state: SubagentState, workflowRunId: string, asyncD
 function controlIsLiveInWorkflow(control: ForegroundRunControl, workflowRunId: string, sessionId: string): boolean {
 	return control.parentWorkflowRunId === workflowRunId
 		&& control.sessionId === sessionId
-		&& Boolean(control.workflowSteeringDir)
 		&& (control.activeChildren?.size ?? 0) > 0;
 }
 
@@ -77,17 +67,70 @@ function managementError(message: string): AgentToolResult<Details> {
 	return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
 }
 
-export async function steerWorkflowForegroundTarget(input: {
-	target: WorkflowForegroundSteeringTarget;
+/** Local controllers remain authoritative; recorded foreign ownership permits enqueue, not takeover or proof of liveness. */
+export async function steerWorkflowRun(input: {
+	state: SubagentState;
+	runId: string;
+	asyncDir: string;
 	message: string;
 	mode?: SteerDeliveryMode;
 	index?: number;
 	signal?: AbortSignal;
 	ackTimeoutMs?: number;
+}): Promise<AgentToolResult<Details>> {
+	const { state, runId, asyncDir } = input;
+	const status = readStatus(asyncDir);
+	if (!status || status.mode !== "workflow" || status.runId !== runId || path.basename(asyncDir) !== runId) {
+		return managementError(`Workflow '${runId}' does not match its resolved run directory.`);
+	}
+	if (state.workflowControllers?.has(runId)) {
+		const route = resolveWorkflowForegroundSteeringTarget({ state, workflowRunId: runId, asyncDirRoot: path.dirname(asyncDir) });
+		if (!route.ok) return managementError(route.message);
+		return steerWorkflowForegroundTarget({ target: route.target, message: input.message, mode: input.mode, index: input.index });
+	}
+	if (!state.currentSessionId) return managementError("Workflow steering requires an active parent session.");
+	if (status.sessionId !== state.currentSessionId) return managementError(`Workflow '${runId}' was not found in the active session.`);
+	if (status.state !== "running" && status.state !== "queued") return managementError(`Workflow '${runId}' is not running or queued and cannot be steered.`);
+	if (typeof status.completionOwnerId !== "string" || !status.completionOwnerId.trim()
+		|| status.completionOwnerId === (state.completionOwnerId ?? currentCompletionOwnerId())
+		|| [...state.foregroundControls.values()].some((control) => control.parentWorkflowRunId === runId)) {
+		return managementError(`Workflow '${runId}' has no live foreground child and is not a recorded foreign workflow.`);
+	}
+	if (input.index !== undefined) {
+		const step = status.steps?.[input.index];
+		if (!Number.isInteger(input.index) || input.index < 0 || !step) return managementError(`Workflow '${runId}' index ${input.index} is out of range or invalid.`);
+		if (step.status !== "running" && step.status !== "pending") return managementError(`Workflow '${runId}' child ${input.index} is ${step.status} and cannot be steered.`);
+		if (typeof step.workflowKey !== "string" || !step.workflowKey.trim()) return managementError(`Workflow '${runId}' child ${input.index} has no projected workflow key.`);
+	}
+	const requestId = randomUUID();
+	try {
+		requestAsyncSteer(asyncDir, { id: requestId, message: input.message, mode: input.mode, ...(input.index !== undefined ? { targetIndex: input.index } : {}), source: "steer-action" });
+	} catch (error) {
+		return managementError(`Failed to queue steering for workflow ${runId}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	// Only the owner writes the ledger. No acknowledgment leaves an honest, unaddressed queued receipt.
+	const steering = await waitForSteeringAction({ asyncDir, sourceRunId: runId, requestId, timeoutMs: input.ackTimeoutMs ?? 3_000, signal: input.signal })
+		?? { requestId, state: "pending" as const, deliveryStatus: "queued" as const, sourceRunId: runId, targets: input.index === undefined ? [] : [{ index: input.index, state: "pending" as const }] };
+	const failed = steering.state === "failed" || steering.state === "partial";
+	return {
+		content: [{ type: "text", text: steeringReceipt(input.message, `Steering ${failed ? steering.state : steering.deliveryStatus === "delivered" ? "delivered" : "queued"} for workflow ${runId} (request ${requestId}).`) }],
+		...(failed ? { isError: true } : {}),
+		details: { mode: "management", results: [], steering },
+	};
+}
+
+/**
+ * Steer a live workflow-owned foreground child through its in-process session.
+ * `steer` (and `auto`) interrupt the child at its next safe point; `follow_up`
+ * queues the message until the current run settles.
+ */
+export async function steerWorkflowForegroundTarget(input: {
+	target: WorkflowForegroundSteeringTarget;
+	message: string;
+	mode?: SteerDeliveryMode;
+	index?: number;
 }): Promise<AgentToolResult<Details>> {
 	const { control, sourceRunId } = input.target;
-	const routeDir = control.workflowSteeringDir;
-	if (!routeDir || !fs.existsSync(routeDir)) return managementError(`Foreground run '${control.runId}' has no live workflow steering route.`);
 	const activeIndexes = [...(control.activeChildren?.keys() ?? [])].sort((left, right) => left - right);
 	const index = input.index ?? (activeIndexes.length === 1 ? activeIndexes[0] : undefined);
 	if (index === undefined) {
@@ -95,94 +138,31 @@ export async function steerWorkflowForegroundTarget(input: {
 			? `Foreground run '${control.runId}' has no live child session.`
 			: `Foreground run '${control.runId}' has ${activeIndexes.length} live child sessions; provide index.`);
 	}
-	if (!activeIndexes.includes(index)) return managementError(`Foreground run '${control.runId}' child ${index} is not live.`);
-	const capability = readSteerCapability(routeDir, index);
-	if (capability?.supported === false) return managementError(`Foreground run '${control.runId}' child ${index} does not support steering.`);
+	const child = control.activeChildren?.get(index);
+	if (!child) return managementError(`Foreground run '${control.runId}' child ${index} is not live.`);
+	if (!child.steer) return managementError(`Foreground run '${control.runId}' child ${index} does not support steering.`);
 
-	const request: SteerRequest = {
-		type: "steer",
-		id: randomUUID(),
-		ts: Date.now(),
-		message: input.message.trim(),
-		...(input.mode && input.mode !== "steer" ? { mode: input.mode } : {}),
-		targetIndex: index,
-		source: "steer-action",
-	};
-	try {
-		writeSteerRequestToExistingDir(stepSteerInboxDir(routeDir, index), request);
-	} catch (error) {
-		if (typeof error === "object" && error !== null && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT") {
-			return managementError(`Foreground run '${control.runId}' has no live workflow steering route.`);
-		}
-		return managementError(`Failed to queue steering for foreground run ${control.runId}: ${error instanceof Error ? error.message : String(error)}`);
-	}
+	const message = input.message.trim();
+	const requestId = randomUUID();
 
-	const deadline = Date.now() + (input.ackTimeoutMs ?? 3_000);
-	let ack;
-	let routeRemoved = false;
-	while (Date.now() <= deadline) {
-		ack = consumeSteerAckFromDir(steerAcksDir(routeDir, index), request.id);
-		if (ack || input.signal?.aborted) break;
-		if (!fs.existsSync(routeDir)) {
-			routeRemoved = true;
-			break;
-		}
-		await new Promise<void>((resolve) => setTimeout(resolve, Math.min(50, Math.max(1, deadline - Date.now()))));
-	}
-	if (routeRemoved || (!ack && !input.signal?.aborted && !fs.existsSync(routeDir))) {
-		return managementError(`Foreground run '${control.runId}' has no live child session.`);
-	}
-	const target = ack?.state === "delivered"
-		? { index, state: "delivered" as const, deliveredAt: ack.ts }
-		: ack?.state === "queued"
+	const outcome = await child.steer({ message, ...(input.mode && input.mode !== "steer" ? { mode: input.mode } : {}) });
+	const target = outcome.state === "delivered"
+		? { index, state: "delivered" as const, deliveredAt: Date.now() }
+		: outcome.state === "queued"
 			? { index, state: "queued" as const }
-			: ack?.state === "failed"
-				? { index, state: "failed" as const, reason: ack.message }
-				: { index, state: "pending" as const };
+			: { index, state: "failed" as const, reason: outcome.reason };
 	const steering = {
-		requestId: request.id,
-		state: ack?.state === "delivered" ? "delivered" as const : ack?.state === "failed" ? "failed" as const : "pending" as const,
-		deliveryStatus: ack?.state === "delivered" ? "delivered" as const : "queued" as const,
+		requestId,
+		state: outcome.state === "delivered" ? "delivered" as const : outcome.state === "failed" ? "failed" as const : "pending" as const,
+		deliveryStatus: outcome.state === "delivered" ? "delivered" as const : "queued" as const,
 		sourceRunId,
 		targets: [target],
 	};
-	if (input.signal?.aborted) {
-		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering pending for foreground run ${control.runId} (request ${request.id}); caller aborted before acknowledgment.`) }], details: { mode: "management", results: [], steering } };
-	}
-	if (ack?.state === "delivered") {
-		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering delivered for foreground run ${control.runId} (request ${request.id}).`) }], details: { mode: "management", results: [], steering } };
-	}
-	if (ack?.state === "queued") {
-		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering queued for foreground run ${control.runId} (request ${request.id}).`) }], details: { mode: "management", results: [], steering } };
+	if (outcome.state === "delivered") {
+		return { content: [{ type: "text", text: steeringReceipt(message, `Steering delivered for foreground run ${control.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering } };
 	}
-	if (ack?.state === "failed") {
-		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering failed for foreground run ${control.runId} (request ${request.id}): ${ack.message}`) }], isError: true, details: { mode: "management", results: [], steering } };
+	if (outcome.state === "queued") {
+		return { content: [{ type: "text", text: steeringReceipt(message, `Steering queued for foreground run ${control.runId} (request ${requestId}).`) }], details: { mode: "management", results: [], steering } };
 	}
-	return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering pending for foreground run ${control.runId} (request ${request.id}); no acknowledgment was received.`) }], details: { mode: "management", results: [], steering } };
+	return { content: [{ type: "text", text: steeringReceipt(message, `Steering failed for foreground run ${control.runId} (request ${requestId}): ${outcome.reason ?? "unknown error"}`) }], isError: true, details: { mode: "management", results: [], steering } };
 }
-
-export function workflowForegroundSteeringDir(asyncDirRoot: string, workflowRunId: string, childRunId: string): string {
-	return path.join(asyncDirRoot, workflowRunId, "control", "workflow-foreground", childRunId);
-}
-
-export function removeWorkflowForegroundSteeringRoute(control: ForegroundRunControl): void {
-	if (!control.workflowSteeringDir) return;
-	try {
-		fs.rmSync(control.workflowSteeringDir, { recursive: true, force: true });
-	} catch (error) {
-		console.warn(`[pi-subagents] Failed to remove workflow foreground steering route '${control.workflowSteeringDir}': ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-export function workflowForegroundSteeringLaunchOptions(control: ForegroundRunControl | undefined, index: number): Pick<import("../../shared/types.ts").RunSyncOptions, "steerInboxDir" | "steerCapabilityPath" | "steerAckDir"> {
-	if (!control?.workflowSteeringDir) return {};
-	const steerInboxDir = stepSteerInboxDir(control.workflowSteeringDir, index);
-	const steerAckDir = steerAcksDir(control.workflowSteeringDir, index);
-	fs.mkdirSync(steerInboxDir, { recursive: true });
-	fs.mkdirSync(steerAckDir, { recursive: true });
-	return {
-		steerInboxDir,
-		steerCapabilityPath: steerCapabilityPath(control.workflowSteeringDir, index),
-		steerAckDir,
-	};
-}

package/dist/extensions/pi-subagents/src/runs/shared/abort-recovery.ts

@@ -101,9 +101,9 @@ export function planAbortRecovery(input: {
 	if (input.alreadyResumed) return settle("resume already attempted");
 	if (!input.sessionAvailable) return settle("retained session unavailable");
 	if (input.stopped || input.interrupted) return settle("explicit stop or interrupt");
-	// A compaction abort can leave the child process open until the runner's
-	// terminal drain sends SIGTERM. The compaction + settlement markers make
-	// that cleanup signal non-authoritative; explicit stop/interrupt still wins.
+	// An external-job runner reports a process signal when its terminal drain
+	// ends a child left open by a compaction abort. The compaction + settlement
+	// markers make that cleanup signal non-authoritative; explicit stop/interrupt still wins.
 	if (input.processSignal && !compactionAbortCandidate) return settle("process terminated by signal");
 	if (input.timedOut) return settle("elapsed timeout");
 	if (input.toolBudgetExhausted || input.usageBudgetExhausted) return settle("budget exhausted");

package/dist/extensions/pi-subagents/src/runs/shared/acceptance.ts

@@ -24,7 +24,7 @@ import type {
 	ChildWatchdogProgress,
 } from "../../shared/types.ts";
 import { unresolvedChildWatchdogBlockers } from "../../watchdog/child-status.ts";
-import { isAgentContractV1 } from "./agent-contract.ts";
+import { isAgentContract } from "./agent-contract.ts";
 import { classifyTaskMutationIntent, stripSeverityCompounds, taskMayMutate } from "./task-intent.ts";
 
 const LEVEL_RANK: Record<Exclude<AcceptanceLevel, "auto">, number> = {
@@ -202,10 +202,23 @@ export function normalizeGateAcceptance(gate: unknown, acceptance: AcceptanceInp
 		return normalized.error ? { ok: false, error: normalized.error } : { ok: true, acceptance: normalized.value as AcceptanceInput };
 	}
 	if (typeof gate !== "string" || !gate.trim()) return { ok: false, error: "gate must be a non-empty command string." };
-	if (acceptance !== undefined) return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." };
+	if (acceptance !== undefined && acceptance !== false) return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." + describeGateAcceptanceConflict(gate, acceptance) };
 	return { ok: true, acceptance: { level: "verified", verify: [{ id: "gate", command: gate.trim() }] } };
 }
 
+export function describeGateAcceptanceConflict(gate: unknown, acceptance: unknown): string {
+	const render = (value: unknown): string => {
+		let encoded: string;
+		try {
+			encoded = JSON.stringify(value) ?? String(value);
+		} catch {
+			encoded = String(value);
+		}
+		return encoded.length > 120 ? `${encoded.slice(0, 120)}...` : encoded;
+	};
+	return ` Both fields were present: gate=${render(gate)} acceptance=${render(acceptance)}.`;
+}
+
 function explicitAcceptanceCanDisable(explicit: AcceptanceConfig): boolean {
 	return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
 }
@@ -422,7 +435,7 @@ export function resolveEffectiveAcceptance(input: {
 }): ResolvedAcceptanceConfig {
 	const explicit = normalizeAcceptanceInput(input.explicit);
 	const explicitLevel = normalizeLevel(explicit.level);
-	if (isAgentContractV1(input.agentContract)) {
+	if (isAgentContract(input.agentContract)) {
 		const level = explicitAcceptanceCanDisable(explicit) || explicitLevel === "auto"
 			? "none"
 			: explicitLevel;

package/dist/extensions/pi-subagents/src/runs/shared/agent-contract.ts

@@ -1,6 +1,6 @@
 import type { AgentContract, EffectsProjection, ExecutionProjection, ReviewProjection, SingleResult } from "../../shared/types.ts";
 
-export function isAgentContractV1(contract: AgentContract | undefined): boolean {
+export function isAgentContract(contract: AgentContract | undefined): boolean {
 	return contract?.version === 1;
 }