pi-subagents 0.51.0 → 0.52.0

package/src/runs/background/async-execution.ts

@@ -24,7 +24,7 @@ import { resolveNodeExecutable } from "../../shared/node-executable.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.ts";
 import { buildAgentMemoryInjection } from "../../agents/agent-memory.ts";
 import { PI_CODING_AGENT_PACKAGE_ROOT_ENV, PROMPT_REDACTED, resolveChildCwd } from "../../shared/utils.ts";
-import { buildModelCandidates, resolveEffectiveSubagentModel, resolveModelCandidate, resolveSubagentModelOverride, type AvailableModelInfo, type ParentModel } from "../shared/model-fallback.ts";
+import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel, resolveModelCandidate, resolveSubagentModelOverride, type AvailableModelInfo, type ParentModel } from "../shared/model-fallback.ts";
 import { resolveToolTimeoutMs, toolTimeoutFromEnv } from "../shared/tool-timeout.ts";
 import type { ModelScopeConfig } from "../shared/model-scope.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
@@ -220,6 +220,7 @@ interface AsyncSingleParams {
 	agentContract?: AgentContract;
 	structuredOutputSchema?: JsonSchemaObject;
 	modelOverride?: string;
+	modelOverrideFromParent?: boolean;
 	thinkingOverride?: AgentConfig["thinking"];
 	availableModels?: AvailableModelInfo[];
 	maxSubagentDepth: number;
@@ -837,7 +838,10 @@ export function buildAsyncRunnerSteps(id: string, params: AsyncRunnerStepBuildPa
 			model,
 			thinking: resolveEffectiveThinking(model, effectiveThinking),
 			launchResolvedExtensions,
-			modelCandidates: externalRunner ? undefined : buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) =>
+			modelCandidates: externalRunner ? undefined : buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider, {
+				scope: ctx.modelScope,
+				primaryModelFromParent: inheritsParentModel(s.model, a.model, ctx.currentModel),
+			}).map((candidate) =>
 				applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined),
 			),
 			tools: a.tools,
@@ -1414,12 +1418,14 @@ export function executeAsyncSingle(
 		? `[Read from: ${readPaths.join(", ")}]\n\n`
 		: "";
 	const taskText = readsInstruction + taskWithOutputInstruction;
-	const primaryModel = externalRunner ? undefined : resolveSubagentModelOverride(
-		params.modelOverride ?? agentConfig.model,
-		ctx.currentModel,
-		availableModels,
-		ctx.currentModelProvider,
-	);
+	const primaryModel = externalRunner ? undefined : params.modelOverrideFromParent
+		? params.modelOverride
+		: resolveSubagentModelOverride(
+			params.modelOverride ?? agentConfig.model,
+			ctx.currentModel,
+			availableModels,
+			ctx.currentModelProvider,
+		);
 	const effectiveThinking = externalRunner ? undefined : params.thinkingOverride ?? agentConfig.thinking;
 	const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
 	const toolBudgetInput = params.toolBudget ?? agentConfig.toolBudget ?? params.configToolBudget;
@@ -1446,7 +1452,10 @@ export function executeAsyncSingle(
 		: undefined;
 	const modelCandidates = externalRunner
 		? []
-		: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope })
+		: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, {
+			scope: ctx.modelScope,
+			primaryModelFromParent: params.modelOverrideFromParent,
+		})
 			.flatMap((candidate) => {
 				const resolved = applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined);
 				return resolved ? [resolved] : [];
@@ -1504,6 +1513,7 @@ export function executeAsyncSingle(
 		...(sessionFile ? { sessionFile } : {}),
 		cwd: runnerCwd,
 		...(model ? { model } : {}),
+		...(params.modelOverrideFromParent ? { modelOverrideFromParent: true } : {}),
 		...(recoveryAgentConfig.fallbackModels ? { fallbackModels: [...recoveryAgentConfig.fallbackModels] } : {}),
 		...(effectiveThinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {}),
 		...(recoveryAgentConfig.tools ? { tools: [...recoveryAgentConfig.tools] } : {}),

package/src/runs/background/async-resume.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { DIRS, type AcceptanceInput, type AsyncStatus, type ResolvedTurnBudget, type SteeringRecoveryDescriptor } from "../../shared/types.ts";
+import { DIRS, type AcceptanceInput, type AsyncStatus, type ResolvedTurnBudget, type SteeringRecoveryDescriptor, type SubagentRunMode } from "../../shared/types.ts";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { validateAcceptanceInput } from "../shared/acceptance.ts";
 import { validateToolBudgetConfig } from "../shared/tool-budget.ts";
@@ -36,6 +36,7 @@ export type AsyncResumeTarget = {
 	runId: string;
 	asyncDir?: string;
 	state: AsyncStatus["state"];
+	mode?: SubagentRunMode;
 	agent: string;
 	index: number;
 	cwd?: string;
@@ -293,6 +294,17 @@ function normalizeRecoveryTurnBudget(value: unknown, descriptorPath: string): Re
 	return result.turnBudget;
 }
 
+export function asyncReviveRequiresRecoveryDescriptor(target: Pick<AsyncResumeTarget, "recoveryDescriptor" | "mode" | "sessionFile">): boolean {
+	if (target.recoveryDescriptor) return false;
+	return !(target.mode === "workflow" && Boolean(target.sessionFile));
+}
+
+function resumeTargetMode(status: AsyncStatus | null, result: AsyncResultFile | undefined): SubagentRunMode | undefined {
+	if (status?.mode) return status.mode;
+	if (result?.mode === "single" || result?.mode === "parallel" || result?.mode === "chain" || result?.mode === "workflow") return result.mode;
+	return undefined;
+}
+
 export function readAsyncRecoveryDescriptor(asyncDir: string | undefined): SteeringRecoveryDescriptor | undefined {
 	if (!asyncDir) return undefined;
 	const descriptorPath = path.join(asyncDir, "recovery-descriptor.json");
@@ -306,7 +318,7 @@ export function readAsyncRecoveryDescriptor(asyncDir: string | undefined): Steer
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid async recovery descriptor '${descriptorPath}': expected an object.`);
 	const parsed = value as Record<string, unknown>;
 	const allowedFields = new Set([
-		"version", "launchContractDigest", "sourceRunId", "agentContract", "agent", "sessionFile", "cwd", "model", "fallbackModels", "thinking", "tools", "extensions",
+		"version", "launchContractDigest", "sourceRunId", "agentContract", "agent", "sessionFile", "cwd", "model", "modelOverrideFromParent", "fallbackModels", "thinking", "tools", "extensions",
 		"subagentOnlyExtensions", "mcpDirectTools", "systemPrompt", "systemPromptMode", "inheritProjectContext", "inheritSkills", "skills",
 		"skillPath", "agentFilePath", "completionGuard", "memory", "outputPath", "outputMode", "structuredOutputSchema", "acceptance", "sessionDir", "artifactConfig",
 		"artifactsDir", "maxOutput", "controlConfig", "intercomBridge", "absoluteDeadlineAt", "initialTurnBudget", "initialToolBudget", "maxSubagentDepth", "share", "capabilityCeiling",
@@ -333,6 +345,7 @@ export function readAsyncRecoveryDescriptor(asyncDir: string | undefined): Steer
 	}
 	if (parsed.systemPromptMode !== "append" && parsed.systemPromptMode !== "replace") throw new Error(`Invalid async recovery descriptor '${descriptorPath}': systemPromptMode is invalid.`);
 	if (parsed.outputMode !== "inline" && parsed.outputMode !== "file-only") throw new Error(`Invalid async recovery descriptor '${descriptorPath}': outputMode is invalid.`);
+	if (parsed.modelOverrideFromParent !== undefined && typeof parsed.modelOverrideFromParent !== "boolean") throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelOverrideFromParent must be a boolean.`);
 	for (const field of ["inheritProjectContext", "inheritSkills", "share"] as const) {
 		if (typeof parsed[field] !== "boolean") throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${field} must be a boolean.`);
 	}
@@ -438,6 +451,7 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 	const recoveryDescriptor = readAsyncRecoveryDescriptor(location.asyncDir ?? undefined);
 	const result = location.resultPath ? readResultFile(location.resultPath) : undefined;
 	const runId = status?.runId ?? result?.runId ?? result?.id ?? location.resolvedId ?? (location.asyncDir ? path.basename(location.asyncDir) : "unknown");
+	const mode = resumeTargetMode(status, result);
 	if (options.sessionId && ((status && status.sessionId !== options.sessionId) || (result && result.sessionId !== options.sessionId))) {
 		throw new Error(`Async run '${runId}' was not found in the active session.`);
 	}
@@ -464,6 +478,7 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 					runId,
 					asyncDir: location.asyncDir ?? undefined,
 					state,
+					...(mode ? { mode } : {}),
 					agent: selectedStep.agent,
 					index: requestedIndex,
 					cwd: status?.cwd ?? result?.cwd,
@@ -491,6 +506,7 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 				runId,
 				asyncDir: location.asyncDir ?? undefined,
 				state,
+				...(mode ? { mode } : {}),
 				agent: selected.step.agent,
 				index: selected.index,
 				cwd: status?.cwd ?? result?.cwd,
@@ -531,6 +547,7 @@ export function resolveAsyncResumeTarget(params: AsyncResumeParams, deps: AsyncR
 		runId,
 		asyncDir: location.asyncDir ?? undefined,
 		state,
+		...(mode ? { mode } : {}),
 		agent,
 		index,
 		...(resumeCwd ? { cwd: resumeCwd } : {}),

package/src/runs/background/async-retention.ts

@@ -330,13 +330,11 @@ function processStartIdentity(pid: number): string | undefined {
 		}
 	}
 	if (process.platform === "win32") {
-		const result = spawnSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8" });
+		const result = spawnSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", windowsHide: true });
 		const started = result.status === 0 ? result.stdout.trim() : "";
 		return started ? `win:${started}` : undefined;
 	}
-	const result = spawnSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf-8" });
-	const started = result.status === 0 ? result.stdout.trim() : "";
-	return started ? `${process.platform}:${started}` : undefined;
+	return undefined;
 }
 
 function processIsAlive(pid: number): boolean | undefined {

package/src/runs/background/completion-dedupe.ts

@@ -3,6 +3,7 @@ interface CompletionDataLike {
 	agent?: unknown;
 	timestamp?: unknown;
 	sessionId?: unknown;
+	state?: unknown;
 	taskIndex?: unknown;
 	totalTasks?: unknown;
 	success?: unknown;
@@ -22,7 +23,10 @@ function asFiniteNumber(value: unknown): number | undefined {
 export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
 	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
 	const id = asNonEmptyString(data.id);
-	if (id) return `session:${sessionId}:id:${id}`;
+	const state = asNonEmptyString(data.state);
+	if (id) return state
+		? `session:${sessionId}:id:${id}:state:${state}`
+		: `session:${sessionId}:id:${id}`;
 	const agent = asNonEmptyString(data.agent) ?? "unknown";
 	const timestamp = asFiniteNumber(data.timestamp);
 	const taskIndex = asFiniteNumber(data.taskIndex);

package/src/runs/background/completion-replay.ts

@@ -14,6 +14,7 @@ const lastCleanupByResultsDir = new Map<string, number>();
 
 export interface CompletionArchiveEntry {
 	agent?: string;
+	resultIndex?: number;
 	source: "output-artifact" | "session" | "result-tail";
 	path?: string;
 	text?: string;
@@ -71,39 +72,45 @@ function outputArtifactPath(child: Record<string, unknown>): string | undefined
 /** Create a small archive that references saved child artifacts and retains only bounded fallback output text. */
 export function writeCompletionArchive(resultsDir: string, runId: string, data: Record<string, unknown>, createdAt: number): string {
 	const entries: CompletionArchiveEntry[] = [];
-	const fallback: string[] = [];
 	const results = Array.isArray(data.results) ? data.results : [];
-	for (const value of results) {
+	for (let resultIndex = 0; resultIndex < results.length; resultIndex++) {
+		const value = results[resultIndex];
 		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
 		const child = value as Record<string, unknown>;
 		const agent = nonEmptyString(child.agent);
 		const artifactPath = outputArtifactPath(child);
 		if (artifactPath) {
-			entries.push({ ...(agent ? { agent } : {}), source: "output-artifact", path: artifactPath });
+			entries.push({ ...(agent ? { agent } : {}), resultIndex, source: "output-artifact", path: artifactPath });
 			continue;
 		}
 		const sessionPath = existingFile(child.sessionFile);
 		if (sessionPath) {
-			entries.push({ ...(agent ? { agent } : {}), source: "session", path: sessionPath });
+			entries.push({ ...(agent ? { agent } : {}), resultIndex, source: "session", path: sessionPath });
 			continue;
 		}
 		const output = nonEmptyString(child.output);
 		const error = nonEmptyString(child.error);
 		if (output || error) {
-			fallback.push([agent ? `[${agent}]` : undefined, error ? `Error: ${error}` : undefined, output].filter(Boolean).join("\n"));
+			const bounded = utf8Tail([error ? `Error: ${error}` : undefined, output].filter(Boolean).join("\n"), ARCHIVE_TEXT_LIMIT_BYTES);
+			entries.push({
+				...(agent ? { agent } : {}),
+				resultIndex,
+				source: "result-tail",
+				text: bounded.text,
+				...(bounded.truncated ? { truncated: true } : {}),
+			});
 		}
 	}
 	if (results.length === 0) {
 		const sessionPath = existingFile(data.sessionFile);
 		if (sessionPath) entries.push({ source: "session", path: sessionPath });
 	}
-	if (entries.length === 0 && fallback.length === 0) {
+	if (entries.length === 0) {
 		const summary = nonEmptyString(data.summary);
-		if (summary) fallback.push(summary);
-	}
-	if (fallback.length > 0) {
-		const bounded = utf8Tail(fallback.join("\n\n"), ARCHIVE_TEXT_LIMIT_BYTES);
-		entries.push({ source: "result-tail", text: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) });
+		if (summary) {
+			const bounded = utf8Tail(summary, ARCHIVE_TEXT_LIMIT_BYTES);
+			entries.push({ source: "result-tail", text: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) });
+		}
 	}
 	const archive: CompletionArchive = { version: ARCHIVE_VERSION, runId, createdAt, entries };
 	const archivePath = completionArchivePath(resultsDir, runId);
@@ -165,6 +172,7 @@ function parseArchive(value: unknown): CompletionArchive | undefined {
 		if (entry.source !== "output-artifact" && entry.source !== "session" && entry.source !== "result-tail") return [];
 		return [{
 			...(typeof entry.agent === "string" ? { agent: entry.agent } : {}),
+			...(typeof entry.resultIndex === "number" && Number.isSafeInteger(entry.resultIndex) && entry.resultIndex >= 0 ? { resultIndex: entry.resultIndex } : {}),
 			source: entry.source,
 			...(typeof entry.path === "string" ? { path: entry.path } : {}),
 			...(typeof entry.text === "string" ? { text: entry.text } : {}),
@@ -228,7 +236,9 @@ export function readCompletionReplay(resultsDir: string, runId: string, options:
 
 export function readCompletionArchive(archivePath: string): CompletionArchive | undefined {
 	try {
-		return parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+		const archive = parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+		if (!archive) throw new Error("Completion archive is malformed.");
+		return archive;
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
 		throw error;

package/src/runs/background/fleet-view.ts

@@ -156,34 +156,83 @@ function stringifyJsonPreview(value: unknown, maxLength = 240): string {
 	return raw.length > maxLength ? `${raw.slice(0, maxLength)}…` : raw;
 }
 
-function contentText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content.map((part) => {
-		if (!part || typeof part !== "object") return "";
-		const entry = part as { type?: unknown; text?: unknown; name?: unknown; toolName?: unknown; args?: unknown; result?: unknown; content?: unknown };
-		if (typeof entry.text === "string") return entry.text;
+/** One structured content part of a session JSONL record. Shared by the prose transcript formatter and inspect RPC. */
+export interface SessionTranscriptMessage {
+	role: string;
+	kind: "text" | "toolCall" | "toolResult";
+	text: string;
+	name?: string;
+	isError?: boolean;
+	/** Ordinal of the session record this part came from, so consumers can
+	 *  regroup multi-part messages (one session record can yield several parts). */
+	recordIndex?: number;
+}
+
+function sessionMessageParts(record: unknown): SessionTranscriptMessage[] {
+	if (!record || typeof record !== "object") return [];
+	const outer = record as { message?: unknown; role?: unknown; content?: unknown; type?: unknown };
+	const message = outer.message && typeof outer.message === "object" ? outer.message as { role?: unknown; content?: unknown } : outer;
+	const role = typeof message.role === "string" ? message.role : undefined;
+	if (!role) return [];
+	const content = message.content;
+	if (typeof content === "string") return content.trim() ? [{ role, kind: "text", text: content }] : [];
+	if (!Array.isArray(content)) return [];
+	const parts: SessionTranscriptMessage[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") continue;
+		const entry = part as { type?: unknown; text?: unknown; name?: unknown; toolName?: unknown; args?: unknown; result?: unknown; content?: unknown; isError?: unknown };
+		if (typeof entry.text === "string") {
+			if (entry.text.trim()) parts.push({ role, kind: "text", text: entry.text });
+			continue;
+		}
 		if (entry.type === "toolCall" || entry.type === "tool_call") {
 			const name = typeof entry.name === "string" ? entry.name : typeof entry.toolName === "string" ? entry.toolName : "tool";
-			return `[tool: ${name}${entry.args === undefined ? "" : ` ${stringifyJsonPreview(entry.args)}`}]`;
+			parts.push({ role, kind: "toolCall", name, text: `[tool: ${name}${entry.args === undefined ? "" : ` ${stringifyJsonPreview(entry.args)}`}]` });
+			continue;
 		}
 		if (entry.type === "toolResult" || entry.type === "tool_result") {
-			return `[tool result${entry.result === undefined ? "" : `: ${stringifyJsonPreview(entry.result)}`}]`;
+			const name = typeof entry.name === "string" ? entry.name : typeof entry.toolName === "string" ? entry.toolName : undefined;
+			parts.push({ role, kind: "toolResult", ...(name ? { name } : {}), ...(entry.isError === true ? { isError: true } : {}), text: `[tool result${entry.result === undefined ? "" : `: ${stringifyJsonPreview(entry.result)}`}]` });
+			continue;
+		}
+		if (entry.content !== undefined) {
+			const preview = stringifyJsonPreview(entry.content);
+			if (preview.trim()) parts.push({ role, kind: "text", text: preview });
 		}
-		if (entry.content !== undefined) return stringifyJsonPreview(entry.content);
-		return "";
-	}).filter(Boolean).join("\n");
+	}
+	return parts;
 }
 
 function sessionMessageLine(record: unknown): string | undefined {
-	if (!record || typeof record !== "object") return undefined;
-	const outer = record as { message?: unknown; role?: unknown; content?: unknown; type?: unknown };
-	const message = outer.message && typeof outer.message === "object" ? outer.message as { role?: unknown; content?: unknown } : outer;
-	const role = typeof message.role === "string" ? message.role : undefined;
-	if (!role) return undefined;
-	const text = contentText(message.content).trim();
+	const parts = sessionMessageParts(record);
+	if (parts.length === 0) return undefined;
+	const text = parts.map((part) => part.text).join("\n").trim();
 	if (!text) return undefined;
-	return `${role}: ${text}`;
+	return `${parts[0]!.role}: ${text}`;
+}
+
+/** Structured session tail: parsed content parts, newest last, bounded by
+ *  maxMessages. Same trusted-root containment as the prose transcript tail. */
+export function readSessionMessagesTail(sessionFile: string, maxMessages: number, trustedRoots: string[]): { messages: SessionTranscriptMessage[]; warnings: string[]; truncated: boolean } {
+	const tail = readContainedTextTail(sessionFile, Math.max(maxMessages * 4, maxMessages), trustedRoots, "session");
+	const warnings: string[] = [];
+	if (tail.error) warnings.push(`Session read failed for ${sessionFile}: ${tail.error}`);
+	const parsedMessages: SessionTranscriptMessage[] = [];
+	let malformed = 0;
+	let recordIndex = 0;
+	for (const line of tail.lines) {
+		if (!line.trim()) continue;
+		try {
+			const parsed = JSON.parse(line) as unknown;
+			for (const part of sessionMessageParts(parsed)) parsedMessages.push({ ...part, recordIndex });
+		} catch {
+			malformed++;
+		}
+		recordIndex++;
+	}
+	if (malformed > 0) warnings.push(`Skipped ${malformed} malformed session tail line${malformed === 1 ? "" : "s"}.`);
+	const messages = parsedMessages.slice(-maxMessages);
+	return { messages, warnings, truncated: tail.truncated || parsedMessages.length > messages.length };
 }
 
 function readSessionTranscriptTail(sessionFile: string, maxLines: number, trustedRoots: string[]): { lines: string[]; warnings: string[] } {