@selesai/code 0.13.32 → 0.13.34

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

@@ -105,7 +105,7 @@ import { SUBAGENT_CHILD_ENV } from "../shared/child-runtime-config.ts";
 import { deriveChildSessionName } from "../../shared/child-session-name.ts";
 import { alignForkedSessionCwd } from "../../shared/fork-session-cwd.ts";
 import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
-import { clearStructuredOutputCaptures, createStructuredOutputFileCapture, createStructuredOutputRuntime, MISSING_STRUCTURED_OUTPUT_CALL_ERROR, readStructuredOutput, readStructuredOutputAcceptanceReport } from "../shared/structured-output.ts";
+import { clearStructuredOutputCaptures, createStructuredOutputFileCapture, createStructuredOutputRuntime, formatStructuredOutputRejectionError, MISSING_STRUCTURED_OUTPUT_CALL_ERROR, readStructuredOutput, readStructuredOutputAcceptanceReport } from "../shared/structured-output.ts";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit, isUnexplainedProcessSignal } from "../shared/process-signal.ts";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.ts";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.ts";
@@ -285,6 +285,7 @@ interface StepResult {
 	review?: import("../../shared/types.ts").ReviewProjection;
 	effects?: import("../../shared/types.ts").EffectsProjection;
 	structuredOutput?: unknown;
+	structuredOutputFailed?: boolean;
 	structuredOutputPath?: string;
 	structuredOutputSchemaPath?: string;
 	acceptance?: import("../../shared/types.ts").AcceptanceLedger;
@@ -1221,7 +1222,8 @@ export async function runSingleStepInner(
 					schemaPath: effectiveStructuredOutput.schemaPath,
 					outputPath: effectiveStructuredOutput.outputPath,
 				});
-				if (structured.error) structuredError = structured.error;
+				if (structured.error === MISSING_STRUCTURED_OUTPUT_CALL_ERROR) structuredError = formatStructuredOutputRejectionError(run.messages);
+				else if (structured.error) structuredError = structured.error;
 				else {
 					structuredOutput = structured.value;
 					const acceptanceReport = readStructuredOutputAcceptanceReport(effectiveStructuredOutput);
@@ -1343,7 +1345,7 @@ export async function runSingleStepInner(
 			afterCompactionSettlement: run.afterCompactionSettlement === true,
 		});
 		const fileMutationEffect = completionEvidence.fileMutation ?? (missingRequiredOutputAfterMutation ? { status: "observed" as const, expected: completionEvidence.mutationExpected, attempted: true, evidence: mutationEvidence } : undefined);
-		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput, runtimeAcknowledgedExtensions, ...(step.agentContract ? { agentContract: step.agentContract } : {}), ...(fileMutationEffect || settlementDiagnostic ? { effects: { ...(fileMutationEffect ? { fileMutation: fileMutationEffect } : {}), ...(settlementDiagnostic ? { settlementDiagnostic } : {}) } } : {}) } as RunChildSessionResult;
+		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput, structuredOutputFailed: structuredError ? true : undefined, runtimeAcknowledgedExtensions, ...(step.agentContract ? { agentContract: step.agentContract } : {}), ...(fileMutationEffect || settlementDiagnostic ? { effects: { ...(fileMutationEffect ? { fileMutation: fileMutationEffect } : {}), ...(settlementDiagnostic ? { settlementDiagnostic } : {}) } } : {}) } as RunChildSessionResult;
 		const abortRecovery = !attempt.success ? planAbortRecovery({
 			messages: run.messages,
 			error,
@@ -1603,6 +1605,7 @@ export async function runSingleStepInner(
 		completionGuardTriggered: completionGuardTriggeredFinal,
 		...((finalResult as (RunChildSessionResult & { effects?: import("../../shared/types.ts").EffectsProjection }) | undefined)?.effects ? { effects: (finalResult as RunChildSessionResult & { effects?: import("../../shared/types.ts").EffectsProjection }).effects } : {}),
 		structuredOutput: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : (finalResult as (RunChildSessionResult & { structuredOutput?: unknown }) | undefined)?.structuredOutput,
+		structuredOutputFailed: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : finalResult?.structuredOutputFailed,
 		structuredOutputPath: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : effectiveStructuredOutput?.outputPath,
 		structuredOutputSchemaPath: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : effectiveStructuredOutput?.schemaPath,
 		acceptance: effectiveAcceptance,
@@ -3788,6 +3791,7 @@ export async function runSubagent(
 					review: pr.review,
 					timeoutRecovery: pr.timeoutRecovery,
 					structuredOutput: pr.structuredOutput,
+					structuredOutputFailed: pr.structuredOutputFailed,
 					structuredOutputPath: pr.structuredOutputPath,
 					structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
 					acceptance: pr.acceptance,
@@ -4245,6 +4249,7 @@ export async function runSubagent(
 							review: pr.review,
 							timeoutRecovery: pr.timeoutRecovery,
 							structuredOutput: pr.structuredOutput,
+							structuredOutputFailed: pr.structuredOutputFailed,
 						structuredOutputPath: pr.structuredOutputPath,
 						structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
 						acceptance: pr.acceptance,
@@ -4539,6 +4544,7 @@ export async function runSubagent(
 				review: singleResult.review,
 				timeoutRecovery: singleResult.timeoutRecovery,
 				structuredOutput: singleResult.structuredOutput,
+				structuredOutputFailed: singleResult.structuredOutputFailed,
 				structuredOutputPath: singleResult.structuredOutputPath,
 				structuredOutputSchemaPath: singleResult.structuredOutputSchemaPath,
 				acceptance: singleResult.acceptance,
@@ -4923,6 +4929,7 @@ export async function runSubagent(
 				review: r.review,
 				effects: r.effects,
 				structuredOutput: r.structuredOutput,
+				structuredOutputFailed: r.structuredOutputFailed,
 				structuredOutputPath: r.structuredOutputPath,
 				structuredOutputSchemaPath: r.structuredOutputSchemaPath,
 				acceptance: r.acceptance,

package/dist/extensions/pi-subagents/src/runs/background/workflow-terminal-proof.ts

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AsyncStatus, ProcessTerminal, WorkflowChildSummary, WorkflowTerminalProof } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { readProcessTerminal } from "./process-terminal.ts";
+
+const TERMINAL_WORKFLOW_STATES = new Set<WorkflowChildSummary["workflowState"]>(["completed", "failed", "stopped"]);
+
+export function isTerminalAsyncState(state: AsyncStatus["state"]): boolean {
+	return state !== "queued" && state !== "running" && state !== "paused";
+}
+
+export type WorkflowChildProcessEvidence =
+	| { state: "observed"; children: ProcessTerminal[] }
+	| { state: "pending" | "unknown"; reason: string };
+
+/**
+ * Process evidence for a workflow's async children. Status proofs and capacity
+ * release both use this so they cannot disagree about the same workflow.
+ * Synchronous children run inside the workflow host and have no process of their own.
+ */
+export function readWorkflowChildProcessEvidence(workflowAsyncDir: string, steps: AsyncStatus["steps"]): WorkflowChildProcessEvidence {
+	const children: ProcessTerminal[] = [];
+	for (const step of steps ?? []) {
+		const label = step.workflowKey ?? step.agent;
+		if (typeof step.async !== "boolean") return { state: "unknown", reason: `workflow child ${label} is missing async classification` };
+		if (!step.async) continue;
+		if (!step.runId || path.basename(step.runId) !== step.runId) return { state: "unknown", reason: `async workflow child ${label} is missing run id` };
+		const childDir = path.join(path.dirname(workflowAsyncDir), step.runId);
+		if (!fs.existsSync(childDir)) return { state: "unknown", reason: `async workflow child ${label} directory is missing` };
+		const childStatus = readStatus(childDir);
+		if (!childStatus) return { state: "unknown", reason: `async workflow child ${label} status is missing or unreadable` };
+		if (!isTerminalAsyncState(childStatus.state)) return { state: "pending", reason: `async workflow child ${label} is still ${childStatus.state}` };
+		const recorded = childStatus.processTerminal;
+		if (!recorded?.runnerProcessInstanceId) return { state: "unknown", reason: `async workflow child ${label} has no runner process identity` };
+		// A runner startup failure records `not-started` in status and never writes a process-terminal sidecar.
+		if (recorded.state === "not-started" && recorded.runId === step.runId && typeof childStatus.error === "string" && childStatus.error) {
+			children.push(recorded);
+			continue;
+		}
+		const proof = readProcessTerminal(childDir, { runId: step.runId, runnerProcessInstanceId: recorded.runnerProcessInstanceId });
+		if (proof?.state !== "observed" || proof.runId !== step.runId) {
+			return { state: !proof || proof.state === "pending" ? "pending" : "unknown", reason: `async workflow child ${label} process-terminal proof is ${proof?.state ?? "missing"}` };
+		}
+		children.push(proof);
+	}
+	return { state: "observed", children };
+}
+
+function unresolved(runId: string, state: "pending" | "unknown", dispatchClosed: boolean, reason: string): WorkflowTerminalProof {
+	return { version: 1, kind: "workflow", runId, state, dispatchClosed, reason };
+}
+
+/** A persistent workflow host is terminal only after dispatch closes and every async child has process evidence. */
+export function readWorkflowTerminalProof(asyncDir: string, steps: AsyncStatus["steps"], summary: WorkflowChildSummary, hostCommandCount: number, closedAt: number): WorkflowTerminalProof {
+	const runId = summary.workflowRunId;
+	if (!summary.inventoryComplete || !TERMINAL_WORKFLOW_STATES.has(summary.workflowState)) {
+		return unresolved(runId, "pending", false, "Workflow dispatch is still open.");
+	}
+	if (hostCommandCount > 0) {
+		return unresolved(runId, "unknown", true, "Workflow host commands have no process-terminal proof.");
+	}
+	const evidence = readWorkflowChildProcessEvidence(asyncDir, steps);
+	if (evidence.state !== "observed") return unresolved(runId, evidence.state, true, evidence.reason);
+	const observedAt = Math.max(closedAt, ...evidence.children.map((child) => child.state === "observed" ? child.observedAt : 0));
+	return { version: 1, kind: "workflow", runId, state: "observed", dispatchClosed: true, observedAt, children: evidence.children };
+}

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

@@ -71,7 +71,7 @@ import { deriveChildSessionName } from "../../shared/child-session-name.ts";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.ts";
-import { MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.ts";
+import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.ts";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.ts";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.ts";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.ts";
@@ -1431,10 +1431,14 @@ async function runSingleAttempt(
 		result.structuredOutputSchemaPath = options.structuredOutput.schemaPath;
 		result.structuredOutputPath = options.structuredOutput.outputPath;
 		const structured = capture.structuredOutput();
-		if (!structuredOutputToolInvoked || !structured.called) {
+		if (!structuredOutputToolInvoked) {
 			result.exitCode = 1;
 			result.error = MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
 			result.structuredOutputFailed = true;
+		} else if (!structured.called) {
+			result.exitCode = 1;
+			result.error = formatStructuredOutputRejectionError(result.messages ?? []);
+			result.structuredOutputFailed = true;
 		} else {
 			result.structuredOutput = structured.value;
 			const acceptanceMode = options.structuredOutput.acceptanceReportPath

package/dist/extensions/pi-subagents/src/runs/shared/child-tool-plan.ts

@@ -30,6 +30,17 @@ import {
 } from "./capability-ceiling.ts";
 
 const MAX_LAUNCH_RESOLVED_EXTENSION_IDS = 32;
+export const CAPABILITY_GATEWAY_EXTENSION_PATH = path.join(
+	path.dirname(fileURLToPath(import.meta.url)),
+	"..",
+	"..",
+	"..",
+	"..",
+	"capability-gateway",
+	"index.ts",
+);
+const CAPABILITY_GATEWAY_TOOL_NAMES = ["capability_catalog", "capability_discover", "capability_skill_show"] as const;
+const CAPABILITY_GATEWAY_ENABLED_ENV = "SELESAI_CAPABILITY_GATEWAY";
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(
 	path.dirname(fileURLToPath(import.meta.url)),
 	"subagent-prompt-runtime.ts",
@@ -172,6 +183,8 @@ export interface PiLaunchToolPlan {
 	extensionArgs: string[];
 	disableAmbientExtensions: boolean;
 	capabilityAudit?: SubagentCapabilityAudit;
+	/** Whether the capability gateway is loaded for this child's permitted extension/tool policy. */
+	capabilityGatewayEnabled: boolean;
 	/** Non-fatal launch warnings; they do not change behavior. */
 	warnings: string[];
 }
@@ -195,6 +208,14 @@ function hasPermissionRules(rules: PermissionRules | undefined): boolean {
 	return rules !== undefined && Object.keys(rules).length > 0;
 }
 
+function isCapabilityGatewayExtensionPath(value: string, cwd?: string): boolean {
+	const resolved = path.normalize(path.resolve(cwd ?? process.cwd(), value));
+	return (
+		resolved === path.normalize(CAPABILITY_GATEWAY_EXTENSION_PATH) ||
+		resolved === path.normalize(path.dirname(CAPABILITY_GATEWAY_EXTENSION_PATH))
+	);
+}
+
 /**
  * Children are pi sessions inside the parent or the runner process; a spawned
  * `pi` received extra MCP server definitions as a CLI argument, but a session
@@ -330,6 +351,9 @@ export function resolvePiLaunchToolPlan(
 		!excludedToolSet.has("subagent") &&
 		(!allowedToolSet || allowedToolSet.has("subagent"))
 	);
+	if (effectiveDeclaredBuiltinTools.includes("subagent_supervisor") && !fanoutAuthorized) {
+		throw new Error("Tool 'subagent_supervisor' requires fanout authorization: include 'subagent' in the effective tools allowlist or enable allowNestedSubagents.");
+	}
 	const toolExtensionPaths: string[] = capabilityCeiling?.denyExtensions
 		? []
 		: (input.tools ?? []).filter(
@@ -363,13 +387,41 @@ export function resolvePiLaunchToolPlan(
 		(input.mcpDirectTools?.length ?? 0) > 0 ||
 		allowedToolSet !== undefined;
 	const internalTools = (input.structuredOutput ? ["structured_output"] : []).filter((tool) => !excludedToolSet.has(tool));
-	const effectiveToolAllowlist = [
+	const baseEffectiveToolAllowlist = [
 		...new Set([
 			...effectiveDeclaredBuiltinTools,
 			...effectiveMcpTools,
 			...internalTools,
 		]),
 	];
+	const explicitlyNoTools =
+		explicitToolAllowlist &&
+		effectiveDeclaredBuiltinTools.length === 0 &&
+		effectiveMcpTools.length === 0;
+	const gatewayExplicitlyConfigured = [
+		...toolExtensionPaths,
+		...(input.extensions ?? []),
+		...(input.subagentOnlyExtensions ?? []),
+	].some((extensionPath) => isCapabilityGatewayExtensionPath(extensionPath, input.cwd));
+	const gatewayExtensionPolicyAllows =
+		capabilityCeiling?.denyExtensions !== true &&
+		fs.existsSync(CAPABILITY_GATEWAY_EXTENSION_PATH) &&
+		(input.extensions === undefined || gatewayExplicitlyConfigured);
+	const permittedGatewayTools = CAPABILITY_GATEWAY_TOOL_NAMES.filter(
+		(name) => (!allowedToolSet || allowedToolSet.has(name)) && !excludedToolSet.has(name),
+	);
+	const capabilityGatewayEnabled =
+		gatewayExtensionPolicyAllows &&
+		!explicitlyNoTools &&
+		permittedGatewayTools.length > 0 &&
+		process.env[CAPABILITY_GATEWAY_ENABLED_ENV] !== "0";
+	const gatewayTools = capabilityGatewayEnabled ? permittedGatewayTools : [];
+	const effectiveToolAllowlist = [
+		...new Set([
+			...baseEffectiveToolAllowlist,
+			...(explicitToolAllowlist ? gatewayTools : []),
+		]),
+	];
 	// Supervisor-coordination names stay in the --tools allowlist but are never
 	// strict requirements: children register contact_supervisor at runtime through
 	// the native supervisor channel (or pi-intercom). The pre-0.50 bridge always
@@ -383,6 +435,7 @@ export function resolvePiLaunchToolPlan(
 					...(input.tools !== undefined ? effectiveDeclaredBuiltinTools : []),
 					...(input.mcpDirectTools?.length ? effectiveMcpTools : []),
 					...internalTools,
+					...gatewayTools,
 				].filter((tool) => tool !== "contact_supervisor" && (!legacySupervisorPairing || tool !== "intercom"))),
 			]
 		: [];
@@ -395,6 +448,9 @@ export function resolvePiLaunchToolPlan(
 	const fastModeExtensions = resolveFastModeExtension({ fast: input.fast, model: input.model, modelCandidates: input.modelCandidates, agentName: input.agentName });
 	const runtimeExtensions = [
 		PROMPT_RUNTIME_EXTENSION_PATH,
+		...(capabilityGatewayEnabled && !gatewayExplicitlyConfigured
+			? [CAPABILITY_GATEWAY_EXTENSION_PATH]
+			: []),
 		...fastModeExtensions,
 		...(fanoutAuthorized ? [FANOUT_CHILD_EXTENSION_PATH] : []),
 		...(permSystemExt ? [permSystemExt] : []),
@@ -412,20 +468,25 @@ export function resolvePiLaunchToolPlan(
 				+ "List the extensions this child actually needs instead of an empty array.",
 		);
 	}
+	const gatewayFilteredExtensions = (extensions: string[]) =>
+		extensions.filter(
+			(extensionPath) =>
+				!isCapabilityGatewayExtensionPath(extensionPath, input.cwd) || capabilityGatewayEnabled,
+		);
 	const configuredExtensions = capabilityCeiling?.denyExtensions
 		? []
-		: [
+		: gatewayFilteredExtensions([
 				...toolExtensionPaths,
 				...(input.extensions ?? []),
 				...(input.subagentOnlyExtensions ?? []),
-			];
+			]);
 	const extensionArgs = disableAmbientExtensions
 		? [...new Set([...runtimeExtensions, ...configuredExtensions])]
 		: [
 				...new Set([
 					...runtimeExtensions,
-					...toolExtensionPaths,
-					...(input.subagentOnlyExtensions ?? []),
+					...gatewayFilteredExtensions(toolExtensionPaths),
+					...gatewayFilteredExtensions(input.subagentOnlyExtensions ?? []),
 				]),
 			];
 	const requestedToolNames =
@@ -494,6 +555,7 @@ export function resolvePiLaunchToolPlan(
 		configuredExtensions,
 		extensionArgs,
 		disableAmbientExtensions,
+		capabilityGatewayEnabled,
 		warnings,
 		...(capabilityAudit ? { capabilityAudit } : {}),
 	};

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

@@ -17,6 +17,12 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"intercom",
 	"contact_supervisor",
 	"structured_output",
+	// Gateway controls only search, activate, or load capabilities; activation stays
+	// filtered by the child's own tool policy, so they are not mutation-capable.
+	// Kept literal: child-tool-plan transitively imports this module (via single-output).
+	"capability_catalog",
+	"capability_discover",
+	"capability_skill_show",
 ]);
 
 // Cursor native edit/write often land as thinking traces (inactive_trace /

package/dist/extensions/pi-subagents/src/runs/shared/external-cli-runner.ts

@@ -6,6 +6,7 @@ import { finished } from "node:stream/promises";
 import type { ExternalProcessStatus } from "../../shared/types.ts";
 import { createOwnedProcessTreeController, type OwnedProcessTreeController } from "../background/owned-process-tree.ts";
 import { omitExtensionBindingsEnv } from "./extension-bindings.ts";
+import { omitGitRoutingEnv } from "./git-environment.ts";
 import {
 	invalidateExternalCliPreflight,
 	preflightExternalCli,
@@ -86,7 +87,7 @@ function narrowLimit(value: number | undefined, ceiling: number, label: string):
 }
 
 function externalEnvironment(allowlist: readonly string[] | undefined, values: Readonly<Record<string, string>> | undefined): NodeJS.ProcessEnv {
-	if (!allowlist) return omitExtensionBindingsEnv(process.env);
+	if (!allowlist) return omitGitRoutingEnv(omitExtensionBindingsEnv(process.env));
 	const allowed = new Set(allowlist);
 	const env: NodeJS.ProcessEnv = {};
 	for (const key of allowed) {

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

@@ -0,0 +1,29 @@
+// ponytail: this static list can lag Git additions; refresh from `git rev-parse --local-env-vars` and indexed config keys when Git changes.
+const GIT_ROUTING_VARIABLES = new Set([
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_COMMON_DIR",
+	"GIT_CONFIG",
+	"GIT_CONFIG_COUNT",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_DIR",
+	"GIT_GRAFT_FILE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_NAMESPACE",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_SHALLOW_FILE",
+	"GIT_WORK_TREE",
+]);
+
+function isGitRoutingVariable(name: string): boolean {
+	const upper = name.toUpperCase();
+	return GIT_ROUTING_VARIABLES.has(upper) || /^GIT_CONFIG_(?:KEY|VALUE)_\d+$/.test(upper);
+}
+
+/** Remove inherited values that can route Git commands away from the child cwd. */
+export function omitGitRoutingEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	return Object.fromEntries(Object.entries(env).filter(([name]) => !isGitRoutingVariable(name)));
+}

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

@@ -3,12 +3,81 @@ import { createRequire } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import type { Message } from "@earendil-works/pi-ai";
 import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 import type { ResolvedAcceptanceReportMode } from "./acceptance.ts";
 
 export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
 export const MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR = "Missing acceptanceReport in structured_output call; acceptance.report is \"on\".";
+export const STRUCTURED_OUTPUT_REJECTION_ERROR = "structured_output was invoked but no valid output was captured.";
+export const INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR = "Structured output invocation was rejected: invalid outputSchema.";
+export const STRUCTURED_OUTPUT_VALIDATOR_UNAVAILABLE_ERROR = "Structured output invocation was rejected: validator unavailable.";
+export const MAX_STRUCTURED_OUTPUT_REJECTION_ERROR_BYTES = 4096;
+
+function utf8Prefix(value: string, maxBytes: number): string {
+	if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+	const suffix = "...";
+	const contentLimit = maxBytes - Buffer.byteLength(suffix, "utf8");
+	let bytes = 0;
+	let result = "";
+	for (const character of value) {
+		const characterBytes = Buffer.byteLength(character, "utf8");
+		if (bytes + characterBytes > contentLimit) break;
+		result += character;
+		bytes += characterBytes;
+	}
+	return result + suffix;
+}
+
+function messageText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((part): part is { type: "text"; text: string } => Boolean(part) && typeof part === "object" && (part as { type?: unknown }).type === "text" && typeof (part as { text?: unknown }).text === "string")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function sanitizeStructuredOutputRejection(text: string): string {
+	const withoutControls = text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+	if (/invalid outputSchema(?:\s*:|$)/i.test(withoutControls)) return INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR;
+	if (/failed to validate structured output:|cannot load typebox\/compile/i.test(withoutControls)) return STRUCTURED_OUTPUT_VALIDATOR_UNAVAILABLE_ERROR;
+	const validationMarker = "Structured output validation failed:";
+	const markerIndex = withoutControls.indexOf(validationMarker);
+	const diagnostic = markerIndex >= 0 ? withoutControls.slice(markerIndex) : withoutControls;
+	const lines = diagnostic.split(/\r?\n/).filter((line) => {
+		const trimmed = line.trim();
+		return trimmed.length > 0
+			&& !/^at\s/.test(trimmed)
+			&& !/^(?:arguments?|parameters?|submitted value|input|outputSchema|schema|stack)\s*:/i.test(trimmed);
+	});
+	const sanitized = lines.join("\n")
+		.replace(/\b(received|actual|got)(?:\s+value)?\s*[:=]\s*(?:\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'|\{[^\n]*\}|\[[^\n]*\]|\S+)/gi, "$1: [redacted]")
+		.trim();
+	return sanitized || STRUCTURED_OUTPUT_REJECTION_ERROR;
+}
+
+/** Returns bounded evidence from the latest failed structured_output result in a terminal transcript. */
+export function formatStructuredOutputRejectionError(messages: readonly Message[]): string {
+	const toolCallIds = new Set<string>();
+	for (const message of messages) {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+		for (const part of message.content) {
+			const call = part as { type?: unknown; id?: unknown; name?: unknown };
+			if (call.type === "toolCall" && call.name === "structured_output" && typeof call.id === "string") toolCallIds.add(call.id);
+		}
+	}
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index] as Message & { toolCallId?: unknown; toolName?: unknown; isError?: unknown };
+		if (message.role !== "toolResult" || message.isError !== true) continue;
+		const matchingName = message.toolName === "structured_output";
+		const matchingId = typeof message.toolCallId === "string" && toolCallIds.has(message.toolCallId);
+		if (!matchingName && !matchingId) continue;
+		return utf8Prefix(sanitizeStructuredOutputRejection(messageText(message.content)), MAX_STRUCTURED_OUTPUT_REJECTION_ERROR_BYTES);
+	}
+	return STRUCTURED_OUTPUT_REJECTION_ERROR;
+}
 
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -704,6 +704,25 @@ export type ProcessTerminal =
 		diagnostic?: string;
 	});
 
+export type WorkflowTerminalProof =
+	| {
+		version: 1;
+		kind: "workflow";
+		runId: string;
+		state: "observed";
+		dispatchClosed: true;
+		observedAt: number;
+		children: ProcessTerminal[];
+	}
+	| {
+		version: 1;
+		kind: "workflow";
+		runId: string;
+		state: "pending" | "unknown";
+		dispatchClosed: boolean;
+		reason: string;
+	};
+
 /** Identifies the durable schedule that launched a run, so its completion is attributable. */
 export interface ScheduleOrigin {
 	id: string;
@@ -1398,6 +1417,7 @@ export interface Details {
 	context?: "fresh" | "fork" | "mixed";
 	results: SingleResult[];
 	workflowChildren?: WorkflowChildSummary;
+	workflowTerminalProof?: WorkflowTerminalProof;
 	/**
 	 * Terminal completion payloads for runs this bg_wait call observed
 	 * finishing. Async completions travel as result files that are consumed and