@selesai/code 0.5.28 → 0.5.29

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

@@ -1,22 +1,24 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import "../../shared/env.ts";
 import { fileURLToPath } from "node:url";
 import { encodeNestedPathEnv, parseNestedPathEnv, type NestedPathEntry } from "./nested-path.ts";
 import { resolveMcpDirectToolSelections, type ResolvedMcpDirectToolSelection } from "./mcp-direct-tool-allowlist.ts";
 import { resolvePiPackageRoot } from "./pi-spawn.ts";
+import { RUNTIME_EXTENSION_ACK_PATH_ENV } from "./runtime-acknowledged-extensions.ts";
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "./structured-output.ts";
-import { TEMP_ROOT_DIR, type JsonSchemaObject, type ResolvedToolBudget } from "../../shared/types.ts";
+import { TEMP_ROOT_DIR, type JsonSchemaObject, type LaunchResolvedChildExtensionsV1, type ResolvedToolBudget } from "../../shared/types.ts";
 import { THINKING_LEVELS } from "../../shared/model-info.ts";
 import { TOOL_BUDGET_ENV, TOOL_BUDGET_ZERO_AUTH_ENV, encodeToolBudgetEnv } from "./tool-budget.ts";
 import { CHILD_TOOL_DIAGNOSTIC_PATH_ENV, MCP_DIRECT_CHILD_TOOLS_ENV, REQUIRED_CHILD_TOOLS_ENV } from "./tool-availability.ts";
 import { CHILD_WATCHDOG_CONFIG_ENV, encodeChildWatchdogConfig, type ChildWatchdogConfig } from "../../watchdog/child-status.ts";
 import { WAIT_TOOL_ENABLED_ENV } from "../background/wait-config.ts";
 import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.ts";
-import { SUBAGENT_CAPABILITY_CEILING_ENV, decodeSubagentCapabilityCeiling, encodeSubagentCapabilityCeiling, intersectSubagentCapabilityCeilings, type ResolvedSubagentCapabilityCeiling, type SubagentCapabilityAudit } from "./capability-ceiling.ts";
+import { SUBAGENT_CAPABILITY_CEILING_ENV, capabilityCeilingAgentRestrictionSources, decodeSubagentCapabilityCeiling, encodeSubagentCapabilityCeiling, intersectSubagentCapabilityCeilings, isAgentAllowedByCapabilityCeiling, type ResolvedSubagentCapabilityCeiling, type SubagentCapabilityAudit } from "./capability-ceiling.ts";
 
 const TASK_ARG_LIMIT = 8000;
+const MAX_LAUNCH_RESOLVED_EXTENSION_IDS = 32;
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
 const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", "fanout-child.ts");
 export const SUBAGENT_CHILD_ENV = "SELESAI_SUBAGENT_CHILD";
@@ -39,6 +41,8 @@ export const SUBAGENT_PARENT_SESSION_ENV = "SELESAI_SUBAGENT_PARENT_SESSION";
 export const SUBAGENT_STEER_INBOX_ENV = "SELESAI_SUBAGENT_STEER_INBOX";
 export const SUBAGENT_STEER_CAPABILITY_ENV = "SELESAI_SUBAGENT_STEER_CAPABILITY";
 export const SUBAGENT_STEER_ACK_DIR_ENV = "SELESAI_SUBAGENT_STEER_ACK_DIR";
+export const PI_INTERCOM_STABLE_ID_ENV = "PI_INTERCOM_STABLE_ID";
+export const PI_INTERCOM_SESSION_ID_ENV = "PI_INTERCOM_SESSION_ID";
 
 export interface BuildPiArgsInput {
 	parentSessionId?: string;
@@ -93,6 +97,7 @@ export interface BuildPiArgsResult {
 	env: Record<string, string | undefined>;
 	tempDir?: string;
 	toolDiagnosticPath?: string;
+	runtimeAcknowledgedExtensionsPath?: string;
 	capabilityAudit?: SubagentCapabilityAudit;
 }
 
@@ -123,6 +128,7 @@ export interface ResolvePiLaunchToolPlanInput {
 	structuredOutput?: boolean;
 	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 	inheritedCapabilityCeiling?: ResolvedSubagentCapabilityCeiling;
+	agentName?: string;
 }
 
 export interface PiLaunchToolPlan {
@@ -145,6 +151,37 @@ export interface PiLaunchToolPlan {
 	capabilityAudit?: SubagentCapabilityAudit;
 }
 
+function extensionIdentifier(value: string): string {
+	return `sha256:${createHash("sha256").update(path.normalize(value.trim())).digest("hex").slice(0, 16)}`;
+}
+
+function boundedExtensionIdentifiers(values: string[]): { ids: string[]; omitted: number } {
+	const ids = [...new Set(values.map(extensionIdentifier))];
+	return {
+		ids: ids.slice(0, MAX_LAUNCH_RESOLVED_EXTENSION_IDS),
+		omitted: Math.max(0, ids.length - MAX_LAUNCH_RESOLVED_EXTENSION_IDS),
+	};
+}
+
+export function projectLaunchResolvedChildExtensions(toolPlan: Pick<PiLaunchToolPlan, "runtimeExtensions" | "configuredExtensions" | "extensionArgs" | "disableAmbientExtensions">): LaunchResolvedChildExtensionsV1 {
+	const runtime = boundedExtensionIdentifiers(toolPlan.runtimeExtensions);
+	const configured = boundedExtensionIdentifiers(toolPlan.configuredExtensions);
+	const effective = boundedExtensionIdentifiers(toolPlan.extensionArgs);
+	return {
+		version: 1,
+		source: "launch-resolved",
+		disableAmbientExtensions: toolPlan.disableAmbientExtensions,
+		runtime: runtime.ids,
+		configured: configured.ids,
+		effective: effective.ids,
+		omitted: {
+			runtime: runtime.omitted,
+			configured: configured.omitted,
+			effective: effective.omitted,
+		},
+	};
+}
+
 export function resolvePiLaunchToolPlan(input: ResolvePiLaunchToolPlanInput): PiLaunchToolPlan {
 	const capabilityCeiling = intersectSubagentCapabilityCeilings(input.capabilityCeiling, input.inheritedCapabilityCeiling);
 	const allowedToolSet = capabilityCeiling?.allowedTools === undefined ? undefined : new Set(capabilityCeiling.allowedTools);
@@ -191,6 +228,8 @@ export function resolvePiLaunchToolPlan(input: ResolvePiLaunchToolPlanInput): Pi
 		removedExtensionCount: capabilityCeiling.denyExtensions ? (input.extensions?.length ?? 0) + (input.subagentOnlyExtensions?.length ?? 0) + ((input.tools ?? []).filter((tool) => tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")).length) : 0,
 		requestedMcpToolCount: input.mcpDirectTools?.length ?? 0,
 		effectiveMcpTools,
+		agentAllowed: input.agentName === undefined ? true : isAgentAllowedByCapabilityCeiling(input.agentName, capabilityCeiling),
+		...(capabilityCeilingAgentRestrictionSources(capabilityCeiling) ? { agentRestrictionSources: capabilityCeilingAgentRestrictionSources(capabilityCeiling) } : {}),
 	} satisfies SubagentCapabilityAudit : undefined;
 	return {
 		...(capabilityCeiling ? { capabilityCeiling } : {}),
@@ -244,6 +283,7 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		structuredOutput: input.structuredOutput,
 		capabilityCeiling: input.capabilityCeiling,
 		inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+		agentName: input.childAgentName,
 	});
 	if (toolPlan.explicitToolAllowlist) {
 		args.push(toolPlan.effectiveToolAllowlist.length > 0 ? "--tools" : "--no-tools");
@@ -254,6 +294,9 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	}
 	for (const extPath of toolPlan.extensionArgs) args.push("--extension", extPath);
 
+	if (!input.inheritProjectContext) {
+		args.push("--no-context-files");
+	}
 	if (!input.inheritSkills) {
 		args.push("--no-skills");
 	}
@@ -281,6 +324,9 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	const env: Record<string, string | undefined> = {};
 	const piPackageRoot = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] ?? resolvePiPackageRoot();
 	if (piPackageRoot) env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = piPackageRoot;
+	if (!tempDir) tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+	const runtimeAcknowledgedExtensionsPath = path.join(tempDir, "runtime-acknowledged-extensions.json");
+	env[RUNTIME_EXTENSION_ACK_PATH_ENV] = runtimeAcknowledgedExtensionsPath;
 	let toolDiagnosticPath: string | undefined;
 	if (toolPlan.requiredChildTools.length > 0) {
 		if (!tempDir) tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
@@ -329,6 +375,8 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		: "";
 	env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
 	env.SELESAI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
+	env[PI_INTERCOM_STABLE_ID_ENV] = input.intercomSessionName || undefined;
+	env[PI_INTERCOM_SESSION_ID_ENV] = undefined;
 	if (input.intercomSessionName) {
 		env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
 	}
@@ -376,7 +424,7 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 
 	env[SUBAGENT_PARENT_SESSION_ENV] = input.parentSessionId ?? process.env[SUBAGENT_PARENT_SESSION_ENV] ?? "";
 
-	return { args, env, tempDir, toolDiagnosticPath, capabilityAudit: toolPlan.capabilityAudit };
+	return { args, env, tempDir, toolDiagnosticPath, runtimeAcknowledgedExtensionsPath, capabilityAudit: toolPlan.capabilityAudit };
 }
 
 export const parseParentPathEnv = parseNestedPathEnv;

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

@@ -0,0 +1,19 @@
+export function formatProcessSignalError(signal: string): string {
+	return `Subagent process terminated by signal ${signal}.`;
+}
+
+export function isUnexplainedProcessSignal(input: {
+	processSignal?: string | null;
+	interrupted?: boolean;
+	timedOut?: boolean;
+	stopped?: boolean;
+	turnBudgetExceeded?: boolean;
+	forcedDrainAfterFinalSuccess?: boolean;
+}): boolean {
+	return Boolean(input.processSignal)
+		&& input.interrupted !== true
+		&& input.timedOut !== true
+		&& input.stopped !== true
+		&& input.turnBudgetExceeded !== true
+		&& input.forcedDrainAfterFinalSuccess !== true;
+}

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

@@ -18,6 +18,7 @@ const ROTATE_KEEP = 1000;
 const PRIVATE_DIR_MODE = 0o700;
 const PRIVATE_FILE_MODE = 0o600;
 const REDACTED_TASK = "[redacted]";
+const historyFileStates = new Map<string, { mtimeMs: number; ctimeMs: number; size: number; ino: number; lineCount: number }>();
 
 function getHistoryPath(): string {
 	return path.join(getAgentDir(), "run-history.jsonl");
@@ -30,8 +31,12 @@ function hashTask(task: string): string {
 function hardenHistoryStorage(historyPath: string): void {
 	const historyDir = path.dirname(historyPath);
 	fs.mkdirSync(historyDir, { recursive: true, mode: PRIVATE_DIR_MODE });
-	try { fs.chmodSync(historyDir, PRIVATE_DIR_MODE); } catch {}
-	try { if (fs.existsSync(historyPath)) fs.chmodSync(historyPath, PRIVATE_FILE_MODE); } catch {}
+	try {
+		if ((fs.statSync(historyDir).mode & 0o777) !== PRIVATE_DIR_MODE) fs.chmodSync(historyDir, PRIVATE_DIR_MODE);
+	} catch {}
+	try {
+		if ((fs.statSync(historyPath).mode & 0o777) !== PRIVATE_FILE_MODE) fs.chmodSync(historyPath, PRIVATE_FILE_MODE);
+	} catch {}
 }
 
 function sanitizeHistoryLine(line: string): string | undefined {
@@ -80,11 +85,39 @@ function writePrivateHistory(historyPath: string, lines: string[]): void {
 	try { fs.chmodSync(historyPath, PRIVATE_FILE_MODE); } catch {}
 }
 
-function sanitizeHistoryFile(historyPath: string): void {
-	if (!fs.existsSync(historyPath)) return;
+function rememberHistoryFile(historyPath: string, lineCount: number): void {
+	const stat = fs.statSync(historyPath);
+	historyFileStates.set(historyPath, {
+		mtimeMs: stat.mtimeMs,
+		ctimeMs: stat.ctimeMs,
+		size: stat.size,
+		ino: stat.ino,
+		lineCount,
+	});
+	if (historyFileStates.size > 8) historyFileStates.delete(historyFileStates.keys().next().value!);
+}
+
+function sanitizeHistoryFile(historyPath: string): number {
+	let stat: fs.Stats;
+	try {
+		stat = fs.statSync(historyPath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return 0;
+		throw error;
+	}
+	const cached = historyFileStates.get(historyPath);
+	if (cached
+		&& cached.mtimeMs === stat.mtimeMs
+		&& cached.ctimeMs === stat.ctimeMs
+		&& cached.size === stat.size
+		&& cached.ino === stat.ino) {
+		return cached.lineCount;
+	}
 	const raw = fs.readFileSync(historyPath, "utf-8");
 	const { lines, changed } = sanitizeHistoryLines(raw);
 	if (changed) writePrivateHistory(historyPath, lines);
+	rememberHistoryFile(historyPath, lines.length);
+	return lines.length;
 }
 
 function appendPrivateHistoryLine(historyPath: string, line: string): void {
@@ -94,7 +127,6 @@ function appendPrivateHistoryLine(historyPath: string, line: string): void {
 	} finally {
 		fs.closeSync(fd);
 	}
-	try { fs.chmodSync(historyPath, PRIVATE_FILE_MODE); } catch {}
 }
 
 export function recordRun(agent: string, task: string, exitCode: number, durationMs: number): void {
@@ -110,8 +142,11 @@ export function recordRun(agent: string, task: string, exitCode: number, duratio
 		};
 		const historyPath = getHistoryPath();
 		hardenHistoryStorage(historyPath);
-		try { sanitizeHistoryFile(historyPath); } catch {}
+		let lineCount: number | undefined;
+		try { lineCount = sanitizeHistoryFile(historyPath); } catch {}
 		appendPrivateHistoryLine(historyPath, JSON.stringify(entry));
+		if (lineCount === undefined) historyFileStates.delete(historyPath);
+		else rememberHistoryFile(historyPath, lineCount + 1);
 	} catch {
 		// Best-effort — never crash the execution flow for history recording
 	}
@@ -134,9 +169,10 @@ export function loadRunsForAgent(agent: string): RunEntry[] {
 		lines = lines.slice(-ROTATE_KEEP);
 		changed = true;
 	}
-	if (changed) {
-		try { writePrivateHistory(historyPath, lines); } catch {}
-	}
+	try {
+		if (changed) writePrivateHistory(historyPath, lines);
+		rememberHistoryFile(historyPath, lines.length);
+	} catch {}
 
 	return lines
 		.map((line) => { try { return JSON.parse(line) as RunEntry; } catch { return undefined; } })

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

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RuntimeAcknowledgedChildExtensionsV1 } from "../../shared/types.ts";
+
+export const RUNTIME_EXTENSION_ACK_EVENT = "subagent:acknowledge-extension";
+export const RUNTIME_EXTENSION_ACK_PATH_ENV = "SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS";
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS = 32;
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH = 128;
+// Generous bound for a valid capture (32 ids x 128 chars plus envelope); larger files are child misbehavior.
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES = 64 * 1024;
+
+export function isRuntimeAcknowledgedExtensionId(value: unknown): value is string {
+	return typeof value === "string"
+		&& value.length > 0
+		&& value.length <= MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH
+		&& /^[A-Za-z0-9._:@+-]+$/.test(value)
+		&& !value.includes("..")
+		&& !value.includes("/")
+		&& !value.includes("\\");
+}
+
+export function projectRuntimeAcknowledgedExtensions(ids: Iterable<unknown>): RuntimeAcknowledgedChildExtensionsV1 | undefined {
+	const unique: string[] = [];
+	const seen = new Set<string>();
+	for (const id of ids) {
+		if (!isRuntimeAcknowledgedExtensionId(id) || seen.has(id)) continue;
+		seen.add(id);
+		unique.push(id);
+	}
+	if (unique.length === 0) return undefined;
+	return {
+		version: 1,
+		source: "child-runtime",
+		ids: unique.slice(0, MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
+		omitted: Math.max(0, unique.length - MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
+	};
+}
+
+export function sanitizeRuntimeAcknowledgedExtensions(value: unknown): RuntimeAcknowledgedChildExtensionsV1 | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (raw.version !== 1 || raw.source !== "child-runtime" || !Array.isArray(raw.ids)) return undefined;
+	const projected = projectRuntimeAcknowledgedExtensions(raw.ids);
+	if (!projected) return undefined;
+	const omitted = typeof raw.omitted === "number" && Number.isFinite(raw.omitted)
+		? Math.max(0, Math.floor(raw.omitted))
+		: 0;
+	return { ...projected, omitted: projected.omitted + omitted };
+}
+
+export function readRuntimeAcknowledgedExtensions(filePath: string | undefined): RuntimeAcknowledgedChildExtensionsV1 | undefined {
+	if (!filePath) return undefined;
+	try {
+		if (fs.statSync(filePath).size > MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES) return undefined;
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
+		return sanitizeRuntimeAcknowledgedExtensions(parsed);
+	} catch {
+		return undefined;
+	}
+}
+
+export function writeRuntimeAcknowledgedExtensions(filePath: string, ids: Iterable<unknown>): void {
+	const projection = projectRuntimeAcknowledgedExtensions(ids);
+	try {
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		if (projection) fs.writeFileSync(filePath, JSON.stringify(projection), { mode: 0o600 });
+		else fs.rmSync(filePath, { force: true });
+	} catch {
+		// Runtime acknowledgement is best-effort observability only.
+	}
+}

package/dist/extensions/pi-subagents/src/runs/shared/subagent-prompt-runtime.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI } from "@selesai/code";
 import { registerNativeSupervisorClient } from "../../intercom/native-supervisor-channel.ts";
 import { consumeSteerRequestsFromDir, steerAckPathFromDir, writeSteerAckAt, writeSteerCapabilityAt, writeSteerRequestToDir, type SteerRequest } from "../background/control-channel.ts";
 import { SUBAGENT_CHILD_AGENT_ENV, SUBAGENT_CHILD_INDEX_ENV, SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_STEER_ACK_DIR_ENV, SUBAGENT_STEER_CAPABILITY_ENV, SUBAGENT_STEER_INBOX_ENV } from "./pi-args.ts";
+import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV, isRuntimeAcknowledgedExtensionId, writeRuntimeAcknowledgedExtensions } from "./runtime-acknowledged-extensions.ts";
 import { createStructuredOutputToolParameters, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
 import {
 	CHILD_TOOL_DIAGNOSTIC_PATH_ENV,
@@ -34,7 +35,7 @@ const STRUCTURED_OUTPUT_INSTRUCTIONS = [
 
 export const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
 	"You are a child subagent, not the parent orchestrator.",
-	"The parent session owns delegation, orchestration, review fanout, and follow-up worker launches.",
+	"The parent session owns delegation, orchestration, review fanout, and follow-up builder launches.",
 	"Ignore prior parent-only orchestration instructions in inherited conversation history.",
 	"Do not propose or run subagents. Complete only your assigned role-specific task with the tools available to you.",
 	"If you need to edit files, use the available editing tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
@@ -99,6 +100,34 @@ function refreshChildToolDiagnostic(pi: ExtensionAPI): ChildToolDiagnostic | und
 	return writeChildToolDiagnostic(filePath, required, available, process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim(), readMcpDirectChildTools());
 }
 
+function registerRuntimeExtensionAcknowledgements(pi: ExtensionAPI): void {
+	const outputPath = process.env[RUNTIME_EXTENSION_ACK_PATH_ENV]?.trim();
+	if (!outputPath) return;
+	const ids: string[] = [];
+	let finalized = false;
+	const acknowledge = (payload: unknown): undefined => {
+		if (finalized || !payload || typeof payload !== "object") return undefined;
+		const id = (payload as { id?: unknown }).id;
+		if (isRuntimeAcknowledgedExtensionId(id)) ids.push(id);
+		return undefined;
+	};
+	const finalize = (): undefined => {
+		if (finalized) return undefined;
+		finalized = true;
+		writeRuntimeAcknowledgedExtensions(outputPath, ids);
+		return undefined;
+	};
+	try {
+		const events = (pi as { events?: { on?: (event: string, handler: (payload: unknown) => unknown) => unknown } }).events;
+		events?.on?.(RUNTIME_EXTENSION_ACK_EVENT, acknowledge);
+		const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event?: unknown, ctx?: unknown) => unknown) => void;
+		onRuntimeEvent("agent_end", finalize);
+		onRuntimeEvent("session_shutdown", finalize);
+	} catch {
+		// Acknowledgement collection is optional observability and must not affect child execution.
+	}
+}
+
 function findSectionEnd(prompt: string, startIndex: number, nextHeaders: string[]): number {
 	let endIndex = prompt.length;
 	for (const header of nextHeaders) {
@@ -346,6 +375,7 @@ export function registerSteeringInbox(
 }
 
 export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
+	registerRuntimeExtensionAcknowledgements(pi);
 	registerSteeringInbox(pi);
 	registerToolBudget(pi, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV], { allowZero: process.env[TOOL_BUDGET_ZERO_AUTH_ENV] === "1" }));
 	registerChildWatchdog(pi);

package/dist/extensions/pi-subagents/src/runs/shared/subagent-startup-retry.ts

@@ -0,0 +1,101 @@
+import type { Usage } from "../../shared/types.ts";
+
+/**
+ * Retry delays for child processes that exit before any model or tool activity.
+ * The schedule is intentionally short and bounded to avoid amplifying persistent
+ * launch failures while allowing concurrent Pi startup locks to clear.
+ */
+export const SUBAGENT_STARTUP_RETRY_DELAYS_MS = [250, 750, 1500] as const;
+
+/** A genuine startup race should fail well before a model request can complete. */
+export const MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS = 2000;
+
+export interface SubagentStartupFailureEvidence {
+	exitCode: number | null | undefined;
+	error?: string;
+	finalOutput?: string;
+	messageCount: number;
+	toolCount: number;
+	usage: Usage;
+	durationMs: number;
+	protocolError?: unknown;
+	processSignal?: string | null;
+	observedMutationAttempt?: boolean;
+	detached?: boolean;
+	interrupted?: boolean;
+	timedOut?: boolean;
+	stopped?: boolean;
+	turnBudgetExceeded?: boolean;
+}
+
+function hasUsage(usage: Usage): boolean {
+	return usage.input !== 0
+		|| usage.output !== 0
+		|| usage.cacheRead !== 0
+		|| usage.cacheWrite !== 0
+		|| usage.cost !== 0
+		|| usage.turns !== 0;
+}
+
+/**
+ * Classify only unexplained, zero-activity child exits as startup failures.
+ * This intentionally fails closed: any model output, tool activity, usage,
+ * mutation evidence, diagnostic, or lifecycle interruption prevents a retry.
+ */
+export function isRetryableSubagentStartupFailure(evidence: SubagentStartupFailureEvidence): boolean {
+	return evidence.exitCode !== undefined
+		&& evidence.exitCode !== null
+		&& evidence.exitCode !== 0
+		&& !evidence.error?.trim()
+		&& !evidence.finalOutput?.trim()
+		&& evidence.messageCount === 0
+		&& evidence.toolCount === 0
+		&& !hasUsage(evidence.usage)
+		&& evidence.durationMs >= 0
+		&& evidence.durationMs <= MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS
+		&& evidence.protocolError === undefined
+		&& (evidence.processSignal === undefined || evidence.processSignal === null)
+		&& evidence.observedMutationAttempt !== true
+		&& evidence.detached !== true
+		&& evidence.interrupted !== true
+		&& evidence.timedOut !== true
+		&& evidence.stopped !== true
+		&& evidence.turnBudgetExceeded !== true;
+}
+
+export function formatSubagentStartupRetryNote(input: {
+	model: string;
+	attempt: number;
+	maxAttempts: number;
+	delayMs: number;
+}): string {
+	return `[startup-retry] ${input.model} exited before model or tool activity (attempt ${input.attempt}/${input.maxAttempts}). Retrying the same model in ${input.delayMs}ms.`;
+}
+
+export function formatSubagentStartupRetryExhaustedError(input: {
+	model: string;
+	attempts: number;
+}): string {
+	return `Subagent failed to start after ${input.attempts} attempts on ${input.model}; no model, tool, output, usage, or diagnostic activity was observed. This may be a concurrent Pi startup race. Retry the run or temporarily lower subagent concurrency.`;
+}
+
+/** Wait for a retry delay, returning false when any lifecycle signal aborts it. */
+export async function waitForSubagentStartupRetry(delayMs: number, signals: Array<AbortSignal | undefined>): Promise<boolean> {
+	const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+	if (activeSignals.some((signal) => signal.aborted)) return false;
+	if (delayMs <= 0) return true;
+
+	return await new Promise<boolean>((resolve) => {
+		let settled = false;
+		const finish = (shouldRetry: boolean): void => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			for (const signal of activeSignals) signal.removeEventListener("abort", abort);
+			resolve(shouldRetry);
+		};
+		const abort = (): void => finish(false);
+		const timer = setTimeout(() => finish(true), delayMs);
+		for (const signal of activeSignals) signal.addEventListener("abort", abort, { once: true });
+	});
+}

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

@@ -40,7 +40,7 @@ const REVIEWER_REQUIRED_EDIT_PATTERNS = [
 const NO_EDIT_PROHIBITION_PATTERN = /\b(?:do not|don't|must not)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b((?:(?!\b(?:but|and|then)\b)[^.;,:!?\n–—-])*)/gi;
 
 /** Objects of a no-edit prohibition that mean "the codebase in general" rather than a named scope. */
-const GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|source|sources|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i;
+const GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|product|source|sources|config|configs|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i;
 
 const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
 	/\bdo not edit files?\s+outside\b/i,

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

@@ -0,0 +1,65 @@
+import type { CostSummary, UsageBudgetConfig, UsageBudgetLimitConfig, UsageBudgetState } from "../../shared/types.ts";
+
+function validateLimit(value: unknown, label: string): { limit?: UsageBudgetLimitConfig; error?: string } {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
+	const raw = value as Record<string, unknown>;
+	const unknown = Object.keys(raw).find((key) => key !== "soft" && key !== "hard");
+	if (unknown) return { error: `${label}.${unknown} is not supported.` };
+	if (typeof raw.hard !== "number" || !Number.isFinite(raw.hard) || raw.hard <= 0) return { error: `${label}.hard must be a positive number.` };
+	if (raw.soft !== undefined && (typeof raw.soft !== "number" || !Number.isFinite(raw.soft) || raw.soft <= 0)) return { error: `${label}.soft must be a positive number.` };
+	if (typeof raw.soft === "number" && raw.soft > raw.hard) return { error: `${label}.soft must be less than or equal to ${label}.hard.` };
+	return { limit: { ...(typeof raw.soft === "number" ? { soft: raw.soft } : {}), hard: raw.hard } };
+}
+
+export function validateUsageBudgetConfig(value: unknown, label = "usageBudget"): { budget?: UsageBudgetConfig; error?: string } {
+	if (value === undefined) return {};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
+	const raw = value as Record<string, unknown>;
+	const unknown = Object.keys(raw).find((key) => key !== "tokens" && key !== "costUsd");
+	if (unknown) return { error: `${label}.${unknown} is not supported.` };
+	const budget: UsageBudgetConfig = {};
+	if (raw.tokens !== undefined) {
+		const tokens = validateLimit(raw.tokens, `${label}.tokens`);
+		if (tokens.error) return { error: tokens.error };
+		budget.tokens = tokens.limit;
+	}
+	if (raw.costUsd !== undefined) {
+		const costUsd = validateLimit(raw.costUsd, `${label}.costUsd`);
+		if (costUsd.error) return { error: costUsd.error };
+		budget.costUsd = costUsd.limit;
+	}
+	if (!budget.tokens && !budget.costUsd) return { error: `${label} must include tokens or costUsd.` };
+	return { budget };
+}
+
+function metricState(limit: UsageBudgetLimitConfig | undefined, used: number): UsageBudgetState["tokens"] {
+	if (!limit) return undefined;
+	return {
+		...limit,
+		used,
+		outcome: used >= limit.hard ? "hard-exceeded" : limit.soft !== undefined && used >= limit.soft ? "soft-exceeded" : "within-budget",
+	};
+}
+
+export function usageBudgetState(config: UsageBudgetConfig | undefined, totals: CostSummary | undefined): UsageBudgetState | undefined {
+	if (!config) return undefined;
+	const inputTokens = totals?.inputTokens ?? 0;
+	const outputTokens = totals?.outputTokens ?? 0;
+	const tokens = metricState(config.tokens, inputTokens + outputTokens);
+	const costUsd = metricState(config.costUsd, totals?.costUsd ?? 0);
+	const reason = tokens?.outcome === "hard-exceeded" ? "tokens" : costUsd?.outcome === "hard-exceeded" ? "costUsd" : undefined;
+	return {
+		version: 1,
+		source: "reported",
+		...(tokens ? { tokens } : {}),
+		...(costUsd ? { costUsd } : {}),
+		exhausted: reason !== undefined,
+		...(reason ? { reason } : {}),
+	};
+}
+
+export function usageBudgetExceededMessage(state: UsageBudgetState): string {
+	if (state.reason === "tokens" && state.tokens) return `Usage budget exhausted: reported tokens ${state.tokens.used} reached hard limit ${state.tokens.hard}.`;
+	if (state.reason === "costUsd" && state.costUsd) return `Usage budget exhausted: reported cost $${state.costUsd.used.toFixed(6)} reached hard limit $${state.costUsd.hard.toFixed(6)}.`;
+	return "Usage budget exhausted.";
+}

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

@@ -1,4 +1,4 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { isCheckpointStep, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { SingleResult, SubagentRunMode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../shared/types.ts";
 
 export interface WorkflowGraphBuildInput {
@@ -26,6 +26,8 @@ function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undef
 			return "paused";
 		case "detached":
 			return "detached";
+		case "rejected":
+			return "rejected";
 		case "pending":
 			return "pending";
 		default:
@@ -62,6 +64,7 @@ function seqLabel(step: SequentialStep, stepIndex: number): string {
 
 function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
 	if (statuses.some((status) => status === "running")) return "running";
+	if (statuses.some((status) => status === "rejected")) return "rejected";
 	if (statuses.some((status) => status === "failed")) return "failed";
 	if (statuses.some((status) => status === "paused")) return "paused";
 	if (statuses.some((status) => status === "detached")) return "detached";
@@ -78,6 +81,28 @@ export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): Work
 
 	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
 		const step = input.steps[stepIndex]!;
+		if (isCheckpointStep(step)) {
+			const status = normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
+				?? (input.currentStepIndex === stepIndex ? "paused" : "pending");
+			const checkpoint = { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: status === "rejected" ? "rejected" as const : status === "completed" ? "approved" as const : "pending" as const, stepIndex };
+			const id = `step-${stepIndex}`;
+			nodes.push({
+				id,
+				kind: "checkpoint",
+				phase: step.phase,
+				label: step.label?.trim() || step.checkpoint,
+				status,
+				flatIndex,
+				stepIndex,
+				checkpoint,
+				error: input.stepStatuses?.[flatIndex]?.error,
+			});
+			pushPhase(phases, step.phase, id);
+			if (status === "paused" || input.currentStepIndex === stepIndex) currentNodeId = id;
+			flatIndex++;
+			continue;
+		}
+
 		if (isParallelStep(step)) {
 			const groupId = `step-${stepIndex}`;
 			const children: WorkflowGraphNode[] = [];