@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/src/shared/atomic-json.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
 
 type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
 
@@ -8,39 +9,13 @@ type AtomicJsonWriterOptions = {
 	now?: () => number;
 	pid?: number;
 	random?: () => number;
+	mode?: number;
 	retryRenameErrors?: boolean;
+	retryDirectoryErrors?: boolean;
 	retryDelaysMs?: readonly number[];
 	wait?: (delayMs: number) => void;
 };
 
-const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
-const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
-const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
-const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
-
-function waitSync(delayMs: number): void {
-	if (delayMs <= 0) return;
-	if (WAIT_VIEW) {
-		try {
-			// writeAtomicJson is synchronous because callers often update status from sync callbacks.
-			// Atomics.wait gives Windows rename locks time to clear without burning CPU.
-			Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
-			return;
-		} catch {
-			// Fall through to the portable busy wait below.
-		}
-	}
-	const end = Date.now() + delayMs;
-	while (Date.now() < end) {
-		// Portable fallback for runtimes where Atomics.wait is unavailable.
-	}
-}
-
-function isRetryableRenameError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return typeof code === "string" && RETRYABLE_RENAME_ERROR_CODES.has(code);
-}
-
 function renameWithRetry(
 	fsImpl: AtomicJsonFs,
 	sourcePath: string,
@@ -48,16 +23,9 @@ function renameWithRetry(
 	retryDelaysMs: readonly number[],
 	wait: (delayMs: number) => void,
 ): void {
-	for (let attempt = 0; ; attempt++) {
-		try {
-			fsImpl.renameSync(sourcePath, targetPath);
-			return;
-		} catch (error) {
-			const delayMs = retryDelaysMs[attempt];
-			if (delayMs === undefined || !isRetryableRenameError(error)) throw error;
-			wait(delayMs);
-		}
-	}
+	runFileSystemOperationWithRetry(() => {
+		fsImpl.renameSync(sourcePath, targetPath);
+	}, { retryDelaysMs, wait });
 }
 
 export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
@@ -65,18 +33,24 @@ export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (
 	const now = options.now ?? Date.now;
 	const pid = options.pid ?? process.pid;
 	const random = options.random ?? Math.random;
+	const mode = options.mode;
 	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
-	const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
-	const wait = options.wait ?? waitSync;
+	const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
+	const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
+	const wait = options.wait ?? waitForFileSystemRetry;
 	return (filePath: string, payload: object): void => {
-		fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		}, { retryDelaysMs: directoryRetryDelaysMs, wait });
 		const tempPath = path.join(
 			path.dirname(filePath),
 			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
 		);
 		try {
-			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-			renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
+			renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
 		} finally {
 			fsImpl.rmSync(tempPath, { force: true });
 		}
@@ -84,3 +58,4 @@ export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (
 }
 
 export const writeAtomicJson = createAtomicJsonWriter();
+export const writePrivateAtomicJson = createAtomicJsonWriter({ mode: 0o600 });

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

@@ -3,6 +3,30 @@ import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
 import { extractTextFromContent, extractToolArgsPreview } from "./utils.ts";
 
+const MAX_TOOL_PAYLOAD_BYTES = 32 * 1024;
+const TOOL_PAYLOAD_TRUNCATION_MARKER = "\n\n… payload truncated";
+
+function boundedPayload(value: unknown, maxBytes = MAX_TOOL_PAYLOAD_BYTES): string | undefined {
+	let text: string;
+	if (typeof value === "string") text = value;
+	else {
+		try {
+			const serialized = JSON.stringify(value, null, 2);
+			if (serialized === undefined) return undefined;
+			text = serialized;
+		} catch {
+			return undefined;
+		}
+	}
+	if (!text.trim()) return undefined;
+	const payload = Buffer.from(text, "utf-8");
+	if (payload.length <= maxBytes) return text;
+	const markerBytes = Buffer.byteLength(TOOL_PAYLOAD_TRUNCATION_MARKER, "utf-8");
+	let end = Math.max(0, maxBytes - markerBytes);
+	while (end > 0 && (payload[end]! & 0xc0) === 0x80) end--;
+	return `${payload.subarray(0, end).toString("utf-8")}${TOOL_PAYLOAD_TRUNCATION_MARKER}`;
+}
+
 export const CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1;
 const DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
 
@@ -19,8 +43,10 @@ type ChildTranscriptMessage = Message & {
 interface ChildTranscriptEvent {
 	type?: string;
 	message?: ChildTranscriptMessage;
+	toolCallId?: string;
 	toolName?: string;
 	args?: unknown;
+	isError?: boolean;
 }
 
 interface ChildTranscriptWriterInput {
@@ -147,6 +173,27 @@ export function createChildTranscriptWriter(input: ChildTranscriptWriterInput):
 
 	const writeMessage = (sourceEventType: string, message: ChildTranscriptMessage) => {
 		const text = extractTextFromContent(message.content);
+		if (message.role === "toolResult") {
+			const output = boundedPayload(text);
+			writeRecord({
+				...baseRecord("message"),
+				sourceEventType,
+				role: message.role,
+				toolCallId: message.toolCallId,
+				toolName: message.toolName,
+				isError: message.isError,
+				...(output ? { text: output, outputTruncated: output.includes("… payload truncated") } : {}),
+				message: {
+					role: message.role,
+					toolCallId: message.toolCallId,
+					toolName: message.toolName,
+					isError: message.isError,
+					content: output ? [{ type: "text", text: output }] : [],
+					...(message.timestamp !== undefined ? { timestamp: message.timestamp } : {}),
+				},
+			});
+			return;
+		}
 		writeRecord({
 			...baseRecord("message"),
 			sourceEventType,
@@ -178,11 +225,14 @@ export function createChildTranscriptWriter(input: ChildTranscriptWriterInput):
 			}
 			if (event.type === "tool_execution_start" && event.toolName) {
 				const args = eventArgs(event);
+				const argsPayload = boundedPayload(args);
 				writeRecord({
 					...baseRecord("tool_start"),
 					sourceEventType: event.type,
+					...(event.toolCallId ? { toolCallId: event.toolCallId } : {}),
 					toolName: event.toolName,
 					...(Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {}),
+					...(argsPayload ? { argsPayload } : {}),
 				});
 				return;
 			}
@@ -190,7 +240,9 @@ export function createChildTranscriptWriter(input: ChildTranscriptWriterInput):
 				writeRecord({
 					...baseRecord("tool_end"),
 					sourceEventType: event.type,
+					...(event.toolCallId ? { toolCallId: event.toolCallId } : {}),
 					...(event.toolName ? { toolName: event.toolName } : {}),
+					...(typeof event.isError === "boolean" ? { isError: event.isError } : {}),
 				});
 			}
 		},

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

@@ -0,0 +1,16 @@
+/** Preserve pi-subagents v0.33 and earlier environment configuration. */
+const LEGACY_PREFIX = /^PI_SUBAGENTS?_/;
+
+export function normalizeLegacySubagentEnv(env: NodeJS.ProcessEnv = process.env): void {
+	for (const [name, value] of Object.entries(env)) {
+		if (value === undefined || !LEGACY_PREFIX.test(name)) continue;
+		const selesaiName = name.replace(LEGACY_PREFIX, (prefix) => prefix === "PI_SUBAGENTS_" ? "SELESAI_SUBAGENTS_" : "SELESAI_SUBAGENT_");
+		if (env[selesaiName] === undefined) env[selesaiName] = value;
+	}
+}
+
+normalizeLegacySubagentEnv();
+
+export function readSubagentEnv(env: NodeJS.ProcessEnv, selesaiName: string): string | undefined {
+	return env[selesaiName] ?? env[selesaiName.replace(/^SELESAI_/, "PI_")];
+}

package/dist/extensions/pi-subagents/src/shared/file-system-retry.ts

@@ -0,0 +1,47 @@
+const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
+const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
+const RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+
+export const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
+
+export type FileSystemRetryOptions = {
+	retryDelaysMs?: readonly number[];
+	wait?: (delayMs: number) => void;
+};
+
+export function waitForFileSystemRetry(delayMs: number): void {
+	if (delayMs <= 0) return;
+	if (WAIT_VIEW) {
+		try {
+			// Callers are synchronous status/result writers; Atomics.wait gives
+			// Windows directory and rename locks time to clear without burning CPU.
+			Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
+			return;
+		} catch {
+			// Fall through to the portable busy wait below.
+		}
+	}
+	const end = Date.now() + delayMs;
+	while (Date.now() < end) {
+		// Portable fallback for runtimes where Atomics.wait is unavailable.
+	}
+}
+
+export function isRetryableFileSystemError(error: unknown): boolean {
+	const code = (error as NodeJS.ErrnoException | undefined)?.code;
+	return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
+}
+
+export function runFileSystemOperationWithRetry<T>(operation: () => T, options: FileSystemRetryOptions = {}): T {
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const wait = options.wait ?? waitForFileSystemRetry;
+	for (let attempt = 0; ; attempt++) {
+		try {
+			return operation();
+		} catch (error) {
+			const delayMs = retryDelaysMs[attempt];
+			if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;
+			wait(delayMs);
+		}
+	}
+}

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { SessionManager } from "@selesai/code";
+import { findModelInfo, type ModelInfo } from "./model-info.ts";
 
 type SubagentExecutionContext = "fresh" | "fork";
 
@@ -35,6 +36,9 @@ interface ForkableSessionManager {
 
 interface ForkContextResolverOptions {
 	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
+	/** Decide per child index whether a sanitized transcript must also disable the child's
+	 * thinking. Defaults to true (the pre-existing conservative behavior) when omitted. */
+	forceThinkingOffForIndex?: (index: number) => boolean;
 }
 
 interface ForkContextResolution {
@@ -51,6 +55,20 @@ export function resolveSubagentContext(value: unknown): SubagentExecutionContext
 	return value === "fork" ? "fork" : "fresh";
 }
 
+/** Decide whether a resolved child model uses Anthropic's provider or message API, which
+ * requires the sanitized fork to disable thinking. Unknown models stay conservative. */
+export function forkedChildRequiresThinkingOff(
+	model: string | undefined,
+	availableModels?: ModelInfo[],
+	preferredProvider?: string,
+): boolean {
+	if (!model) return true;
+	const info = findModelInfo(model, availableModels, preferredProvider);
+	if (!info) return true;
+	return info.provider.toLowerCase() === "anthropic"
+		|| info.api?.toLowerCase() === "anthropic-messages";
+}
+
 function isUnsafeAnthropicThinkingBlock(message: BranchSessionEntry["message"], block: unknown): boolean {
 	if (!message || !block || typeof block !== "object" || !("type" in block)) return false;
 	const provider = typeof message.provider === "string" ? message.provider.toLowerCase() : "";
@@ -94,7 +112,6 @@ function sanitizeUnsafeThinkingBlocks(entries: BranchSessionEntry[]): boolean {
 		entry.message.content = filtered;
 		sanitized = true;
 	}
-	if (sanitized) appendThinkingOffEntry(entries);
 	return sanitized;
 }
 
@@ -150,6 +167,8 @@ export function createForkContextResolver(
 			if (!sessionFile) {
 				throw new Error("Session manager did not return a forked session file.");
 			}
+			const forceThinkingOff = (sanitized: boolean): boolean =>
+				sanitized && (options.forceThinkingOffForIndex?.(index) ?? true);
 			let thinkingOverride: "off" | undefined;
 			if (!fs.existsSync(sessionFile)) {
 				const header = sourceManager.getHeader?.();
@@ -157,13 +176,19 @@ export function createForkContextResolver(
 				if (!header || !entries) {
 					throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
 				}
-				if (sanitizeUnsafeThinkingBlocks(entries)) thinkingOverride = "off";
+				if (forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries))) {
+					appendThinkingOffEntry(entries);
+					thinkingOverride = "off";
+				}
 				fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
 				fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
 			} else {
 				const entries = readSessionEntries(sessionFile);
 				if (sanitizeUnsafeThinkingBlocks(entries)) {
-					thinkingOverride = "off";
+					if (forceThinkingOff(true)) {
+						appendThinkingOffEntry(entries);
+						thinkingOverride = "off";
+					}
 					fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
 				}
 			}

package/dist/extensions/pi-subagents/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/dist/extensions/pi-subagents/src/shared/model-info.ts

@@ -1,4 +1,4 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export type ThinkingLevel = typeof THINKING_LEVELS[number];
 export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
 
@@ -6,6 +6,7 @@ export interface ModelInfo {
 	provider: string;
 	id: string;
 	fullId: string;
+	api?: string;
 	reasoning?: boolean;
 	thinkingLevelMap?: ThinkingLevelMap;
 }
@@ -13,6 +14,7 @@ export interface ModelInfo {
 interface RegistryModelLike {
 	provider: string;
 	id: string;
+	api?: string;
 	reasoning?: boolean;
 	thinkingLevelMap?: ThinkingLevelMap;
 }
@@ -22,6 +24,7 @@ export function toModelInfo(model: RegistryModelLike): ModelInfo {
 		provider: model.provider,
 		id: model.id,
 		fullId: `${model.provider}/${model.id}`,
+		api: model.api,
 		reasoning: model.reasoning,
 		thinkingLevelMap: model.thinkingLevelMap,
 	};
@@ -30,7 +33,7 @@ export function toModelInfo(model: RegistryModelLike): ModelInfo {
 /** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
  * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
  * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(model: string | undefined, configThinking: string | undefined): string | undefined {
+export function resolveEffectiveThinking(model: string | undefined, configThinking: string | false | undefined): string | undefined {
 	if (!model) return undefined;
 	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
 	if (thinkingSuffix) return thinkingSuffix.slice(1);
@@ -63,15 +66,15 @@ export function findModelInfo(model: string | undefined, availableModels: ModelI
 }
 
 export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-	if (!model) return [...THINKING_LEVELS];
+	if (!model) return THINKING_LEVELS.filter((level) => level !== "max");
 	if (model.reasoning === false) return ["off"];
 
-	if (!model.thinkingLevelMap) return [...THINKING_LEVELS];
+	if (!model.thinkingLevelMap) return THINKING_LEVELS.filter((level) => level !== "max");
 
 	const levels = THINKING_LEVELS.filter((level) => {
 		const mapped = model.thinkingLevelMap?.[level];
 		if (mapped === null) return false;
-		if (level === "xhigh") return mapped !== undefined;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
 		return true;
 	});
 	return levels;

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

@@ -6,7 +6,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
 import { normalizeSkillInput } from "../agents/skills.ts";
-import { CHAIN_RUNS_DIR, type AcceptanceInput, type JsonSchemaObject, type OutputMode, type ToolBudgetConfig } from "./types.ts";
+import { CHAIN_RUNS_DIR, type AcceptanceInput, type AgentContract, type ChainGateLayer, type JsonSchemaObject, type OutputMode, type ToolBudgetConfig } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
 
@@ -57,6 +57,8 @@ export interface SequentialStep {
 	model?: string;
 	toolBudget?: ToolBudgetConfig;
 	acceptance?: AcceptanceInput;
+	agentContract?: AgentContract;
+	gateOn?: ChainGateLayer;
 }
 
 /** Parallel task item within a parallel step */
@@ -77,6 +79,8 @@ export interface ParallelTaskItem {
 	model?: string;
 	toolBudget?: ToolBudgetConfig;
 	acceptance?: AcceptanceInput;
+	agentContract?: AgentContract;
+	gateOn?: ChainGateLayer;
 }
 
 export interface DynamicExpandSpec {
@@ -106,6 +110,8 @@ export interface DynamicParallelStep {
 	phase?: string;
 	label?: string;
 	acceptance?: AcceptanceInput;
+	agentContract?: AgentContract;
+	gateOn?: ChainGateLayer;
 }
 
 /** Parallel step: multiple agents running concurrently */
@@ -115,6 +121,8 @@ export interface ParallelStep {
 	failFast?: boolean;
 	worktree?: boolean;
 	cwd?: string;
+	agentContract?: AgentContract;
+	gateOn?: ChainGateLayer;
 }
 
 /** Union type for chain steps */

package/dist/extensions/pi-subagents/src/shared/status-format.ts

@@ -16,7 +16,10 @@ export function formatActivityLabel(lastActivityAt: number | undefined, activity
 	}
 	const age = formatActivityAge(Math.max(0, now - lastActivityAt));
 	if (activityState === "needs_attention") return `no activity for ${age}`;
-	if (activityState === "active_long_running") return `active but long-running · last activity ${age} ago`;
+	if (activityState === "active_long_running") {
+		const activityAge = age === "now" ? "now" : `${age} ago`;
+		return `active but long-running · last activity ${activityAge}`;
+	}
 	return age === "now" ? "active now" : `active ${age} ago`;
 }
 
@@ -27,6 +30,7 @@ function isCompletedStepStatus(status: AsyncJobStep["status"]): boolean {
 export function aggregateStepStatus(steps: StepStatusLike[]): AsyncJobStep["status"] {
 	if (steps.some((step) => step.status === "running")) return "running";
 	if (steps.some((step) => step.status === "failed")) return "failed";
+	if (steps.some((step) => step.status === "stopped")) return "stopped";
 	if (steps.some((step) => step.status === "paused")) return "paused";
 	if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status))) return "complete";
 	return "pending";
@@ -40,10 +44,12 @@ export function formatParallelOutcome(steps: StepStatusLike[], total: number, op
 	const running = steps.filter((step) => step.status === "running").length;
 	const done = steps.filter((step) => isCompletedStepStatus(step.status)).length;
 	const failed = steps.filter((step) => step.status === "failed").length;
+	const stopped = steps.filter((step) => step.status === "stopped").length;
 	const paused = steps.filter((step) => step.status === "paused").length;
 	const parts = [`${done}/${total} done`];
 	if (options.showRunning !== false && running > 0) parts.unshift(formatAgentRunningLabel(running));
 	if (failed > 0) parts.push(`${failed} failed`);
+	if (stopped > 0) parts.push(`${stopped} stopped`);
 	if (paused > 0) parts.push(`${paused} paused`);
 	return parts.join(" · ");
 }