@selesai/code 0.5.19 → 0.5.21

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

@@ -0,0 +1,38 @@
+import type { AgentContract, EffectsProjection, ExecutionProjection, ReviewProjection, SingleResult } from "../../shared/types.ts";
+
+export function isAgentContractV1(contract: AgentContract | undefined): boolean {
+	return contract?.version === 1;
+}
+
+export function buildExecutionProjection(result: Pick<SingleResult, "exitCode" | "error" | "interrupted" | "timedOut" | "stopped" | "detached">): ExecutionProjection {
+	if (result.detached) {
+		return { status: "detached", success: false, exitCode: result.exitCode, detached: true, ...(result.error ? { error: result.error } : {}) };
+	}
+	if (result.stopped) {
+		return { status: "stopped", success: false, exitCode: result.exitCode, stopped: true, ...(result.error ? { error: result.error } : {}) };
+	}
+	if (result.interrupted) {
+		return { status: "paused", success: true, exitCode: result.exitCode, interrupted: true, ...(result.error ? { error: result.error } : {}) };
+	}
+	const success = result.exitCode === 0 && !result.error && !result.timedOut;
+	return {
+		status: success ? "completed" : "failed",
+		success,
+		exitCode: result.exitCode,
+		...(result.error ? { error: result.error } : {}),
+		...(result.timedOut ? { timedOut: true } : {}),
+	};
+}
+
+export function buildReviewProjection(result: Pick<SingleResult, "acceptance">): ReviewProjection {
+	const review = result.acceptance?.reviewResult;
+	if (!review) return { status: "not-requested" };
+	return { status: review.status, findings: review.findings };
+}
+
+export function attachContractProjections<T extends SingleResult>(result: T): T {
+	result.execution = buildExecutionProjection(result);
+	result.review = buildReviewProjection(result);
+	if (!result.effects) result.effects = {} satisfies EffectsProjection;
+	return result;
+}

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

@@ -0,0 +1,178 @@
+import { Buffer } from "node:buffer";
+import "../../shared/env.ts";
+
+export const SUBAGENT_CAPABILITY_CEILING_VERSION = 1 as const;
+export const SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "pi-subagents.capability-ceiling.v1";
+export const SUBAGENT_CAPABILITY_CEILING_ENV = "SELESAI_SUBAGENT_CAPABILITY_CEILING_V1";
+
+export type SubagentCapabilityCeiling =
+	| { allowedTools: readonly string[]; denyExtensions?: boolean }
+	| { allowedTools?: readonly string[]; denyExtensions: boolean };
+
+export interface ResolvedSubagentCapabilityCeiling {
+	version: typeof SUBAGENT_CAPABILITY_CEILING_VERSION;
+	allowedTools?: string[];
+	denyExtensions: boolean;
+	sources: string[];
+}
+
+export interface SubagentCapabilityAudit {
+	ceiling: ResolvedSubagentCapabilityCeiling;
+	requestedTools?: string[];
+	effectiveTools: string[];
+	removedTools: string[];
+	internalTools: string[];
+	extensionsDenied: boolean;
+	removedExtensionCount: number;
+	requestedMcpToolCount: number;
+	effectiveMcpTools: string[];
+}
+
+export interface RegisterSubagentCapabilityCeilingOptions {
+	sessionId: string;
+	source: string;
+	ceiling: SubagentCapabilityCeiling;
+}
+
+export interface SubagentCapabilityCeilingHandle {
+	update(ceiling: SubagentCapabilityCeiling): void;
+	dispose(): void;
+}
+
+type Registration = { source: string; ceiling: ResolvedSubagentCapabilityCeiling };
+type Registry = Map<string, Map<symbol, Registration>>;
+
+function registry(): Registry {
+	const key = Symbol.for(SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY);
+	const store = globalThis as typeof globalThis & { [key: symbol]: unknown };
+	const existing = store[key];
+	if (existing instanceof Map) return existing as Registry;
+	const created: Registry = new Map();
+	store[key] = created;
+	return created;
+}
+
+function validateText(value: unknown, field: string): string {
+	if (typeof value !== "string" || !value.trim() || /[\u0000-\u001f\u007f]/u.test(value) || Buffer.byteLength(value.trim(), "utf8") > 256) {
+		throw new Error(`Invalid capability ceiling ${field}; expected a non-empty string without control characters (max 256 UTF-8 bytes).`);
+	}
+	return value.trim();
+}
+
+function normalizeCeiling(ceiling: SubagentCapabilityCeiling): ResolvedSubagentCapabilityCeiling {
+	if (!ceiling || typeof ceiling !== "object" || Array.isArray(ceiling)) throw new Error("Invalid capability ceiling; expected an object.");
+	const hasAllowedTools = Object.hasOwn(ceiling, "allowedTools");
+	const hasDenyExtensions = Object.hasOwn(ceiling, "denyExtensions");
+	if (!hasAllowedTools && !hasDenyExtensions) throw new Error("Invalid capability ceiling; expected allowedTools or denyExtensions.");
+	if (hasDenyExtensions && typeof ceiling.denyExtensions !== "boolean") throw new Error("Invalid capability ceiling denyExtensions; expected a boolean.");
+	let allowedTools: string[] | undefined;
+	if (hasAllowedTools) {
+		if (!Array.isArray(ceiling.allowedTools)) throw new Error("Invalid capability ceiling allowedTools; expected an array.");
+		if (ceiling.allowedTools.length > 256) throw new Error("Invalid capability ceiling allowedTools; expected at most 256 names.");
+		allowedTools = [...new Set(ceiling.allowedTools.map((tool) => {
+			const name = validateText(tool, "allowedTools entry");
+			if (!/^[A-Za-z0-9_.:-]+$/u.test(name)) throw new Error(`Invalid capability ceiling allowedTools entry '${name}'.`);
+			if (Buffer.byteLength(name, "utf8") > 128) throw new Error(`Invalid capability ceiling allowedTools entry '${name}'; max 128 UTF-8 bytes.`);
+			return name;
+		}))].sort();
+	}
+	return {
+		version: SUBAGENT_CAPABILITY_CEILING_VERSION,
+		...(allowedTools ? { allowedTools } : {}),
+		denyExtensions: ceiling.denyExtensions === true,
+		sources: [],
+	};
+}
+
+export function parseSubagentCapabilityCeiling(value: unknown, field = "capability ceiling"): ResolvedSubagentCapabilityCeiling {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid ${field}; expected an object.`);
+	const record = value as Record<string, unknown>;
+	if (record.version !== SUBAGENT_CAPABILITY_CEILING_VERSION) throw new Error(`Invalid ${field} version.`);
+	const normalized = normalizeCeiling(record as SubagentCapabilityCeiling);
+	const sources = record.sources;
+	if (!Array.isArray(sources) || sources.some((source) => typeof source !== "string")) throw new Error(`Invalid ${field} sources; expected an array of strings.`);
+	normalized.sources = [...new Set(sources.map((source) => validateText(source, `${field} source`)))].sort();
+	return normalized;
+}
+
+export function registerSubagentCapabilityCeiling(options: RegisterSubagentCapabilityCeilingOptions): SubagentCapabilityCeilingHandle {
+	const sessionId = validateText(options.sessionId, "sessionId");
+	const source = validateText(options.source, "source");
+	let normalized = normalizeCeiling(options.ceiling);
+	const token = Symbol(source);
+	const store = registry();
+	let session = store.get(sessionId);
+	if (!session) {
+		session = new Map();
+		store.set(sessionId, session);
+	}
+	const setRegistration = () => {
+		normalized = normalizeCeiling(normalized);
+		normalized.sources = [source];
+		session!.set(token, { source, ceiling: normalized });
+	};
+	setRegistration();
+	let disposed = false;
+	return {
+		update(ceiling) {
+			if (disposed) throw new Error("Cannot update a disposed capability ceiling handle.");
+			normalized = normalizeCeiling(ceiling);
+			normalized.sources = [source];
+			session!.set(token, { source, ceiling: normalized });
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			session!.delete(token);
+			if (session!.size === 0) store.delete(sessionId);
+		},
+	};
+}
+
+export function intersectSubagentCapabilityCeilings(...ceilings: Array<ResolvedSubagentCapabilityCeiling | undefined>): ResolvedSubagentCapabilityCeiling | undefined {
+	const active = ceilings.filter((ceiling): ceiling is ResolvedSubagentCapabilityCeiling => ceiling !== undefined);
+	if (active.length === 0) return undefined;
+	const definedLists = active.filter((ceiling) => ceiling.allowedTools !== undefined).map((ceiling) => new Set(ceiling.allowedTools));
+	let allowedTools: string[] | undefined;
+	if (definedLists.length > 0) {
+		allowedTools = [...definedLists[0]!].filter((tool) => definedLists.every((list) => list.has(tool))).sort();
+	}
+	return {
+		version: SUBAGENT_CAPABILITY_CEILING_VERSION,
+		...(allowedTools ? { allowedTools } : {}),
+		denyExtensions: active.some((ceiling) => ceiling.denyExtensions),
+		sources: [...new Set(active.flatMap((ceiling) => ceiling.sources))].sort(),
+	};
+}
+
+export function resolveSubagentCapabilityCeiling(sessionId: string | undefined, inherited?: ResolvedSubagentCapabilityCeiling): ResolvedSubagentCapabilityCeiling | undefined {
+	const active: ResolvedSubagentCapabilityCeiling[] = [];
+	if (sessionId) {
+		const registrations = registry().get(sessionId);
+		if (registrations) active.push(...Array.from(registrations.values(), ({ ceiling }) => ceiling));
+	}
+	return intersectSubagentCapabilityCeilings(inherited, ...active);
+}
+
+export function resolveCurrentSubagentCapabilityCeiling(sessionId: string | undefined): ResolvedSubagentCapabilityCeiling | undefined {
+	return resolveSubagentCapabilityCeiling(sessionId, decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]));
+}
+
+export function encodeSubagentCapabilityCeiling(ceiling: ResolvedSubagentCapabilityCeiling | undefined): string | undefined {
+	if (!ceiling) return undefined;
+	return Buffer.from(JSON.stringify(ceiling), "utf8").toString("base64url");
+}
+
+export function decodeSubagentCapabilityCeiling(value: string | undefined): ResolvedSubagentCapabilityCeiling | undefined {
+	if (value === undefined || value === "") return undefined;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+	} catch (error) {
+		throw new Error(`Invalid inherited capability ceiling: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || (parsed as { version?: unknown }).version !== SUBAGENT_CAPABILITY_CEILING_VERSION) {
+		throw new Error("Invalid inherited capability ceiling version.");
+	}
+	return parseSubagentCapabilityCeiling(parsed, "inherited capability ceiling");
+}

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

@@ -0,0 +1,121 @@
+import { Buffer } from "node:buffer";
+import type { ProtocolOutputLimit } from "../../shared/types.ts";
+
+export type { ProtocolOutputLimit } from "../../shared/types.ts";
+
+export const MAX_CHILD_PENDING_LINE_BYTES = 16 * 1024 * 1024;
+export const MAX_CHILD_STDERR_BYTES = 128 * 1024;
+const MAX_PROTOCOL_DIAGNOSTIC_BYTES = 4096;
+
+export function formatProtocolOutputLimit(limit: ProtocolOutputLimit): string {
+	return `${limit.code}: child ${limit.stream} line exceeded ${limit.limitBytes} bytes (observed at least ${limit.observedBytes} bytes without a newline).`;
+}
+
+export function createBoundedLineReader(options: {
+	stream?: "stdout" | "stderr";
+	maxPendingLineBytes?: number;
+	onLine: (line: string) => void;
+	onLimit: (limit: ProtocolOutputLimit) => void;
+}): {
+	push(chunk: Buffer | string): void;
+	end(): void;
+	exceeded(): boolean;
+} {
+	const maxPendingLineBytes = options.maxPendingLineBytes ?? MAX_CHILD_PENDING_LINE_BYTES;
+	if (!Number.isInteger(maxPendingLineBytes) || maxPendingLineBytes < 1) {
+		throw new Error("maxPendingLineBytes must be a positive integer.");
+	}
+	let pending: Buffer[] = [];
+	let pendingBytes = 0;
+	let limitExceeded = false;
+
+	const emitPending = (): void => {
+		if (pendingBytes === 0) return;
+		options.onLine(Buffer.concat(pending, pendingBytes).toString("utf8"));
+		pending = [];
+		pendingBytes = 0;
+	};
+
+	const append = (segment: Buffer): boolean => {
+		if (segment.length === 0) return true;
+		const observedBytes = pendingBytes + segment.length;
+		if (observedBytes > maxPendingLineBytes) {
+			const prior = pendingBytes > 0 ? Buffer.concat(pending, pendingBytes) : Buffer.alloc(0);
+			const prefixFromPrior = prior.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES);
+			const prefix = prefixFromPrior.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
+				? prefixFromPrior
+				: Buffer.concat([prefixFromPrior, segment.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES - prefixFromPrior.length)]);
+			const tailFromSegment = segment.subarray(Math.max(0, segment.length - MAX_PROTOCOL_DIAGNOSTIC_BYTES));
+			const tail = tailFromSegment.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
+				? tailFromSegment
+				: Buffer.concat([prior.subarray(Math.max(0, prior.length - (MAX_PROTOCOL_DIAGNOSTIC_BYTES - tailFromSegment.length))), tailFromSegment]);
+			limitExceeded = true;
+			pending = [];
+			pendingBytes = 0;
+			options.onLimit({
+				code: "protocol_output_limit",
+				stream: options.stream ?? "stdout",
+				limitBytes: maxPendingLineBytes,
+				observedBytes,
+				diagnosticPrefix: prefix.toString("utf8"),
+				diagnosticTail: tail.toString("utf8"),
+			});
+			return false;
+		}
+		pending.push(segment);
+		pendingBytes = observedBytes;
+		return true;
+	};
+
+	return {
+		push(chunk) {
+			if (limitExceeded) return;
+			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			let start = 0;
+			for (let index = 0; index < bytes.length; index++) {
+				if (bytes[index] !== 0x0a) continue;
+				if (!append(bytes.subarray(start, index))) return;
+				emitPending();
+				start = index + 1;
+			}
+			append(bytes.subarray(start));
+		},
+		end() {
+			if (!limitExceeded) emitPending();
+		},
+		exceeded: () => limitExceeded,
+	};
+}
+
+function trimToUtf8Boundary(buffer: Buffer, maxBytes: number): Buffer {
+	if (buffer.length <= maxBytes) return buffer;
+	let start = buffer.length - maxBytes;
+	while (start < buffer.length && (buffer[start]! & 0xc0) === 0x80) start++;
+	return buffer.subarray(start);
+}
+
+export function createBoundedByteTail(maxBytes = MAX_CHILD_STDERR_BYTES): {
+	push(chunk: Buffer | string): void;
+	text(): string;
+	byteLength(): number;
+} {
+	if (!Number.isInteger(maxBytes) || maxBytes < 1) throw new Error("maxBytes must be a positive integer.");
+	let tail = Buffer.alloc(0);
+	return {
+		push(chunk) {
+			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			tail = trimToUtf8Boundary(Buffer.concat([tail, bytes]), maxBytes);
+		},
+		text: () => tail.toString("utf8"),
+		byteLength: () => tail.length,
+	};
+}
+
+export type ChildLifecycleAction = "start-drain" | "cancel-drain" | "none";
+
+export function projectChildLifecycle(event: { type?: string; willRetry?: unknown }, terminalAssistantStop = false): ChildLifecycleAction {
+	if (event.type === "agent_end" && event.willRetry === true) return "cancel-drain";
+	if (event.type === "agent_settled") return "start-drain";
+	if (terminalAssistantStop) return "start-drain";
+	return "none";
+}

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

@@ -1,58 +1,8 @@
 import type { Message } from "@earendil-works/pi-ai";
-import { isMutatingBashCommand } from "./long-running-guard.ts";
+import { isMutatingTool } from "./long-running-guard.ts";
+import { expectsImplementationMutation } from "./task-intent.ts";
 
-const REVIEW_ONLY_PATTERNS = [
-	/\breview only\b/i,
-	/\bsuggest fixes only\b/i,
-	/\bonly return findings\b/i,
-	/\breturn findings only\b/i,
-];
-
-const REVIEWER_REQUIRED_EDIT_PATTERNS = [
-	/\bmust\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\bregardless\s+of\s+findings\b/i,
-	/\balways\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
-	/\bmake\s+(?:the\s+)?code\s+changes\b/i,
-];
-
-const EXPLICIT_NO_EDIT_PATTERNS = [
-	/\bdo not edit\b/i,
-	/\bdon't edit\b/i,
-	/\bdo not modify\b/i,
-	/\bdo not change files\b/i,
-];
-
-const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
-	/\bdo not edit files?\s+outside\b/i,
-	/\bdo not edit\s+outside\b/i,
-	/\bdo not edit\s+unrelated files?\b/i,
-	/\bdo not change\s+unrelated files?\b/i,
-	/\bdo not modify\s+unrelated files?\b/i,
-];
-
-const RESEARCH_AGENT_PATTERNS = [
-	/\binvestigate\b/i,
-	/\bscout\b/i,
-	/\bresearch(?:er)?\b/i,
-];
-
-const WORKER_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|fix|edit|modify|patch|refactor|delete)\b/i,
-	/\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
-	/\bapply\s+(?:the\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-];
-
-const GENERAL_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|fix|edit|modify|patch|refactor)\b/i,
-	/\bapply\s+(?:the\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-	/\b(?:update|add|remove|replace|delete|create)\s+(?:the\s+)?(?:file|files|code|source|implementation|test|tests|component|function|module|class|method|logic|import|imports|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command)\b/i,
-];
+export { expectsImplementationMutation };
 
 const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"read",
@@ -66,6 +16,12 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"contact_supervisor",
 ]);
 
+// Cursor native edit/write often land as thinking traces (inactive_trace /
+// transcript_trace) rather than toolCall parts when native tool replay is off
+// or the tool is inactive in context. Match pi-cursor-sdk display labels.
+const CURSOR_FILE_MUTATION_THINKING =
+	/(?:^|\n)\s*Cursor (?:edit|write)\s*:/i;
+
 interface CompletionMutationGuardInput {
 	agent: string;
 	task: string;
@@ -80,64 +36,56 @@ interface CompletionMutationGuardResult {
 	triggered: boolean;
 }
 
-function stripFrameworkInstructions(task: string): string {
-	return task
-		.split("\n")
-		.filter((line) => !/^\s*\[(?:Write to|Read from):/i.test(line))
-		.filter((line) => !/^\s*(?:Create and maintain progress at:|Update progress at:|\*\*Output:\*\*|Write your findings to(?: exactly this path)?:|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line))
-		.join("\n");
-}
-
-function stripScopedNoEditConstraints(task: string): string {
-	let stripped = task;
-	for (const pattern of SCOPED_NO_EDIT_CONSTRAINT_PATTERNS) {
-		stripped = stripped.replace(pattern, " ");
-	}
-	return stripped;
-}
-
-function declaresOnlyReadOnlyTools(tools: string[] | undefined, mcpDirectTools: string[] | undefined): boolean {
-	return tools !== undefined
-		&& tools.length > 0
-		&& (mcpDirectTools?.length ?? 0) === 0
-		&& tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
+export function hasMutationToolCapability(tools: string[] | undefined, mcpDirectTools: string[] | undefined): boolean {
+	if ((mcpDirectTools?.length ?? 0) > 0) return true;
+	if (tools === undefined) return true;
+	return !tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
 }
 
-export function expectsImplementationMutation(agent: string, task: string): boolean {
-	const taskText = stripFrameworkInstructions(task);
-	const taskTextWithoutScopedConstraints = stripScopedNoEditConstraints(taskText);
-	if (REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskTextWithoutScopedConstraints))) return false;
-	if (EXPLICIT_NO_EDIT_PATTERNS.some((pattern) => pattern.test(taskTextWithoutScopedConstraints))) return false;
-
-	if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent))) return false;
-	if (/\breviewer\b/i.test(agent)) return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
-
-	const workerIntent = agent === "worker" && WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-	if (workerIntent) return true;
-
-	return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
+function hasCheckpointMutationEvidence(message: Message): boolean {
+	const record = message as unknown as {
+		role?: string;
+		type?: string;
+		customType?: unknown;
+		data?: unknown;
+		details?: unknown;
+	};
+	if ((record.role !== "custom" && record.type !== "custom") || record.customType !== "pi-checkpoint") return false;
+	const details = typeof record.details === "object" && record.details !== null && !Array.isArray(record.details)
+		? record.details as Record<string, unknown>
+		: undefined;
+	const data = typeof record.data === "object" && record.data !== null && !Array.isArray(record.data)
+		? record.data as Record<string, unknown>
+		: typeof details?.beforeCommit === "string" || typeof details?.afterCommit === "string"
+			? details
+			: details?.data && typeof details.data === "object" && !Array.isArray(details.data)
+				? details.data as Record<string, unknown>
+				: undefined;
+	return typeof data?.beforeCommit === "string"
+		&& typeof data.afterCommit === "string"
+		&& data.beforeCommit !== data.afterCommit;
 }
 
 export function hasMutationToolCall(messages: Message[]): boolean {
 	for (const message of messages) {
+		if (hasCheckpointMutationEvidence(message)) return true;
 		if (message.role !== "assistant") continue;
 		for (const part of message.content) {
+			if (part.type === "thinking" && CURSOR_FILE_MUTATION_THINKING.test(part.thinking)) return true;
 			if (part.type !== "toolCall") continue;
-			if (part.name === "edit" || part.name === "write") return true;
-			if (part.name !== "bash") continue;
 			const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments)
 				? part.arguments as Record<string, unknown>
 				: {};
-			if (typeof args.command === "string" && isMutatingBashCommand(args.command)) return true;
+			if (isMutatingTool(part.name, args)) return true;
 		}
 	}
 	return false;
 }
 
 export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
-	const expectedMutation = declaresOnlyReadOnlyTools(input.tools, input.mcpDirectTools)
-		? false
-		: expectsImplementationMutation(input.agent, input.task);
+	const expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools)
+		? expectsImplementationMutation(input.agent, input.task)
+		: false;
 	const attemptedMutation = hasMutationToolCall(input.messages);
 	return {
 		expectedMutation,

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

@@ -0,0 +1,44 @@
+export type ContextMode = "fresh" | "fork";
+export type ContextSummary = ContextMode | "mixed";
+
+export function isContextMode(value: unknown): value is ContextMode {
+	return value === "fresh" || value === "fork";
+}
+
+export function isContextSummary(value: unknown): value is ContextSummary {
+	return isContextMode(value) || value === "mixed";
+}
+
+export function summarizeContextModes(modes: Array<ContextMode | undefined>): ContextSummary | undefined {
+	const resolved = modes.filter(isContextMode);
+	if (resolved.length === 0) return undefined;
+	const first = resolved[0]!;
+	return resolved.every((mode) => mode === first) ? first : "mixed";
+}
+
+export function contextModeLabel(mode: ContextMode | ContextSummary | undefined): string {
+	if (mode === "fork") return "[fork]";
+	if (mode === "fresh") return "[fresh]";
+	if (mode === "mixed") return "[mixed]";
+	return "";
+}
+
+export function contextModeBadge(
+	theme: { fg(name: string, text: string): string },
+	mode: ContextMode | ContextSummary | undefined,
+): string {
+	const label = contextModeLabel(mode);
+	if (!label) return "";
+	if (mode === "fork") return theme.fg("warning", ` ${label}`);
+	return theme.fg("dim", ` ${label}`);
+}
+
+export function contextModePrefix(
+	theme: { fg(name: string, text: string): string },
+	mode: ContextMode | ContextSummary | undefined,
+): string {
+	const label = contextModeLabel(mode);
+	if (!label) return "";
+	if (mode === "fork") return `${theme.fg("warning", label)} `;
+	return `${theme.fg("dim", label)} `;
+}

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

@@ -27,6 +27,7 @@ export interface DynamicCollectedResult {
 	structured?: unknown;
 	error?: string;
 	timedOut?: boolean;
+	stopped?: boolean;
 	outputPath?: string;
 	artifactPaths?: ArtifactPaths;
 }
@@ -41,16 +42,16 @@ const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
 const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
-const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance"]);
-const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "sessionFiles", "thinkingOverrides"]);
+const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance", "agentContract", "gateOn"]);
+const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "sessionFiles", "thinkingOverrides"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "toolBudget", "acceptance"]);
+const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "toolBudget", "acceptance", "agentContract", "gateOn"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
-	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",
-	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "parentSessionId",
+	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "waitToolEnabled",
+	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "capabilityCeiling", "completionGuard", "systemPrompt",
+	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 
@@ -263,7 +264,7 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 export function collectDynamicResults(
 	step: DynamicParallelStep,
 	items: DynamicMaterializedItem[],
-	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "timedOut" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
+	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "timedOut" | "stopped" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
 ): DynamicCollectedResult[] {
 	return items.map((entry, index) => {
 		const result = results[index];
@@ -280,15 +281,16 @@ export function collectDynamicResults(
 			...(result?.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
 			...(result?.error ? { error: result.error } : {}),
 			...(result?.timedOut ? { timedOut: true } : {}),
+			...(result?.stopped ? { stopped: true } : {}),
 			...(result?.savedOutputPath ? { outputPath: result.savedOutputPath } : {}),
 			...(result?.artifactPaths ? { artifactPaths: result.artifactPaths } : {}),
 		};
 	});
 }
 
-export function validateDynamicCollection(schema: JsonSchemaObject | undefined, value: DynamicCollectedResult[]): void {
+export async function validateDynamicCollection(schema: JsonSchemaObject | undefined, value: DynamicCollectedResult[]): Promise<void> {
 	if (!schema) return;
-	const validation = validateStructuredOutputValue(schema, value);
+	const validation = await validateStructuredOutputValue(schema, value);
 	if (validation.status === "invalid") {
 		throw new DynamicFanoutError(`Collected output validation failed: ${validation.message}`);
 	}

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

@@ -103,6 +103,10 @@ export function isMutatingBashCommand(command: string): boolean {
 export function isMutatingTool(toolName: string | undefined, args: Record<string, unknown> | undefined): boolean {
 	if (!toolName) return false;
 	if (toolName === "edit" || toolName === "write") return true;
+	if (toolName === "cursor") {
+		const activityTitle = typeof args?.activityTitle === "string" ? args.activityTitle : "";
+		return /^Cursor (?:edit|write)\b/i.test(activityTitle);
+	}
 	if (toolName !== "bash") return false;
 	const command = typeof args?.command === "string" ? args.command : "";
 	if (!command.trim()) return false;