pi-subagents 0.36.0 → 0.37.0

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -7,6 +7,7 @@ import { SUBAGENT_CHILD_AGENT_ENV, SUBAGENT_CHILD_INDEX_ENV, SUBAGENT_FANOUT_CHI
 import { createStructuredOutputToolParameters, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
 import {
 	CHILD_TOOL_DIAGNOSTIC_PATH_ENV,
+	MCP_DIRECT_CHILD_TOOLS_ENV,
 	REQUIRED_CHILD_TOOLS_ENV,
 	writeChildToolDiagnostic,
 	type ChildToolDiagnostic,
@@ -78,12 +79,24 @@ function readRequiredChildTools(): string[] | undefined {
 	return required;
 }
 
+function readMcpDirectChildTools(): string[] | undefined {
+	const encoded = process.env[MCP_DIRECT_CHILD_TOOLS_ENV]?.trim();
+	if (!encoded) return undefined;
+	try {
+		const tools = JSON.parse(encoded) as unknown;
+		if (!Array.isArray(tools) || tools.some((name) => typeof name !== "string" || !name)) return undefined;
+		return tools;
+	} catch {
+		return undefined;
+	}
+}
+
 function refreshChildToolDiagnostic(pi: ExtensionAPI): ChildToolDiagnostic | undefined {
 	const filePath = process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV]?.trim();
 	const required = readRequiredChildTools();
 	if (!filePath || !required) return undefined;
 	const available = pi.getAllTools().map((tool) => tool.name);
-	return writeChildToolDiagnostic(filePath, required, available, process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim());
+	return writeChildToolDiagnostic(filePath, required, available, process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim(), readMcpDirectChildTools());
 }
 
 function findSectionEnd(prompt: string, startIndex: number, nextHeaders: string[]): number {

package/src/runs/shared/tool-availability.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 export const REQUIRED_CHILD_TOOLS_ENV = "PI_SUBAGENT_REQUIRED_TOOLS";
+export const MCP_DIRECT_CHILD_TOOLS_ENV = "PI_SUBAGENT_MCP_DIRECT_TOOLS";
 export const CHILD_TOOL_DIAGNOSTIC_PATH_ENV = "PI_SUBAGENT_TOOL_DIAGNOSTIC_PATH";
 
 export interface ChildToolDiagnostic {
@@ -9,6 +10,7 @@ export interface ChildToolDiagnostic {
 	required: string[];
 	available: string[];
 	missing: string[];
+	missingMcpDirectTools?: string[];
 }
 
 const PI_CORE_CHILD_TOOLS = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
@@ -18,6 +20,7 @@ export function writeChildToolDiagnostic(
 	required: string[],
 	available: string[],
 	agent?: string,
+	mcpDirectTools?: string[],
 ): ChildToolDiagnostic | undefined {
 	const availableNames = new Set([...available, ...PI_CORE_CHILD_TOOLS]);
 	const missing = required.filter((name) => !availableNames.has(name));
@@ -26,7 +29,16 @@ export function writeChildToolDiagnostic(
 		return undefined;
 	}
 
-	const diagnostic: ChildToolDiagnostic = { agent, required, available, missing };
+	const missingMcpDirectTools = mcpDirectTools?.length
+		? missing.filter((name) => mcpDirectTools.includes(name))
+		: [];
+	const diagnostic: ChildToolDiagnostic = {
+		agent,
+		required,
+		available,
+		missing,
+		...(missingMcpDirectTools.length > 0 ? { missingMcpDirectTools } : {}),
+	};
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	fs.writeFileSync(filePath, JSON.stringify(diagnostic), { mode: 0o600 });
 	return diagnostic;
@@ -36,7 +48,7 @@ export function readChildToolDiagnostic(filePath: string | undefined): ChildTool
 	if (!filePath || !fs.existsSync(filePath)) return undefined;
 	const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as Partial<ChildToolDiagnostic>;
 	const stringArray = (value: unknown): value is string[] => Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.length > 0);
-	if (!stringArray(parsed.required) || !stringArray(parsed.available) || !stringArray(parsed.missing) || (parsed.agent !== undefined && typeof parsed.agent !== "string")) {
+	if (!stringArray(parsed.required) || !stringArray(parsed.available) || !stringArray(parsed.missing) || (parsed.agent !== undefined && typeof parsed.agent !== "string") || (parsed.missingMcpDirectTools !== undefined && !stringArray(parsed.missingMcpDirectTools))) {
 		throw new Error(`Malformed child tool diagnostic at '${filePath}'.`);
 	}
 	return {
@@ -44,6 +56,7 @@ export function readChildToolDiagnostic(filePath: string | undefined): ChildTool
 		required: parsed.required,
 		available: parsed.available,
 		missing: parsed.missing,
+		...(parsed.missingMcpDirectTools ? { missingMcpDirectTools: parsed.missingMcpDirectTools } : {}),
 	};
 }
 
@@ -52,6 +65,9 @@ export function formatChildToolDiagnostic(diagnostic: ChildToolDiagnostic): stri
 	return [
 		`${subject} requested unavailable child tools: ${diagnostic.missing.join(", ")}.`,
 		"The `tools` field is a strict allowlist; it does not load extension code.",
+		...(diagnostic.missingMcpDirectTools?.length
+			? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. This indicates a host/pi-mcp-adapter registration problem, not a tool-call failure.`]
+			: []),
 		"For extension tools, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
 		"For MCP tools, verify the MCP adapter configuration and selected tool names. For builtin tools, verify the name against the installed Pi version.",
 	].join("\n");

package/src/shared/launch-contract.ts

@@ -0,0 +1,123 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import type { AgentConfig } from "../agents/agents.ts";
+
+export const AGENT_DEFINITION_PROJECTION_VERSION = 1 as const;
+export const LAUNCH_BINDING_PROJECTION_VERSION = 1 as const;
+
+function stableJson(value: unknown): string {
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	if (value && typeof value === "object") {
+		return `{${Object.entries(value as Record<string, unknown>)
+			.filter(([, entry]) => entry !== undefined)
+			.sort(([a], [b]) => a.localeCompare(b))
+			.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+			.join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+
+function sha256(value: unknown): string {
+	return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+
+function fileDigest(filePath: string): string | undefined {
+	try {
+		return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+	} catch {
+		return undefined;
+	}
+}
+
+/** Public-safe, deterministic evidence for the parsed launch-affecting agent definition. */
+export function projectAgentDefinition(agent: AgentConfig): Record<string, unknown> {
+	return {
+		version: AGENT_DEFINITION_PROJECTION_VERSION,
+		name: agent.name,
+		localName: agent.localName,
+		packageName: agent.packageName,
+		filePath: agent.filePath,
+		fileContentDigest: fileDigest(agent.filePath),
+		systemPrompt: agent.systemPrompt,
+		systemPromptMode: agent.systemPromptMode,
+		inheritProjectContext: agent.inheritProjectContext,
+		inheritSkills: agent.inheritSkills,
+		model: agent.model,
+		fallbackModels: agent.fallbackModels,
+		thinking: agent.thinking,
+		tools: agent.tools,
+		mcpDirectTools: agent.mcpDirectTools,
+		extensions: agent.extensions,
+		subagentOnlyExtensions: agent.subagentOnlyExtensions,
+		skills: agent.skills,
+		skillPath: agent.skillPath,
+		output: agent.output,
+		defaultReads: agent.defaultReads,
+		defaultProgress: agent.defaultProgress,
+		defaultContext: agent.defaultContext,
+		defaultAsync: agent.defaultAsync,
+		defaultTimeoutMs: agent.defaultTimeoutMs,
+		defaultTurnBudget: agent.defaultTurnBudget,
+		defaultAcceptance: agent.defaultAcceptance,
+		acceptanceRole: agent.acceptanceRole,
+		interactive: agent.interactive,
+		maxSubagentDepth: agent.maxSubagentDepth,
+		completionGuard: agent.completionGuard,
+		toolBudget: agent.toolBudget,
+		memory: agent.memory,
+	};
+}
+
+export function agentDefinitionDigest(agent: AgentConfig): string {
+	return sha256(projectAgentDefinition(agent));
+}
+
+export interface LaunchBindingInput {
+	definitionDigest: string;
+	/** Caller task; runtime acceptance/output task annotations are explicitly outside the preflight-known subset. */
+	task?: string;
+	model?: string;
+	modelCandidates?: string[];
+	thinking?: string;
+	systemPrompt?: string | null;
+	systemPromptMode?: AgentConfig["systemPromptMode"];
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
+	skills?: string[];
+	tools?: string[];
+	extensions?: string[];
+	subagentOnlyExtensions?: string[];
+	mcpDirectTools?: string[];
+	outputPath?: string;
+	outputMode?: string;
+	structuredOutputSchema?: unknown;
+}
+
+/** Canonical projection of the resolved inputs handed to the child. */
+export function projectLaunchBinding(input: LaunchBindingInput): Record<string, unknown> {
+	return {
+		version: LAUNCH_BINDING_PROJECTION_VERSION,
+		definitionDigest: input.definitionDigest,
+		taskDigest: input.task === undefined ? undefined : sha256(input.task),
+		// The ordered candidate set already contains each attempted model; keeping only
+		// this set makes retries correlate to the same preflight binding.
+		modelCandidates: input.modelCandidates,
+		thinking: input.thinking,
+		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : sha256(input.systemPrompt),
+		systemPromptMode: input.systemPromptMode,
+		inheritProjectContext: input.inheritProjectContext,
+		inheritSkills: input.inheritSkills,
+		skills: input.skills,
+		tools: input.tools,
+		extensions: input.extensions,
+		subagentOnlyExtensions: input.subagentOnlyExtensions,
+		mcpDirectTools: input.mcpDirectTools,
+		outputPath: input.outputPath,
+		outputMode: input.outputMode,
+		structuredOutputSchema: input.structuredOutputSchema,
+	};
+}
+
+export function launchBindingDigest(input: LaunchBindingInput): string {
+	return sha256(projectLaunchBinding(input));
+}

package/src/shared/types.ts

@@ -9,6 +9,7 @@ import type { AgentConfig } from "../agents/agents.ts";
 import type { FSWatcher } from "node:fs";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { ModelScopeConfig } from "../runs/shared/model-scope.ts";
+import type { ResolvedSubagentCapabilityCeiling, SubagentCapabilityAudit } from "../runs/shared/capability-ceiling.ts";
 
 // ============================================================================
 // Basic Types
@@ -302,7 +303,7 @@ export interface ExecutionProjection {
 }
 
 export interface ReviewProjection {
-	status: "not-requested" | "no-blockers" | "blockers" | "needs-parent-decision";
+	status: "not-requested" | "review-required" | "reviewed" | "blockers";
 	findings?: AcceptanceReviewResult["findings"];
 }
 
@@ -317,9 +318,69 @@ export interface EffectsProjection {
 	fileMutation?: FileMutationEffect;
 }
 
-export const SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 2;
+export const SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 3;
 export type SubagentLifecycleArtifactVersion = typeof SUBAGENT_LIFECYCLE_ARTIFACT_VERSION;
 
+export type ProcessTerminalState = "pending" | "observed" | "unknown" | "not-started";
+export type ProcessTerminalReason =
+	| "observer-unavailable"
+	| "runner-candidate-missing"
+	| "runner-instance-mismatch"
+	| "writer-close-unverified"
+	| "canonical-session-unavailable"
+	| "canonical-session-lease-active"
+	| "canonical-session-release-unverified"
+	| "proof-write-failed"
+	| "stale-repair";
+
+export interface RunnerProcessInstanceExitV1 {
+	processInstanceId: string;
+	kind: "runner";
+	closeObservedAt: number;
+	exitCode: number | null;
+	signal: string | null;
+}
+
+export interface PiWriterProcessInstanceExitV1 {
+	processInstanceId: string;
+	kind: "pi-writer";
+	attempt: number;
+	closeObservedAt: number;
+	exitCode: number | null;
+	signal: string | null;
+}
+
+export type ProcessInstanceExitV1 = RunnerProcessInstanceExitV1 | PiWriterProcessInstanceExitV1;
+
+export interface CanonicalSessionTerminalV1 {
+	canonicalSessionId: string;
+	leaseDisposition: "released" | "not-held";
+	freeAtObservation: true;
+	canonicalSessionLeaseReleased?: true;
+}
+
+interface ProcessTerminalBaseV1 {
+	version: 1;
+	runId: string;
+	childIndex?: number;
+	runnerProcessInstanceId: string;
+	resumeDisposition?: "resumable" | "non-resumable" | "unavailable";
+}
+
+export type ProcessTerminalV1 =
+	| (ProcessTerminalBaseV1 & { state: "pending" | "not-started" })
+	| (ProcessTerminalBaseV1 & {
+		state: "observed";
+		observedAt: number;
+		instances: ProcessInstanceExitV1[];
+		canonicalSession?: CanonicalSessionTerminalV1;
+	})
+	| (ProcessTerminalBaseV1 & {
+		state: "unknown";
+		reason: ProcessTerminalReason;
+		diagnostic?: string;
+	});
+
 export type SteeringActionState = "delivered" | "scheduled" | "pending" | "partial" | "recovered" | "failed";
 export type SteeringTargetState = "scheduled" | "routed" | "delivered" | "late" | "failed" | "recovered";
 
@@ -384,6 +445,7 @@ export interface SteeringNotice {
 
 export interface SteeringRecoveryDescriptor {
 	version: 1;
+	launchContractDigest?: string;
 	sourceRunId: string;
 	agentContract?: AgentContract;
 	agent: string;
@@ -415,6 +477,7 @@ export interface SteeringRecoveryDescriptor {
 	initialToolBudget?: ResolvedToolBudget;
 	maxSubagentDepth: number;
 	maxOutput?: MaxOutputConfig;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 	share: boolean;
 	sessionDir?: string;
 	artifactsDir?: string;
@@ -532,7 +595,7 @@ export interface ModelAttempt {
 	usage?: Usage;
 }
 
-export type AcceptanceLevel = "auto" | "none" | "attested" | "checked" | "verified" | "reviewed";
+export type AcceptanceLevel = "auto" | "none" | "attested" | "checked" | "verified";
 
 export type AcceptanceEvidenceKind =
 	| "changed-files"
@@ -641,7 +704,7 @@ export interface AcceptanceVerifyResult {
 }
 
 export interface AcceptanceReviewResult {
-	status: "no-blockers" | "blockers" | "needs-parent-decision";
+	status: "review-required" | "reviewed" | "blockers";
 	findings: Array<{
 		severity: "blocker" | "non-blocking";
 		file?: string;
@@ -650,19 +713,24 @@ export interface AcceptanceReviewResult {
 	}>;
 }
 
-export type AcceptanceLedgerStatus =
+export type AcceptanceEvidenceStatus =
 	| "pending"
 	| "not-required"
 	| "claimed"
 	| "attested"
 	| "checked"
 	| "verified"
-	| "reviewed"
-	| "accepted"
 	| "rejected";
 
+export type AcceptanceLedgerStatus =
+	| AcceptanceEvidenceStatus
+	| "review-required"
+	| "reviewed"
+	| "accepted";
+
 export interface AcceptanceLedger {
 	status: AcceptanceLedgerStatus;
+	evidenceStatus: AcceptanceEvidenceStatus;
 	explicit: boolean;
 	effectiveAcceptance: ResolvedAcceptanceConfig;
 	inferredReason: string[];
@@ -733,6 +801,7 @@ export interface SingleResult {
 	structuredOutputSchemaPath?: string;
 	acceptance?: AcceptanceLedger;
 	agentContract?: AgentContract;
+	launchContractDigest?: string;
 	execution?: ExecutionProjection;
 	review?: ReviewProjection;
 	effects?: EffectsProjection;
@@ -740,6 +809,8 @@ export interface SingleResult {
 	transcriptError?: string;
 	children?: NestedRunSummary[];
 	watchdog?: ChildWatchdogProgress;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 }
 
 export interface SpawnBudgetGrant {
@@ -799,7 +870,13 @@ export interface Details {
 	// Aggregated cost across all agents in the run
 	totalCost?: CostSummary;
 	spawnBudget?: SpawnBudgetSnapshot;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 	parallelHandoff?: ParallelHandoffReference;
+	lifecycleStatus?: {
+		processTerminal?: ProcessTerminalV1;
+	};
+	launchContractDigest?: string;
 }
 
 // ============================================================================
@@ -873,6 +950,9 @@ export interface NestedStepSummary {
 	wrapUpRequested?: boolean;
 	toolBudget?: ToolBudgetState;
 	toolBudgetBlocked?: boolean;
+	processTerminal?: ProcessTerminalV1;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 	children?: NestedRunSummary[];
 }
 
@@ -888,6 +968,9 @@ export interface NestedRunSummary extends NestedRunAddress {
 	controlInbox?: string;
 	capabilityToken?: string;
 	mode?: SubagentRunMode;
+	processTerminal?: ProcessTerminalV1;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 	state: NestedRunState;
 	agent?: string;
 	agents?: string[];
@@ -946,10 +1029,12 @@ export interface AsyncStartedEvent {
 	chainStepCount?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	workflowGraph?: WorkflowGraphSnapshot;
+	launchContractDigest?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
 	turnBudget?: TurnBudgetState;
 	nestedRoute?: NestedRouteInfo;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 }
 
 export interface AsyncStatus {
@@ -987,6 +1072,10 @@ export interface AsyncStatus {
 	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	workflowGraph?: WorkflowGraphSnapshot;
+	processTerminal?: ProcessTerminalV1;
+	launchContractDigest?: string;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 	steps?: Array<{
 		agent: string;
 		/** Resolved launch context for this child step. */
@@ -1035,10 +1124,14 @@ export interface AsyncStatus {
 		structuredOutputSchemaPath?: string;
 		acceptance?: AcceptanceLedger;
 		agentContract?: AgentContract;
+		launchContractDigest?: string;
 		execution?: ExecutionProjection;
 		review?: ReviewProjection;
 		effects?: EffectsProjection;
 		watchdog?: ChildWatchdogProgress;
+		processTerminal?: ProcessTerminalV1;
+		capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+		capabilityAudit?: SubagentCapabilityAudit;
 	}>;
 	sessionDir?: string;
 	outputFile?: string;
@@ -1133,6 +1226,8 @@ export interface ForegroundResumeChild {
 	execution?: ExecutionProjection;
 	review?: ReviewProjection;
 	effects?: EffectsProjection;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	capabilityAudit?: SubagentCapabilityAudit;
 	updatedAt?: number;
 }
 
@@ -1252,6 +1347,7 @@ export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
 export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
 export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
 export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
+export const SUBAGENT_PROCESS_TERMINAL_EVENT = "subagent:process-terminal";
 export const SUBAGENT_FOREGROUND_COMPLETE_EVENT = "subagent:foreground-complete";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
@@ -1299,6 +1395,7 @@ export interface RunSyncOptions {
 	maxSubagentDepth?: number;
 	/** Effective parent wait-tool setting propagated to the child runtime. */
 	waitToolEnabled?: boolean;
+	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 	nestedRoute?: NestedRouteInfo;
 	/** Override the agent's default model (format: "provider/id" or just "id") */
 	modelOverride?: string;

package/src/shared/utils.ts

@@ -412,6 +412,14 @@ export function compactForegroundDetails(details: Details): Details {
 	};
 }
 
+export function hasEmptyTerminalAssistantResponse(messages: Message[]): boolean {
+	const lastAssistant = messages.findLast((message) => message.role === "assistant");
+	return lastAssistant?.role === "assistant"
+		&& Array.isArray(lastAssistant.content)
+		&& lastAssistant.content.length === 0
+		&& lastAssistant.usage.output === 0;
+}
+
 /**
  * Detect errors in subagent execution from messages (only errors with no subsequent success)
  */
@@ -438,50 +446,17 @@ export function detectSubagentError(messages: Message[]): ErrorInfo {
 		const toolName = "toolName" in msg && typeof msg.toolName === "string" ? msg.toolName : undefined;
 		const isError = "isError" in msg && msg.isError === true;
 
-		if (isError) {
-			const text = msg.content.find((c) => c.type === "text");
-			const details = text && "text" in text ? text.text : undefined;
-			const exitMatch = details?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
-			return {
-				hasError: true,
-				exitCode: exitMatch ? parseInt(exitMatch[1], 10) : 1,
-				errorType: toolName || "tool",
-				details: details?.slice(0, 200),
-			};
-		}
-
-		if (toolName !== "bash") continue;
+		if (!isError) continue;
 
 		const text = msg.content.find((c) => c.type === "text");
-		if (!text || !("text" in text)) continue;
-		const output = text.text;
-
-		const exitMatch = output.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
-		if (exitMatch) {
-			const code = parseInt(exitMatch[1], 10);
-			if (code !== 0) {
-				return { hasError: true, exitCode: code, errorType: "bash", details: output.slice(0, 200) };
-			}
-		}
-
-		// NOTE: These patterns can match legitimate output (grep results, logs,
-		// testing). With the assistant-message check above, most false positives
-		// are mitigated since the agent will have responded after routine errors.
-		const fatalPatterns = [
-			/command not found/i,
-			/permission denied/i,
-			/no such file or directory/i,
-			/segmentation fault/i,
-			/killed|terminated/i,
-			/out of memory/i,
-			/connection refused/i,
-			/timeout/i,
-		];
-		for (const pattern of fatalPatterns) {
-			if (pattern.test(output)) {
-				return { hasError: true, exitCode: 1, errorType: "bash", details: output.slice(0, 200) };
-			}
-		}
+		const details = text && "text" in text ? text.text : undefined;
+		const exitMatch = details?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
+		return {
+			hasError: true,
+			exitCode: exitMatch ? parseInt(exitMatch[1], 10) : 1,
+			errorType: toolName || "tool",
+			details: details?.slice(0, 200),
+		};
 	}
 
 	return { hasError: false };

package/src/slash/delegation-adapters.ts

@@ -491,7 +491,7 @@ export function toSubagentDelegationResponse(
 		...(child?.finalOutput ? { output: child.finalOutput } : {}),
 		...(child?.savedOutputPath ? { outputPath: child.savedOutputPath } : {}),
 		...(child?.sessionFile ? { sessionFile: child.sessionFile } : {}),
-		...(child?.acceptance ? { acceptance: { status: child.acceptance.status, explicit: child.acceptance.explicit } } : {}),
+		...(child?.acceptance ? { acceptance: { status: child.acceptance.status, evidenceStatus: child.acceptance.evidenceStatus, explicit: child.acceptance.explicit } } : {}),
 		...(child?.review ? { review: child.review as SubagentDelegationReviewResult } : {}),
 		...(child?.effects ? { effects: child.effects as SubagentDelegationEffectsResult } : {}),
 		...(typeof child?.usage?.turns === "number" ? { turns: child.usage.turns } : {}),

package/src/slash/slash-commands.ts

@@ -1008,7 +1008,7 @@ function validateInlineAcceptanceInput(value: string, agent: string): void {
 	const errors = validateAcceptanceInput(value, `acceptance for step '${agent}'`);
 	if (errors.length > 0) throw new SlashParseError(errors[0]!);
 	if (!INLINE_ACCEPTANCE_LEVELS.has(value)) {
-		throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none or verified acceptance contracts; reviewed is inferred-only.`);
+		throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none, verified, or review requirements; reviewed is an achieved status, not an input level.`);
 	}
 }